APU.hpp

Go to the documentation of this file.

//
// Created by Melefo on 24/01/2020.
//
 
#pragma once
 
#include <memory>
#include "DSP/DSP.hpp"
#include "Memory/AMemory.hpp"
#include "Ram/Ram.hpp"
#include "IPL/IPL.hpp"
#include "Renderer/IRenderer.hpp"
#include "Cartridge/Cartridge.hpp"
 
#ifdef DEBUGGER_ENABLED
#include "Debugger/APUDebug.hpp"
#endif
 
namespace ComSquare::APU
{
    struct InternalRegisters {
 
        uint8_t x;
 
        union {
            struct {
                uint8_t a;
                uint8_t y;
            };
            uint16_t ya;
        };
 
        uint8_t sp;
 
        union {
            struct {
                uint8_t pcl;
                uint8_t pch;
            };
            uint16_t pc;
        };
 
        union {
            struct {
                bool c : 1;
                bool z : 1;
                bool i : 1;
                bool h : 1;
                bool b : 1;
                bool p : 1;
                bool v : 1;
                bool n : 1;
            };
            uint8_t psw;
        };
    };
 
    struct Registers
    {
        uint8_t unknown;
 
        uint8_t ctrlreg;
 
        uint8_t dspregAddr;
 
        uint8_t port0;
        uint8_t port1;
        uint8_t port2;
        uint8_t port3;
 
        uint8_t regmem1;
        uint8_t regmem2;
 
        uint8_t timer0;
        uint8_t timer1;
        uint8_t timer2;
 
        uint8_t counter0;
        uint8_t counter1;
        uint8_t counter2;
 
    };
 
    enum StateMode
    {
        Running,
        Sleeping,
        Stopped
    };
 
    struct MemoryMap
    {
        Ram::Ram Page0;
        Ram::Ram Page1;
        Ram::Ram Memory;
        IPL::IPL IPL;
 
        MemoryMap();
        MemoryMap(const MemoryMap &) = delete;
        MemoryMap &operator=(const MemoryMap &) = delete;
        ~MemoryMap() = default;
    };
 
    class APU : public Memory::AMemory {
    private:
        Registers _registers{};
        InternalRegisters _internalRegisters{};
 
        MemoryMap _map;
 
        DSP::DSP _dsp;
 
        [[nodiscard]] uint8_t _internalRead(uint24_t addr) const;
 
        void _internalWrite(uint24_t addr, uint8_t data);
 
        StateMode _state = Running;
 
        unsigned int _paddingCycles = 0;
 
        uint8_t _getImmediateData();
        uint24_t _getDirectAddr();
        uint24_t _getIndexXAddr();
        uint24_t _getIndexYAddr();
        uint24_t _getDirectAddrByX();
        uint24_t _getDirectAddrByY();
        uint24_t _getAbsoluteAddr();
        uint24_t _getAbsoluteByXAddr();
        uint24_t _getAbsoluteAddrByX();
        uint24_t _getAbsoluteAddrByY();
        uint24_t _getAbsoluteDirectByXAddr();
        uint24_t _getAbsoluteDirectAddrByY();
        std::pair<uint24_t, uint24_t> _getAbsoluteBit();
 
        void _setNZflags(uint8_t value);
 
        int _executeInstruction();
 
        int NOP();
        int SLEEP();
        int STOP();
 
        int CLRC();
        int SETC();
        int NOTC();
        int CLRV();
        int CLRP();
        int SETP();
        int EI();
        int DI();
 
        int SET1(uint24_t dp, uint8_t bit);
        int CLR1(uint24_t dp, uint8_t bit);
        int TSET1(uint24_t abs);
        int TCLR1(uint24_t abs);
        int AND1(std::pair<uint24_t, uint24_t> operand, bool invert = false);
        int OR1(std::pair<uint24_t, uint24_t> operand, bool invert = false);
        int EOR1(std::pair<uint24_t, uint24_t> operand);
        int NOT1(std::pair<uint24_t, uint24_t> operand);
        int MOV1(std::pair<uint24_t, uint24_t> operand, bool to_carry = false);
 
