RetroReplay.java

package libsidplay.components.cart.supported;

import libsidplay.common.Event;
import libsidplay.components.cart.Cartridge;
import libsidplay.components.pla.Bank;
import libsidplay.components.pla.PLA;

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.util.Arrays;

import static java.nio.charset.StandardCharsets.US_ASCII;

/**
 * CRT 36: Retro Replay (subtype 0) / Nordic Replay (subtype 1).
 * Read-only flash, default boot-bank jumper and no clockport device.
 * Register/memory reference: VICE vice/src/c64/cart/retroreplay.c.
 */
public final class RetroReplay extends Cartridge {
    private final boolean nordic;
    private final byte[][] rom = new byte[16][8192];
    private final byte[] ram = new byte[32768];
    private boolean active, frozen, pending, detached, buttonPressed;
    private boolean writeOnce, allowBank, noFreeze, reuMapping, clockport;
    private boolean exportRam, exportA000Ram, phi1Ultimax;
    private int bank, mode, stackWrites;
    private long lastStackWrite;

    public RetroReplay(DataInputStream input, PLA pla, boolean nordic) throws IOException {
        super(pla);
        this.nordic = nordic;
        for (byte[] bytes : rom) Arrays.fill(bytes, (byte) 0xff);
        byte[] header = new byte[16];
        int records = 0;
        for (;;) {
            int count = readChipHeader(input, header);
            if (count == 0) break;
            if (count != header.length) throw new EOFException("Truncated Retro Replay CHIP header");
            if (!"CHIP".equals(new String(header, 0, 4, US_ASCII))) {
                throw new IOException("Invalid Retro Replay CHIP signature");
            }
            if (++records > 16) throw new IOException("Too many Retro Replay CHIP records");
            long length = (long) u16(header, 4) << 16 | u16(header, 6);
            int type = u16(header, 8), number = u16(header, 10), size = u16(header, 14);
            // Banked hardware does not decode the CHIP load-address metadata.
            if (length < 16L + size || (type != 0 && type != 2) || number > 15 || size != 8192) {
                throw new IOException("Invalid Retro Replay CHIP record");
            }
            try {
                input.readFully(rom[number]);
            } catch (EOFException e) {
                throw new EOFException("Truncated Retro Replay CHIP payload");
            }
            skipFully(input, length - 16 - size, "Truncated Retro Replay CHIP padding");
        }
        if (records != 4 && records != 8 && records != 16) {
            throw new IOException("Retro Replay requires 4, 8 or 16 CHIP records");
        }
    }

    private static int u16(byte[] bytes, int offset) {
        return (bytes[offset] & 255) << 8 | bytes[offset + 1] & 255;
    }

    private byte floating(int address) { return pla.getDisconnectedBusBank().read(address); }
    private int ioRamOffset(int address) { return (allowBank ? bank & 3 : 0) * 8192 + (address & 8191); }
    private int ramOffset(int address) { return (bank & 3) * 8192 + (address & 8191); }
    private int status() {
        return (bank & 3) << 3 | (bank & 4) << 5 | (allowBank ? 2 : 0)
                | (reuMapping ? 0x40 : 0) | (buttonPressed ? 4 : 0);
    }
    private void map() {
        int selected = frozen ? 3 : mode;
        pla.setGameExrom(!phi1Ultimax, phi1Ultimax,
                (selected & 1) == 0, (selected & 2) != 0);
    }

    private void control(int value) {
        bank = (value >> 3 & 3) | (value >> 5 & 4);
        mode = value & 3;
        exportA000Ram = (value & 0x67) == 0x22;
        exportRam = (value & 0x20) != 0;
        if (exportA000Ram) {
            mode = nordic ? 1 : 2;
            exportRam = !nordic;
        } else if ((value & 0x40) != 0 && frozen) {
            frozen = false;
            setNMI(false);
            setIRQ(false);
        }
        phi1Ultimax = false;
        active = (value & 4) == 0;
        map();
    }

    private byte ioRead(int address) {
        if (!active) return floating(address);
        int offset = address & 255;
        if ((address & 0xff00) == 0xde00) {
            if (offset <= 1) return (byte) status();
            if (clockport && offset < 16 || !reuMapping) return floating(address);
        } else if (reuMapping) return floating(address);
        if (frozen) return floating(address);
        if (exportRam || exportA000Ram) return ram[ioRamOffset(address)];
        return mode == 0 || mode == 2 ? rom[bank][address & 8191] : floating(address);
    }

    private void ioWrite(int address, byte value) {
        if (!active) return;
        int offset = address & 255;
        if ((address & 0xff00) == 0xde00) {
            if (offset == 0) { control(value & 255); return; }
            if (offset == 1) {
                if (!writeOnce) {
                    allowBank = (value & 2) != 0;
                    noFreeze = (value & 4) != 0;
                    reuMapping = (value & 0x40) != 0;
                    writeOnce = true;
                }
                bank = (value >> 3 & 3) | (value >> 5 & 4);
                clockport = (value & 1) != 0;
                map();
                return;
            }
            if (clockport && offset < 16 || !reuMapping) return;
        } else if (reuMapping) return;
        if (!frozen && (exportRam || nordic && exportA000Ram)) ram[ioRamOffset(address)] = value;
    }

