2014-05-03 18:27:38 -04:00
|
|
|
/*
|
2017-07-18 23:01:22 -04:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 18:27:38 -04:00
|
|
|
*
|
|
|
|
* Taken from ST Cube library and heavily modified. See below for original
|
|
|
|
* copyright header.
|
|
|
|
*/
|
|
|
|
|
2014-03-15 12:54:23 -04:00
|
|
|
/**
|
|
|
|
******************************************************************************
|
|
|
|
* @file USB_Device/CDC_Standalone/Src/usbd_cdc_interface.c
|
|
|
|
* @author MCD Application Team
|
|
|
|
* @version V1.0.1
|
|
|
|
* @date 26-February-2014
|
|
|
|
* @brief Source file for USBD CDC interface
|
|
|
|
******************************************************************************
|
|
|
|
* @attention
|
|
|
|
*
|
|
|
|
* <h2><center>© COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
|
|
|
|
*
|
|
|
|
* Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
|
|
|
|
* You may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at:
|
|
|
|
*
|
|
|
|
* http://www.st.com/software_license_agreement_liberty_v2
|
|
|
|
*
|
2017-07-18 23:01:22 -04:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
2014-03-15 12:54:23 -04:00
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*
|
|
|
|
******************************************************************************
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
2014-07-31 05:30:42 -04:00
|
|
|
|
2014-03-15 12:54:23 -04:00
|
|
|
#include <stdbool.h>
|
2014-11-01 17:26:06 -04:00
|
|
|
#include <stdint.h>
|
2014-07-31 05:30:42 -04:00
|
|
|
|
2014-03-29 20:00:15 -04:00
|
|
|
#include "usbd_cdc_msc_hid.h"
|
2014-03-15 12:54:23 -04:00
|
|
|
#include "usbd_cdc_interface.h"
|
|
|
|
#include "pendsv.h"
|
2014-07-31 05:30:42 -04:00
|
|
|
|
2014-11-01 17:26:06 -04:00
|
|
|
#include "py/obj.h"
|
2017-02-15 00:39:30 -05:00
|
|
|
#include "lib/utils/interrupt_char.h"
|
2015-06-07 18:48:07 -04:00
|
|
|
#include "irq.h"
|
2014-11-01 17:26:06 -04:00
|
|
|
|
2018-05-27 20:46:49 -04:00
|
|
|
#if MICROPY_HW_ENABLE_USB
|
|
|
|
|
2014-03-22 08:46:23 -04:00
|
|
|
// CDC control commands
|
|
|
|
#define CDC_SEND_ENCAPSULATED_COMMAND 0x00
|
|
|
|
#define CDC_GET_ENCAPSULATED_RESPONSE 0x01
|
|
|
|
#define CDC_SET_COMM_FEATURE 0x02
|
|
|
|
#define CDC_GET_COMM_FEATURE 0x03
|
|
|
|
#define CDC_CLEAR_COMM_FEATURE 0x04
|
|
|
|
#define CDC_SET_LINE_CODING 0x20
|
|
|
|
#define CDC_GET_LINE_CODING 0x21
|
|
|
|
#define CDC_SET_CONTROL_LINE_STATE 0x22
|
|
|
|
#define CDC_SEND_BREAK 0x23
|
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
// Used to control the connect_state variable when USB host opens the serial port
|
|
|
|
static uint8_t usbd_cdc_connect_tx_timer;
|
|
|
|
|
2018-05-14 02:15:58 -04:00
|
|
|
uint8_t *usbd_cdc_init(usbd_cdc_state_t *cdc_in) {
|
|
|
|
usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
|
2017-10-12 21:00:47 -04:00
|
|
|
|
|
|
|
// Reset all the CDC state
|
|
|
|
// Note: we don't reset tx_buf_ptr_in in order to allow the output buffer to
|
|
|
|
// be filled (by usbd_cdc_tx_always) before the USB device is connected.
|
2017-08-30 23:54:49 -04:00
|
|
|
cdc->rx_buf_put = 0;
|
|
|
|
cdc->rx_buf_get = 0;
|
2018-12-14 01:07:12 -05:00
|
|
|
cdc->rx_buf_full = false;
|
2017-08-30 23:54:49 -04:00
|
|
|
cdc->tx_buf_ptr_out = 0;
|
|
|
|
cdc->tx_buf_ptr_out_shadow = 0;
|
|
|
|
cdc->tx_need_empty_packet = 0;
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
cdc->connect_state = USBD_CDC_CONNECT_STATE_DISCONNECTED;
|
2017-09-06 08:57:20 -04:00
|
|
|
|
|
|
|
// Return the buffer to place the first USB OUT packet
|
|
|
|
return cdc->rx_packet_buf;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
|
2018-10-14 21:24:40 -04:00
|
|
|
void usbd_cdc_deinit(usbd_cdc_state_t *cdc_in) {
|
|
|
|
usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
cdc->connect_state = USBD_CDC_CONNECT_STATE_DISCONNECTED;
|
2018-10-14 21:24:40 -04:00
|
|
|
}
|
|
|
|
|
2017-08-30 23:54:49 -04:00
|
|
|
// Manage the CDC class requests
|
|
|
|
// cmd: command code
|
|
|
|
// pbuf: buffer containing command data (request parameters)
|
|
|
|
// length: number of data to be sent (in bytes)
|
|
|
|
// Returns USBD_OK if all operations are OK else USBD_FAIL
|
2018-05-14 02:15:58 -04:00
|
|
|
int8_t usbd_cdc_control(usbd_cdc_state_t *cdc_in, uint8_t cmd, uint8_t* pbuf, uint16_t length) {
|
|
|
|
usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
|
|
|
|
|
2014-03-22 09:21:58 -04:00
|
|
|
switch (cmd) {
|
|
|
|
case CDC_SEND_ENCAPSULATED_COMMAND:
|
|
|
|
/* Add your code here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CDC_GET_ENCAPSULATED_RESPONSE:
|
|
|
|
/* Add your code here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CDC_SET_COMM_FEATURE:
|
|
|
|
/* Add your code here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CDC_GET_COMM_FEATURE:
|
|
|
|
/* Add your code here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CDC_CLEAR_COMM_FEATURE:
|
|
|
|
/* Add your code here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CDC_SET_LINE_CODING:
|
|
|
|
#if 0
|
|
|
|
LineCoding.bitrate = (uint32_t)(pbuf[0] | (pbuf[1] << 8) |\
|
|
|
|
(pbuf[2] << 16) | (pbuf[3] << 24));
|
|
|
|
LineCoding.format = pbuf[4];
|
|
|
|
LineCoding.paritytype = pbuf[5];
|
|
|
|
LineCoding.datatype = pbuf[6];
|
|
|
|
/* Set the new configuration */
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CDC_GET_LINE_CODING:
|
|
|
|
/* Add your code here */
|
|
|
|
pbuf[0] = (uint8_t)(115200);
|
|
|
|
pbuf[1] = (uint8_t)(115200 >> 8);
|
|
|
|
pbuf[2] = (uint8_t)(115200 >> 16);
|
|
|
|
pbuf[3] = (uint8_t)(115200 >> 24);
|
|
|
|
pbuf[4] = 0; // stop bits (1)
|
|
|
|
pbuf[5] = 0; // parity (none)
|
|
|
|
pbuf[6] = 8; // number of bits (8)
|
|
|
|
break;
|
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
case CDC_SET_CONTROL_LINE_STATE: {
|
|
|
|
// wValue, indicating the state, is passed in length (bit of a hack)
|
|
|
|
if (length & 1) {
|
|
|
|
// The actual connection state is delayed to give the host a chance to
|
|
|
|
// configure its serial port (in most cases to disable local echo)
|
|
|
|
PCD_HandleTypeDef *hpcd = cdc->base.usbd->pdev->pData;
|
|
|
|
USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
|
|
|
|
cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTING;
|
|
|
|
usbd_cdc_connect_tx_timer = 8; // wait for 8 SOF IRQs
|
|
|
|
USBx->GINTMSK |= USB_OTG_GINTMSK_SOFM;
|
|
|
|
} else {
|
|
|
|
cdc->connect_state = USBD_CDC_CONNECT_STATE_DISCONNECTED;
|
|
|
|
}
|
2014-03-22 09:21:58 -04:00
|
|
|
break;
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
}
|
2014-03-22 09:21:58 -04:00
|
|
|
|
|
|
|
case CDC_SEND_BREAK:
|
|
|
|
/* Add your code here */
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return USBD_OK;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
// Called when the USB IN endpoint is ready to receive more data
|
|
|
|
// (cdc.base.tx_in_progress must be 0)
|
|
|
|
void usbd_cdc_tx_ready(usbd_cdc_state_t *cdc_in) {
|
|
|
|
|
|
|
|
usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
|
|
|
|
cdc->tx_buf_ptr_out = cdc->tx_buf_ptr_out_shadow;
|
2014-04-16 10:51:27 -04:00
|
|
|
|
2017-08-30 23:54:49 -04:00
|
|
|
if (cdc->tx_buf_ptr_out == cdc->tx_buf_ptr_in && !cdc->tx_need_empty_packet) {
|
2014-04-16 10:51:27 -04:00
|
|
|
// No outstanding data to send
|
|
|
|
return;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
2014-04-16 10:51:27 -04:00
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
uint32_t len;
|
|
|
|
if (cdc->tx_buf_ptr_out > cdc->tx_buf_ptr_in) { // rollback
|
|
|
|
len = USBD_CDC_TX_DATA_SIZE - cdc->tx_buf_ptr_out;
|
|
|
|
} else {
|
|
|
|
len = cdc->tx_buf_ptr_in - cdc->tx_buf_ptr_out;
|
2014-04-13 20:46:25 -04:00
|
|
|
}
|
2014-04-16 10:51:27 -04:00
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
// Should always succeed because cdc.base.tx_in_progress==0
|
|
|
|
USBD_CDC_TransmitPacket(&cdc->base, len, &cdc->tx_buf[cdc->tx_buf_ptr_out]);
|
2014-04-16 10:51:27 -04:00
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
cdc->tx_buf_ptr_out_shadow += len;
|
|
|
|
if (cdc->tx_buf_ptr_out_shadow == USBD_CDC_TX_DATA_SIZE) {
|
|
|
|
cdc->tx_buf_ptr_out_shadow = 0;
|
|
|
|
}
|
2014-04-16 10:51:27 -04:00
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
// According to the USB specification, a packet size of 64 bytes (CDC_DATA_FS_MAX_PACKET_SIZE)
|
|
|
|
// gets held at the USB host until the next packet is sent. This is because a
|
|
|
|
// packet of maximum size is considered to be part of a longer chunk of data, and
|
|
|
|
// the host waits for all data to arrive (ie, waits for a packet < max packet size).
|
|
|
|
// To flush a packet of exactly max packet size, we need to send a zero-size packet.
|
|
|
|
// See eg http://www.cypress.com/?id=4&rID=92719
|
|
|
|
cdc->tx_need_empty_packet = (len > 0 && len % usbd_cdc_max_packet(cdc->base.usbd->pdev) == 0 && cdc->tx_buf_ptr_out_shadow == cdc->tx_buf_ptr_in);
|
|
|
|
}
|
2014-04-16 10:51:27 -04:00
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
// Attempt to queue data on the USB IN endpoint
|
|
|
|
static void usbd_cdc_try_tx(usbd_cdc_itf_t *cdc) {
|
|
|
|
uint32_t basepri = raise_irq_pri(IRQ_PRI_OTG_FS);
|
|
|
|
if (cdc == NULL || cdc->connect_state == USBD_CDC_CONNECT_STATE_DISCONNECTED) {
|
|
|
|
// CDC device is not connected to a host, so we are unable to send any data
|
|
|
|
} else if (cdc->base.tx_in_progress) {
|
|
|
|
// USB driver will call callback when ready
|
|
|
|
} else {
|
|
|
|
usbd_cdc_tx_ready(&cdc->base);
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
restore_irq_pri(basepri);
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
|
2018-05-14 09:44:45 -04:00
|
|
|
void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd) {
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
if (usbd_cdc_connect_tx_timer > 0) {
|
|
|
|
--usbd_cdc_connect_tx_timer;
|
|
|
|
} else {
|
|
|
|
usbd_cdc_msc_hid_state_t *usbd = ((USBD_HandleTypeDef*)hpcd->pData)->pClassData;
|
|
|
|
hpcd->Instance->GINTMSK &= ~USB_OTG_GINTMSK_SOFM;
|
|
|
|
usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)usbd->cdc;
|
|
|
|
if (cdc->connect_state == USBD_CDC_CONNECT_STATE_CONNECTING) {
|
|
|
|
cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTED;
|
|
|
|
usbd_cdc_try_tx(cdc);
|
|
|
|
}
|
|
|
|
#if MICROPY_HW_USB_ENABLE_CDC2
|
|
|
|
cdc = (usbd_cdc_itf_t*)usbd->cdc2;
|
|
|
|
if (cdc->connect_state == USBD_CDC_CONNECT_STATE_CONNECTING) {
|
|
|
|
cdc->connect_state = USBD_CDC_CONNECT_STATE_CONNECTED;
|
|
|
|
usbd_cdc_try_tx(cdc);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
2018-05-14 09:44:45 -04:00
|
|
|
}
|
|
|
|
|
2018-12-14 01:07:12 -05:00
|
|
|
bool usbd_cdc_rx_buffer_full(usbd_cdc_itf_t *cdc) {
|
|
|
|
int get = cdc->rx_buf_get, put = cdc->rx_buf_put;
|
|
|
|
int remaining = (get - put) + (-((int) (get <= put)) & USBD_CDC_RX_DATA_SIZE);
|
|
|
|
return remaining < CDC_DATA_MAX_PACKET_SIZE + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void usbd_cdc_rx_check_resume(usbd_cdc_itf_t *cdc) {
|
|
|
|
uint32_t irq_state = disable_irq();
|
|
|
|
if (cdc->rx_buf_full) {
|
|
|
|
if (!usbd_cdc_rx_buffer_full(cdc)) {
|
|
|
|
cdc->rx_buf_full = false;
|
|
|
|
enable_irq(irq_state);
|
|
|
|
USBD_CDC_ReceivePacket(&cdc->base, cdc->rx_packet_buf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
enable_irq(irq_state);
|
|
|
|
}
|
|
|
|
|
2017-08-30 23:54:49 -04:00
|
|
|
// Data received over USB OUT endpoint is processed here.
|
2017-09-06 08:57:20 -04:00
|
|
|
// len: number of bytes received into the buffer we passed to USBD_CDC_ReceivePacket
|
2017-08-30 23:54:49 -04:00
|
|
|
// Returns USBD_OK if all operations are OK else USBD_FAIL
|
2018-05-14 02:15:58 -04:00
|
|
|
int8_t usbd_cdc_receive(usbd_cdc_state_t *cdc_in, size_t len) {
|
|
|
|
usbd_cdc_itf_t *cdc = (usbd_cdc_itf_t*)cdc_in;
|
|
|
|
|
2017-04-04 02:23:25 -04:00
|
|
|
// copy the incoming data into the circular buffer
|
2017-09-06 08:57:20 -04:00
|
|
|
for (const uint8_t *src = cdc->rx_packet_buf, *top = cdc->rx_packet_buf + len; src < top; ++src) {
|
2018-05-14 09:44:45 -04:00
|
|
|
if (cdc->attached_to_repl && mp_interrupt_char != -1 && *src == mp_interrupt_char) {
|
2017-04-04 02:23:25 -04:00
|
|
|
pendsv_kbd_intr();
|
|
|
|
} else {
|
2017-08-30 23:54:49 -04:00
|
|
|
uint16_t next_put = (cdc->rx_buf_put + 1) & (USBD_CDC_RX_DATA_SIZE - 1);
|
|
|
|
if (next_put == cdc->rx_buf_get) {
|
2017-04-04 02:23:25 -04:00
|
|
|
// overflow, we just discard the rest of the chars
|
|
|
|
break;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
2017-08-30 23:54:49 -04:00
|
|
|
cdc->rx_user_buf[cdc->rx_buf_put] = *src;
|
|
|
|
cdc->rx_buf_put = next_put;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-14 01:07:12 -05:00
|
|
|
if ((cdc->flow & USBD_CDC_FLOWCONTROL_RTS) && (usbd_cdc_rx_buffer_full(cdc))) {
|
|
|
|
cdc->rx_buf_full = true;
|
|
|
|
return USBD_BUSY;
|
|
|
|
} else {
|
|
|
|
// initiate next USB packet transfer
|
|
|
|
cdc->rx_buf_full = false;
|
|
|
|
return USBD_CDC_ReceivePacket(&cdc->base, cdc->rx_packet_buf);
|
|
|
|
}
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
|
2017-08-30 23:54:49 -04:00
|
|
|
int usbd_cdc_tx_half_empty(usbd_cdc_itf_t *cdc) {
|
|
|
|
int32_t tx_waiting = (int32_t)cdc->tx_buf_ptr_in - (int32_t)cdc->tx_buf_ptr_out;
|
2014-10-30 20:12:02 -04:00
|
|
|
if (tx_waiting < 0) {
|
2017-08-30 23:54:49 -04:00
|
|
|
tx_waiting += USBD_CDC_TX_DATA_SIZE;
|
2014-10-30 20:12:02 -04:00
|
|
|
}
|
2017-08-30 23:54:49 -04:00
|
|
|
return tx_waiting <= USBD_CDC_TX_DATA_SIZE / 2;
|
2014-10-30 20:12:02 -04:00
|
|
|
}
|
|
|
|
|
2014-07-31 05:30:42 -04:00
|
|
|
// timout in milliseconds.
|
|
|
|
// Returns number of bytes written to the device.
|
2017-08-30 23:54:49 -04:00
|
|
|
int usbd_cdc_tx(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len, uint32_t timeout) {
|
2014-07-31 05:30:42 -04:00
|
|
|
for (uint32_t i = 0; i < len; i++) {
|
|
|
|
// Wait until the device is connected and the buffer has space, with a given timeout
|
|
|
|
uint32_t start = HAL_GetTick();
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
while (cdc->connect_state == USBD_CDC_CONNECT_STATE_DISCONNECTED
|
|
|
|
|| ((cdc->tx_buf_ptr_in + 1) & (USBD_CDC_TX_DATA_SIZE - 1)) == cdc->tx_buf_ptr_out) {
|
|
|
|
usbd_cdc_try_tx(cdc);
|
2014-07-31 05:30:42 -04:00
|
|
|
// Wraparound of tick is taken care of by 2's complement arithmetic.
|
|
|
|
if (HAL_GetTick() - start >= timeout) {
|
|
|
|
// timeout
|
|
|
|
return i;
|
|
|
|
}
|
2015-06-07 18:48:07 -04:00
|
|
|
if (query_irq() == IRQ_STATE_DISABLED) {
|
|
|
|
// IRQs disabled so buffer will never be drained; return immediately
|
|
|
|
return i;
|
|
|
|
}
|
2014-07-31 05:30:42 -04:00
|
|
|
__WFI(); // enter sleep mode, waiting for interrupt
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write data to device buffer
|
2017-08-30 23:54:49 -04:00
|
|
|
cdc->tx_buf[cdc->tx_buf_ptr_in] = buf[i];
|
|
|
|
cdc->tx_buf_ptr_in = (cdc->tx_buf_ptr_in + 1) & (USBD_CDC_TX_DATA_SIZE - 1);
|
2014-07-31 05:30:42 -04:00
|
|
|
}
|
|
|
|
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
usbd_cdc_try_tx(cdc);
|
|
|
|
|
2014-07-31 05:30:42 -04:00
|
|
|
// Success, return number of bytes read
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Always write all of the data to the device tx buffer, even if the
|
|
|
|
// device is not connected, or if the buffer is full. Has a small timeout
|
|
|
|
// to wait for the buffer to be drained, in the case the device is connected.
|
2017-08-30 23:54:49 -04:00
|
|
|
void usbd_cdc_tx_always(usbd_cdc_itf_t *cdc, const uint8_t *buf, uint32_t len) {
|
2014-03-15 12:54:23 -04:00
|
|
|
for (int i = 0; i < len; i++) {
|
2014-04-16 10:51:27 -04:00
|
|
|
// If the CDC device is not connected to the host then we don't have anyone to receive our data.
|
|
|
|
// The device may become connected in the future, so we should at least try to fill the buffer
|
|
|
|
// and hope that it doesn't overflow by the time the device connects.
|
|
|
|
// If the device is not connected then we should go ahead and fill the buffer straight away,
|
|
|
|
// ignoring overflow. Otherwise, we should make sure that we have enough room in the buffer.
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
if (cdc->connect_state != USBD_CDC_CONNECT_STATE_DISCONNECTED) {
|
2014-04-16 10:51:27 -04:00
|
|
|
// If the buffer is full, wait until it gets drained, with a timeout of 500ms
|
|
|
|
// (wraparound of tick is taken care of by 2's complement arithmetic).
|
|
|
|
uint32_t start = HAL_GetTick();
|
2017-08-30 23:54:49 -04:00
|
|
|
while (((cdc->tx_buf_ptr_in + 1) & (USBD_CDC_TX_DATA_SIZE - 1)) == cdc->tx_buf_ptr_out && HAL_GetTick() - start <= 500) {
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
usbd_cdc_try_tx(cdc);
|
2015-06-07 18:48:07 -04:00
|
|
|
if (query_irq() == IRQ_STATE_DISABLED) {
|
|
|
|
// IRQs disabled so buffer will never be drained; exit loop
|
|
|
|
break;
|
|
|
|
}
|
2014-04-16 10:51:27 -04:00
|
|
|
__WFI(); // enter sleep mode, waiting for interrupt
|
|
|
|
}
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
2014-04-16 10:51:27 -04:00
|
|
|
|
2017-08-30 23:54:49 -04:00
|
|
|
cdc->tx_buf[cdc->tx_buf_ptr_in] = buf[i];
|
|
|
|
cdc->tx_buf_ptr_in = (cdc->tx_buf_ptr_in + 1) & (USBD_CDC_TX_DATA_SIZE - 1);
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
stm32/usbd_cdc_interface: Refactor USB CDC tx code to not use SOF IRQ.
Prior to this commit the USB CDC used the USB start-of-frame (SOF) IRQ to
regularly check if buffered data needed to be sent out to the USB host.
This wasted resources (CPU, power) if no data needed to be sent.
This commit changes how the USB CDC transmits buffered data:
- When new data is first available to send the data is queued immediately
on the USB IN endpoint, ready to be sent as soon as possible.
- Subsequent additions to the buffer (via usbd_cdc_try_tx()) will wait.
- When the low-level USB driver has finished sending out the data queued
in the USB IN endpoint it calls usbd_cdc_tx_ready() which immediately
queues any outstanding data, waiting for the next IN frame.
The benefits on this new approach are:
- SOF IRQ does not need to run continuously so device has a better chance
to sleep for longer, and be more responsive to other IRQs.
- Because SOF IRQ is off, current consumption is reduced by a small amount,
roughly 200uA when USB is connected (measured on PYBv1.0).
- CDC tx throughput (USB IN) on PYBv1.0 is about 2.3 faster (USB OUT is
unchanged).
- When USB is connected, Python code that is executing is slightly faster
because SOF IRQ no longer interrupts continuously.
- On F733 with USB HS, CDC tx throughput is about the same as prior to this
commit.
- On F733 with USB HS, Python code is about 5% faster because of no SOF.
As part of this refactor, the serial port should no longer echo initial
characters when the serial port is first opened (this only used to happen
rarely on USB FS, but on USB HS is was more evident).
2018-10-15 00:35:10 -04:00
|
|
|
usbd_cdc_try_tx(cdc);
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
|
2014-07-31 05:30:42 -04:00
|
|
|
// Returns number of bytes in the rx buffer.
|
2017-08-30 23:54:49 -04:00
|
|
|
int usbd_cdc_rx_num(usbd_cdc_itf_t *cdc) {
|
|
|
|
int32_t rx_waiting = (int32_t)cdc->rx_buf_put - (int32_t)cdc->rx_buf_get;
|
2017-04-04 02:23:25 -04:00
|
|
|
if (rx_waiting < 0) {
|
2017-08-30 23:54:49 -04:00
|
|
|
rx_waiting += USBD_CDC_RX_DATA_SIZE;
|
2017-04-04 02:23:25 -04:00
|
|
|
}
|
2018-12-14 01:07:12 -05:00
|
|
|
usbd_cdc_rx_check_resume(cdc);
|
2017-04-04 02:23:25 -04:00
|
|
|
return rx_waiting;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
|
|
|
|
2014-07-31 05:30:42 -04:00
|
|
|
// timout in milliseconds.
|
|
|
|
// Returns number of bytes read from the device.
|
2017-08-30 23:54:49 -04:00
|
|
|
int usbd_cdc_rx(usbd_cdc_itf_t *cdc, uint8_t *buf, uint32_t len, uint32_t timeout) {
|
2014-07-31 05:30:42 -04:00
|
|
|
// loop to read bytes
|
|
|
|
for (uint32_t i = 0; i < len; i++) {
|
|
|
|
// Wait until we have at least 1 byte to read
|
|
|
|
uint32_t start = HAL_GetTick();
|
2017-08-30 23:54:49 -04:00
|
|
|
while (cdc->rx_buf_put == cdc->rx_buf_get) {
|
2014-07-31 05:30:42 -04:00
|
|
|
// Wraparound of tick is taken care of by 2's complement arithmetic.
|
|
|
|
if (HAL_GetTick() - start >= timeout) {
|
|
|
|
// timeout
|
|
|
|
return i;
|
|
|
|
}
|
2015-06-07 18:48:07 -04:00
|
|
|
if (query_irq() == IRQ_STATE_DISABLED) {
|
|
|
|
// IRQs disabled so buffer will never be filled; return immediately
|
|
|
|
return i;
|
|
|
|
}
|
2018-12-14 01:07:12 -05:00
|
|
|
usbd_cdc_rx_check_resume(cdc);
|
2014-07-31 05:30:42 -04:00
|
|
|
__WFI(); // enter sleep mode, waiting for interrupt
|
|
|
|
}
|
2014-03-15 12:54:23 -04:00
|
|
|
|
2014-07-31 05:30:42 -04:00
|
|
|
// Copy byte from device to user buffer
|
2017-08-30 23:54:49 -04:00
|
|
|
buf[i] = cdc->rx_user_buf[cdc->rx_buf_get];
|
|
|
|
cdc->rx_buf_get = (cdc->rx_buf_get + 1) & (USBD_CDC_RX_DATA_SIZE - 1);
|
2014-07-31 05:30:42 -04:00
|
|
|
}
|
2018-12-14 01:07:12 -05:00
|
|
|
usbd_cdc_rx_check_resume(cdc);
|
2014-03-23 14:54:48 -04:00
|
|
|
|
2014-07-31 05:30:42 -04:00
|
|
|
// Success, return number of bytes read
|
|
|
|
return len;
|
2014-03-15 12:54:23 -04:00
|
|
|
}
|
2018-05-27 20:46:49 -04:00
|
|
|
|
|
|
|
#endif
|