mbed_async_usbserial.cxx

Go to the documentation of this file.

 
#include "mbed.h"
#include "USBSerial.h"
#include "Serial.hxx"
#include "os/os.h"
#include "utils/macros.h"
#include "portmacro.h"
#include "utils/Atomic.hxx"
#include "executor/Notifiable.hxx"
 
#ifdef TARGET_LPC2368
#endif
 
#define TX_DATA_SIZE 64
#define RX_DATA_SIZE 64
 
#include <stdlib.h>
 
void *operator new(size_t size);
void *operator new[](size_t size);
void operator delete(void *ptr);
void operator delete[](void *ptr);
 
__extension__ typedef int __guard __attribute__((mode(__DI__)));
 
extern "C" int __cxa_guard_acquire(__guard *);
extern "C" void __cxa_guard_release(__guard *);
extern "C" void __cxa_guard_abort(__guard *);
extern "C" void __cxa_pure_virtual(void);
 
static Atomic critical_lock;
 
class MbedAsyncUSBSerial : public USBCDC, public ::NonBlockNode
{
public:
    MbedAsyncUSBSerial(const char *name, uint16_t vendor_id = 0x1f00,
        uint16_t product_id = 0x2012, uint16_t product_release = 0x0001)
        : USBCDC(vendor_id, product_id, product_release)
        , NonBlockNode(name)
        , overrunCount_(0)
        , txCount_(0)
        , rxBegin_(0)
        , rxEnd_(0)
        , txPending_(false)
        , rxPending_(false)
    {
    }
 
    ~MbedAsyncUSBSerial()
    {
    }
 
protected:
    bool EP2_OUT_callback() override
    {
        // HASSERT(IsEpPending());
        // and wake up the RX thread.
        rxPending_ = 1;
        if (readableNotify_)
        {
            readableNotify_->notify_from_isr();
            readableNotify_ = nullptr;
        }
        return false;
    }
 
    bool EP2_IN_callback() override
    {
        configASSERT(txPending_);
        TxHelper();
        if (writableNotify_)
        {
            writableNotify_->notify_from_isr();
            writableNotify_ = nullptr;
        }
        return true;
    }
 
private:
    void enable() OVERRIDE
    {
    }
    void disable() OVERRIDE
    {
    }
    void flush_buffers() OVERRIDE
    {
    }
 
    bool has_rx_buffer_data() OVERRIDE
    {
        return (rxPending_ || rxBegin_ < rxEnd_);
    }
 
    bool has_tx_buffer_space() OVERRIDE
    {
        return (!txPending_ || txCount_ < sizeof(txData_));
    }
 
    ssize_t read(File *file, void *buf, size_t count) OVERRIDE
    {
        uint8_t *rbuf = static_cast<uint8_t *>(buf);
        ssize_t result = 0;
        while (true)
        {
            {
                OSMutexLock l(&lock_);
                while (result < (int)count && rxBegin_ < rxEnd_)
                {
                    *rbuf++ = rxData_[rxBegin_++];
                    ++result;
                }
                if (rxBegin_ >= rxEnd_ && rxPending_)
                {
                    bool result = true;
                    {
                        AtomicHolder h(&critical_lock);
                        if (!rxPending_)
                        {
                            continue;
                        }
                        uint32_t rxSize = 0;
                        // we read the packet received to our assembly buffer
                        result = readEP_NB(rxData_, &rxSize);
                        rxPending_ = 0;
                        HASSERT(rxSize >= 0 && rxSize <= 255);
                        rxEnd_ = rxSize;
                        rxBegin_ = 0;
                    }
                    if (!result)
                    {
                        diewith(0x80000CCC);
                    }
                    continue;
                }
                if (result > 0)
                {
                    return result;
                }
            } // lock
            // Now: we have no data to give back.
            if (file->flags & O_NONBLOCK)
            {
                return result;
            }
            Notifiable *n = nullptr;
            {
                AtomicHolder h(&critical_lock);
                if (rxPending_ || rxBegin_ < rxEnd_)
                {
                    continue;
                }
                // Will be called at the end if non-null.
                n = readableNotify_;
                if (n == &readSync_)
                {
                    DIE("This serial driver does not support having multiple "
                        "threads execute blocking reads concurrently.");
                }
                readableNotify_ = &readSync_;
            }
            readSync_.wait_for_notification();
            if (n)
            {
                n->notify();
            }
        }
    }
 
    ssize_t write(File *file, const void *buf, size_t count) OVERRIDE
    {
        const uint8_t *wbuf = static_cast<const uint8_t *>(buf);
        ssize_t result = 0;
        while (true)
        {
            {
                OSMutexLock l(&lock_);
                {
                    AtomicHolder h(&critical_lock);
                    while (result < (int)count && txCount_ < sizeof(txData_))
                    {
                        txData_[txCount_++] = *wbuf++;
                        ++result;
                    }
                    if (txCount_ > 0 && !txPending_)
                    {
                        TxHelper();
                        continue;
                    }
                } // end atomic
            }     // end mutex
            // Now: we have either result == count or tx buffer full and still
            // having data to write.
            if (result > 0)
            {
                return result;
            }
            // Now: we couldn't yet write anything.
            if (file->flags & O_NONBLOCK)
            {
                return result;
            }
            // Now: let's wait for some space in the buffer to be available.
            Notifiable *n = nullptr;
            {
                AtomicHolder h(&critical_lock);
                if (txCount_ < sizeof(txData_) || !txPending_)
                {
                    continue;
                }
                Notifiable *n = writableNotify_;
                if (n == &writeSync_)
                {
                    DIE("This serial driver does not support having multiple "
                        "threads execute blocking writes concurrently.");
                }
                writableNotify_ = &writeSync_;
            }
            writeSync_.wait_for_notification();
            if (n)
            {
                n->notify();
            }
        } // while trying to write
    }
 
    static const int MAX_TX_PACKET_LENGTH = 64;
    static const int MAX_RX_PACKET_LENGTH = 64;
 
    void TxHelper()
    {
        if (!txCount_)
        {
            txPending_ = false;
            return;
        }
        if (!configured())
        {
            // An error occured, data was lost.
            txPending_ = false;
            overrunCount_ += txCount_;
            return;
        }
        txPending_ = true;
        sendNB(txData_, txCount_);
        txCount_ = 0;
    }
 
    unsigned overrunCount_;
    uint8_t txData_[MAX_TX_PACKET_LENGTH];
    uint8_t rxData_[MAX_RX_PACKET_LENGTH];
    uint8_t txCount_;
    uint8_t rxBegin_;
    uint8_t rxEnd_;
    uint8_t txPending_ : 1; 
    uint8_t rxPending_ : 1; 
    SyncNotifiable readSync_;
    SyncNotifiable writeSync_;
};
 
void *operator new(size_t size)
{
    return malloc(size);
}
 
void *operator new [](size_t size)
{ return malloc(size); } void
operator delete(void *ptr) noexcept(true)
{
    free(ptr);
}
 
void operator delete [](void *ptr) noexcept(true)
{ free(ptr); } int __cxa_guard_acquire(__guard *g)
{
    return !*(char *)(g);
};
void __cxa_guard_release(__guard *g)
{
    *(char *)g = 1;
};
void __cxa_guard_abort(__guard *) {};
 
void __cxa_pure_virtual(void)
{
    configASSERT(0);
};
 
MbedAsyncUSBSerial g_mbed_usb_serial("/dev/serUSB0");