AbstractIDEDevice.hh

Go to the documentation of this file.

#ifndef ABSTRACTIDEDEVICE_HH
#define ABSTRACTIDEDEVICE_HH
 
#include "IDEDevice.hh"
#include "AlignedBuffer.hh"
#include "serialize_meta.hh"
#include <string>
 
namespace openmsx {
 
class MSXMotherBoard;
 
class AbstractIDEDevice : public IDEDevice
{
public:
        void reset(EmuTime::param time) override;
 
        [[nodiscard]] word readData(EmuTime::param time) override;
        [[nodiscard]] byte readReg(nibble reg, EmuTime::param time) override;
 
        void writeData(word value, EmuTime::param time) override;
        void writeReg(nibble reg, byte value, EmuTime::param time) override;
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
protected:
        // Bit flags for the status register:
        static constexpr byte DRDY = 0x40;
        static constexpr byte DSC = 0x10;
        static constexpr byte DRQ = 0x08;
        static constexpr byte ERR = 0x01;
 
        // Bit flags for the error register:
        static constexpr byte UNC = 0x40;
        static constexpr byte IDNF = 0x10;
        static constexpr byte ABORT = 0x04;
 
        explicit AbstractIDEDevice(MSXMotherBoard& motherBoard);
        ~AbstractIDEDevice() override = default;
 
        [[nodiscard]] virtual bool isPacketDevice() = 0;
 
        [[nodiscard]] virtual std::string_view getDeviceName() = 0;
 
        virtual void fillIdentifyBlock(AlignedBuffer& buffer) = 0;
 
        [[nodiscard]] virtual unsigned readBlockStart(AlignedBuffer& buffer, unsigned count) = 0;
 
        virtual void readEnd();
 
        virtual void writeBlockComplete(AlignedBuffer& buffer, unsigned count) = 0;
 
        virtual void executeCommand(byte cmd);
 
        void setError(byte error);
 
        [[nodiscard]] unsigned getSectorNumber() const;
 
        [[nodiscard]] unsigned getNumSectors() const;
 
        void setInterruptReason(byte value);
 
        [[nodiscard]] unsigned getByteCount() const;
 
        void setByteCount(unsigned count);
 
        void setSectorNumber(unsigned lba);
 
        void startLongReadTransfer(unsigned count);
 
        [[nodiscard]] AlignedBuffer& startShortReadTransfer(unsigned count);
 
        void abortReadTransfer(byte error);
 
        void startWriteTransfer(unsigned count);
 
        void abortWriteTransfer(byte error);
 
        [[nodiscard]] byte getFeatureReg() const { return featureReg; }
        void setLBALow (byte value) { sectorNumReg    = value; }
        void setLBAMid (byte value) { cylinderLowReg  = value; }
        void setLBAHigh(byte value) { cylinderHighReg = value; }
 
        [[nodiscard]] MSXMotherBoard& getMotherBoard() const { return motherBoard; }
 
private:
        [[nodiscard]] byte diagnostic() const;
 
        void createSignature(bool preserveDevice = false);
 
        void createIdentifyBlock(AlignedBuffer& buffer);
 
        void startReadTransfer();
 
        void readNextBlock();
 
        void setTransferRead(bool status);
 
        void writeNextBlock();
 
        void setTransferWrite(bool status);
 
private:
        MSXMotherBoard& motherBoard;
 
        AlignedByteArray<512> buffer;
 
        unsigned transferIdx = 0; // avoid UMR on serialize
 
        unsigned bufferLeft = 0;
 
        unsigned transferCount = 0;
 
        // ATA registers:
        byte errorReg;
        byte sectorCountReg;
        byte sectorNumReg;
        byte cylinderLowReg;
        byte cylinderHighReg;
        byte devHeadReg;
        byte statusReg;
        byte featureReg;
 
        bool transferRead = false;
        bool transferWrite = false;
};
 
REGISTER_BASE_NAME_HELPER(AbstractIDEDevice, "IDEDevice");
 
} // namespace openmsx
 
#endif // ABSTRACTIDEDEVICE_HH