CDC-ACM: move allocation of cdc-acm shared buffers to LMT

LMT shall now be responsible for allocating shared data buffers
used to exchange CDC-ACM data between ARC and LMT.

Defined a revised set of structures to allow the pointers to
be passed from LMT to ARC during initialisation.

NOTE THAT THIS DEPENDS ON A CORRESPONDING CHANGE IN THUNDERDOME
FIRMWARE

Signed-off-by: Dan O'Donovan <dan@emutex.com>

Author: Dan-Lightsource

cores/arduino/CDCSerialClass.cpp

@@ -37,16 +37,20 @@ extern void serialEvent1(void) __attribute__((weak));
 
 // Constructors ////////////////////////////////////////////////////////////////
 
-CDCSerialClass::CDCSerialClass( uart_init_info *info, RingBuffer *pRx_buffer,
-                        RingBuffer *pTx_buffer )
+CDCSerialClass::CDCSerialClass(uart_init_info *info)
 {
     this->info = info;
-    this->_rx_buffer = pRx_buffer;
-    this->_tx_buffer = pTx_buffer;
 }
 
 // Public Methods //////////////////////////////////////////////////////////////
 
+void CDCSerialClass::setSharedData(struct cdc_acm_shared_data *cdc_acm_shared_data)
+{
+    this->_shared_data = cdc_acm_shared_data;
+    this->_rx_buffer = cdc_acm_shared_data->rx_buffer;
+    this->_tx_buffer = cdc_acm_shared_data->tx_buffer;
+}
+
 void CDCSerialClass::begin(const uint32_t dwBaudRate)
 {
     begin(dwBaudRate, (uint8_t)SERIAL_8N1 );
@@ -55,37 +59,43 @@ void CDCSerialClass::begin(const uint32_t dwBaudRate)
 void CDCSerialClass::begin(const uint32_t dwBaudRate, const uint8_t config)
 {
     init(dwBaudRate, config );
-    opened = true;
 }
 
 
 void CDCSerialClass::init(const uint32_t dwBaudRate, const uint8_t modeReg)
 {
+    /* Set a per-byte write delay approximately equal to the time it would
+     * take to clock out a byte on a standard UART at this baud rate */
+    _writeDelayUsec = 8000000 / dwBaudRate;
+
     // Make sure both ring buffers are initialized back to empty.
-    _rx_buffer->_iHead = _rx_buffer->_iTail = 0;
-    _tx_buffer->_iHead = _tx_buffer->_iTail = 0;
+    _rx_buffer->head = _rx_buffer->tail = 0;
+    _tx_buffer->head = _tx_buffer->tail = 0;
+
+    _shared_data->device_open = true;
 }
 
 void CDCSerialClass::end( void )
 {
-    opened = false;
-    _rx_buffer->_iHead = 0;
-    _rx_buffer->_iTail = 0;
+    _shared_data->device_open = false;
+
+    _rx_buffer->head = 0;
+    _rx_buffer->tail = 0;
 }
 
 int CDCSerialClass::available( void )
 {
 #define SBS	SERIAL_BUFFER_SIZE
-    return (int)(SBS + _rx_buffer->_iHead - _rx_buffer->_iTail) % SBS;
+    return (int)(SBS + _rx_buffer->head - _rx_buffer->tail) % SBS;
 }
 
 int CDCSerialClass::availableForWrite(void)
 {
-    if (!opened)
+    if (!_shared_data->device_open || !_shared_data->host_open)
         return(0);
 
-    int head = _tx_buffer->_iHead;
-    int tail = _tx_buffer->_iTail;
+    int head = _tx_buffer->head;
+    int tail = _tx_buffer->tail;
 
     if (head >= tail)
         return SERIAL_BUFFER_SIZE - head + tail - 1;
@@ -94,37 +104,52 @@ int CDCSerialClass::availableForWrite(void)
 
 int CDCSerialClass::peek(void)
 {
-  if ( _rx_buffer->_iHead == _rx_buffer->_iTail )
+  if ( _rx_buffer->head == _rx_buffer->tail )
     return -1;
 
-  return _rx_buffer->_aucBuffer[_rx_buffer->_iTail];
+  return _rx_buffer->data[_rx_buffer->tail];
 }
 
 int CDCSerialClass::read( void )
 {
-  if ( _rx_buffer->_iHead == _rx_buffer->_iTail )
+  if ( _rx_buffer->head == _rx_buffer->tail )
     return -1;
 
-  uint8_t uc = _rx_buffer->_aucBuffer[_rx_buffer->_iTail];
-  _rx_buffer->_iTail = (_rx_buffer->_iTail + 1) % SERIAL_BUFFER_SIZE;
+  uint8_t uc = _rx_buffer->data[_rx_buffer->tail];
+  _rx_buffer->tail = (_rx_buffer->tail + 1) % SERIAL_BUFFER_SIZE;
   return uc;
 }
 
 void CDCSerialClass::flush( void )
 {
-    while (_tx_buffer->_iTail != _tx_buffer->_iHead) {
+    while (_tx_buffer->tail != _tx_buffer->head) {
 	    delayMicroseconds(1);
     }
 }
 
 size_t CDCSerialClass::write( const uint8_t uc_data )
 {
-    if (!opened)
+    uint32_t retries = 1;
+
+    if (!_shared_data->device_open || !_shared_data->host_open)
         return(0);
 
     do {
-        _tx_buffer->store_char(uc_data);
-    } while (_tx_buffer->_buffer_overflow);
+        int i = (uint32_t)(_tx_buffer->head + 1) % SERIAL_BUFFER_SIZE;
+        // if we should be storing the received character into the location
+        // just before the tail (meaning that the head would advance to the
+        // current location of the tail), we're about to overflow the buffer
+        // and so we don't write the character or advance the head.
+        if (i != _tx_buffer->tail) {
+            _tx_buffer->data[_tx_buffer->head] = uc_data;
+            _tx_buffer->head = i;
+
+	    // Mimick the throughput of a typical UART by throttling the data
+	    // flow according to the configured baud rate
+	    delayMicroseconds(_writeDelayUsec);
+            break;
+        }
+    } while (retries--);
 
     return 1;
 }

cores/arduino/CDCSerialClass.h

@@ -24,15 +24,17 @@
 #define _CFWSERIAL_CLASS_
 
 #include "HardwareSerial.h"
-#include "RingBuffer.h"
+#include "platform.h"
 
 #include <board.h>
 #include <uart.h>
 
 class CDCSerialClass : public HardwareSerial
 {
   public:
-    CDCSerialClass(uart_init_info *info, RingBuffer *pRx_buffer, RingBuffer *pTx_buffer );
+    CDCSerialClass(uart_init_info *info);
+
+    void setSharedData(struct cdc_acm_shared_data *cdc_acm_shared_data);
 
     void begin(const uint32_t dwBaudRate);
     void begin(const uint32_t dwBaudRate, const uint8_t config);
@@ -45,19 +47,18 @@ class CDCSerialClass : public HardwareSerial
     size_t write(const uint8_t c);
     using Print::write; // pull in write(str) and write(buf, size) from Print
 
-
-    operator bool() { return true; }; // CDCSerial always active
+    operator bool() { return (_shared_data && _shared_data->host_open); };
 
   protected:
     void init(const uint32_t dwBaudRate, const uint8_t config);
 
-    RingBuffer *_rx_buffer;
-    RingBuffer *_tx_buffer;
+    struct cdc_acm_shared_data *_shared_data;
+    struct cdc_ring_buffer *_rx_buffer;
+    struct cdc_ring_buffer *_tx_buffer;
 
     uart_init_info *info;
+    uint32_t _writeDelayUsec;
     uint32_t _dwId;
-    uint32_t opened;
-
 };
 
 #endif // _CDCSerial_CLASS_

system/libarc32_edu/framework/include/platform.h

@@ -39,14 +39,27 @@
 #define CPU_ID_HOST 3
 #define NUM_CPU     4
 
+#define SERIAL_BUFFER_SIZE 256
+
+struct cdc_ring_buffer
+{
+    /** Ring buffer data */
+    uint8_t data[SERIAL_BUFFER_SIZE];
+    /** Ring buffer head pointer, modified by producer */
+    int head;
+    /** Ring buffer head pointer, modified by consumer */
+    int tail;
+};
+
 struct cdc_acm_shared_data {
-    uint8_t * rx_buffer;
-    int	    * rx_head;
-    int	    * rx_tail;
-    uint8_t * tx_buffer;
-    int	    * tx_head;
-    int	    * tx_tail;
-    uint32_t	serial_buffer_size;
+    /** Ring buffer to pass CDC-ACM data from LMT to ARC */
+    struct cdc_ring_buffer *rx_buffer;
+    /** Ring buffer to pass CDC-ACM data from ARC to LMT */
+    struct cdc_ring_buffer *tx_buffer;
+    /** Boolean flag set by LMT when CDC-ACM host connection is opened */
+    int host_open;
+    /** Boolean flag set by ARC when CDC-ACM endpoint connection is opened */
+    int device_open;
 };
 
 /**
@@ -91,21 +104,9 @@ struct platform_shared_block_ {
 
     /* Pointer to shared structure used by CDC-ACM.
      *
-     * The ARC core is responsible for allocating memory and initialising the
+     * The QRK core is responsible for allocating memory and initialising the
      * pointers of this structure.
-     * The LMT core counts on ARC to find valid pointers in place.
-     *
-     * It embeds pointers to following:
-     *	    Rx Buffer and its Head and Tail
-     *	    Tx Buffer and its Head and Tail
-     *
-     * Tx Buffer =  buffer used by ARC to Send data out to CDC-ACM
-     * Rx Buffer = buffer used by LMT to put data read from CDC-ACM
-     *
-     * LMT updates:
-     *	    Rx Head index every time an acm_read and a rx_buffer write are
-     *	    successfully done.
-     *	    Tx Tail index when some bytes are queued to CDC-ACM.
+     * The ARC core counts on QRK to find valid pointers in place.
      */
     struct cdc_acm_shared_data	* cdc_acm_buffers;
 };

variants/intel_edu_x/variant.cpp

@@ -98,11 +98,9 @@ uint32_t sizeof_g_APinDescription;
 
 // Serial - CDC-ACM port
 
-RingBuffer rx_buffer_cdc;
-RingBuffer tx_buffer_cdc;
 uart_init_info info_cdc;
 
-CDCSerialClass Serial(&info_cdc, &rx_buffer_cdc, &tx_buffer_cdc);
+CDCSerialClass Serial(&info_cdc);
 
 void serialEvent() __attribute__((weak));
 void serialEvent() { }
@@ -219,28 +217,16 @@ void variantAdcInit(void)
 
 void initVariant( void )
 {
+    /* Initialise CDC-ACM shared buffers pointers, provided by LMT */
+    Serial.setSharedData(shared_data->cdc_acm_buffers);
+
     /* For now, lets enable clocks for all interfaces we need
      * TODO - Consider only enabling as needed later to reduce power consumption
      */
     variantGpioInit();
     variantPwmInit();
     variantAdcInit();
 
-    /* TODO: REMOVE ME! */
-    Serial1.begin(115200);
-
-    /* Initialise CDC-ACM shared buffers pointers */
-    shared_data->cdc_acm_buffers =
-	    (struct cdc_acm_shared_data *)malloc(sizeof(struct cdc_acm_shared_data));
-
-    shared_data->cdc_acm_buffers->rx_buffer = rx_buffer_cdc._aucBuffer;
-    shared_data->cdc_acm_buffers->rx_head   = &(rx_buffer_cdc._iHead);
-    shared_data->cdc_acm_buffers->rx_tail   = &(rx_buffer_cdc._iTail);
-    shared_data->cdc_acm_buffers->tx_buffer = tx_buffer_cdc._aucBuffer;
-    shared_data->cdc_acm_buffers->tx_head   = &(tx_buffer_cdc._iHead);
-    shared_data->cdc_acm_buffers->tx_tail   = &(tx_buffer_cdc._iTail);
-    shared_data->cdc_acm_buffers->serial_buffer_size	= SERIAL_BUFFER_SIZE;
-
     cfw_platform_init();
 }