pci.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef PCI_HH
#define PCI_HH
 
#include "boards/board.h"
#include "boards/board_traits.h"
#include <avr/interrupt.h>
#include "interrupts.h"
#include "utilities.h"
 
#define REGISTER_PCI_ISR_METHOD(PCI_NUM, HANDLER, CALLBACK, PIN, ...)                             \
    ISR(CAT3(PCINT, PCI_NUM, _vect))                                                              \
    {                                                                                             \
        interrupt::isr_handler_pci::pci_method<PCI_NUM, HANDLER, CALLBACK, PIN, ##__VA_ARGS__>(); \
    }
 
#define REGISTER_PCI_ISR_FUNCTION(PCI_NUM, CALLBACK, PIN, ...)                             \
    ISR(CAT3(PCINT, PCI_NUM, _vect))                                                       \
    {                                                                                      \
        interrupt::isr_handler_pci::pci_function<PCI_NUM, CALLBACK, PIN, ##__VA_ARGS__>(); \
    }
 
#define REGISTER_PCI_ISR_EMPTY(PCI_NUM, PIN, ...)                                   \
    extern "C" void CAT3(PCINT, PCI_NUM, _vect)(void) NAKED_SIGNAL;                 \
    void CAT3(PCINT, PCI_NUM, _vect)(void)                                          \
    {                                                                               \
        interrupt::isr_handler_pci::check_pci_pins<PCI_NUM, PIN, ##__VA_ARGS__>();  \
        __asm__ __volatile__("reti" ::);                                            \
    }
 
#define DECL_PCI_ISR_HANDLERS_FRIEND            \
    friend struct interrupt::isr_handler_pci;   \
    DECL_PCINT_ISR_FRIENDS
 
namespace board
{
    template<InterruptPin PCI> constexpr DigitalPin PCI_PIN() INLINE;
    template<InterruptPin PCI> constexpr DigitalPin PCI_PIN()
    {
        return DigitalPin(uint8_t(PCI));
    }
};
 
namespace interrupt
{
    // All PCI-related methods called by pre-defined ISR are defined here
    //====================================================================
 
    struct isr_handler_pci
    {
        template<uint8_t PCI_NUM_, board::InterruptPin PCIPIN_>
        static constexpr uint8_t get_pci_pin_bit()
        {
            constexpr board::DigitalPin PIN = board::PCI_PIN<PCIPIN_>();
            using PINTRAIT = board_traits::DigitalPin_trait<PIN>;
            using PORTTRAIT = board_traits::Port_trait<PINTRAIT::PORT>;
            return bits::BV8(PINTRAIT::BIT) << PORTTRAIT::PCI_SHIFT;
        }
 
        template<uint8_t PCI_NUM_> static void check_pci_pins() {}
 
        template<uint8_t PCI_NUM_, board::InterruptPin PCIPIN1_, board::InterruptPin... PCIPINS_>
        static void check_pci_pins()
        {
            static_assert(board_traits::PCI_trait<PCI_NUM_>::SUPPORTED, "PCI_NUM must support PCI");
            constexpr board::DigitalPin PIN = board::PCI_PIN<PCIPIN1_>();
            using PINTRAIT = board_traits::DigitalPin_trait<PIN>;
            using PORTTRAIT = board_traits::Port_trait<PINTRAIT::PORT>;
            using PCITRAIT = board_traits::PCI_trait<PCI_NUM_>;
            static_assert(PORTTRAIT::PCINT == PCI_NUM_, "PIN PORT must use this PCINT");
            static_assert(PCITRAIT::PCI_MASK & get_pci_pin_bit<PCI_NUM_, PCIPIN1_>(), 
                          "PIN must be a PCI within this PCINT");
            // Check other pins
            check_pci_pins<PCI_NUM_, PCIPINS_...>();
        }
 
        template<uint8_t PCI_NUM_, typename HANDLER_, void (HANDLER_::*CALLBACK_)(), board::InterruptPin... PCIPINS_>
        static void pci_method()
        {
            // Check pin is compliant
            check_pci_pins<PCI_NUM_, PCIPINS_...>();
            // Call handler back
            interrupt::CallbackHandler<void (HANDLER_::*)(), CALLBACK_>::call();
        }
 
