irq_manager.hpp

#if !defined(__IRQ_MANAGER_HPP__)
#define __IRQ_MANAGER_HPP__

//
// local includes
//
#include "core/machine/generic/resource_manager.hpp"
#include "irq_source.hpp"
#include "irq.hpp"

//
// forward declarations
//
struct machine_config;

struct irq_manager : public resource_manager, private noncopyable
{
    static const bool VERBOSE_ALLOCATION = false;
    static const int FIRST_HANDLE        = 0x100;
    static const uint16_t NUM_IRQS       = 24;

    //
    //     irq_line_t must be unsigned, since values below 0 are used for error codes
    //
    static_assert(is_unsigned<l4_irq_t>::conforms, "l4_irq_t must be an unsigned integer");
    static_assert(integer_traits<l4_irq_t>::const_max >= NUM_IRQS - 1,
                  "l4_irq_t's max value is too small");

    enum irqs_constants
    {
        NO_IRQ                = integer_traits<l4_irq_t>::const_max,
    };

    static_assert(NO_IRQ >= NUM_IRQS, "NO_IRQ must be >= NUM_IRQS");

    typedef resource_flags irq_flags;

    struct irq_state : public irq_flags, public irq
    {
        //
        // attribute bits to store the current (management) state and mechanism routines
        //     derived from base classes
        //
        /* const */ l4_irq_t l4vmm_irq;         // this IRQ's line
        /* const */ int l4vmm_handle;           // handle to be returned by l4vmm_irq_attach

        l4_irq_t omega0_irq;                    // omega0's IRQ (the real one)
        int omega0_handle;                      // handle returned by omega0_attach

        irq_source *src;                        // the source (the device); stored here to
                                                // remap the IRQ later
        l4_threadid_t client;                   // attached client thread's ID

        inline irq_state(void)
            : irq_flags(0), l4vmm_irq(NO_IRQ), l4vmm_handle(-L4_ENOHANDLE),
              omega0_irq(NO_IRQ), omega0_handle(-L4_ENOHANDLE),
              src(nullptr), client(L4_INVALID_ID)
        {}

        //
        // query functions
        //
        inline bool is_source(const irq_source *src) const
        {
            return this->src == src;
        }

        inline bool is_client(const l4_threadid_t client) const
        {
            return l4_thread_equal(this->client, client);
        }

        //
        // source (device) management functions
        //
        inline irq_state &register_source(irq_source *src, const irq_flags use,
                                          const l4_irq_t physical_irq=NO_IRQ)
        {
            set(use & USE_MASK);
            omega0_irq=use.is_physical() ? physical_irq : static_cast<l4_irq_t>(NO_IRQ);
            this->src=src;
            return *this;
        }

        inline irq_state &copy_source(const irq_state &other)
        {
            clear(USE_MASK);
            set(other.bits & USE_MASK);
            omega0_irq=other.omega0_irq;
            src=other.src;
            return *this;
        }

        //
        // client (the attached thread) management functions
        //     note: omega0_irq should have already been set by the source (the device)
        //
        inline irq_state &attach(const l4_threadid_t client, const int handle=-L4_ENOHANDLE)
        {
            set(ATTACHED);
            this->omega0_handle=handle;
            this->client=client;
            return *this;
        }

        inline irq_state &detach(void)
        {
            clear(ATTACHED);
            omega0_handle=-L4_ENOHANDLE;
            client=L4_INVALID_ID;
            return *this;
        }

        //
        // reset everything back to defaults
        //
        inline int reset(void)
        {
            clear(USE_MASK | ATTACHED);
            // clear any information about physical usage
            omega0_irq=NO_IRQ;
            omega0_handle=-L4_ENOHANDLE;
            src=nullptr;
            client=L4_INVALID_ID;
            return 0;
        }
    };

  protected:
    const machine_config &config;

  public:
    //
    // TODO: should be protected, but at first I need to move the API
    //       implementation into the machine_base class.
    //
    lock irq_lock;

  protected:
    irq_state irq_states[NUM_IRQS];

  public:
    //
    // constructors & destructors
    //
    irq_manager(const machine_config &config);
    virtual ~irq_manager(void);

    //
    // convert line/handle/source/client thread ID to irq_state struct
    // TODO: should be protected or return const objects, but at first I need to
    //       move the API implementation into the machine_base class.
    //
    inline const irq_state *irq_state_from_line(const l4_irq_t irq) const
    {
        // no need to search the irq_state object. they are already ordered.
        return is_valid_irq(irq) ? &irq_states[irq] : nullptr;
    }

    inline irq_state *irq_state_from_line(const l4_irq_t irq)
    {
        // no need to search the irq_state object. they are already ordered.
        return is_valid_irq(irq) ? &irq_states[irq] : nullptr;
    }

    inline irq_state *irq_state_from_handle(const int handle)
    {
        return irq_state_from_line(handle - FIRST_HANDLE);
    }

    inline irq_state *irq_state_from_source(const irq_source *src)
    {
        for (irq_state *state=beginof(irq_states); state != endof(irq_states); state++)
            if (state->is_source(src)) return state;
        return nullptr;
    }

    inline irq_state *irq_state_from_client(const l4_threadid_t client)
    {
        for (irq_state *state=beginof(irq_states); state != endof(irq_states); state++)
            if (state->is_client(client)) return state;
        return nullptr;
    }

    //
    // IRQ management functions regarding sources (devices)
    //
    virtual int check_irq_request(const irq_source *src, irq_flags use,
                                  l4_irq_t irq, l4_irq_t physical_irq,
                                  bool verbose=VERBOSE_ALLOCATION) const;

    virtual int request_irq(irq_source *src, irq_flags use,
                            l4_irq_t physical_irq=NO_IRQ, bool verbose=VERBOSE_ALLOCATION);

    virtual int register_irq(irq_source *src, irq_flags use, l4_irq_t irq=NO_IRQ,
                             l4_irq_t physical_irq=NO_IRQ, bool verbose=VERBOSE_ALLOCATION);

    virtual int unregister_irq(const irq_source *src, l4_irq_t irq, bool verbose=VERBOSE_ALLOCATION);

    inline void assert_irq(const l4_irq_t irq)
    {
        assert_logd(L4VMM_DEBUG_IRQS, is_valid_irq(irq), "irq: "l4_irq_fmt"\n", irq);
        irq_state_from_line(irq)->assert_irq();
    }

    inline void assert_irq(const irq_source *src, const l4_irq_t irq)
    {
        assert_logd(L4VMM_DEBUG_IRQS, is_valid_irq(irq), "irq: "l4_irq_fmt"\n", irq);
        irq_state *state=irq_state_from_line(irq);
        if (!state->is_source(src)) enter_kdebug(" wrong IRQ asserted ");
        state->assert_irq();
    }

    //
    // debug stuff
    //
    virtual void print_irq_states(const char *header=nullptr);

  protected:
    virtual int init_irqs(void);
    virtual irq_state *find_free_irq(irq_flags use);

  public:
    static inline bool is_valid_irq(const l4_irq_t irq)
    {
        return range_traits<l4_irq_t, NUM_IRQS>::is_valid(irq);
    }
};

#endif

// ***** end of source ***** //