Serial: Tx use FIFO plus fixes

This is a reasonably major update to the Serial(UART)
code base, which is mostly concentrated on the Output(TX)
side of it.

Simple part of the description:
The currently released code, did not use the FIFO object that
was built into the Serial object.  Instead it would output one
character at a time and then wait for a callback from the lower
level code base, which could be TDRE or TEND (mostly likely TDRE)
before it would return from the call.  There were several other
methods that did not work or were not implemented including:
flush(), availableForWrite().

Also the write with buffer and count did not work as it did
not have the same parameters as the one in the Print class, so
the print class simply enumerated each byte.

**More Complex stuff:**
**Write Call**
I added a 16 byte buffer to the UART class that I use to pass down to
the R_SCI_UART_Write calls, with as much data as I have up to 16 from the
write method if a write is not currently in process. If not active and
the FIFO is empty. I detect that and bypass using FIFO up to the first
16 characters.  If write is active, the new data is added to the FIFO.

**UART_EVENT_TX_DATA_EMPTY**
Note: I mention TDRE here, but also cases for FIFO which are different.
When lower level completes the write, it will do a callback with the
event: UART_EVENT_TX_DATA_EMPTY.  First try was to simply grab what is
available up to 16 bytes and recall R_SCI_UART_Write with that.  But that
can lose data, as the callback is called when the ISR code has put the last
byte into the TDR register, and the Write call always tries to put the first
character out, which if the TDRE state is not set, will lose the last byte.
Found I needed to handle two cases:
1) If TDRE I call the write function again.
2) if not TDRE, I update the Buffer/count member variables and reset which interrupt
events which will happen.

**TIMING**
I was still running into conditions where either data was lost or the transfers did
not work correctly.

RingBuffer:
Found in several cases we were spending too much time in the ISR and
we could lose interrupts on either UARTS or the same UARTS but different Interrupt.
Found a lot of the time was spent in the SafeRingBufferN code, where it creates a class object
which disables all interrupts and maybe reenables them at the end.  This is needed as the API/
RingBufferN code is inherently unsafe to use here.  I created my own versions of these classes
that make the RingBuffer class safer such that the Safe version could be a minimal subset.
That decreased the overhead a lot.

FIFO Size:
When using one of the UARTS with FIFO, we filled the RX before any was returned. So the ISR might need to process 16 characters, which took awhile.  I have it currently set to 8.  I
updated all of the Variants to allow each to set their preference.

**RX**
As mentioned above, when we receive bytes and the ISR is triggered, it calls our callback with
the UART_EVENT_RX_CHAR event.  For simple double buffer UARTS, we simply store one character away.

However for FIFO UARTS, it will callback to us one time for each character in the FIFO.  Which
 before took a lot of time. As for character it would setup the callback, call it, where we
 disabled the interrupts...

The new cod instead extracts the remaining characters from the FIFO and stuffs them directly
back into our fifo queue.

To keep from having to look each time at, am I running on a FIFO queue or not, I have two
 different callbacks, so they don't have to keep asking.

**DEBUG CODE**
Currently I have a fair amount of debug code built into the Serial class, to help
debug, including fast functions to set/clear/toggle digital pins as well as to maybe
save some state information.  I have hopefully all of this under #ifdef

Author: KurtE

cores/arduino/FasterSafeRingBuffer.h

