ll_data_pdu_buffer.hpp

#ifndef BLUETOE_LINK_LAYER_LL_DAAT_BUFFER_HPP
#define BLUETOE_LINK_LAYER_LL_DAAT_BUFFER_HPP
 
#include <cstdlib>
#include <cstdint>
#include <cassert>
#include <initializer_list>
#include <algorithm>
 
#include <bluetoe/default_pdu_layout.hpp>
#include "ring_buffer.hpp"
 
namespace bluetoe {
namespace link_layer {
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    class ll_data_pdu_buffer
    {
    public:
        ll_data_pdu_buffer();
 
        using layout = typename pdu_layout_by_radio< Radio >::pdu_layout;
 
        static constexpr std::size_t    size            = TransmitSize + ReceiveSize;
 
        static constexpr std::size_t    min_buffer_size = 29;
 
        static constexpr std::size_t    max_buffer_size = 251;
 
        static constexpr std::size_t    header_size     = 2u;
 
        static constexpr std::size_t    layout_overhead = layout::data_channel_pdu_memory_size( 0 ) - header_size;
 
        static_assert( TransmitSize >= layout_overhead + min_buffer_size,
            "TransmitSize should at least be large enough to store one L2CAP PDU plus overheader required by the hardware." );
 
        static_assert( ReceiveSize >= layout_overhead + min_buffer_size,
            "ReceiveSize should at least be large enough to store one L2CAP PDU plus overheader required by the hardware." );
 
        constexpr std::size_t max_max_rx_size() const
        {
            return ReceiveSize - layout_overhead;
        }
 
        std::size_t max_rx_size() const;
 
        void max_rx_size( std::size_t max_size );
 
        constexpr std::size_t max_max_tx_size() const
        {
            return TransmitSize - ( layout::data_channel_pdu_memory_size( 0 ) - 2 );
        }
 
        std::size_t max_tx_size() const;
 
        void max_tx_size( std::size_t max_size );
 
        std::uint8_t* raw_pdu_buffer();
 
        void stop_pdu_buffer();
 
        void reset_pdu_buffer();
 
        read_buffer allocate_transmit_buffer( std::size_t size );
 
        read_buffer allocate_transmit_buffer();
 
        void commit_transmit_buffer( read_buffer );
 
        bool pending_outgoing_data_available() const;
 
        write_buffer next_received() const;
 
        void free_received();
 
    protected:
        read_buffer allocate_receive_buffer() const;
 
        write_buffer received( read_buffer );
 
        write_buffer acknowledge( read_buffer );
 
        write_buffer next_transmit();
    private:
        // transmit buffer followed by receive buffer at buffer_[ TransmitSize ]
        std::uint8_t    buffer_[ size ];
 
        pdu_ring_buffer< ReceiveSize, read_buffer, layout >  receive_buffer_;
        volatile std::size_t            max_rx_size_;
 
        pdu_ring_buffer< TransmitSize, read_buffer, layout > transmit_buffer_;
        volatile std::size_t            max_tx_size_;
 
        bool                    sequence_number_;
        bool                    next_expected_sequence_number_;
        uint8_t                 empty_[ layout::data_channel_pdu_memory_size( 0 ) ];
        bool                    next_empty_;
        bool                    empty_sequence_number_;
 
        static constexpr std::size_t  ll_header_size = 2;
        static constexpr std::uint8_t more_data_flag = 0x10;
        static constexpr std::uint8_t sn_flag        = 0x8;
        static constexpr std::uint8_t nesn_flag      = 0x4;
        static constexpr std::uint8_t ll_empty_id    = 0x01;
 
 
        const std::uint8_t* transmit_buffer() const
        {
            return &buffer_[ 0 ];
        }
 
        std::uint8_t* transmit_buffer()
        {
            return &buffer_[ 0 ];
        }
 
        const std::uint8_t* receive_buffer() const
        {
            return &buffer_[ TransmitSize ];
        }
 
        std::uint8_t* receive_buffer()
        {
            return &buffer_[ TransmitSize ];
        }
 
        write_buffer set_next_expected_sequence_number( read_buffer ) const;
 
        void acknowledge( bool sequence_number );
    };
 