    private final Bank ioBank = new Bank() {
        @Override public byte read(int address) { return ioRead(address); }
        @Override public void write(int address, byte value) { ioWrite(address, value); }
    };
    private final Bank romlBank = new Bank() {
        @Override public byte read(int address) {
            if (frozen) return floating(address);
            if (exportRam) return ram[ramOffset(address)];
            return mode == 1 && !exportA000Ram ? floating(address) : rom[bank][address & 8191];
        }
        @Override public void write(int address, byte value) {
            if (exportRam) ram[ramOffset(address)] = value;
        }
    };
    private final Bank romhBank = new Bank() {
        @Override public byte read(int address) {
            if (nordic && exportA000Ram && !frozen) return ram[ioRamOffset(address)];
            int selected = !allowBank && (exportRam || nordic && exportA000Ram) ? bank & ~3 : bank;
            return rom[selected][address & 8191];
        }
        @Override public void write(int address, byte value) {
            if (nordic && exportA000Ram && !frozen) ram[ioRamOffset(address)] = value;
            else pla.getRAMBank().write(address, value);
        }
    };
    private final Bank ultimaxBank = new Bank() {
        @Override public byte read(int address) {
            return nordic && exportA000Ram && (address & 0xe000) == 0xa000
                    ? ram[ioRamOffset(address)] : floating(address);
        }
        @Override public void write(int address, byte value) {
            if (nordic && exportA000Ram && (address & 0xe000) == 0xa000) ram[ioRamOffset(address)] = value;
        }
    };

    @Override public void installBankHooks(Bank[] reads, Bank[] writes) {
        if (nordic && exportRam) {
            for (int page = 8; page <= 9; page++) {
                Bank original = writes[page];
                if (original == romlBank) continue;
                writes[page] = new Bank() {
                    @Override public void write(int address, byte value) {
                        original.write(address, value);
                        ram[ramOffset(address)] = value;
                    }
                };
            }
        }
        if (nordic && exportA000Ram && !frozen) {
            for (int page = 10; page <= 11; page++) if (reads[page] == romhBank) writes[page] = romhBank;
        }
        if (pending) {
            Bank original = writes[0];
            writes[0] = new Bank() {
                @Override public void write(int address, byte value) {
                    original.write(address, value);
                    long cycle = pla.getCPU().getEventScheduler().getTime(Event.Phase.PHI2);
                    if ((address & 0xff00) != 0x100) { stackWrites = 0; return; }
                    stackWrites = cycle == lastStackWrite + 1 ? stackWrites + 1 : 1;
                    lastStackWrite = cycle;
                    if (stackWrites == 3) enterFrozen();
                }
            };
        }
    }

    private void enterFrozen() {
        pending = false;
        frozen = active = phi1Ultimax = true;
        mode = 3;
        bank = 0;
        exportRam = false;
        map();
        setNMI(false);
        setIRQ(false);
    }

    private final Event releaseButton = Event.of("Retro Replay button release", event -> buttonPressed = false);

    @Override public void doFreeze() {
        if (detached) return;
        var scheduler = pla.getCPU().getEventScheduler();
        buttonPressed = true;
        scheduler.cancel(releaseButton);
        scheduler.schedule(releaseButton, (long) Math.ceil(scheduler.getCyclesPerSecond() * 0.6), Event.Phase.PHI1);
        if (noFreeze || pending || frozen) return;
        pending = true;
        stackWrites = 0;
        lastStackWrite = Long.MIN_VALUE;
        map();
        // IRQ also lets the button freeze a machine whose NMI is already held.
        setNMI(true);
        setIRQ(true);
    }

    @Override public void reset() {
        pla.getCPU().getEventScheduler().cancel(releaseButton);
        super.reset();
        active = true;
        frozen = pending = detached = buttonPressed = false;
        writeOnce = allowBank = noFreeze = reuMapping = clockport = false;
        exportRam = exportA000Ram = phi1Ultimax = false;
        bank = mode = stackWrites = 0;
        map();
    }

    @Override public void onDetach() {
        detached = true;
        active = pending = frozen = buttonPressed = false;
        exportRam = exportA000Ram = false;
        pla.getCPU().getEventScheduler().cancel(releaseButton);
        setNMI(false);
        setIRQ(false);
        pla.setGameExrom(true, true);
    }

    @Override public Bank getRoml() { return romlBank; }
    @Override public Bank getRomh() { return romhBank; }
    @Override public Bank getUltimaxMemory() { return ultimaxBank; }
    @Override public Bank getIO1() { return ioBank; }
    @Override public Bank getIO2() { return ioBank; }
    @Override public boolean isIO2ReadDriven(int address) {
        return active && !reuMapping && !frozen && (exportRam || exportA000Ram || mode == 0 || mode == 2);
    }
    @Override public String toString() { return nordic ? "Nordic Replay" : "Retro Replay"; }
}