@@ -0,0 +1,196 @@
+/*
+  Copyright (c) 2020 Arduino.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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 Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifdef __cplusplus
+
+#ifndef _FASTER_SAFE_RING_BUFFER_
+#define _FASTER_SAFE_RING_BUFFER_
+#include "sync.h"
+
+
+// Note: Below is a modified version of the RingBuffer.h, that removes the
+// count member variable, such that the producer and consumer don't need to
+// modify the same members.  Allows one or both of them to run without needing
+// to disable interrupts for reading and writing members.
+
+// Define constants and variables for buffering incoming serial data.  We're
+// using a ring buffer (I think), in which head is the index of the location
+// to which to write the next incoming character and tail is the index of the
+// location from which to read.
+namespace arduino {
+
+#define SERIAL_BUFFER_SIZE 64
+
+template <int N>
+class SaferRingBufferN
+{
+  public:
+    uint8_t _aucBuffer[N] ;
+    volatile int _iHead ;
+    volatile int _iTail ;
+
+  public:
+    SaferRingBufferN( void ) ;
+    void store_char( uint8_t c ) ;
+    void clear();
+    int read_char();
+    int available();
+    int availableForStore();
+    int peek();
+    bool isFull();
+
+  private:
+    int nextIndex(int index);
+    inline bool isEmpty() const { return (_iHead == _iTail); }
+};
+
+typedef SaferRingBufferN<SERIAL_BUFFER_SIZE> SaferRingBuffer;
+
+
+template <int N>
+SaferRingBufferN<N>::SaferRingBufferN( void )
+{
+    memset( _aucBuffer, 0, N ) ;
+    clear();
+}
+
+template <int N>
+void SaferRingBufferN<N>::store_char( uint8_t c )
+{
+  // 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.
+  int newhead = nextIndex(_iHead);
+  if (newhead != _iTail)
+  {
+    _aucBuffer[_iHead] = c ;
+    _iHead = newhead;
+  }
+}
+
+template <int N>
+void SaferRingBufferN<N>::clear()
+{
+  _iHead = 0;
+  _iTail = 0;
+}
+
+template <int N>
+int SaferRingBufferN<N>::read_char()
+{
+  if (_iHead == _iTail)
+    return -1;
+
+  uint8_t value = _aucBuffer[_iTail];
+  _iTail = nextIndex(_iTail);
+
+  return value;
+}
+
+template <int N>
+int SaferRingBufferN<N>::available()
+{
+  // grab state of head and tail, to keep result consistent 
+  int head = _iHead;
+  int tail = _iTail;
+
+  if (head >= tail) 
+    return head - tail;
+  return N + head - tail;
+}
+
+template <int N>
+int SaferRingBufferN<N>::availableForStore()
+{
+  // grab state of head and tail, to keep result consistent 
+  int head = _iHead;
+  int tail = _iTail;
+  if (head >= tail) return N - 1 - head + tail;
+  return tail - head - 1;
+}
+
+template <int N>
+int SaferRingBufferN<N>::peek()
+{
+  if (isEmpty())
+    return -1;
+
+  return _aucBuffer[_iTail];
+}
+
+template <int N>
+int SaferRingBufferN<N>::nextIndex(int index)
+{
+  return (uint32_t)(index + 1) % N;
+}
+
+template <int N>
+bool SaferRingBufferN<N>::isFull()
+{
+  int newhead = nextIndex(_iHead);
+  return  (newhead == _iTail);
+}
+
+///////////////////////////////////
+
+// Protect writes for potential multiple writers 
+template <int N>
+class FasterSafeWriteRingBufferN : public SaferRingBufferN<N>
+{
+  public:
+    void store_char( uint8_t c ) ;
+};
+
+typedef FasterSafeWriteRingBufferN<SERIAL_BUFFER_SIZE> FasterSafeWriteRingBuffer;
+
+
+template <int N>
+void FasterSafeWriteRingBufferN<N>::store_char(uint8_t c) {
+  synchronized {
+    SaferRingBufferN<N>::store_char(c);
+  }
+}
+
+template <int N>
+class FasterSafeReadRingBufferN : public SaferRingBufferN<N>
+{
+  public:
+    int read_char();
+};
+
+typedef FasterSafeReadRingBufferN<SERIAL_BUFFER_SIZE> FasterSafeReadRingBuffer;
+
+template <int N>
+int FasterSafeReadRingBufferN<N>::read_char() {
+  synchronized {
+    return SaferRingBufferN<N>::read_char();
+  }
+
+  // We should never reached this line because the synchronized {} block gets
+  // executed at least once. However the compiler gets confused and prints a
+  // warning about control reaching the end of a non-void function. This
+  // silences that warning.
+  return -1;
+}
+
+
+}
+
+#endif /* _SAFE_RING_BUFFER_ */
+#endif /* __cplusplus */

cores/arduino/IRQManager.cpp

@@ -12,6 +12,7 @@
 #define SDCARD_CARD_PRIORITY       12
 #define EXTERNAL_PIN_PRIORITY      12
 #define UART_SCI_PRIORITY          12
+#define UART_SCI_RX_PRIORITY       10
 #define USB_PRIORITY               12
 #define AGT_PRIORITY               14
 #define RTC_PRIORITY               12
@@ -487,14 +488,14 @@ bool IRQManager::addPeripheral(Peripheral_t p, void *cfg) {
             last_interrupt_index++;
 
             /* RX interrupt */
-            p_cfg->rxi_ipl = UART_SCI_PRIORITY;
+            p_cfg->rxi_ipl = UART_SCI_RX_PRIORITY;
             p_cfg->rxi_irq = (IRQn_Type)last_interrupt_index;
             *(irq_ptr + last_interrupt_index) = (uint32_t)sci_uart_rxi_isr;
             set_sci_rx_link_event(last_interrupt_index, p_cfg->channel);
             last_interrupt_index++;
 
             /* RX-ERROR interrupt */
-            p_cfg->eri_ipl = UART_SCI_PRIORITY;
+            p_cfg->eri_ipl = UART_SCI_RX_PRIORITY;
             p_cfg->eri_irq = (IRQn_Type)last_interrupt_index;
             *(irq_ptr + last_interrupt_index) = (uint32_t)sci_uart_eri_isr;
             set_sci_eri_link_event(last_interrupt_index, p_cfg->channel);
@@ -1659,7 +1660,7 @@ void IRQManager::set_can_tx_link_event(int li, int ch)
 #endif
 }
 
-void IRQManager::set_canfd_error_link_event(int li, int ch)
+void IRQManager::set_canfd_error_link_event(__attribute__((unused)) int li, __attribute__((unused)) int ch)
 {
   if (0) {}
 #ifdef ELC_EVENT_CAN0_CHERR
@@ -1674,7 +1675,7 @@ void IRQManager::set_canfd_error_link_event(int li, int ch)
 #endif
 }
 
-void IRQManager::set_canfd_rx_link_event(int li, int ch)
+void IRQManager::set_canfd_rx_link_event(__attribute__((unused)) int li, __attribute__((unused)) int ch)
 {
   if (0) {}
 #ifdef ELC_EVENT_CAN0_COMFRX
@@ -1689,7 +1690,7 @@ void IRQManager::set_canfd_rx_link_event(int li, int ch)
 #endif
 }
 
-void IRQManager::set_canfd_tx_link_event(int li, int ch)
+void IRQManager::set_canfd_tx_link_event(__attribute__((unused)) int li, __attribute__((unused)) int ch)
 {
   if (0) {}
 #ifdef ELC_EVENT_CAN0_TX