CartridgeWithREU.java

package libsidplay.components.cart;

import libsidplay.components.cart.supported.REU;
import libsidplay.components.pla.Bank;

/** One expansion-port cartridge containing a ROM cartridge and an explicitly selected REU. */
public final class CartridgeWithREU extends Cartridge {
    private final Cartridge cartridge;
    private final REU reu;

    public CartridgeWithREU(Cartridge cartridge, REU reu) {
        super(cartridge.pla);
        if (cartridge instanceof CartridgeWithREU || cartridge instanceof REU || cartridge.pla != reu.pla) {
            throw new IllegalArgumentException("A REU bundle requires one cartridge and one REU on the same PLA");
        }
        this.cartridge = cartridge;
        this.reu = reu;
    }

    public Cartridge getCartridge() { return cartridge; }
    public REU getREU() { return reu; }

    @Override public Bank getRoml() { return cartridge.getRoml(); }
    @Override public Bank getRomh() { return cartridge.getRomh(); }
    @Override public Bank getUltimaxMemory() { return cartridge.getUltimaxMemory(); }
    @Override public Bank getIO1() { return cartridge.getIO1(); }
    @Override public Bank getIO2() { return io2Bank; }

    private final Bank io2Bank = new Bank() {
        @Override public byte read(int address) {
            boolean cartDriven = cartridge.isIO2ReadDriven(address);
            boolean reuDriven = reu.isIO2ReadDriven(address);
            // Both devices see the access, even when a read only changes a latch.
            byte cartValue = cartridge.getIO2().read(address);
            byte reuValue = reu.getIO2().read(address);
            if (!cartDriven) return reuValue;
            if (!reuDriven) return cartValue;
            // Deterministic contention model; a conflicting ROM is not made REU-compatible.
            return (byte) (cartValue & reuValue);
        }

        @Override public void write(int address, byte value) {
            cartridge.getIO2().write(address, value);
            reu.getIO2().write(address, value);
        }
    };

    @Override public boolean isIO2ReadDriven(int address) {
        return cartridge.isIO2ReadDriven(address) || reu.isIO2ReadDriven(address);
    }

    @Override public void installBankHooks(Bank[] reads, Bank[] writes) {
        cartridge.installBankHooks(reads, writes);
        reu.installBankHooks(reads, writes);
    }

    @Override public void reset() {
        super.reset();
        cartridge.reset();
        reu.reset();
    }

    @Override protected void doFreeze() {
        if (pla.getCartridge().contains(cartridge)) cartridge.doFreeze();
    }

    @Override public void changedBA(boolean state) { changedBA(state, false); }

    @Override public void changedBA(boolean state, boolean lateSpriteDma) {
        cartridge.changedBA(state, lateSpriteDma);
        reu.changedBA(state, lateSpriteDma);
    }

    @Override public void changedNMI(boolean state) {
        cartridge.changedNMI(state);
        reu.changedNMI(state);
    }

    @Override public void nmiAcknowledged() {
        cartridge.nmiAcknowledged();
        reu.nmiAcknowledged();
    }

    @Override public void changedIRQ(boolean state) {
        cartridge.changedIRQ(state);
        reu.changedIRQ(state);
    }

    @Override public void clock() {
        cartridge.clock();
        reu.clock();
    }

    @Override public boolean contains(Cartridge device) {
        return this == device || cartridge.contains(device) || reu.contains(device);
    }

    @Override public void onDetach(Cartridge replacement) {
        cartridge.onDetach(replacement);
        reu.onDetach(replacement);
    }

    @Override public void onDetach() {
        cartridge.onDetach();
        reu.onDetach();
    }

    @Override public String toString() { return cartridge + " + " + reu; }
}