usb.h

/* -*- mode: C; c-basic-offset: 4; intent-tabs-mode: nil -*-
 *
 * Sifteo SDK
 *
 * Copyright <c> 2013 Sifteo, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#pragma once
#ifdef NOT_USERSPACE
#   error This is a userspace-only header, not allowed by the current build.
#endif

#include <sifteo/abi.h>

namespace Sifteo {

class Usb {
public:

    static bool isConnected() {
        return _SYS_usb_isConnected();
    }
};


struct UsbPacket {
    _SYSUsbPacket sys;

    // Implicit conversions
    operator _SYSUsbPacket* () { return &sys; }
    operator const _SYSUsbPacket* () const { return &sys; }

    static unsigned capacity() {
        return _SYS_USB_PACKET_BYTES;
    }

    void clear() {
        resize(0);
        setType(0);
    }

    unsigned size() const {
        return sys.length;
    }

    void resize(unsigned bytes) {
        ASSERT(bytes <= capacity());
        sys.length = bytes;
    }

    bool empty() const {
        return size() == 0;
    }

    uint8_t *bytes() {
        return sys.bytes;
    }
    const uint8_t *bytes() const {
        return sys.bytes;
    }

    unsigned type() const {
        return sys.type;
    }

    void setType(unsigned type) {
        ASSERT(type <= 0xfffffff);
        sys.type = type;
    }
};


template < unsigned tCapacity >
struct UsbQueue {
    struct SysType {
        union {
            _SYSIoQueueHeader header;
            uint32_t header32;
        };
        _SYSUsbPacket packets[tCapacity + 1];
    } sys;

    // Implicit conversions
    operator _SYSUsbQueue* () { return reinterpret_cast<_SYSUsbQueue*>(&sys); }
    operator const _SYSUsbQueue* () const { return reinterpret_cast<const _SYSUsbQueue*>(&sys); }

    unsigned capacity() const {
        return tCapacity;
    }

    void clear()
    {
        unsigned lastIndex = tCapacity;

        STATIC_ASSERT(sizeof sys.header == sizeof sys.header32);
        STATIC_ASSERT(lastIndex >= 1);
        STATIC_ASSERT(lastIndex <= 255);

        sys.header32 = lastIndex << 16;

        ASSERT(sys.header.head == 0);
        ASSERT(sys.header.tail == 0);
        ASSERT(sys.header.last == lastIndex);
    }

    bool full() const {
        unsigned size = tCapacity + 1;
        return (sys.header.tail + 1) % size == sys.header.head;
    }

    bool empty() const {
        return sys.header.tail == sys.header.head;
    }

    void read(UsbPacket &buffer)
    {
        buffer = peek();
        pop();
    }

    const UsbPacket &peek() const
    {
        ASSERT(!empty());
        unsigned head = sys.header.head;
        ASSERT(head <= tCapacity);
        return *reinterpret_cast<const UsbPacket *>(&sys.packets[head]);
    }

    void pop()
    {
        ASSERT(!empty());
        unsigned head = sys.header.head + 1;
        if (head > tCapacity)
            head = 0;
        sys.header.head = head;
    }

    void write(const UsbPacket &buffer)
    {
        reserve() = buffer;
        commit();
    }

    UsbPacket &reserve()
    {
        ASSERT(!full());
        unsigned tail = sys.header.tail;
        ASSERT(tail <= tCapacity);
        return *reinterpret_cast<UsbPacket *>(&sys.packets[tail]);
    }

    void commit()
    {
        ASSERT(!full());
        unsigned tail = sys.header.tail + 1;
        if (tail > tCapacity)
            tail = 0;
        sys.header.tail = tail;

        /*
         * Poke the system to look at our queue, in case it's ready to
         * transmit immediately. Has no effect if this queue isn't
         * attached as the current TX pipe.
         *
         * This wakeup is only necessary when the queue transitions
         * from empty to full, but we have no way of knowing for sure when
         * this happens. If we see that the queue is non-empty when we
         * commit(), there's no way to know that the system hasn't dequeued
         * the packet during this function's execution.
         */
        _SYS_usb_queueWriteHint();
    }
};


template < unsigned tSendCapacity = 4, unsigned tReceiveCapacity = 4 >
struct UsbPipe {

    UsbQueue< tSendCapacity > sendQueue;

    UsbQueue< tReceiveCapacity > receiveQueue;

    void attach() {
        sendQueue.clear();
        receiveQueue.clear();
        _SYS_usb_setPipe(sendQueue, receiveQueue);
    }

    void detach() {
        _SYS_usb_setPipe(0, 0);
    }

    bool write(const UsbPacket &buffer)
    {
        if (!sendQueue.full()) {
            sendQueue.write(buffer);
            return true;
        }
        return false;
    }

    bool read(UsbPacket &buffer)
    {
        if (!receiveQueue.empty()) {
            receiveQueue.read(buffer);
            return true;
        }
        return false;
    }

    bool readAvailable() const {
        return !receiveQueue.empty();
    }

    bool writeAvailable() const {
        return !sendQueue.full();
    }
};


struct UsbCounters
{
    _SYSUsbCounters current;
    _SYSUsbCounters base;

    void reset() {
        _SYS_usb_counters(&base, sizeof base);
    }

    void capture() {
        _SYS_usb_counters(&current, sizeof current);
    }

    uint32_t receivedPackets() {
        return current.rxPackets - base.rxPackets;
    }

    uint32_t sentPackets() {
        return current.txPackets - base.txPackets;
    }

    uint32_t receivedBytes() {
        return current.rxBytes - base.rxBytes;
    }

    uint32_t sentBytes() {
        return current.txBytes - base.txBytes;
    }

    uint32_t userPacketsDropped() {
        return current.rxUserDropped - base.rxUserDropped;
    }
};


} // namespace Sifteo