nrf.hpp

#ifndef BLUETOE_BINDINGS_NRF_HPP
#define BLUETOE_BINDINGS_NRF_HPP
 
#include <bluetoe/meta_types.hpp>
#include <bluetoe/default_pdu_layout.hpp>
 
#include <nrf.h>
 
namespace bluetoe
{
    namespace nrf52_details {
        void gpio_debug_hfxo_stopped();
        void init_calibration_timer();
        void deassign_hfxo();
    }
 
    namespace nrf
    {
        /*
         * Some aliases that can be used in the debugger
         */
        static NRF_RADIO_Type* const        nrf_radio            = NRF_RADIO;
        static NRF_TIMER_Type* const        nrf_timer            = NRF_TIMER0;
        static NRF_TIMER_Type* const        nrf_cb_timer         = NRF_TIMER1;
        static NRF_CLOCK_Type* const        nrf_clock            = NRF_CLOCK;
        static NRF_TEMP_Type* const         nrf_temp             = NRF_TEMP;
        static NRF_RTC_Type* const          nrf_rtc              = NRF_RTC0;
        static NRF_CCM_Type* const          nrf_ccm              = NRF_CCM;
        static NRF_AAR_Type* const          nrf_aar              = NRF_AAR;
        static NRF_PPI_Type* const          nrf_ppi              = NRF_PPI;
        static NRF_RNG_Type* const          nrf_random           = NRF_RNG;
        static NRF_ECB_Type* const          nrf_aes              = NRF_ECB;
        static NRF_GPIOTE_Type* const       nrf_gpiote           = NRF_GPIOTE;
        static NVIC_Type* const             nvic                 = NVIC;
 
        static constexpr auto lfxo_clk_freq = 32768;
 
        /*
         * Interrupt priorities
         */
        static constexpr uint32_t nrf_interrupt_prio_ble = 0;
        static constexpr uint32_t nrf_interrupt_prio_user_cb = 1 << ( __NVIC_PRIO_BITS - 1 );
        static constexpr uint32_t nrf_interrupt_prio_calibrate_rtc = nrf_interrupt_prio_user_cb - 1;
 
        namespace nrf_details {
            struct radio_option_meta_type : ::bluetoe::details::binding_option_meta_type {};
            struct sleep_clock_source_meta_type : radio_option_meta_type {};
            struct hfxo_startup_time_meta_type : radio_option_meta_type {};
            struct leave_run_on_interrupt_type : radio_option_meta_type {};
 
            static void start_high_frequency_clock()
            {
                // This tasks starts the high frequency crystal oscillator (HFXO)
                nrf_clock->TASKS_HFCLKSTART = 1;
 
                // TODO: do not wait busy
                // Issue: do not poll for readiness of the high frequency clock #63
                while ( !nrf_clock->EVENTS_HFCLKSTARTED )
                    ;
 
                nrf_clock->EVENTS_HFCLKSTARTED = 0;
            }
 
            inline void start_lfclock_and_rtc()
            {
                nrf_clock->EVENTS_LFCLKSTARTED = 0;
                nrf_clock->TASKS_LFCLKSTART = 1;
 
                while ( nrf_clock->EVENTS_LFCLKSTARTED == 0 )
                    ;
 
                // https://infocenter.nordicsemi.com/topic/errata_nRF52840_Rev3/ERR/nRF52840/Rev3/latest/anomaly_840_20.html#anomaly_840_20
                nrf_rtc->TASKS_STOP = 0;
                nrf_rtc->TASKS_START = 1;
 
                // Configure the RTC to generate these two events
                // Overflow flag does not harm the power performance much and is used for
                // debugging.
                nrf_rtc->EVTEN =
                    ( RTC_EVTEN_COMPARE0_Enabled << RTC_EVTEN_COMPARE0_Pos )
                  | ( RTC_EVTEN_COMPARE1_Enabled << RTC_EVTEN_COMPARE1_Pos )
                  | ( RTC_EVTEN_OVRFLW_Enabled << RTC_EVTEN_OVRFLW_Pos );
            }
        }
 
