sim_interrupt.h

Go to the documentation of this file.

/*
 * sim_interrupt.h
 *
 *  Copyright 2021-2026 Clement Savergne <csavergne@yahoo.com>
 
    This file is part of yasim-avr.
 
    yasim-avr is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    yasim-avr is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with yasim-avr.  If not, see <http://www.gnu.org/licenses/>.
 */
 
//=======================================================================================
 
#ifndef __YASIMAVR_INTERRUPT_H__
#define __YASIMAVR_INTERRUPT_H__
 
#include "sim_peripheral.h"
#include "sim_types.h"
#include "sim_signal.h"
 
YASIMAVR_BEGIN_NAMESPACE
 
class InterruptHandler;
 
 
//=======================================================================================
/*
 * CTLREQ definitions
*/
 
//AVR_CTLREQ_GET_SIGNAL :
//    The signal returned is raised when an interrupt is raised
//    the index is set to the vector index
//    the value 'u' is set to the interrupt state (IntrState_Raised)
 
//Request sent to by any peripheral to register an interrupt vector
//The index shall be the interrupt vector index
//The value 'p' shall be the corresponding InterruptHandler object
//Notes:
//   . a vector can only be registered once
//   . the vector 0 cannot be registered
#define AVR_CTLREQ_INTR_REGISTER    (AVR_CTLREQ_BASE + 1)
 
//Request sent to raise or clear artificially any interrupt
//The index shall be the interrupt vector index
//The value 'u' shall be 1 for raising the interrupt, 0 for clearing it.
#define AVR_CTLREQ_INTR_RAISE       (AVR_CTLREQ_BASE + 2)
 
#define AVR_INTERRUPT_NONE          -1
 
 
//=======================================================================================
class AVR_CORE_PUBLIC_API InterruptController : public Peripheral {
 
    friend class InterruptHandler;
 
public:
 
    enum SignalId {
        Signal_StateChange
    };
 
    enum State {
        State_Raised          = 0x01,
        State_Cancelled       = 0x10,
        State_Acknowledged    = 0x20,
        State_Returned        = 0x30,
        State_RaisedFromSleep = 0x41,
        State_Reset           = 0x50
    };
 
    struct IRQ_t {
        int_vect_t vector;
        flash_addr_t address;
        bool nmi;
    };
 
    static constexpr IRQ_t NO_INTERRUPT = { AVR_INTERRUPT_NONE, 0, false };
 
    //===== Constructor/destructor =====
    explicit InterruptController(unsigned int vector_count);
 
    //===== Override of IO_CTL virtual methods =====
    virtual void reset(int flags) override;
    virtual bool ctlreq(ctlreq_id_t req, ctlreq_data_t* data) override;
    virtual void sleep(bool on, SleepMode mode) override;
 
    //===== Interface API for the CPU =====
    bool cpu_has_irq() const;
    IRQ_t cpu_get_irq() const;
    void cpu_ack_irq();
    virtual void cpu_reti();
 
protected:
 
    //Helper methods to access the vector table, for concrete implementing sub-classes
    bool interrupt_raised(int_vect_t vector) const;
    int_vect_t intr_count() const;
    void set_interrupt_raised(int_vect_t vector, bool raised);
 
    virtual void cpu_ack_irq(int_vect_t vector);
 
    virtual IRQ_t get_next_irq() const = 0;
 
    void update_irq();
 
private:
 
    //===== Structure holding data on the vector table =====
    struct interrupt_t {
        bool used = false;
        bool raised = false;
        InterruptHandler* handler = nullptr;
    };
 
    //Interrupt vector table
    std::vector<interrupt_t> m_interrupts;
    //Variable holding the vector to be executed next
    IRQ_t m_irq;
    //Signal raised with changes of interrupt state
    Signal m_signal;
 
    //private API used by the interrupt handlers
    void raise_interrupt(int_vect_t vector);
    void cancel_interrupt(int_vect_t vector);
    void disconnect_handler(InterruptHandler* handler);
 
};
 
inline bool InterruptController::cpu_has_irq() const
{
    return m_irq.vector > AVR_INTERRUPT_NONE;
}
 
inline InterruptController::IRQ_t InterruptController::cpu_get_irq() const
{
    if (m_irq.vector > AVR_INTERRUPT_NONE)
        return m_irq;
    else
        return NO_INTERRUPT;
}
 
inline int_vect_t InterruptController::intr_count() const
{
    return m_interrupts.size();
}
 
inline bool InterruptController::interrupt_raised(int_vect_t vector) const
{
    return m_interrupts[vector].raised;
}
 
 
//=======================================================================================
class AVR_CORE_PUBLIC_API InterruptHandler {
 
    friend class InterruptController;
 
public:
 
    InterruptHandler();
    virtual ~InterruptHandler();
 
    //Controlling method for raising (or cancelling) interrupts
    //It can actually raise any interrupt so long as it has been
    //registered with the controller
    void raise_interrupt(int_vect_t vector) const;
    void cancel_interrupt(int_vect_t vector) const;
    bool interrupt_raised(int_vect_t vector) const;
 
    virtual bool interrupt_ack_handler(int_vect_t vector) = 0;
 
    //Disable copy semantics
    InterruptHandler(const InterruptHandler&) = delete;
    InterruptHandler& operator=(const InterruptHandler&) = delete;
 
private:
 
    InterruptController* m_intctl;
 
};
 
 
//=======================================================================================
class AVR_CORE_PUBLIC_API AbstractInterruptFlag : public InterruptHandler {
 
public:
 
    explicit AbstractInterruptFlag(bool clear_on_ack = false);
 
    bool init(Device& device, int_vect_t vector);
 
    int update();
 
    bool raised() const;
 
    //Override, returns the value of clear_on_ack
    virtual bool interrupt_ack_handler(int_vect_t vector) override;
 
protected:
 
    bool clear_on_ack() const;
 
    virtual bool flag_raised() const = 0;
 
private:
 
    bool m_clr_on_ack;
    int_vect_t m_vector;
 
};
 
inline bool AbstractInterruptFlag::raised() const
{
    return interrupt_raised(m_vector);
}
 
inline bool AbstractInterruptFlag::clear_on_ack() const
{
    return m_clr_on_ack;
}
 
 
//=======================================================================================
class AVR_CORE_PUBLIC_API InterruptFlag : public AbstractInterruptFlag, public IORegHandler {
 
public:
 
    explicit InterruptFlag(bool clear_on_ack = false);
 
    bool init(Device& device, const regmask_t& rm_enable, const regmask_t& rm_flag, int_vect_t vector);
 
    bool set_flag(bitmask_t mask = 0xFF);
    bool clear_flag(bitmask_t mask = 0xFF);
 
private:
 
    regmask_t m_rm_enable;
    regmask_t m_rm_flag;
 
    IORegister* m_flag_reg;
    IORegister* m_enable_reg;
 
    virtual bool flag_raised() const override final;
    //Override to clear the flag on ACK if clear_on_ack is true
    virtual bool interrupt_ack_handler(int_vect_t vector) override final;
 
    virtual uint8_t ioreg_read_handler(reg_addr_t addr, uint8_t value) override final;
    virtual uint8_t ioreg_peek_handler(reg_addr_t addr, uint8_t value) override final;
    virtual void ioreg_write_handler(reg_addr_t addr, const ioreg_write_t& data) override final;
 
};
 
 
YASIMAVR_END_NAMESPACE
 
#endif //__YASIMAVR_INTERRUPT_H__