MSXDevice.hh

Go to the documentation of this file.

#ifndef MSXDEVICE_HH
#define MSXDEVICE_HH

#include "DeviceConfig.hh"
#include "EmuTime.hh"
#include "openmsx.hh"
#include "serialize_meta.hh"
#include <string>
#include <vector>
#include <utility> // for pair

namespace openmsx {

class XMLElement;
class MSXMotherBoard;
class MSXCPU;
class MSXCPUInterface;
class Scheduler;
class CliComm;
class Reactor;
class CommandController;
class LedStatus;
class PluggingController;
class HardwareConfig;
class TclObject;

class MSXDevice
{
public:
        MSXDevice(const MSXDevice&) = delete;
        MSXDevice& operator=(const MSXDevice&) = delete;

        using Devices = std::vector<MSXDevice*>;

        virtual ~MSXDevice() = 0;

        const HardwareConfig& getHardwareConfig() const {
                return deviceConfig.getHardwareConfig();
        }

        void testRemove(Devices alreadyRemoved) const;

        virtual void reset(EmuTime::param time);

        virtual byte readIRQVector();

        virtual void powerDown(EmuTime::param time);

        virtual void powerUp(EmuTime::param time);

        virtual std::string getName() const;

        virtual void getNameList(TclObject& result) const;

        void getDeviceInfo(TclObject& result) const;

        void getVisibleMemRegion(unsigned& base, unsigned& size) const;

        // IO

        virtual byte readIO(word port, EmuTime::param time);

        virtual void writeIO(word port, byte value, EmuTime::param time);

        virtual byte peekIO(word port, EmuTime::param time) const;


        // Memory

        virtual byte readMem(word address, EmuTime::param time);

        virtual void writeMem(word address, byte value, EmuTime::param time);

        virtual const byte* getReadCacheLine(word start) const;

        virtual byte* getWriteCacheLine(word start) const;

        virtual byte peekMem(word address, EmuTime::param time) const;

        virtual void globalWrite(word address, byte value, EmuTime::param time);

        virtual void globalRead(word address, EmuTime::param time);

        void invalidateMemCache(word start, unsigned size);

        MSXMotherBoard& getMotherBoard() const;

        const XMLElement& getDeviceConfig() const {
                return *deviceConfig.getXML();
        }
        const DeviceConfig& getDeviceConfig2() const { // TODO
                return deviceConfig;
        }

        const Devices& getReferences() const;

        // convenience functions, these delegate to MSXMotherBoard
        EmuTime::param getCurrentTime() const;
        MSXCPU& getCPU() const;
        MSXCPUInterface& getCPUInterface() const;
        Scheduler& getScheduler() const;
        CliComm& getCliComm() const;
        Reactor& getReactor() const;
        CommandController& getCommandController() const;
        PluggingController& getPluggingController() const;
        LedStatus& getLedStatus() const;

        template<typename Archive>
        void serialize(Archive& ar, unsigned version);

protected:
        MSXDevice(const DeviceConfig& config, const std::string& name);
        explicit MSXDevice(const DeviceConfig& config);

        friend class DeviceFactory;
        virtual void init();

        virtual void getExtraDeviceInfo(TclObject& result) const;

public:
        // public to allow non-MSXDevices to use these same arrays
        static byte unmappedRead [0x10000]; // Read only
        static byte unmappedWrite[0x10000]; // Write only

private:
        void initName(const std::string& name);
        void staticInit();

        void lockDevices();
        void unlockDevices();

        void registerSlots();
        void unregisterSlots();

        void registerPorts();
        void unregisterPorts();

        using MemRegions = std::vector<std::pair<unsigned, unsigned>>;
        MemRegions memRegions;
        std::vector<byte> inPorts;
        std::vector<byte> outPorts;

        DeviceConfig deviceConfig;
        std::string deviceName;

        Devices references;
        Devices referencedBy;

        int ps;
        int ss;
};

REGISTER_BASE_NAME_HELPER(MSXDevice, "Device");

#define REGISTER_MSXDEVICE(CLASS, NAME) \
REGISTER_POLYMORPHIC_INITIALIZER(MSXDevice, CLASS, NAME);

} // namespace openmsx

#endif