        struct synthesized_sleep_clock
        {
            using meta_type = nrf_details::sleep_clock_source_meta_type;
 
            static void start_clocks()
            {
                nrf_details::start_high_frequency_clock();
 
                nrf_clock->LFCLKSRC = CLOCK_LFCLKSRCCOPY_SRC_Synth << CLOCK_LFCLKSRCCOPY_SRC_Pos;
                nrf_details::start_lfclock_and_rtc();
            }
 
            static void stop_high_frequency_crystal_oscilator()
            {
            }
        };
 
        struct sleep_clock_crystal_oscillator
        {
            using meta_type = nrf_details::sleep_clock_source_meta_type;
 
            static void start_clocks()
            {
                nrf_details::start_high_frequency_clock();
 
                nrf_clock->LFCLKSRC = CLOCK_LFCLKSRCCOPY_SRC_Xtal << CLOCK_LFCLKSRCCOPY_SRC_Pos;
                nrf_details::start_lfclock_and_rtc();
            }
 
            static void stop_high_frequency_crystal_oscilator()
            {
                nrf_clock->TASKS_HFCLKSTOP = 1;
 
#               if defined BLUETOE_NRF52_RADIO_DEBUG
                    bluetoe::nrf52_details::gpio_debug_hfxo_stopped();
#               endif
 
            }
        };
 
        struct calibrated_rc_sleep_clock
        {
            using meta_type = nrf_details::sleep_clock_source_meta_type;
 
            static void start_clocks()
            {
                nrf_details::start_high_frequency_clock();
 
                nrf_clock->LFCLKSRC = CLOCK_LFCLKSRCCOPY_SRC_RC << CLOCK_LFCLKSRCCOPY_SRC_Pos;
                nrf_details::start_lfclock_and_rtc();
                nrf52_details::init_calibration_timer();
            }
 
            static void stop_high_frequency_crystal_oscilator()
            {
                nrf52_details::deassign_hfxo();
            }
        };
 
        template < unsigned StartupTimeMicroSeconds >
        struct high_frequency_crystal_oscillator_startup_time
        {
            using meta_type = nrf_details::hfxo_startup_time_meta_type;
 
            static constexpr unsigned value = StartupTimeMicroSeconds;
        };
 
        using high_frequency_crystal_oscillator_startup_time_default = high_frequency_crystal_oscillator_startup_time< 300 >;
 
        struct leave_run_on_interrupt {
            using meta_type = nrf_details::leave_run_on_interrupt_type;
        };
    }
 
    namespace nrf_details
    {
        struct encrypted_pdu_layout : bluetoe::link_layer::details::layout_base< encrypted_pdu_layout >
        {
            static constexpr std::size_t header_size = sizeof( std::uint16_t );
 
            using bluetoe::link_layer::details::layout_base< encrypted_pdu_layout >::header;
 
            static std::uint16_t header( const std::uint8_t* pdu )
            {
                return ::bluetoe::details::read_16bit( pdu );
            }
 
            static void header( std::uint8_t* pdu, std::uint16_t header_value )
            {
                ::bluetoe::details::write_16bit( pdu, header_value );
            }
 
            static std::pair< std::uint8_t*, std::uint8_t* > body( const link_layer::read_buffer& pdu )
            {
                assert( pdu.size >= header_size );
 
                return { &pdu.buffer[ header_size + 1 ], &pdu.buffer[ pdu.size ] };
            }
 
            static std::pair< const std::uint8_t*, const std::uint8_t* > body( const link_layer::write_buffer& pdu )
            {
                assert( pdu.size >= header_size );
 
                return { &pdu.buffer[ header_size + 1 ], &pdu.buffer[ pdu.size ] };
            }
 
            static constexpr std::size_t data_channel_pdu_memory_size( std::size_t payload_size )
            {
                return header_size + payload_size + 1;
            }
        };
    }
}
 
#endif