        template<uint8_t PCI_NUM_, void (*CALLBACK_)(), board::InterruptPin... PCIPINS_> static void pci_function()
        {
            // Check pin is compliant
            check_pci_pins<PCI_NUM_, PCIPINS_...>();
            // Call handler back
            CALLBACK_();
        }
    };
 
    template<uint8_t PCINT_> class PCISignal
    {
    private:
        using TRAIT = board_traits::PCI_trait<PCINT_>;
 
    public:
        PCISignal(const PCISignal&) = delete;
        PCISignal& operator=(const PCISignal&) = delete;
        
        //NOTE this constructor exists only to add a static_assert checked when
        // PCISignal is constructed not when its template type gets instantiated.
        PCISignal()
        {
            static_assert(TRAIT::SUPPORTED, "PCINT_ must be a valid PCINT number");
        }
 
        static constexpr const uint8_t PCINT = PCINT_;
 
        void enable()
        {
            synchronized TRAIT::PCICR_ |= TRAIT::PCICR_MASK;
        }
 
        void disable()
        {
            synchronized TRAIT::PCICR_ &= bits::COMPL(TRAIT::PCICR_MASK);
        }
 
        void clear()
        {
            synchronized TRAIT::PCIFR_ |= TRAIT::PCIFR_MASK;
        }
 
        void set_enable_pins(uint8_t mask)
        {
            synchronized TRAIT::PCMSK_ = mask;
        }
 
        void enable_pins(uint8_t mask)
        {
            synchronized TRAIT::PCMSK_ |= mask;
        }
 
        void disable_pins(uint8_t mask)
        {
            synchronized TRAIT::PCMSK_ &= bits::COMPL(mask);
        }
 
        template<board::InterruptPin PIN> void enable_pin()
        {
            check_pin_pci<PIN>();
            enable_pins(isr_handler_pci::get_pci_pin_bit<PCINT, PIN>());
        }
 
        template<board::InterruptPin PIN> void disable_pin()
        {
            check_pin_pci<PIN>();
            disable_pins(isr_handler_pci::get_pci_pin_bit<PCINT, PIN>());
        }
 
        void enable_()
        {
            TRAIT::PCICR_ |= TRAIT::PCICR_MASK;
        }
 
        void disable_()
        {
            TRAIT::PCICR_ &= bits::COMPL(TRAIT::PCICR_MASK);
        }
 
        void clear_()
        {
            TRAIT::PCIFR_ |= TRAIT::PCIFR_MASK;
        }
 
        void set_enable_pins_(uint8_t mask)
        {
            TRAIT::PCMSK_ = mask;
        }
 
        void enable_pins_(uint8_t mask)
        {
            TRAIT::PCMSK_ |= mask;
        }
 
        void disable_pins_(uint8_t mask)
        {
            TRAIT::PCMSK_ &= bits::COMPL(mask);
        }
 
        template<board::InterruptPin PIN> void enable_pin_()
        {
            check_pin_pci<PIN>();
            enable_pins_(isr_handler_pci::get_pci_pin_bit<PCINT, PIN>());
        }
 
        template<board::InterruptPin PIN> void disable_pin_()
        {
            check_pin_pci<PIN>();
            disable_pins_(isr_handler_pci::get_pci_pin_bit<PCINT, PIN>());
        }
 
    private:
        template<board::InterruptPin PIN> void check_pin_pci()
        {
            isr_handler_pci::check_pci_pins<PCINT, PIN>();
        }
    };
 
    template<board::InterruptPin PIN> struct PCIType
    {
    private:
        using PIN_TRAIT = board_traits::DigitalPin_trait<board::PCI_PIN<PIN>()>;
        using PORT_TRAIT = board_traits::Port_trait<PIN_TRAIT::PORT>;
 
    public:
        static constexpr const uint8_t PCINT = PORT_TRAIT::PCINT;
        using TYPE = PCISignal<PCINT>;
    };
 
    template<board::InterruptPin PIN>
    using PCI_SIGNAL = typename PCIType<PIN>::TYPE;
 
    template<board::Port PORT>
    using PCI_PORT_SIGNAL = PCISignal<board_traits::Port_trait<PORT>::PCINT>;
}
 
#endif /* PCI_HH */