mirror of https://github.com/sanni/cartreader.git
859 lines
24 KiB
C++
859 lines
24 KiB
C++
//******************************************
|
|
// COMMODORE 64 MODULE
|
|
//******************************************
|
|
#ifdef ENABLE_C64
|
|
// Commodore 64
|
|
// Cartridge Pinout
|
|
// 44P 2.54mm pitch connector
|
|
//
|
|
// FRONT BACK
|
|
// SIDE SIDE
|
|
// +-------+
|
|
// GND -| 1 A |- GND
|
|
// +5VDC -| 2 B |- /ROMH
|
|
// +5VDC -| 3 C |- /RESET
|
|
// /IRQ -| 4 D |- /NMI
|
|
// R/W -| 5 E |- PHI2
|
|
// DOTCLK -| 6 F |- A15
|
|
// /IO1 -| 7 H |- A14
|
|
// /GAME -| 8 J |- A13
|
|
// /EXROM -| 9 K |- A12
|
|
// /IO2 -| 10 L |- A11
|
|
// /ROML -| 11 M |- A10
|
|
// BA -| 12 N |- A9
|
|
// /DMA -| 13 P |- A8
|
|
// D7 -| 14 R |- A7
|
|
// D6 -| 15 S |- A6
|
|
// D5 -| 16 T |- A5
|
|
// D4 -| 17 U |- A4
|
|
// D3 -| 18 V |- A3
|
|
// D2 -| 19 W |- A2
|
|
// D1 -| 20 X |- A1
|
|
// D0 -| 21 Y |- A0
|
|
// GND -| 22 Z |- GND
|
|
// +-------+
|
|
//
|
|
// TOP
|
|
// +---------------------------------------------------------------------------------------+
|
|
// | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
|
|
// LEFT | | RIGHT
|
|
// | A B C D E F H J K L M N P R S T U V W X Y Z |
|
|
// +---------------------------------------------------------------------------------------+
|
|
// BOTTOM
|
|
//
|
|
// CONTROL PINS:
|
|
// /RESET(PH0) - SNES RESET
|
|
// PHI2(PH1) - SNES CPUCLK
|
|
// /GAME(PH3) - SNES /CS
|
|
// /EXROM(PH4) - SNES /IRQ
|
|
// R/W(PH6) - SNES /RD
|
|
// /ROML(PL0) - SNES A16
|
|
// /ROMH(PL1) - SNES A17
|
|
// /IO1(PL2) - SNES A18
|
|
// /IO2(PL3) - SNES A19
|
|
|
|
//******************************************
|
|
// Defines
|
|
//******************************************
|
|
#define PHI2_ENABLE PORTH |= (1 << 1)
|
|
#define PHI2_DISABLE PORTH &= ~(1 << 1)
|
|
#define ROML_DISABLE PORTL |= (1 << 0)
|
|
#define ROML_ENABLE PORTL &= ~(1 << 0)
|
|
#define ROMH_DISABLE PORTL |= (1 << 1)
|
|
#define ROMH_ENABLE PORTL &= ~(1 << 1)
|
|
#define IO1_DISABLE PORTL |= (1 << 2)
|
|
#define IO1_ENABLE PORTL &= ~(1 << 2)
|
|
#define IO2_DISABLE PORTL |= (1 << 3)
|
|
#define IO2_ENABLE PORTL &= ~(1 << 3)
|
|
|
|
//******************************************
|
|
// Supported Mappers
|
|
//******************************************
|
|
// Supported Mapper Array
|
|
// Format = {c64mapper,c64lo,c64hi}
|
|
static const byte PROGMEM c64mapsize[] = {
|
|
0, 0, 3, // Normal 4K/8K/16K + Ultimax 8K/16K
|
|
1, 5, 5, // Action Replay 32K [UNTESTED]
|
|
2, 3, 3, // KCS Power Cartridge 16K [UNTESTED]
|
|
3, 6, 6, // Final Cartridge III 64K [UNTESTED]
|
|
4, 3, 3, // Simons Basic 16K [UNTESTED]
|
|
5, 7, 9, // Ocean 128K/256K/512K
|
|
6, 2, 2, // Expert Cartridge 8K [UNTESTED]
|
|
7, 7, 7, // Fun Play, Power Play 128K [UNTESTED]
|
|
8, 6, 6, // Super Games 64K [UNTESTED]
|
|
9, 5, 5, // Atomic Power 32K [UNTESTED]
|
|
10, 2, 2, // Epyx Fastload 8K [UNTESTED]
|
|
11, 3, 3, // Westermann Learning 16K [UNTESTED]
|
|
12, 1, 1, // Rex Utility 8K [UNTESTED]
|
|
13, 3, 3, // Final Cartridge I 16K [UNTESTED]
|
|
14, 6, 6, // Magic Formel 64K [UNTESTED]
|
|
15, 9, 9, // C64 Game System, System 3 512K [UNTESTED]
|
|
16, 3, 3, // WarpSpeed 16K [UNTESTED]
|
|
17, 7, 7, // Dinamic 128K [UNTESTED]
|
|
18, 4, 4, // Zaxxon, Super Zaxxon (SEGA) 20K [UNTESTED]
|
|
19, 5, 7, // Magic Desk, Domark, HES Australia 32K/64K/128K [UNTESTED]
|
|
20, 6, 6, // Super Snapshot 5 64K [UNTESTED]
|
|
21, 6, 6, // Comal-80 64K [UNTESTED]
|
|
};
|
|
|
|
int C64[] = { 4, 8, 12, 16, 20, 32, 64, 128, 256, 512 };
|
|
byte c64lo = 0; // Lowest Entry
|
|
byte c64hi = 9; // Highest Entry
|
|
|
|
byte c64mapcount = 22; // (sizeof(mapsize)/sizeof(mapsize[0])) / 3;
|
|
byte c64mapselect;
|
|
int c64index;
|
|
|
|
byte c64mapper;
|
|
byte c64size;
|
|
uint8_t c64banks;
|
|
byte c64port; // exrom+game
|
|
|
|
// EEPROM MAPPING
|
|
// 07 MAPPER
|
|
// 08 ROM SIZE
|
|
|
|
//******************************************
|
|
// MENU
|
|
//******************************************
|
|
// Base Menu
|
|
static const char* const menuOptionsC64[] PROGMEM = { FSTRING_SELECT_CART, FSTRING_READ_ROM, FSTRING_SET_SIZE, FSTRING_RESET };
|
|
|
|
void c64Menu() {
|
|
convertPgm(menuOptionsC64, 4);
|
|
uint8_t mainMenu = question_box(F("C64 MENU"), menuOptions, 4, 0);
|
|
|
|
switch (mainMenu) {
|
|
case 0:
|
|
// Select Cart
|
|
setCart_C64();
|
|
setup_C64();
|
|
break;
|
|
|
|
case 1:
|
|
// Read ROM
|
|
sd.chdir("/");
|
|
readROM_C64();
|
|
sd.chdir("/");
|
|
break;
|
|
|
|
case 2:
|
|
// Set Mapper + Size
|
|
setMapper_C64();
|
|
checkMapperSize_C64();
|
|
setROMSize_C64();
|
|
break;
|
|
|
|
case 3:
|
|
// reset
|
|
resetArduino();
|
|
break;
|
|
}
|
|
}
|
|
|
|
//******************************************
|
|
// SETUP
|
|
//******************************************
|
|
void setup_C64() {
|
|
// Request 5V
|
|
setVoltage(VOLTS_SET_5V);
|
|
|
|
// Set Address Pins to Output
|
|
// C64 uses A0-A15
|
|
//A0-A7
|
|
DDRF = 0xFF;
|
|
//A8-A15
|
|
DDRK = 0xFF;
|
|
//A16-A23 - Use A16-A19 for /ROML, /ROMH, /IO1, /IO2
|
|
DDRL = 0xFF;
|
|
|
|
// Set Control Pins to Output
|
|
// /RST(PH0) ---(PH5) R/W(PH6)
|
|
DDRH |= (1 << 0) | (1 << 5) | (1 << 6);
|
|
|
|
// Set Port Pins to Input
|
|
// /GAME(PH3) /EXROM(PH4)
|
|
DDRH &= ~((1 << 3) | (1 << 4));
|
|
|
|
// Set TIME(PJ0) to Output (UNUSED)
|
|
DDRJ |= (1 << 0);
|
|
|
|
// Set Pins (D0-D7) to Input
|
|
DDRC = 0x00;
|
|
|
|
// Setting Control Pins to HIGH
|
|
// /RST(PH0) ---(PH5) R/W(PH6)
|
|
PORTH |= (1 << 0) | (1 << 5) | (1 << 6);
|
|
|
|
// Set /ROML, /ROMH, /IO1, /IO2 to HIGH
|
|
PORTL = 0xFF; // A16-A23 (A16 = /ROML, A17 = /ROMH, A18 = /IO1, A19 = /IO2)
|
|
|
|
// Set Unused Data Pins (PA0-PA7) to Output
|
|
DDRA = 0xFF;
|
|
|
|
// Set Unused Pins HIGH
|
|
PORTA = 0xFF;
|
|
PORTJ |= (1 << 0); // TIME(PJ0)
|
|
|
|
#ifdef ENABLE_CLOCKGEN
|
|
// Adafruit Clock Generator
|
|
|
|
initializeClockOffset();
|
|
|
|
if (!i2c_found) {
|
|
display_Clear();
|
|
print_FatalError(F("Clock Generator not found"));
|
|
}
|
|
|
|
// Set Eeprom clock to 1Mhz
|
|
clockgen.set_freq(100000000ULL, SI5351_CLK1);
|
|
|
|
// Start outputting Eeprom clock
|
|
clockgen.output_enable(SI5351_CLK1, 1); // Eeprom clock
|
|
|
|
// Wait for clock generator
|
|
clockgen.update_status();
|
|
|
|
#else
|
|
// Set PHI2(PH1 to Output
|
|
DDRH |= (1 << 1);
|
|
// Setting Control Pins to HIGH for PHI2(PH1)
|
|
PHI2_ENABLE;
|
|
#endif
|
|
|
|
checkStatus_C64();
|
|
strcpy(romName, "C64");
|
|
|
|
mode = CORE_C64;
|
|
}
|
|
|
|
//******************************************
|
|
// READ DATA
|
|
//******************************************
|
|
uint8_t readData_C64(uint16_t addr) {
|
|
PORTF = addr & 0xFF; // A0-A7
|
|
PORTK = (addr >> 8) & 0xFF; // A8-A15
|
|
NOP;
|
|
NOP;
|
|
|
|
// Set R/W(PH6) to HIGH
|
|
PORTH |= (1 << 6); // R/W HIGH (READ)
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
uint8_t ret = PINC;
|
|
|
|
return ret;
|
|
}
|
|
|
|
void readSegment_C64(uint16_t startaddr, uint32_t endaddr, uint16_t size = 512) {
|
|
for (uint32_t addr = startaddr; addr < endaddr; addr += size) {
|
|
for (uint16_t w = 0; w < size; w++) {
|
|
uint8_t temp = readData_C64(addr + w);
|
|
sdBuffer[w] = temp;
|
|
}
|
|
myFile.write(sdBuffer, size);
|
|
}
|
|
}
|
|
|
|
void readSegmentEnableDisable_C64(uint16_t startaddr, uint32_t endaddr, byte romLow, uint16_t size = 512) {
|
|
PORTL &= ~(1 << romLow); // enable ROML or ROMH
|
|
readSegment_C64(startaddr, endaddr, size);
|
|
PORTL |= (1 << romLow); // disable ROML or ROMH
|
|
}
|
|
|
|
void readSegment16k_C64() {
|
|
readSegmentEnableDisable_C64(0x8000, 0xA000, 0); // 8K
|
|
readSegmentEnableDisable_C64(0xA000, 0xC000, 1); // +8K = 16K
|
|
}
|
|
|
|
void readSegmentBankD0D5_C64(uint16_t banks, uint16_t address, byte romLow) {
|
|
PORTL &= ~(1 << romLow); // enable ROML or ROMH
|
|
uint32_t endAddress = address + 0x2000;
|
|
for (uint16_t x = 0; x < banks; x++) {
|
|
bankSwitch_C64(0xDE00, x); // Switch Bank using D0-D5
|
|
readSegment_C64(address, endAddress);
|
|
}
|
|
PORTL |= (1 << romLow); // disable ROML or ROMH
|
|
}
|
|
|
|
void readSegmentBankA0A4_C64(uint16_t banks) {
|
|
ROML_ENABLE;
|
|
for (uint16_t x = 0; x < banks; x++) {
|
|
bankSwitch_C64(0xDE00 + x, 0); // Switch Bank using address lines
|
|
readSegment_C64(0x8000, 0xA000); // 8K per bank
|
|
}
|
|
ROML_DISABLE;
|
|
}
|
|
|
|
//******************************************
|
|
// WRITE DATA
|
|
//******************************************
|
|
void writeData_C64(uint16_t addr, uint8_t data) {
|
|
PORTF = addr & 0xFF; // A0-A7
|
|
PORTK = (addr >> 8) & 0xFF; // A8-A15
|
|
NOP;
|
|
NOP;
|
|
|
|
DDRC = 0xFF; // Set to Output
|
|
PORTC = data;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
// Set R/W(PH6) to LOW
|
|
PORTH &= ~(1 << 6); // R/W LOW (WRITE)
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
// Set R/W(PH6) to HIGH
|
|
PORTH |= (1 << 6);
|
|
NOP;
|
|
NOP;
|
|
|
|
DDRC = 0x00; // Reset to Input
|
|
}
|
|
|
|
void bankSwitch_C64(uint16_t addr, uint8_t data) {
|
|
PORTF = addr & 0xFF; // A0-A7
|
|
PORTK = (addr >> 8) & 0xFF; // A8-A15
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
DDRC = 0xFF; // Set to Output
|
|
PORTC = data;
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
|
|
// Latch Bank Data
|
|
PHI2_DISABLE; // PHI2 LOW
|
|
if (((addr >> 8) & 0xFF) == 0xDF) // 0xDFxx
|
|
IO2_ENABLE;
|
|
else if (((addr >> 8) & 0xFF) == 0xDE) // 0xDExx
|
|
IO1_ENABLE;
|
|
PORTH &= ~(1 << 6); // R/W LOW (WRITE)
|
|
NOP;
|
|
NOP;
|
|
NOP;
|
|
PORTH |= (1 << 6); // R/W HIGH (READ)
|
|
PHI2_ENABLE; // PHI2 HIGH
|
|
IO2_DISABLE;
|
|
IO1_DISABLE;
|
|
|
|
DDRC = 0x00; // Reset to Input
|
|
}
|
|
|
|
//******************************************
|
|
// READ PORT STATE
|
|
//******************************************
|
|
void readPorts_C64() {
|
|
c64port = (PINH >> 3) & 0x3;
|
|
}
|
|
|
|
//******************************************
|
|
// READ ROM
|
|
//******************************************
|
|
// ADDRESS RANGES
|
|
// $8000-$9FFF/$A0000-$BFFF/$E000-$FFFF
|
|
// NORMAL (EXROM LOW/GAME LOW): ROML = $8000, ROMH = $A000
|
|
// ULTIMAX (EXROM HIGH/GAME LOW/): ROML = $8000, ROMH = $E000
|
|
// GAME HIGH/EXROM LOW: ROML = $8000
|
|
|
|
void readROM_C64() {
|
|
createFolder("C64", "ROM", romName, "bin");
|
|
|
|
display_Clear();
|
|
print_STR(saving_to_STR, 0);
|
|
print_Msg(folder);
|
|
println_Msg(F("/..."));
|
|
display_Update();
|
|
|
|
// open file on sdcard
|
|
if (!myFile.open(fileName, O_RDWR | O_CREAT))
|
|
print_FatalError(sd_error_STR);
|
|
|
|
// write new folder number back to EEPROM
|
|
foldern++;
|
|
EEPROM_writeAnything(0, foldern);
|
|
|
|
switch (c64mapper) {
|
|
case 0: // Normal (4K/8K/16K) & Ultimax (8K/16K)
|
|
readPorts_C64();
|
|
// ULTIMAX CARTS
|
|
if (c64port == 2) { // 2 = 10 = EXROM HIGH/GAME LOW
|
|
if (c64size > 1) { // 16K [NO ROML FOR 8K]
|
|
readSegmentEnableDisable_C64(0x8000, 0xA000, 0); // 8K
|
|
}
|
|
readSegmentEnableDisable_C64(0xE000, 0x10000, 1); // +8K = 8K/16K
|
|
} else { // NORMAL CARTS
|
|
if (c64size > 0) {
|
|
readSegmentEnableDisable_C64(0x8000, 0xA000, 0); // 8K
|
|
if (c64size > 1)
|
|
readSegmentEnableDisable_C64(0xA000, 0xC000, 1); // +8K = 16K
|
|
}
|
|
else
|
|
readSegmentEnableDisable_C64(0x9000, 0xA000, 0); // 4K
|
|
}
|
|
break;
|
|
|
|
case 1: // Action Replay (32K)
|
|
case 9: // Atomic Power (32K)
|
|
ROML_ENABLE;
|
|
for (int x = 0; x < 4; x++) {
|
|
bankSwitch_C64(0xDE00, x << 3); // Switch Bank using D3-D4
|
|
readSegment_C64(0x8000, 0xA000); // 8K *4 = 32K
|
|
}
|
|
ROML_DISABLE;
|
|
break;
|
|
|
|
case 2: // KCS Power Cartridge (16K)
|
|
case 11: // Westermann Learning (16K)
|
|
case 16: // WarpSpeed (16K)
|
|
readSegment16k_C64();
|
|
break;
|
|
|
|
case 3: // Final Cartridge III (64K)
|
|
for (int x = 0; x < 4; x++) {
|
|
bankSwitch_C64(0xDFFF, 0x40 + x); // Switch Bank using $DFFF
|
|
readSegment16k_C64();
|
|
}
|
|
break;
|
|
|
|
case 4: // Simons Basic (16K)
|
|
readSegmentEnableDisable_C64(0x8000, 0xA000, 0); // 8K
|
|
ROMH_ENABLE;
|
|
bankSwitch_C64(0xDE00, 0x1); // Switch Bank to ROM
|
|
readSegment_C64(0xA000, 0xC000); // +8K = 16K
|
|
ROMH_DISABLE;
|
|
break;
|
|
|
|
// Ocean Bank 1/B (Single Chip) Selection Notes (Luigi Di Fraia):
|
|
// 128 KiB cartridges (all known titles): bits 0-3 at $DE00 and /ROML (single 128 KiB chip with A16 on pin 22, rather than the /OE signal)
|
|
// 256 KiB cartridges (just "Chase H.Q. II"): bits 0-4 at $DE00 and /ROML (single 256 KiB chip)
|
|
// 512 KiB cartridges (just "Terminator 2"): bits 0-5 at $DE00 and /ROML (single 512 KiB chip)
|
|
|
|
// Ocean 256K ROM Start Data
|
|
// Single Chip:
|
|
// Chase HQ II 09 80 63 80 C3 C2 CD 38 30 4C 63 80 4C C8 80 80
|
|
// Space Gun 09 80 09 80 C3 C2 CD 38 30 78 A2 FF 9A A9 E7 85
|
|
// Two Chip:
|
|
// Robocop 2 09 80 75 80 C3 C2 CD 38 30 4C 75 80 4C FA 80 80
|
|
// Shadow of the Beast 09 80 83 81 C3 C2 CD 38 30 4C 83 81 4C 76 82 80
|
|
// Read 0x8002 to determine whether Single Chip or Two Chip
|
|
// IF 0x75 OR 0x83, THEN Two Chip ELSE Single Chip
|
|
|
|
case 5: { // Ocean 128K/256K/512K
|
|
ROML_ENABLE;
|
|
bankSwitch_C64(0xDE00, 0); // Reset Bank 0
|
|
uint8_t checkOcean = readData_C64(0x8002);
|
|
ROML_DISABLE;
|
|
if ((c64size == 8) && ((checkOcean == 0x75) || (checkOcean == 0x83))) { // Two Chip 256K
|
|
// Robocop 2 + Shadow of the Beast
|
|
println_Msg(F("TWO CHIP"));
|
|
display_Update();
|
|
readSegmentBankD0D5_C64(16, 0x8000, 0); // 8K * 16 = 128K
|
|
readSegmentBankD0D5_C64(16, 0xA000, 1); // 8K * 16 = +128K = 256K
|
|
} else { // Single Chip 128K/256K/512K
|
|
println_Msg(F("SINGLE CHIP"));
|
|
display_Update();
|
|
c64banks = C64[c64size] / 8;
|
|
readSegmentBankD0D5_C64(c64banks, 0x8000, 0); // 8K * Banks = 128K/256K/512K
|
|
}
|
|
break;
|
|
}
|
|
case 6: // Expert Cartridge (8K)
|
|
readSegmentEnableDisable_C64(0x8000, 0xA000, 0);
|
|
break;
|
|
|
|
case 7: // Fun Play, Power Play (128K)
|
|
ROML_ENABLE;
|
|
for (int x = 0; x < 8; x++) {
|
|
bankSwitch_C64(0xDE00, x * 8); // Switch Bank 0-8
|
|
readSegment_C64(0x8000, 0xA000); // 8K * 8 = 64K
|
|
}
|
|
ROML_DISABLE;
|
|
ROMH_ENABLE;
|
|
for (int x = 0; x < 8; x++) {
|
|
bankSwitch_C64(0xDE00, (x * 8) + 1); // Switch Bank 9-15
|
|
readSegment_C64(0x8000, 0xA000); // 8K * 8 = +64K = 128K
|
|
}
|
|
ROMH_DISABLE;
|
|
bankSwitch_C64(0xDE00, 0x86); // Reset ROM
|
|
break;
|
|
|
|
case 8: // Super Games (64K)
|
|
for (int x = 0; x < 4; x++) {
|
|
bankSwitch_C64(0xDF00, x); // Switch Bank
|
|
readSegment16k_C64();
|
|
}
|
|
break;
|
|
|
|
case 10: // Epyx Fastload (8K)
|
|
ROML_ENABLE;
|
|
bankSwitch_C64(0xDE00, 0); // Read IO1 - Trigger Access
|
|
readSegment_C64(0x8000, 0x9E00); // 7680 Bytes
|
|
readSegment_C64(0x9E00, 0x9F00, 256); // +256 Bytes = 7936 Bytes
|
|
bankSwitch_C64(0xDF00, 0); // Read IO2 - Access Last 256 Bytes
|
|
readSegment_C64(0x9F00, 0xA000, 256); // +256 Bytes = 8K
|
|
ROML_DISABLE;
|
|
break;
|
|
|
|
case 12: // Rex Utility (8K)
|
|
ROML_ENABLE;
|
|
bankSwitch_C64(0xDFC0, 0); // Enable ROM
|
|
readSegment_C64(0x8000, 0xA000); // 8K
|
|
ROML_DISABLE;
|
|
break;
|
|
|
|
case 13: // Final Cartridge I (16K)
|
|
bankSwitch_C64(0xDF00, 0); // Enable ROM
|
|
readSegment16k_C64();
|
|
break;
|
|
|
|
case 14: // Magic Formel (64K)
|
|
ROMH_ENABLE;
|
|
for (int x = 0; x < 8; x++) {
|
|
bankSwitch_C64(0xDF00 + x, 0); // Switch Bank using A0-A2
|
|
readSegment_C64(0xE000, 0x10000); // 8K * 8 = 64K
|
|
}
|
|
ROMH_DISABLE;
|
|
break;
|
|
|
|
case 15: // C64 Game System, System 3 (512K)
|
|
readSegmentBankA0A4_C64(64);
|
|
break;
|
|
|
|
case 17: // Dinamic (128K)
|
|
readSegmentBankA0A4_C64(16);
|
|
break;
|
|
|
|
case 18: // Zaxxon, Super Zaxxon (SEGA) (20K)
|
|
readSegmentEnableDisable_C64(0x8000, 0x9000, 0); // 4K
|
|
readSegmentEnableDisable_C64(0xA000, 0xC000, 1); // +8K = 12K
|
|
// Switch Bank
|
|
readData_C64(0x9000);
|
|
readSegmentEnableDisable_C64(0xA000, 0xC000, 1); // +8K = 20K
|
|
break;
|
|
|
|
case 19: // Magic Desk, Domark, HES Australia (32K/64K/128K)
|
|
c64banks = C64[c64size] / 8;
|
|
readSegmentBankD0D5_C64(c64banks, 0x8000, 0);
|
|
break;
|
|
|
|
case 20: // Super Snapshot 5 (64K)
|
|
for (int x = 0; x < 4; x++) {
|
|
int bank = (((x & 2) << 3) | (0 << 3) | ((x & 1) << 2));
|
|
bankSwitch_C64(0xDE00, bank); // Switch Bank using D2-D4 (D3 == 0 Enable ROM)
|
|
readSegment16k_C64();
|
|
}
|
|
break;
|
|
|
|
case 21: // Comal-80 (64K)
|
|
for (int x = 0; x < 4; x++) {
|
|
bankSwitch_C64(0xDE00, x + 0x80); // Switch Bank
|
|
readSegment16k_C64();
|
|
}
|
|
}
|
|
myFile.close();
|
|
|
|
printCRC(fileName, NULL, 0);
|
|
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
// Prints string out of the common strings array either with or without newline
|
|
print_STR(press_button_STR, 1);
|
|
display_Update();
|
|
wait();
|
|
}
|
|
|
|
//******************************************
|
|
// MAPPER CODE
|
|
//******************************************
|
|
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
void printMapperSelection_C64(int index) {
|
|
display_Clear();
|
|
print_Msg(F("Mapper: "));
|
|
c64index = index * 3;
|
|
c64mapselect = pgm_read_byte(c64mapsize + c64index);
|
|
println_Msg(c64mapselect);
|
|
printMapper_C64(c64mapselect);
|
|
}
|
|
#endif
|
|
|
|
|
|
void setMapper_C64() {
|
|
byte newc64mapper;
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
navigateMenu(0, c64mapcount - 1, &printMapperSelection_C64);
|
|
newc64mapper = c64mapselect;
|
|
|
|
display.setCursor(0, 56);
|
|
print_Msg(F("MAPPER "));
|
|
print_Msg(newc64mapper);
|
|
println_Msg(F(" SELECTED"));
|
|
display_Update();
|
|
delay(1000);
|
|
#else
|
|
setmapper:
|
|
String newmap;
|
|
boolean c64mapfound = false;
|
|
printMapper_C64(0);
|
|
Serial.print(F("Enter Mapper [0-22]: "));
|
|
while (Serial.available() == 0) {}
|
|
newmap = Serial.readStringUntil('\n');
|
|
Serial.println(newmap);
|
|
newc64mapper = newmap.toInt();
|
|
for (int i = 0; i < c64mapcount; i++) {
|
|
c64index = i * 3;
|
|
c64mapselect = pgm_read_byte(c64mapsize + c64index);
|
|
if (newc64mapper == c64mapselect)
|
|
c64mapfound = true;
|
|
}
|
|
if (c64mapfound == false) {
|
|
Serial.println(F("MAPPER NOT SUPPORTED!"));
|
|
Serial.println(FS(FSTRING_EMPTY));
|
|
newc64mapper = 0;
|
|
goto setmapper;
|
|
}
|
|
#endif
|
|
EEPROM_writeAnything(7, newc64mapper);
|
|
c64mapper = newc64mapper;
|
|
}
|
|
|
|
void checkMapperSize_C64() {
|
|
for (int i = 0; i < c64mapcount; i++) {
|
|
c64index = i * 3;
|
|
byte mapcheck = pgm_read_byte(c64mapsize + c64index);
|
|
if (mapcheck == c64mapper) {
|
|
c64lo = pgm_read_byte(c64mapsize + c64index + 1);
|
|
c64hi = pgm_read_byte(c64mapsize + c64index + 2);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//******************************************
|
|
// SET ROM SIZE
|
|
//******************************************
|
|
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
void printRomSize_C64(int index) {
|
|
display_Clear();
|
|
print_Msg(F("ROM Size: "));
|
|
println_Msg(C64[index]);
|
|
}
|
|
#endif
|
|
|
|
void setROMSize_C64() {
|
|
byte newc64size;
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
display_Clear();
|
|
if (c64lo == c64hi)
|
|
newc64size = c64lo;
|
|
else {
|
|
newc64size = navigateMenu(c64lo, c64hi, &printRomSize_C64);
|
|
|
|
display.setCursor(0, 56); // Display selection at bottom
|
|
}
|
|
print_Msg(F("ROM SIZE "));
|
|
print_Msg(C64[newc64size]);
|
|
println_Msg(F("K"));
|
|
display_Update();
|
|
delay(1000);
|
|
#else
|
|
if (c64lo == c64hi)
|
|
newc64size = c64lo;
|
|
else {
|
|
setrom:
|
|
String sizeROM;
|
|
for (int i = 0; i < (c64hi - c64lo + 1); i++) {
|
|
Serial.print(F("Select ROM Size: "));
|
|
Serial.print(i);
|
|
Serial.print(F(" = "));
|
|
Serial.print(C64[i + c64lo]);
|
|
Serial.println(F("K"));
|
|
}
|
|
Serial.print(F("Enter ROM Size: "));
|
|
while (Serial.available() == 0) {}
|
|
sizeROM = Serial.readStringUntil('\n');
|
|
Serial.println(sizeROM);
|
|
newc64size = sizeROM.toInt() + c64lo;
|
|
if (newc64size > c64hi) {
|
|
Serial.println(F("SIZE NOT SUPPORTED"));
|
|
Serial.println(FS(FSTRING_EMPTY));
|
|
goto setrom;
|
|
}
|
|
}
|
|
Serial.print(F("ROM Size = "));
|
|
Serial.print(C64[newc64size]);
|
|
Serial.println(F("K"));
|
|
#endif
|
|
EEPROM_writeAnything(8, newc64size);
|
|
c64size = newc64size;
|
|
}
|
|
|
|
//******************************************
|
|
// CHECK STATUS
|
|
//******************************************
|
|
void checkStatus_C64() {
|
|
EEPROM_readAnything(7, c64mapper);
|
|
EEPROM_readAnything(8, c64size);
|
|
if (c64mapper > 21) {
|
|
c64mapper = 0;
|
|
EEPROM_writeAnything(7, c64mapper);
|
|
}
|
|
if (c64size > 9) {
|
|
c64size = 0;
|
|
EEPROM_writeAnything(8, c64size);
|
|
}
|
|
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
display_Clear();
|
|
println_Msg(F("C64 READER"));
|
|
println_Msg(FS(FSTRING_CURRENT_SETTINGS));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
print_Msg(F("MAPPER: "));
|
|
println_Msg(c64mapper);
|
|
printMapper_C64(c64mapper);
|
|
print_Msg(F("ROM SIZE: "));
|
|
print_Msg(C64[c64size]);
|
|
println_Msg(F("K"));
|
|
display_Update();
|
|
wait();
|
|
#else
|
|
Serial.print(F("CURRENT MAPPER: "));
|
|
Serial.println(c64mapper);
|
|
Serial.print(F("CURRENT ROM SIZE: "));
|
|
Serial.print(C64[c64size]);
|
|
Serial.println(F("K"));
|
|
Serial.println(FS(FSTRING_EMPTY));
|
|
#endif
|
|
}
|
|
|
|
void printMapper_C64(byte c64maplabel) {
|
|
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
|
switch (c64maplabel) {
|
|
case 0:
|
|
println_Msg(F("NORMAL/ULTIMAX"));
|
|
break;
|
|
case 1:
|
|
println_Msg(F("ACTION REPLAY"));
|
|
break;
|
|
case 2:
|
|
println_Msg(F("KCS POWER CARTRIDGE"));
|
|
break;
|
|
case 3:
|
|
println_Msg(F("FINAL CARTRIDGE III"));
|
|
break;
|
|
case 4:
|
|
println_Msg(F("SIMONS BASIC"));
|
|
break;
|
|
case 5:
|
|
println_Msg(F("OCEAN"));
|
|
break;
|
|
case 6:
|
|
println_Msg(F("EXPERT CARTRIDGE"));
|
|
break;
|
|
case 7:
|
|
println_Msg(F("FUN PLAY/POWER PLAY"));
|
|
break;
|
|
case 8:
|
|
println_Msg(F("SUPER GAMES"));
|
|
break;
|
|
case 9:
|
|
println_Msg(F("ATOMIC POWER"));
|
|
break;
|
|
case 10:
|
|
println_Msg(F("EPYX FASTLOAD"));
|
|
break;
|
|
case 11:
|
|
println_Msg(F("WESTERMANN LEARNING"));
|
|
break;
|
|
case 12:
|
|
println_Msg(F("REX UTILITY"));
|
|
break;
|
|
case 13:
|
|
println_Msg(F("FINAL CARTRIDGE I"));
|
|
break;
|
|
case 14:
|
|
println_Msg(F("MAGIC FORMEL"));
|
|
break;
|
|
case 15:
|
|
println_Msg(F("C64 GAME SYSTEM"));
|
|
break;
|
|
case 16:
|
|
println_Msg(F("WARPSPEED"));
|
|
break;
|
|
case 17:
|
|
println_Msg(F("DINAMIC"));
|
|
break;
|
|
case 18:
|
|
println_Msg(F("ZAXXON/SUPER ZAXXON"));
|
|
break;
|
|
case 19:
|
|
println_Msg(F("MAGIC DESK/DOMARK"));
|
|
break;
|
|
case 20:
|
|
println_Msg(F("SUPER SNAPSHOT"));
|
|
break;
|
|
case 21:
|
|
println_Msg(F("COMAL-80"));
|
|
break;
|
|
}
|
|
#else
|
|
Serial.println(F("0 = NORMAL/ULTIMAX"));
|
|
Serial.println(F("1 = ACTION REPLAY"));
|
|
Serial.println(F("2 = KCS POWER CARTRIDGE"));
|
|
Serial.println(F("3 = FINAL CARTRIDGE III"));
|
|
Serial.println(F("4 = SIMONS BASIC"));
|
|
Serial.println(F("5 = OCEAN"));
|
|
Serial.println(F("6 = EXPERT CARTRIDGE"));
|
|
Serial.println(F("7 = FUN PLAY/POWER PLAY"));
|
|
Serial.println(F("8 = SUPER GAMES"));
|
|
Serial.println(F("9 = ATOMIC POWER"));
|
|
Serial.println(F("10 = EPYX FASTLOAD"));
|
|
Serial.println(F("11 = WESTERMANN LEARNING"));
|
|
Serial.println(F("12 = REX UTILITY"));
|
|
Serial.println(F("13 = FINAL CARTRIDGE I"));
|
|
Serial.println(F("14 = MAGIC FORMEL"));
|
|
Serial.println(F("15 = C64 GAME SYSTEM"));
|
|
Serial.println(F("16 = WARPSPEED"));
|
|
Serial.println(F("17 = DINAMIC"));
|
|
Serial.println(F("18 = ZAXXON/SUPER ZAXXON"));
|
|
Serial.println(F("19 = MAGIC DESK/DOMARK/HES AUSTRALIA"));
|
|
Serial.println(F("20 = SUPER SNAPSHOT"));
|
|
Serial.println(F("21 = COMAL-80"));
|
|
#endif
|
|
}
|
|
|
|
//******************************************
|
|
// CART SELECT CODE
|
|
//******************************************
|
|
|
|
void setCart_C64() {
|
|
//go to root
|
|
sd.chdir();
|
|
|
|
struct database_entry_mapper_size entry;
|
|
|
|
// Select starting letter
|
|
byte myLetter = starting_letter();
|
|
|
|
// Open database
|
|
if (myFile.open("c64cart.txt", O_READ)) {
|
|
seek_first_letter_in_database(myFile, myLetter);
|
|
|
|
if(checkCartSelection(myFile, &readDataLineMapperSize, &entry)) {
|
|
EEPROM_writeAnything(7, entry.gameMapper);
|
|
EEPROM_writeAnything(8, entry.gameSize);
|
|
}
|
|
} else {
|
|
print_FatalError(FS(FSTRING_DATABASE_FILE_NOT_FOUND));
|
|
}
|
|
}
|
|
#endif
|