From 048fc9694c100715cdb4003522c8dacc227b5ace Mon Sep 17 00:00:00 2001 From: Scott Shawcroft Date: Fri, 4 Jan 2019 18:27:00 -0800 Subject: Split out txbuf and add unit test. --- src/class/midi/midi_device.c | 82 +++------------------- src/common/tusb_txbuf.c | 159 +++++++++++++++++++++++++++++++++++++++++++ src/common/tusb_txbuf.h | 83 ++++++++++++++++++++++ 3 files changed, 250 insertions(+), 74 deletions(-) create mode 100644 src/common/tusb_txbuf.c create mode 100644 src/common/tusb_txbuf.h (limited to 'src') diff --git a/src/class/midi/midi_device.c b/src/class/midi/midi_device.c index 5acc0b0f1..9850ce251 100644 --- a/src/class/midi/midi_device.c +++ b/src/class/midi/midi_device.c @@ -46,6 +46,7 @@ //--------------------------------------------------------------------+ #include "midi_device.h" #include "class/audio/audio.h" +#include "common/tusb_txbuf.h" #include "device/usbd_pvt.h" //--------------------------------------------------------------------+ @@ -68,11 +69,8 @@ typedef struct // This is a ring buffer that aligns to word boundaries so that it can be transferred directly to // the USB peripheral. There are three states to the data: free, transmitting and pending. - CFG_TUSB_MEM_ALIGN uint8_t tx_buf[CFG_TUD_MIDI_TX_BUFSIZE]; - uint16_t tx_buf_len; - uint16_t first_free; - uint16_t pending_count; - uint16_t transmitting_count; + CFG_TUSB_MEM_ALIGN uint8_t raw_tx_buffer[CFG_TUD_MIDI_TX_BUFSIZE]; + tu_txbuf_t txbuf; // We need to pack messages into words before queueing their transmission so buffer across write // calls. @@ -149,65 +147,6 @@ void midi_rx_done_cb(midid_interface_t* midi, uint8_t const* buffer, uint32_t bu // WRITE API //--------------------------------------------------------------------+ -uint16_t maybe_transmit(midid_interface_t* midi) { - if (midi->transmitting_count > 0 || midi->pending_count == 0) { - return 0; - } - midi->transmitting_count = midi->pending_count; - uint16_t transmit_start_index; - // The pending zone wraps back to the end so we must do two transfers. - if (midi->pending_count > midi->first_free) { - midi->transmitting_count -= midi->first_free; - transmit_start_index = midi->tx_buf_len - midi->transmitting_count; - } else { - transmit_start_index = midi->first_free - midi->transmitting_count; - - // We are transmitting up to first free so ensure it's word aligned for the next transmit. - uint8_t over_aligned = midi->first_free % sizeof(size_t); - if (over_aligned != 0) { - midi->first_free = (midi->first_free + (sizeof(size_t) - midi->first_free)) % midi->tx_buf_len; - } - } - midi->pending_count -= midi->transmitting_count; - - uint8_t* tx_start = midi->tx_buf + transmit_start_index; - if (!dcd_edpt_xfer(0, midi->ep_in, tx_start, midi->transmitting_count)) { - return 0; - } - return midi->transmitting_count; -} - -uint32_t tud_tx_buf_write_done_cb(midid_interface_t* midi, uint32_t bufsize) { - midi->transmitting_count -= bufsize; - - uint16_t len = maybe_transmit(midi); - return len; -} - -uint32_t tud_tx_buf_write(midid_interface_t* midi, uint8_t const* buffer, uint32_t bufsize) { - uint32_t len; - int32_t last_free = midi->first_free - midi->pending_count - midi->transmitting_count; - if (last_free < 0) { - len = (last_free + midi->tx_buf_len) - midi->first_free; - } else { - len = midi->tx_buf_len - midi->first_free; - } - if (bufsize < len) { - len = bufsize; - } - memcpy(midi->tx_buf + midi->first_free, buffer, len); - // uint32_t remaining_bytes - // if (last_free > 0 && len < bufsize) { - // if () - // - // } - midi->first_free = (midi->first_free + len) % midi->tx_buf_len; - midi->pending_count += len; - - maybe_transmit(midi); - return len; -} - uint32_t tud_midi_n_write(uint8_t itf, uint8_t jack_id, uint8_t const* buffer, uint32_t bufsize) { midid_interface_t* midi = &_midid_itf[itf]; @@ -265,7 +204,7 @@ uint32_t tud_midi_n_write(uint8_t itf, uint8_t jack_id, uint8_t const* buffer, u } if (midi->message_buffer_length == midi->message_target_length) { - tud_tx_buf_write(midi, midi->message_buffer, 4); + tu_txbuf_write_n(&midi->txbuf, midi->message_buffer, 4); midi->message_buffer_length = 0; } i++; @@ -291,10 +230,7 @@ void midid_init(void) tu_fifo_config_mutex(&midi->rx_ff, osal_mutex_create(&midi->rx_ff_mutex)); #endif - midi->tx_buf_len = CFG_TUD_MIDI_TX_BUFSIZE; - midi->first_free = 0; - midi->pending_count = 0; - midi->transmitting_count = 0; + tu_txbuf_config(&midi->txbuf, midi->raw_tx_buffer, CFG_TUD_MIDI_TX_BUFSIZE, dcd_edpt_xfer); } } @@ -307,10 +243,7 @@ void midid_reset(uint8_t rhport) midid_interface_t* midi = &_midid_itf[i]; tu_memclr(midi, ITF_MEM_RESET_SIZE); tu_fifo_clear(&midi->rx_ff); - midi->tx_buf_len = CFG_TUD_MIDI_TX_BUFSIZE; - midi->first_free = 0; - midi->pending_count = 0; - midi->transmitting_count = 0; + tu_txbuf_clear(&midi->txbuf); } } @@ -356,6 +289,7 @@ bool midid_open(uint8_t rhport, tusb_desc_interface_t const * p_interface_desc, uint8_t ep_addr = ((tusb_desc_endpoint_t const *) p_desc)->bEndpointAddress; if (tu_edpt_dir(ep_addr) == TUSB_DIR_IN) { p_midi->ep_in = ep_addr; + tu_txbuf_set_ep_addr(&p_midi->txbuf, ep_addr); } else { p_midi->ep_out = ep_addr; } @@ -401,7 +335,7 @@ bool midid_xfer_cb(uint8_t rhport, uint8_t edpt_addr, xfer_result_t result, uint // prepare for next TU_ASSERT( dcd_edpt_xfer(rhport, p_midi->ep_out, p_midi->epout_buf, CFG_TUD_MIDI_EPSIZE), false ); } else if ( edpt_addr == p_midi->ep_in ) { - tud_tx_buf_write_done_cb(p_midi, xferred_bytes); + tu_txbuf_transmit_done_cb(&p_midi->txbuf, xferred_bytes); } // nothing to do with in and notif endpoint diff --git a/src/common/tusb_txbuf.c b/src/common/tusb_txbuf.c new file mode 100644 index 000000000..de1bbe49b --- /dev/null +++ b/src/common/tusb_txbuf.c @@ -0,0 +1,159 @@ +/**************************************************************************/ +/*! + @file tusb_txbuf.c + @author Scott Shawcroft + + @section LICENSE + + Software License Agreement (BSD License) + + Copyright (c) 2018, Scott Shawcroft + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the copyright holders nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + This file is part of the tinyusb stack. + */ +/**************************************************************************/ +#include +#include + +#include "tusb_txbuf.h" + +bool tu_txbuf_config(tu_txbuf_t *txbuf, uint8_t* buffer, uint16_t buffer_length, edpt_xfer xfer) +{ + txbuf->buffer = (uint8_t*) buffer; + txbuf->buf_len = buffer_length; + txbuf->first_free = 0; + txbuf->pending_count = 0; + txbuf->transmitting_count = 0; + txbuf->xfer = xfer; + txbuf->padding = 0; + + return true; +} + +uint16_t maybe_transmit(tu_txbuf_t* buf) { + if (buf->transmitting_count > 0 || buf->pending_count == 0) { + return 0; + } + buf->transmitting_count = buf->pending_count; + uint16_t transmit_start_index; + uint8_t over_aligned = 0; + // The pending zone wraps back to the end so we must do two transfers. + if (buf->pending_count > buf->first_free) { + buf->transmitting_count -= buf->first_free; + transmit_start_index = buf->buf_len - buf->transmitting_count; + } else { + transmit_start_index = buf->first_free - buf->transmitting_count; + + // We are transmitting up to first free so ensure it's word aligned for the next transmit. + over_aligned = buf->first_free % sizeof(uint32_t); + buf->padding = sizeof(uint32_t) - over_aligned; + if (over_aligned != 0) { + buf->first_free = (buf->first_free + buf->padding) % buf->buf_len; + } + } + buf->pending_count -= buf->transmitting_count; + + uint8_t* tx_start = buf->buffer + transmit_start_index; + if (!buf->xfer(0, buf->ep_addr, tx_start, buf->transmitting_count)) { + return 0; + } + return buf->transmitting_count; +} + +uint32_t tu_txbuf_transmit_done_cb(tu_txbuf_t* buf, uint32_t bufsize) { + buf->transmitting_count -= bufsize; + + return maybe_transmit(buf); +} + +/******************************************************************************/ +/*! + @brief This function will write n elements into the array index specified by + the write pointer and increment the write index. If the write index + exceeds the max buffer size, then it will roll over to zero. + + @param[in] f + Pointer to the FIFO buffer to manipulate + @param[in] p_data + The pointer to data to add to the FIFO + @param[in] count + Number of element + @return Number of written elements +*/ +/******************************************************************************/ +uint16_t tu_txbuf_write_n(tu_txbuf_t* txbuf, uint8_t const* buffer, uint32_t bufsize) { + uint32_t len; + int32_t last_free = txbuf->first_free - txbuf->pending_count - txbuf->transmitting_count - txbuf->padding; + if (last_free < 0) { + last_free += txbuf->buf_len; + len = last_free - txbuf->first_free; + } else { + len = txbuf->buf_len - txbuf->first_free; + } + if (bufsize < len) { + len = bufsize; + } + memcpy(txbuf->buffer + txbuf->first_free, buffer, len); + txbuf->first_free = (txbuf->first_free + len) % txbuf->buf_len; + txbuf->pending_count += len; + // Try to transmit now while we wrap the rest. + maybe_transmit(txbuf); + uint32_t remaining_bytes = bufsize - len; + if (remaining_bytes > 0 && last_free != txbuf->first_free) { + uint32_t second_len = remaining_bytes; + if (second_len > (uint32_t) last_free + 1) { + second_len = last_free + 1; + } + memcpy(txbuf->buffer, buffer + len, second_len); + txbuf->first_free = (txbuf->first_free + second_len) % txbuf->buf_len; + txbuf->pending_count += second_len; + len += second_len; + } + + return len; +} + +void tu_txbuf_set_ep_addr(tu_txbuf_t* txbuf, uint8_t ep_addr) { + txbuf->ep_addr = ep_addr; +} + +/******************************************************************************/ +/*! + @brief Clear the txbuf including any currently transmitting data. + + @param[in] t + Pointer to the txbuf to manipulate +*/ +/******************************************************************************/ +bool tu_txbuf_clear(tu_txbuf_t *txbuf) +{ + + txbuf->first_free = 0; + txbuf->pending_count = 0; + txbuf->transmitting_count = 0; + + return true; +} diff --git a/src/common/tusb_txbuf.h b/src/common/tusb_txbuf.h new file mode 100644 index 000000000..88d48ecac --- /dev/null +++ b/src/common/tusb_txbuf.h @@ -0,0 +1,83 @@ +/**************************************************************************/ +/*! + @file tusb_txbuf.h + @author Scott Shawcroft + + @section LICENSE + + Software License Agreement (BSD License) + + Copyright (c) 2018, Scott Shawcroft + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the copyright holders nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY + DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + This file is part of the tinyusb stack. +*/ +/**************************************************************************/ + +/** \ingroup Group_Common + * \defgroup group_txbuf txbuf + * @{ */ + +#ifndef _TUSB_TXBUF_H_ +#define _TUSB_TXBUF_H_ + +#include +#include + +#ifdef __cplusplus + extern "C" { +#endif + +typedef bool (*edpt_xfer) (uint8_t rhport, uint8_t ep_addr, uint8_t* buffer, uint16_t total_bytes); + + +/** \struct tu_txbuf_t + * \brief Circular transmit buffer that manages USB transfer memory. It is not threadsafe and is + * only meant for use in the main task. + */ +typedef struct +{ + uint8_t* buffer ; ///< buffer pointer + uint16_t buf_len; + uint16_t first_free; + uint16_t pending_count; + uint16_t transmitting_count; + uint16_t padding; + uint8_t ep_addr; + edpt_xfer xfer; +} tu_txbuf_t; + +bool tu_txbuf_clear(tu_txbuf_t *f); +bool tu_txbuf_config(tu_txbuf_t *f, uint8_t* buffer, uint16_t depth, edpt_xfer xfer); + +uint16_t tu_txbuf_write_n (tu_txbuf_t* txbuf, uint8_t const * buffer, uint32_t length); +void tu_txbuf_set_ep_addr(tu_txbuf_t* txbuf, uint8_t ep_addr); +uint32_t tu_txbuf_transmit_done_cb(tu_txbuf_t* buf, uint32_t bufsize); + +#ifdef __cplusplus + } +#endif + +#endif /* _TUSB_TXBUF_H_ */ -- cgit v1.3.1