satcat5/interrupts.h

Go to the documentation of this file.

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/list.h>
#include <satcat5/timeref.h>
#include <satcat5/types.h>
 
// By default, time statistics are enabled.
#ifndef SATCAT5_IRQ_STATS
#define SATCAT5_IRQ_STATS   1
#endif
 
namespace satcat5 {
    namespace irq {
        class AtomicLock final {
        public:
            explicit AtomicLock(const char* lbl);
            ~AtomicLock();
 
            void release();
 
        private:
            const char* const m_lbl;
            satcat5::util::TimeVal m_tstart;
            bool m_held;
        };
 
        constexpr int IRQ_NONE = -1;
 
        class Controller {
        public:
            void init(satcat5::util::TimeRef* timer = 0);
 
            static bool is_initialized();
            static bool is_irq_context();
            static bool is_irq_or_locked();
 
            void stop();
 
        protected:
            friend satcat5::irq::AtomicLock;
            friend satcat5::irq::Handler;
 
            Controller() {}
            ~Controller() SATCAT5_OPTIONAL_DTOR;
 
            static void interrupt_static(satcat5::irq::Handler* obj);
 
            virtual void irq_pause() = 0;   
            virtual void irq_resume() = 0;  
 
            virtual void irq_register(satcat5::irq::Handler* obj) = 0;
 
            virtual void irq_unregister(satcat5::irq::Handler* obj) = 0;
 
            virtual void irq_acknowledge(satcat5::irq::Handler* obj);
        };
 
        class ControllerNull final
            : public satcat5::irq::Controller {
        public:
            explicit ControllerNull(satcat5::util::TimeRef* timer = 0);
            ~ControllerNull() {}
 
            void service_all();
            inline void service_one(satcat5::irq::Handler* obj)
                {satcat5::irq::Controller::interrupt_static(obj);}
 
        protected:
            // Empty hardware-abstraction overrides.
            void irq_pause() override {}
            void irq_resume() override {}
            void irq_register(satcat5::irq::Handler* obj) override {}
            void irq_unregister(satcat5::irq::Handler* obj) override {}
            void irq_acknowledge(satcat5::irq::Handler* obj) override {}
        };
 
        class Handler {
        public:
            const char* const m_label;
 
            const int m_irq_idx;
 
        protected:
            friend satcat5::irq::Controller;
 
            Handler(const char* lbl, int irq);
            ~Handler() SATCAT5_OPTIONAL_DTOR;
 
            virtual void irq_event() = 0;
 
            u32 m_max_irqtime;
 
        private:
            // Linked list of all Handler objects.
            friend satcat5::irq::Shared;
            friend satcat5::util::ListCore;
            satcat5::irq::Handler* m_next;
        };
 
        class Adapter : public satcat5::irq::Handler {
        public:
            Adapter(const char* lbl, int irq, satcat5::poll::OnDemand* obj);
            ~Adapter() SATCAT5_OPTIONAL_DTOR;
 
        protected:
            void irq_event() override;
            satcat5::poll::OnDemand* const m_obj;
        };
 
        class Shared final : public satcat5::irq::Handler {
        public:
            Shared(const char* lbl, int irq);
            ~Shared() SATCAT5_OPTIONAL_DTOR;
 
            // Add a child to the list.
            inline void add(satcat5::irq::Handler* child)
                {m_list.add(child);}
 
        protected:
            void irq_event() override;
 
            satcat5::util::List<satcat5::irq::Handler> m_list;
        };
 
        bool pre_test_reset();
 
        #if SATCAT5_IRQ_STATS
            extern satcat5::util::RunningMax
                worst_irq, worst_lock, worst_stack;
        #endif
    }
}