    // implementation
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::ll_data_pdu_buffer()
        : receive_buffer_( receive_buffer() )
        , transmit_buffer_( transmit_buffer() )
    {
        layout::header( empty_, 0 );
        reset_pdu_buffer();
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    std::size_t ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::max_rx_size() const
    {
        return max_rx_size_;
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    void ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::max_rx_size( std::size_t max_size )
    {
        assert( max_size >= min_buffer_size );
        assert( max_size <= max_buffer_size );
        assert( max_size <= ReceiveSize - layout_overhead );
 
        max_rx_size_ = max_size;
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    std::size_t ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::max_tx_size() const
    {
        return max_tx_size_;
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    void ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::max_tx_size( std::size_t max_size )
    {
        assert( max_size >= min_buffer_size );
        assert( max_size <= max_buffer_size );
        assert( max_size <= TransmitSize - layout_overhead );
 
        max_tx_size_ = max_size;
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    void ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::reset_pdu_buffer()
    {
        max_rx_size_    = min_buffer_size;
        receive_buffer_.reset( receive_buffer() );
 
        max_tx_size_    = min_buffer_size;
        transmit_buffer_.reset( transmit_buffer() );
 
        sequence_number_ = false;
        next_expected_sequence_number_ = false;
        next_empty_      = false;
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    std::uint8_t* ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::raw_pdu_buffer()
    {
        return &buffer_[ 0 ];
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    read_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::allocate_transmit_buffer( std::size_t size )
    {
        typename Radio::lock_guard lock;
 
        return transmit_buffer_.alloc_front( transmit_buffer(), size );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    void ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::commit_transmit_buffer( read_buffer pdu )
    {
        static constexpr std::uint8_t header_rfu_mask = 0xe0;
        static_cast< void >( header_rfu_mask );
 
        // make sure, no NFU bits are set
        std::uint16_t header = layout::header( pdu );
        assert( ( header & header_rfu_mask ) == 0 );
 
        typename Radio::lock_guard lock;
 
        // add sequence number
        if ( sequence_number_ )
        {
            header |= sn_flag;
            layout::header( pdu, header );
        }
 
        sequence_number_ = !sequence_number_;
 
        transmit_buffer_.push_front( transmit_buffer(), pdu );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    bool ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::pending_outgoing_data_available() const
    {
        return transmit_buffer_.next_end().size != 0;
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    write_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::set_next_expected_sequence_number( read_buffer buf ) const
    {
        // insert the next expected sequence for every attempt to send the PDU, because it could be that
        // the peripheral is able to receive data, while the central is not able to.
        std::size_t header = layout::header( buf );
 
        header = next_expected_sequence_number_
            ? ( header | nesn_flag )
            : ( header & ~nesn_flag );
 
        layout::header( buf, header );
 
        return write_buffer( buf );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    write_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::next_transmit()
    {
        const read_buffer next = transmit_buffer_.next_end();
 
        if ( next_empty_ )
        {
            // if an empty buffer have to be resend, flag that there is more data
            if ( next.size )
            {
                const std::uint16_t header = layout::header( next ) | more_data_flag;
                layout::header( next, header );
            }
 
            return set_next_expected_sequence_number( read_buffer{ &empty_[ 0 ], sizeof( empty_ ) } );
        }
        else if ( next.size == 0 )
        {
            // we created an PDU, so it has to have a new sequnce number
            const std::uint16_t header = sequence_number_
                ? sn_flag + ll_empty_id
                :           ll_empty_id;
 
            layout::header( empty_, header );
            next_empty_ = true;
 
            // keep sequence number of empty in mind and increment sequence_number_
            empty_sequence_number_ = sequence_number_;
            sequence_number_ = !sequence_number_;
 
            return set_next_expected_sequence_number( read_buffer{ &empty_[ 0 ], sizeof( empty_ ) } );
        }
 
        if ( transmit_buffer_.more_than_one() )
            layout::header( next, layout::header( next ) | more_data_flag );
 
        return set_next_expected_sequence_number( next );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    void ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::acknowledge( bool nesn )
    {
        if ( next_empty_ )
        {
            if ( empty_sequence_number_ != nesn )
                next_empty_ = false;
        }
        else
        {
            const read_buffer next = transmit_buffer_.next_end();
 
            // the transmit buffer could be empty if we receive without sending prior. That happens during testing
            if ( next.empty() )
                return;
 
            const std::uint16_t header = layout::header( next );
            if ( static_cast< bool >( header & sn_flag ) != nesn )
            {
                transmit_buffer_.pop_end( transmit_buffer() );
                static_cast< Radio* >( this )->increment_transmit_packet_counter();
            }
        }
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    read_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::allocate_transmit_buffer()
    {
        return allocate_transmit_buffer( max_tx_size_ + layout_overhead );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    write_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::next_received() const
    {
        typename Radio::lock_guard lock;
 
        return write_buffer( receive_buffer_.next_end() );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    void ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::free_received()
    {
        typename Radio::lock_guard lock;
 
        receive_buffer_.pop_end( receive_buffer() );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    read_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::allocate_receive_buffer() const
    {
        return receive_buffer_.alloc_front( const_cast< std::uint8_t* >( receive_buffer() ), layout::data_channel_pdu_memory_size( max_rx_size_ - ll_header_size ) );
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    write_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::received( read_buffer pdu )
    {
        const std::uint16_t header = layout::header( pdu );
 
        // invalid LLID
        if ( ( header & 0x3 ) != 0 )
        {
            acknowledge( header & nesn_flag );
 
            // resent PDU?
            if ( static_cast< bool >( header & sn_flag ) == next_expected_sequence_number_ )
            {
                next_expected_sequence_number_ = !next_expected_sequence_number_;
 
                if ( ( header & 0xff00 ) != 0 )
                {
                    receive_buffer_.push_front( receive_buffer(), pdu );
                    static_cast< Radio* >( this )->increment_receive_packet_counter();
                }
            }
        }
 
        return next_transmit();
    }
 
    template < std::size_t TransmitSize, std::size_t ReceiveSize, typename Radio >
    write_buffer ll_data_pdu_buffer< TransmitSize, ReceiveSize, Radio >::acknowledge( read_buffer pdu )
    {
        const std::uint16_t header = layout::header( pdu );
 
        // invalid LLID
        if ( ( header & 0x3 ) != 0 )
        {
            acknowledge( header & nesn_flag );
 
            // resent PDU?
            if ( static_cast< bool >( header & sn_flag ) == next_expected_sequence_number_ )
            {
                next_expected_sequence_number_ = !next_expected_sequence_number_;
            }
        }
 
        return next_transmit();
    }
 
}
}
 
#endif