AmdFlash.hh

Go to the documentation of this file.

#ifndef AMDFLASH_HH
#define AMDFLASH_HH
 
#include "MemBuffer.hh"
#include "serialize_meta.hh"
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <span>
 
namespace openmsx {
 
class MSXMotherBoard;
class Rom;
class SRAM;
class DeviceConfig;
 
class AmdFlash
{
public:
        struct SectorInfo {
                size_t size;
                bool writeProtected;
        };
        enum class Addressing {
                BITS_11,
                BITS_12,
        };
        enum class Load {
                NORMAL,
                DONT, // don't load nor save modified flash content
        };
 
        AmdFlash(const Rom& rom, std::span<const SectorInfo> sectorInfo,
                 uint16_t ID, Addressing addressing,
                 const DeviceConfig& config, Load load = Load::NORMAL);
        AmdFlash(const std::string& name, std::span<const SectorInfo> sectorInfo,
                 uint16_t ID, Addressing addressing,
                 const DeviceConfig& config);
        ~AmdFlash();
 
        void reset();
        void setVppWpPinLow(bool value) { vppWpPinLow = value; }
 
        [[nodiscard]] size_t size() const { return sz; }
        [[nodiscard]] uint8_t read(size_t address) const;
        [[nodiscard]] uint8_t peek(size_t address) const;
        void write(size_t address, uint8_t value);
        [[nodiscard]] const uint8_t* getReadCacheLine(size_t address) const;
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
//private:
        struct AmdCmd {
                size_t addr;
                uint8_t value;
 
                template<typename Archive>
                void serialize(Archive& ar, unsigned version);
        };
 
        enum State { ST_IDLE, ST_IDENT };
 
private:
        void init(const std::string& name, const DeviceConfig& config, Load load, const Rom* rom);
        struct GetSectorInfoResult { size_t sector, sectorSize, offset; };
        [[nodiscard]] GetSectorInfoResult getSectorInfo(size_t address) const;
 
        void setState(State newState);
        [[nodiscard]] bool checkCommandReset();
        [[nodiscard]] bool checkCommandEraseSector();
        [[nodiscard]] bool checkCommandEraseChip();
        [[nodiscard]] bool checkCommandProgramHelper(size_t numBytes, std::span<const uint8_t> cmdSeq);
        [[nodiscard]] bool checkCommandProgram();
        [[nodiscard]] bool checkCommandDoubleByteProgram();
        [[nodiscard]] bool checkCommandQuadrupleByteProgram();
        [[nodiscard]] bool checkCommandManufacturer();
        [[nodiscard]] bool partialMatch(std::span<const uint8_t> dataSeq) const;
 
        [[nodiscard]] bool isSectorWritable(size_t sector) const;
 
private:
        MSXMotherBoard& motherBoard;
        std::unique_ptr<SRAM> ram;
        MemBuffer<ptrdiff_t> writeAddress;
        MemBuffer<const uint8_t*> readAddress;
        const std::span<const SectorInfo> sectorInfo;
        const size_t sz;
        const uint16_t ID;
        const Addressing addressing;
 
        static constexpr unsigned MAX_CMD_SIZE = 8;
        std::array<AmdCmd, MAX_CMD_SIZE> cmd;
        unsigned cmdIdx;
        State state = ST_IDLE;
        bool vppWpPinLow = false; // true = protection on
};
SERIALIZE_CLASS_VERSION(AmdFlash, 2);
 
} // namespace openmsx
 
#endif