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"; }
}