MSXDevice.hh

Go to the documentation of this file.

#ifndef MSXDEVICE_HH
#define MSXDEVICE_HH
 
#include "DeviceConfig.hh"
#include "EmuTime.hh"
#include "IterableBitSet.hh"
#include "narrow.hh"
#include "openmsx.hh"
#include "serialize_meta.hh"
#include <array>
#include <cassert>
#include <span>
#include <string>
#include <vector>
 
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(std::span<const std::unique_ptr<MSXDevice>> removed) 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 const 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, std::string_view 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 std::array<byte, 0x10000> unmappedRead;  // Read only
        static inline std::array<byte, 0x10000> unmappedWrite; // Write only
 
private:
        template<typename Action, typename... Args>
        void clip(unsigned start, unsigned size, Action action, Args... args);
 
        void initName(std::string_view name);
        static void staticInit();
 
        void lockDevices();
        void unlockDevices();
 
        void registerSlots();
        void unregisterSlots();
 
        void registerPorts();
        void unregisterPorts();
 
protected:
        std::string deviceName;
 
        [[nodiscard]] byte getPrimarySlot() const {
                // must already be resolved to an actual slot
                assert((0 <= ps) && (ps <= 3));
                return narrow_cast<byte>(ps);
        }
 
private:
        struct BaseSize {
                unsigned base;
                unsigned size;
                [[nodiscard]] unsigned end() const { return base + size; }
        };
        using MemRegions = std::vector<BaseSize>;
        MemRegions memRegions;
        IterableBitSet<256> inPorts;
        IterableBitSet<256> outPorts;
 
        DeviceConfig deviceConfig;
 
        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