CPU1541.h

Go to the documentation of this file.

/*
 *  CPU1541.h - 6502 (1541) emulation (line based)
 *
 *  Frodo (C) 1994-1997 Christian Bauer
 */

#ifndef _CPU_1541_H
#define _CPU_1541_H

#include "CIA.h"
#include "C64.h"


// Set this to 1 if the 6502 PC should be represented by a real pointer
#ifndef FRODO_SC
#ifndef PC_IS_POINTER
#define PC_IS_POINTER 1
#endif
#endif

// Set this to 1 for more precise CPU cycle calculation
#ifndef PRECISE_CPU_CYCLES
#define PRECISE_CPU_CYCLES 0
#endif


// Interrupt types
enum {
        INT_VIA1IRQ,
        INT_VIA2IRQ,
        INT_IECIRQ
        // INT_RESET (private)
};


class C64;
class Job1541;
class C64Display;
struct MOS6502State;


// 6502 emulation (1541)
class MOS6502_1541 {
public:
        MOS6502_1541(C64 *c64, Job1541 *job, C64Display *disp, uint8 *Ram, uint8 *Rom);
        ~MOS6502_1541();

#ifdef FRODO_SC
        void EmulateCycle(void);                        // Emulate one clock cycle
#else
        int EmulateLine(int cycles_left);       // Emulate until cycles_left underflows
#endif
        void Reset(void);
        void AsyncReset(void);                          // Reset the CPU asynchronously
        void GetState(MOS6502State *s);
        void SetState(MOS6502State *s);
        uint8 ExtReadByte(uint16 adr);
        void ExtWriteByte(uint16 adr, uint8 byte);
        void CountVIATimers(int cycles);
        void NewATNState(void);
        void IECInterrupt(void);
        void TriggerJobIRQ(void);
        bool InterruptEnabled(void);

        MOS6526_2 *TheCIA2;             // Pointer to C64 CIA 2

        uint8 IECLines;                 // State of IEC lines (bit 7 - DATA, bit 6 - CLK)
        bool Idle;                              // true: 1541 is idle

private:
        uint8 read_byte(uint16 adr);
        uint8 read_byte_io(uint16 adr);
        uint16 read_word(uint16 adr);
        void write_byte(uint16 adr, uint8 byte);
        void write_byte_io(uint16 adr, uint8 byte);

        uint8 read_zp(uint16 adr);
        uint16 read_zp_word(uint16 adr);
        void write_zp(uint16 adr, uint8 byte);

        void jump(uint16 adr);
        void illegal_op(uint8 op, uint16 at);
        void illegal_jump(uint16 at, uint16 to);

        void do_adc(uint8 byte);
        void do_sbc(uint8 byte);

        uint8 *ram;                             // Pointer to main RAM
        uint8 *rom;                             // Pointer to ROM
        C64 *the_c64;                   // Pointer to C64 object
        C64Display *the_display; // Pointer to C64 display object
        Job1541 *the_job;               // Pointer to 1541 job object

        union {                                 // Pending interrupts
                uint8 intr[4];          // Index: See definitions above
                unsigned long intr_any;
        } interrupt;

        uint8 n_flag, z_flag;
        bool v_flag, d_flag, i_flag, c_flag;
        uint8 a, x, y, sp;
#if PC_IS_POINTER
        uint8 *pc, *pc_base;
#else
        uint16 pc;
#endif

#ifdef FRODO_SC
        uint32 first_irq_cycle;

        uint8 state, op;                // Current state and opcode
        uint16 ar, ar2;                 // Address registers
        uint8 rdbuf;                    // Data buffer for RMW instructions
        uint8 ddr, pr;                  // Processor port
#else
        int borrowed_cycles;    // Borrowed cycles from next line
#endif

        uint8 via1_pra;         // PRA of VIA 1
        uint8 via1_ddra;        // DDRA of VIA 1
        uint8 via1_prb;         // PRB of VIA 1
        uint8 via1_ddrb;        // DDRB of VIA 1
        uint16 via1_t1c;                // T1 Counter of VIA 1
        uint16 via1_t1l;                // T1 Latch of VIA 1
        uint16 via1_t2c;                // T2 Counter of VIA 1
        uint16 via1_t2l;                // T2 Latch of VIA 1
        uint8 via1_sr;          // SR of VIA 1
        uint8 via1_acr;         // ACR of VIA 1
        uint8 via1_pcr;         // PCR of VIA 1
        uint8 via1_ifr;         // IFR of VIA 1
        uint8 via1_ier;         // IER of VIA 1

