cores/arduino/CDCSerialClass.cpp

@@ -30,12 +30,35 @@
 #include "wiring_digital.h"
 #include "variant.h"
 
-#define CDCACM_FIXED_DELAY     64
+#define CDC_MAILBOX_TX_CHANNEL  7
+#define CDC_MAILBOX_RX_CHANNEL  6
 
 extern void CDCSerial_Handler(void);
 extern void serialEventRun1(void) __attribute__((weak));
 extern void serialEvent1(void) __attribute__((weak));
 
+static void cdc_mbox_isr(CurieMailboxMsg msg)
+{
+    char *rxbuffptr = (char*)msg.data;
+    int new_head;
+    for(int i = 0; i < MBOX_BYTES; i++)
+    {
+        if((uint8_t)(*(rxbuffptr+i)) != '\0')
+        {
+            new_head = (Serial._rx_buffer->head +1) % CDCACM_BUFFER_SIZE;
+            if(new_head != Serial._rx_buffer->tail)
+            {
+                Serial._rx_buffer->data[Serial._rx_buffer->head] = *(rxbuffptr+i);
+                Serial._rx_buffer->head = new_head;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+}
+
 // Constructors ////////////////////////////////////////////////////////////////
 
 CDCSerialClass::CDCSerialClass(uart_init_info *info)
@@ -47,9 +70,9 @@ CDCSerialClass::CDCSerialClass(uart_init_info *info)
 
 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;
+    _shared_data = cdc_acm_shared_data;
+    _rx_buffer = cdc_acm_shared_data->rx_buffer;
+    _tx_buffer = cdc_acm_shared_data->tx_buffer;
 }
 
 void CDCSerialClass::begin(const uint32_t dwBaudRate)
@@ -63,8 +86,13 @@ void CDCSerialClass::begin(const uint32_t dwBaudRate, const uint8_t config)
 }
 
 
-void CDCSerialClass::init(const uint32_t dwBaudRate, const uint8_t modeReg)
+void CDCSerialClass::init(uint32_t dwBaudRate, const uint8_t modeReg)
 {
+    /* Set a max internal baud rate due to the limitation of the 
+     * Inter Processor Mailbox */
+     if(dwBaudRate > 115200)
+         dwBaudRate = 115200;
+
     /* 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;
@@ -73,7 +101,9 @@ void CDCSerialClass::init(const uint32_t dwBaudRate, const uint8_t modeReg)
      * Empty the Rx buffer but don't touch Tx buffer: it is drained by the
      * LMT one way or another */
     _rx_buffer->tail = _rx_buffer->head;
-
+
+    mailbox_register(CDC_MAILBOX_RX_CHANNEL, cdc_mbox_isr);
+    mailbox_enable_receive(CDC_MAILBOX_RX_CHANNEL);
     _shared_data->device_open = true;
 }
 
@@ -84,12 +114,10 @@ void CDCSerialClass::end( void )
 
 int CDCSerialClass::available( void )
 {
-#define SBS	CDCACM_BUFFER_SIZE
-
   if (!_shared_data->device_open)
     return (0);
   else
-    return (int)(SBS + _rx_buffer->head - _rx_buffer->tail) % SBS;
+    return (int)(CDCACM_BUFFER_SIZE + _rx_buffer->head - _rx_buffer->tail) % CDCACM_BUFFER_SIZE;
 }
 
 int CDCSerialClass::availableForWrite(void)
@@ -131,28 +159,61 @@ void CDCSerialClass::flush( void )
     }
 }
 
