bluetooth.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 Bluetooth {
public:

    static bool isAvailable()
    {
        if ((_SYS_getFeatures() & _SYS_FEATURE_BLUETOOTH) == 0) {
            return false;
        }

        return _SYS_bt_isAvailable();
    }

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

    static void advertiseState(const uint8_t *bytes, unsigned length)
    {
        _SYS_bt_advertiseState(bytes, length);
    };

    template <typename T>
    static void advertiseState(const T &object)
    {
        advertiseState(reinterpret_cast<const uint8_t*>(&object), sizeof object);
    }
};


struct BluetoothPacket {
    _SYSBluetoothPacket sys;

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

    static unsigned capacity() {
        return _SYS_BT_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 <= 127);
        sys.type = type;
    }
};


template < unsigned tCapacity >
struct BluetoothQueue {
    struct SysType {
        union {
            _SYSBluetoothQueueHeader header;
            uint32_t header32;
        };
        _SYSBluetoothPacket packets[tCapacity + 1];
    } sys;

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

    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);
    }

    unsigned count() const
    {
        unsigned size = tCapacity + 1;
        unsigned head = sys.header.head;
        unsigned tail = sys.header.tail;
        ASSERT(head < size);
        ASSERT(tail < size);
        return (tail - head) % size;
    }

    unsigned readAvailable() const
    {
        return count();
    }

    unsigned writeAvailable() const
    {
        return tCapacity - count();
    }

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

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

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

        /*
         * Notify the system that we have more space for reading. This may
         * communicate additional flow control tokens to our peer if this
         * queue is the current read pipe.
         *
         * This is only absolutely necessary if the queue transitioned
         * from being totally full to being less-than-totally full, but
         * we'd also like to give the system a chance to send flow control
         * tokens speculatively if it wants.
         */
        _SYS_bt_queueReadHint();
    }

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

    BluetoothPacket &reserve()
    {
        ASSERT(writeAvailable() > 0);
        unsigned tail = sys.header.tail;
        ASSERT(tail <= tCapacity);
        return *reinterpret_cast<BluetoothPacket *>(&sys.packets[tail]);
    }

    void commit()
    {
        ASSERT(writeAvailable() > 0);
        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_bt_queueWriteHint();
    }
};


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

    BluetoothQueue< tSendCapacity > sendQueue;

    BluetoothQueue< tReceiveCapacity > receiveQueue;

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

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

    bool write(const BluetoothPacket &buffer)
    {
        if (sendQueue.writeAvailable()) {
            sendQueue.write(buffer);
            return true;
        }
        return false;
    }

    bool read(BluetoothPacket &buffer)
    {
        if (receiveQueue.readAvailable()) {
            receiveQueue.read(buffer);
            return true;
        }
        return false;
    }

    unsigned readAvailable() const
    {
        return receiveQueue.readAvailable();
    }

    unsigned writeAvailable() const
    {
        return sendQueue.writeAvailable();
    }
};


struct BluetoothCounters
{
    _SYSBluetoothCounters current;
    _SYSBluetoothCounters base;

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

    void capture() {
        _SYS_bt_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