        int PUSH(uint8_t value);
        int POP(uint8_t &destination);
 
        int CALL(uint24_t abs);
        int PCALL();
        int TCALL(uint8_t bit);
        int BRK();
        int RET();
        int RETI();
 
        int BRA(int8_t offset);
        int BEQ(int8_t offset);
        int BNE(int8_t offset);
        int BCS(int8_t offset);
        int BCC(int8_t offset);
        int BVS(int8_t offset);
        int BVC(int8_t offset);
        int BMI(int8_t offset);
        int BPL(int8_t offset);
        int BBS(uint24_t addr, int8_t offset, uint8_t bit);
        int BBC(uint24_t addr, int8_t offset, uint8_t bit);
        int CBNE(uint24_t addr, int8_t offset, bool by_x = false);
        int DBNZ(int8_t offset, bool direct_addr = false);
        int JMP(uint24_t addr, bool by_x = false);
 
        int DAA();
        int DAS();
 
        int MUL();
        int DIV();
 
        int INCW(uint24_t addr);
        int DECW(uint24_t addr);
        int ADDW(uint24_t addr);
        int SUBW(uint24_t addr);
        int CMPW(uint24_t addr);
 
        int MOVW(uint24_t addr, bool to_ya = false);
 
        int ASL(uint24_t operand, int cycles, bool accumulator = false);
        int LSR(uint24_t operand, int cycles, bool accumulator = false);
        int ROL(uint24_t operand, int cycles, bool accumulator = false);
        int ROR(uint24_t operand, int cycles, bool accumulator = false);
        int XCN();
 
        int INC(uint24_t addr, int cycles);
        int INCreg(uint8_t &value);
        int DEC(uint24_t addr, int cycles);
        int DECreg(uint8_t &value);
 
        int AND(uint24_t operand1, uint24_t operand2, int cycles);
        int ANDacc(uint24_t addr, int cycles);
        int OR(uint24_t operand1, uint24_t operand2, int cycles);
        int ORacc(uint24_t addr, int cycles);
        int EOR(uint24_t operand1, uint24_t operand2, int cycles);
        int EORacc(uint24_t addr, int cycles);
 
        int ADC(uint24_t operand1, uint24_t operand2, int cycles);
        int ADCacc(uint24_t addr, int cycles);
        int SBC(uint24_t operand1, uint24_t operand2, int cycles);
        int SBCacc(uint24_t addr, int cycles);
        int CMP(uint24_t operand1, uint24_t operand2, int cycles);
        int CMPreg(uint8_t  &reg, uint24_t addr, int cycles);
 
        int MOV(uint8_t &regFrom, uint8_t &regTo, bool setFlags = true);
        int MOV(uint8_t &regFrom, uint24_t memTo, int cycles, bool incrementX = false);
        int MOV(uint24_t memFrom, uint8_t &regTo, int cycles, bool incrementX = false);
        int MOV(uint24_t memFrom, uint24_t memTo);
    public:
        explicit APU(Renderer::IRenderer &renderer);
        APU(const APU &) = default;
        APU &operator=(const APU &) = delete;
        ~APU() override = default;
 
        bool isDisabled = false;
 
        uint8_t read(uint24_t addr) override;
 
        void write(uint24_t addr, uint8_t data) override;
 
        [[nodiscard]] std::string getName() const override;
 
        [[nodiscard]] Component getComponent() const override;
 
        [[nodiscard]] std::string getValueName(uint24_t addr) const override;
 
        [[nodiscard]] uint24_t getSize() const override;
 
        void loadFromSPC(Cartridge::Cartridge &cartridge);
 
        void update(unsigned cycles);
 
        void reset();
 
#ifdef DEBUGGER_ENABLED
        friend Debugger::APU::APUDebug;
#endif
    };
}