-size_t CDCSerialClass::write( const uint8_t uc_data )
+size_t CDCSerialClass::write(uint8_t uc_data )
 {
-    uint32_t retries = 2;
+    CurieMailboxMsg cdcacm_msg;
 
     if (!_shared_data->device_open || !_shared_data->host_open)
         return(0);
 
-    do {
-        int i = (uint32_t)(_tx_buffer->head + 1) % CDCACM_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;
-
-	    // Just use a fixed delay to make it compatible with the CODK-M based firmware
-	    delayMicroseconds(CDCACM_FIXED_DELAY);
-            break;
+    cdcacm_msg.channel = CDC_MAILBOX_TX_CHANNEL;
+    cdcacm_msg.data[0] = uc_data;
+    mailbox_write(cdcacm_msg);
+    delayMicroseconds(_writeDelayUsec);
+    return 1;
+}
+
+size_t CDCSerialClass::write(const uint8_t *buffer, size_t size)
+{
+    CurieMailboxMsg cdcacm_msg;
+     cdcacm_msg.channel = CDC_MAILBOX_TX_CHANNEL;
+    if (!_shared_data->device_open || !_shared_data->host_open)
+        return(0);
+
+    int msg_len = size;
+
+    for(int i = 0;msg_len > 0; msg_len -= MBOX_BYTES, i += MBOX_BYTES)
+    {
+        /* Copy data into mailbox message */
+        memset(cdcacm_msg.data, 0, MBOX_BYTES);
+        if(msg_len >= MBOX_BYTES)
+        {
+            memcpy(cdcacm_msg.data, buffer+i, MBOX_BYTES);
         }
-    } while (retries--);
+        else
+        {
+            memcpy(cdcacm_msg.data, buffer+i, msg_len);
+        }
+        /* Write to mailbox*/
+        mailbox_write(cdcacm_msg);
+    }
 
-    return 1;
+    // Mimick the throughput of a typical UART by throttling the data
+    // flow according to the configured baud rate  
+    delayMicroseconds(_writeDelayUsec * size);
+
+    return size;
+}
+
+size_t CDCSerialClass::write(const char *str)
+{
+    if (str == NULL) return 0;
+    CurieMailboxMsg cdcacm_msg;
+     cdcacm_msg.channel = CDC_MAILBOX_TX_CHANNEL;
+    if (!_shared_data->device_open || !_shared_data->host_open)
+        return(0);
+
+    int msg_len = strlen(str);
+
+    return write((const uint8_t *)str, msg_len);
 }

cores/arduino/CDCSerialClass.h

@@ -26,6 +26,7 @@
 #include "HardwareSerial.h"
 #include "platform.h"
 #include "wiring.h"
+#include "mailbox.h"
 
 #include <board.h>
 #include <uart.h>
@@ -36,6 +37,10 @@ class CDCSerialClass : public HardwareSerial
     CDCSerialClass(uart_init_info *info);
 
     void setSharedData(struct cdc_acm_shared_data *cdc_acm_shared_data);
+
+    struct cdc_acm_shared_data *_shared_data;
+    struct cdc_ring_buffer *_rx_buffer;
+    struct cdc_ring_buffer *_tx_buffer;
 
     void begin(const uint32_t dwBaudRate);
     void begin(const uint32_t dwBaudRate, const uint8_t config);
@@ -46,6 +51,8 @@ class CDCSerialClass : public HardwareSerial
     int read(void);
     void flush(void);
     size_t write(const uint8_t c);
+    size_t write(const char *str);
+    size_t write(const uint8_t *buffer, size_t size);
     using Print::write; // pull in write(str) and write(buf, size) from Print
 
     operator bool() {
@@ -56,11 +63,7 @@ class CDCSerialClass : public HardwareSerial
     };
 
   protected:
-    void init(const uint32_t dwBaudRate, const uint8_t config);
-
-    struct cdc_acm_shared_data *_shared_data;
-    struct cdc_ring_buffer *_rx_buffer;
-    struct cdc_ring_buffer *_tx_buffer;
+    void init(uint32_t dwBaudRate, const uint8_t config);
 
     uart_init_info *info;
     uint32_t _writeDelayUsec;

cores/arduino/Print.h

@@ -47,7 +47,7 @@ class Print
     void clearWriteError() { setWriteError(0); }
 
     virtual size_t write(uint8_t) = 0;
