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;
 
        [[nodiscard]] const HardwareConfig& getHardwareConfig() const {
                return deviceConfig.getHardwareConfig();
        }
 
        void testRemove(Devices alreadyRemoved) const;
 
        virtual void reset(EmuTime::param time);
 
        [[nodiscard]] virtual byte readIRQVector();
 
        virtual void powerDown(EmuTime::param time);
 
        virtual void powerUp(EmuTime::param time);
 
        [[nodiscard]] virtual std::string getName() const;
 
        virtual void getNameList(TclObject& result) const;
 
        void getDeviceInfo(TclObject& result) const;
 
        void getVisibleMemRegion(unsigned& base, unsigned& size) const;
 
        // IO
 
        [[nodiscard]] virtual byte readIO(word port, EmuTime::param time);
 
        virtual void writeIO(word port, byte value, EmuTime::param time);
 
        [[nodiscard]] virtual byte peekIO(word port, EmuTime::param time) const;
 
 
        // Memory
 
        [[nodiscard]] virtual byte readMem(word address, EmuTime::param time);
 
        virtual void writeMem(word address, byte value, EmuTime::param time);
 
        [[nodiscard]] virtual const byte* getReadCacheLine(word start) const;
 
        [[nodiscard]] virtual byte* getWriteCacheLine(word start) const;
 
        [[nodiscard]] 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 invalidateDeviceRWCache() { invalidateDeviceRWCache(0x0000, 0x10000); }
        void invalidateDeviceRCache()  { invalidateDeviceRCache (0x0000, 0x10000); }
        void invalidateDeviceWCache()  { invalidateDeviceWCache (0x0000, 0x10000); }
        void invalidateDeviceRWCache(unsigned start, unsigned size);
        void invalidateDeviceRCache (unsigned start, unsigned size);
        void invalidateDeviceWCache (unsigned start, unsigned size);
 
        void fillDeviceRWCache(unsigned start, unsigned size, byte* rwData);
        void fillDeviceRWCache(unsigned start, unsigned size, const byte* rData, byte* wData);
        void fillDeviceRCache (unsigned start, unsigned size, const byte* rData);
        void fillDeviceWCache (unsigned start, unsigned size, byte* wData);
 
        [[nodiscard]] MSXMotherBoard& getMotherBoard() const;
 
        [[nodiscard]] const XMLElement& getDeviceConfig() const {
                return *deviceConfig.getXML();
        }
        [[nodiscard]] const DeviceConfig& getDeviceConfig2() const { // TODO
                return deviceConfig;
        }
 
        [[nodiscard]] const Devices& getReferences() const;
 
        // convenience functions, these delegate to MSXMotherBoard
        [[nodiscard]] EmuTime::param getCurrentTime() const;
        [[nodiscard]] MSXCPU& getCPU() const;
        [[nodiscard]] MSXCPUInterface& getCPUInterface() const;
        [[nodiscard]] Scheduler& getScheduler() const;
        [[nodiscard]] CliComm& getCliComm() const;
        [[nodiscard]] Reactor& getReactor() const;
        [[nodiscard]] CommandController& getCommandController() const;
        [[nodiscard]] PluggingController& getPluggingController() const;
        [[nodiscard]] 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();
 
        [[nodiscard]] virtual unsigned getBaseSizeAlignment() const;
 
        [[nodiscard]] virtual bool allowUnaligned() const { return false; }
 
        virtual void getExtraDeviceInfo(TclObject& result) const;
 
public:
        // public to allow non-MSXDevices to use these same arrays
        static inline byte unmappedRead [0x10000]; // Read only
        static inline byte unmappedWrite[0x10000]; // Write only
 
private:
        template<typename Action, typename... Args>
        void clip(unsigned start, unsigned size, Action action, Args... args);
 
        void initName(const std::string& name);
        static void staticInit();
 
        void lockDevices();
        void unlockDevices();
 
        void registerSlots();
        void unregisterSlots();
 
        void registerPorts();
        void unregisterPorts();
 
private:
        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 = 0;
        int ss = 0;
};
 
REGISTER_BASE_NAME_HELPER(MSXDevice, "Device");
 
#define REGISTER_MSXDEVICE(CLASS, NAME) \
REGISTER_POLYMORPHIC_INITIALIZER(MSXDevice, CLASS, NAME);
 
} // namespace openmsx
 
#endif