IRQHelper.hh

Go to the documentation of this file.

#ifndef IRQHELPER_HH
#define IRQHELPER_HH

#include "Probe.hh"
#include "MSXMotherBoard.hh"
#include "serialize.hh"
#include <memory>
#include <string>

namespace openmsx {

class MSXCPU;
class DeviceConfig;

// policy class for IRQ source
class IRQSource
{
protected:
        explicit IRQSource(MSXCPU& cpu);
        void raise();
        void lower();
private:
        MSXCPU& cpu;
};

// supports <optional_irq> tag in hardware config

class IRQSink
{
public:
        virtual ~IRQSink() = default;
        virtual void raise() = 0;
        virtual void lower() = 0;
};

class OptionalIRQ
{
protected:
        OptionalIRQ(MSXCPU& cpu, const DeviceConfig& config);
        void raise() { sink->raise(); }
        void lower() { sink->lower(); }
private:
        std::unique_ptr<IRQSink> sink;
};


// generic implementation
template <typename SOURCE> class IntHelper : public SOURCE
{
public:
        IntHelper(const IntHelper&) = delete;
        IntHelper& operator=(const IntHelper&) = delete;

        IntHelper(MSXMotherBoard& motherboard, const std::string& name)
                : SOURCE(motherboard.getCPU())
                , request(motherboard.getDebugger(), name,
                          "Outgoing IRQ signal.", false)
        {
        }
        IntHelper(MSXMotherBoard& motherboard, const std::string& name,
                  const DeviceConfig& config)
                : SOURCE(motherboard.getCPU(), config)
                , request(motherboard.getDebugger(), name,
                          "Outgoing IRQ signal.", false)
        {
        }

        ~IntHelper() {
                reset();
        }

        inline void set() {
                if (!request) {
                        request = true;
                        SOURCE::raise();
                }
        }

        inline void reset() {
                if (request) {
                        request = false;
                        SOURCE::lower();
                }
        }

        inline void set(bool s) {
                if (s) {
                        set();
                } else {
                        reset();
                }
        }

        inline bool getState() const {
                return request;
        }

        template<typename Archive>
        void serialize(Archive& ar, unsigned /*version*/)
        {
                bool pending = request;
                ar.serialize("pending", pending);
                if (ar.isLoader()) {
                        set(pending);
                }
        }

private:
        Probe<bool> request;
};

// convenience types
using IRQHelper         = IntHelper<IRQSource>;
using OptionalIRQHelper = IntHelper<OptionalIRQ>;

} // namespace openmsx

#endif