-    size_t write(const char *str) {
+    virtual size_t write(const char *str) {
       if (str == NULL) return 0;
       return write((const uint8_t *)str, strlen(str));
     }

cores/arduino/mailbox.cpp

@@ -0,0 +1,163 @@
+#include <string.h>
+#include "interrupt.h"
+#include "scss_registers.h"
+#include "mailbox.h"
+
+#define CHANNEL_STS_MASK            0x1
+#define CHANNEL_INT_MASK            0x2
+#define CTRL_WORD_MASK              0x7FFFFFFF
+#define CHALL_STATUS_MASK           0xFFFF
+#define CHANNEL_STS_BITS            (CHANNEL_STS_MASK | CHANNEL_INT_MASK)
+
+/* Mailbox channel status register */
+#define IO_REG_MAILBOX_CHALL_STS    (SCSS_REGISTER_BASE + 0xAC0)
+
+typedef struct mbox_channel mbox_channel_t;
+typedef struct mbox_intmask mbox_intmask_t;
+
+/* Represents the registers for a single mailbox channel */
+struct mbox_channel {
+    uint32_t ctrl;
+    uint32_t data[CHANNEL_DATA_WORDS];
+    uint32_t sts;
+};
+
+/* Mailbox interrupt mask; right now we only care about the
+ * second byte, for SS mailbox interrupts (one bit per mailbox channel) */
+struct mbox_intmask {
+    uint8_t lmt_intmask;
+    uint8_t ss_intmask;
+    uint8_t lmt_halt;
+    uint8_t ss_halt;
+};
+
+static volatile mbox_intmask_t *intmask;
+static volatile mbox_channel_t *mbox;
+static void (*callbacks[NUM_MAILBOX_CHANNELS])(CurieMailboxMsg);
+
+void mailbox_register (int channel, void(*callback)(CurieMailboxMsg))
+{
+    if (channel >= 0 && channel < NUM_MAILBOX_CHANNELS) {
+        callbacks[channel] = callback;
+    }
+}
+
+void mailbox_unregister (int channel)
+{
+    if (channel >= 0 && channel < NUM_MAILBOX_CHANNELS) {
+        callbacks[channel] = 0;
+    }
+}
+
+void mailbox_disable_receive (int channel)
+{
+    intmask->ss_intmask |= 1 << channel;
+}
+
+void mailbox_enable_receive (int channel)
+{
+    intmask->ss_intmask &= ~(1 << channel);
+}
+
+static void do_callback (int channel, CurieMailboxMsg& msg)
+{
+    void (*cb)(CurieMailboxMsg) = callbacks[channel];
+    if (cb) {
+        cb(msg);
+    }
+}
+
+static void mailbox_read (int channel, CurieMailboxMsg& msg)
+{
+    unsigned int i;
+
+    /* Copy channel data into CurieMailboxMsg object */
+    msg.id = mbox[channel].ctrl & CTRL_WORD_MASK;
+    msg.channel = channel;
+
+    for (i = 0; i < CHANNEL_DATA_WORDS; ++i) {
+        msg.data[i] = mbox[channel].data[i];
+    }
+
+    /* Clear channel status & interrupt flags */
+    mbox[channel].sts |= CHANNEL_STS_BITS;
+}
+
+void mailbox_write (CurieMailboxMsg& msg)
+{
+    int i;
+    uint32_t key;
+
+    /* Can't write if channel status flag is set */
+    while ((mbox[msg.channel].sts & CHANNEL_STS_MASK));
+    key = interrupt_lock();
+
+    /* Poplate channel payload */
+    mbox[msg.channel].ctrl |= (msg.id & CTRL_WORD_MASK);
+    for (i = 0; i < CHANNEL_DATA_WORDS; ++i) {
+        mbox[msg.channel].data[i] = msg.data[i];
+    }
+
+    /* Trigger interupt to host */
+    mbox[msg.channel].ctrl |= ~(CTRL_WORD_MASK);
+
+    /* Wait for HW to set the channel status bit */
+    while (!(mbox[msg.channel].sts & CHANNEL_STS_MASK));
+
+    /* Wait for destination processor to clear channel status bit */
+    while ((mbox[msg.channel].sts & CHANNEL_STS_MASK));
+    interrupt_unlock(key);
+}
+
+static uint16_t get_chall_sts (void)
+{
+    return MMIO_REG_VAL(IO_REG_MAILBOX_CHALL_STS) & CHALL_STATUS_MASK;
+}
+
+static void mailbox_isr (void)
+{
+    int i;
+    uint32_t sts;
+    CurieMailboxMsg msg;
+
+    sts = get_chall_sts();
+    /* Get channel number */
+    for (i = 0; i < NUM_MAILBOX_CHANNELS; ++i) {
+        if (sts & (1 << (i * 2 + 1))) {
+            break;
+        }
+    }
+
+    mailbox_read(i, msg);
+    do_callback(i, msg);
+}
+
+static void mailbox_hardware_init (void)
+{
+    int i;
+
+    for (i = 0; i < NUM_MAILBOX_CHANNELS; ++i) {
+        mbox[i].sts &= ~(CHANNEL_STS_BITS);
+    }
+}
+
+static void mailbox_interrupts_init (bool master)
+{
+    interrupt_disable(SOC_MBOX_INTERRUPT);
+
+   /* Mask SS mailbox interrupts for all channels;
+    * Unmasking is done by enableReceive */
+    intmask->ss_intmask = 0xFF;
+
+    if (master) mailbox_hardware_init();
+    interrupt_connect(SOC_MBOX_INTERRUPT, mailbox_isr);
+    interrupt_enable(SOC_MBOX_INTERRUPT);
+}
+
+void mailbox_init (bool master)
+{
+    intmask = (mbox_intmask_t *)IO_REG_MAILBOX_INT_MASK;
+    mbox = (mbox_channel_t *)IO_REG_MAILBOX_BASE;
+    memset(callbacks, 0, sizeof(callbacks));
+    mailbox_interrupts_init(master);
+}