        uint8 via2_pra;         // PRA of VIA 2
        uint8 via2_ddra;        // DDRA of VIA 2
        uint8 via2_prb;         // PRB of VIA 2
        uint8 via2_ddrb;        // DDRB of VIA 2
        uint16 via2_t1c;                // T1 Counter of VIA 2
        uint16 via2_t1l;                // T1 Latch of VIA 2
        uint16 via2_t2c;                // T2 Counter of VIA 2
        uint16 via2_t2l;                // T2 Latch of VIA 2
        uint8 via2_sr;          // SR of VIA 2
        uint8 via2_acr;         // ACR of VIA 2
        uint8 via2_pcr;         // PCR of VIA 2
        uint8 via2_ifr;         // IFR of VIA 2
        uint8 via2_ier;         // IER of VIA 2
};

// 6502 state
struct MOS6502State {
        uint8 a, x, y;
        uint8 p;                        // Processor flags
        uint16 pc, sp;

        uint8 intr[4];          // Interrupt state
        bool instruction_complete;
        bool idle;

        uint8 via1_pra;         // VIA 1
        uint8 via1_ddra;
        uint8 via1_prb;
        uint8 via1_ddrb;
        uint16 via1_t1c;
        uint16 via1_t1l;
        uint16 via1_t2c;
        uint16 via1_t2l;
        uint8 via1_sr;
        uint8 via1_acr;
        uint8 via1_pcr;
        uint8 via1_ifr;
        uint8 via1_ier;

        uint8 via2_pra;         // VIA 2
        uint8 via2_ddra;
        uint8 via2_prb;
        uint8 via2_ddrb;
        uint16 via2_t1c;
        uint16 via2_t1l;
        uint16 via2_t2c;
        uint16 via2_t2l;
        uint8 via2_sr;
        uint8 via2_acr;
        uint8 via2_pcr;
        uint8 via2_ifr;
        uint8 via2_ier;
};



/*
 *  Trigger job loop IRQ
 */

#ifdef FRODO_SC
inline void MOS6502_1541::TriggerJobIRQ(void)
{
        if (!(interrupt.intr[INT_VIA2IRQ]))
                first_irq_cycle = the_c64->CycleCounter;
        interrupt.intr[INT_VIA2IRQ] = true;
        Idle = false;
}
#else
inline void MOS6502_1541::TriggerJobIRQ(void)
{
        interrupt.intr[INT_VIA2IRQ] = true;
        Idle = false;
}
#endif


/*
 *  Count VIA timers
 */

inline void MOS6502_1541::CountVIATimers(int cycles)
{
        unsigned long tmp;

        via1_t1c = tmp = via1_t1c - cycles;
        if (tmp > 0xffff) {
                if (via1_acr & 0x40)    // Reload from latch in free-run mode
                        via1_t1c = via1_t1l;
                via1_ifr |= 0x40;
        }

        if (!(via1_acr & 0x20)) {       // Only count in one-shot mode
                via1_t2c = tmp = via1_t2c - cycles;
                if (tmp > 0xffff)
                        via1_ifr |= 0x20;
        }

        via2_t1c = tmp = via2_t1c - cycles;
        if (tmp > 0xffff) {
                if (via2_acr & 0x40)    // Reload from latch in free-run mode
                        via2_t1c = via2_t1l;
                via2_ifr |= 0x40;
                if (via2_ier & 0x40)
                        TriggerJobIRQ();
        }

        if (!(via2_acr & 0x20)) {       // Only count in one-shot mode
                via2_t2c = tmp = via2_t2c - cycles;
                if (tmp > 0xffff)
                        via2_ifr |= 0x20;
        }
}


/*
 *  ATN line probably changed state, recalc IECLines
 */

inline void MOS6502_1541::NewATNState(void)
{
        uint8 byte = ~via1_prb & via1_ddrb;
        IECLines = (byte << 6) & ((~byte ^ TheCIA2->IECLines) << 3) & 0x80      // DATA (incl. ATN acknowledge)
                | (byte << 3) & 0x40;                                                                                   // CLK
}


/*
 *  Interrupt by negative edge of ATN on IEC bus
 */

inline void MOS6502_1541::IECInterrupt(void)
{
        ram[0x7c] = 1;

        // Wake up 1541
        Idle = false;
}


/*
 *  Test if interrupts are enabled (for job loop)
 */

inline bool MOS6502_1541::InterruptEnabled(void)
{
        return !i_flag;
}

#endif

---