FinalV1.java

package libsidplay.components.cart.supported;

import libsidplay.common.Event;
import libsidplay.common.Event.Phase;
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;

/**
 * CRT 13: Final Cartridge I/II, with 16 KiB ROM and ROM mirrors in both I/O pages.
 * I/O-1 disables ROM; I/O-2 enables it. Both acknowledge the cartridge's NMI.
 * Reference: VICE vice/src/c64/cart/final.c and c64cart.c.
 */
public class FinalV1 extends Cartridge {
    protected final byte[] roml = new byte[0x2000];
    protected final byte[] romh = new byte[0x2000];
    private boolean detached;
    private boolean busAvailable = true;
    private boolean freezeRequested;

    public FinalV1(final DataInputStream input, final PLA pla) throws IOException {
        super(pla);
        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 Final Cartridge I CHIP header");
            if (header[0] != 'C' || header[1] != 'H' || header[2] != 'I' || header[3] != 'P') {
                throw new IOException("Invalid Final Cartridge I CHIP signature");
            }
            if (++records > 1) throw new IOException("Too many Final Cartridge I CHIP records");
            long length = (long) u16(header, 4) << 16 | u16(header, 6);
            int type = u16(header, 8), bank = u16(header, 10), address = u16(header, 12), size = u16(header, 14);
            if (length < 0x4010 || (type != 0 && type != 2) || bank != 0 || address != 0x8000 || size != 0x4000) {
                throw new IOException("Invalid Final Cartridge I CHIP record");
            }
            try {
                input.readFully(roml);
                input.readFully(romh);
            } catch (EOFException e) {
                throw new EOFException("Truncated Final Cartridge I CHIP payload");
            }
            skipFully(input, length - 0x4010, "Truncated Final Cartridge I CHIP padding");
        }
        if (records == 0) throw new IOException("Final Cartridge I requires one CHIP record");
    }

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

    private void selectRom(boolean enabled) {
        if (detached) return;
        pla.setGameExrom(!enabled, !enabled);
        setNMI(false);
    }

    private final Bank io1Bank = new Bank() {
        @Override public byte read(int address) {
            selectRom(false);
            return roml[0x1e00 | address & 0xff];
        }
        @Override public void write(int address, byte value) { selectRom(false); }
    };

    private final Bank io2Bank = new Bank() {
        @Override public byte read(int address) {
            selectRom(true);
            return roml[0x1f00 | address & 0xff];
        }
        @Override public void write(int address, byte value) { selectRom(true); }
    };

    private final Bank romlBank = new Bank() {
        @Override public byte read(int address) { return roml[address & 0x1fff]; }
        @Override public void write(int address, byte value) { }
    };

    private final Bank romhBank = new Bank() {
        @Override public byte read(int address) { return romh[address & 0x1fff]; }
        @Override public void write(int address, byte value) { }
    };

    private final Event freezeMapping = Event.of("Final Cartridge I freeze", event -> {
        pla.setGameExrom(false, true);
        setNMI(false);
    });

    @Override protected void doFreeze() {
        var scheduler = pla.getCPU().getEventScheduler();
        if (detached || freezeRequested || scheduler.isPending(freezeMapping)) return;
        // VICE dispatches the button alarm after stolen bus cycles. Starting
        // the pulse mid-DMA can disconnect an opcode before the CPU takes NMI.
        if (!busAvailable) {
            freezeRequested = true;
            return;
        }
        setNMI(true);
        scheduler.schedule(freezeMapping, 3, Phase.PHI1);
    }

    @Override public void changedBA(boolean state) {
        busAvailable = state;
        if (state && freezeRequested) {
            freezeRequested = false;
            doFreeze();
        }
    }

    @Override public void reset() {
        pla.getCPU().getEventScheduler().cancel(freezeMapping);
        super.reset();
        detached = false;
        busAvailable = true;
        freezeRequested = false;
        pla.setGameExrom(false, false);
    }

    @Override public void onDetach() {
        detached = true;
        freezeRequested = false;
        pla.getCPU().getEventScheduler().cancel(freezeMapping);
        setNMI(false);
        pla.setGameExrom(true, true);
    }

    @Override public Bank getRoml() { return romlBank; }
    @Override public Bank getRomh() { return romhBank; }
    @Override public Bank getIO1() { return io1Bank; }
    @Override public Bank getIO2() { return io2Bank; }
    @Override public String toString() { return "Final Cartridge I"; }
}