From a5f629df784c769e1f6031683a0bdd21024c346f Mon Sep 17 00:00:00 2001 From: splash5 <2173030+splash5@users.noreply.github.com> Date: Thu, 26 Sep 2019 13:38:03 +0800 Subject: [PATCH] Add support for EMS GB Smart 32M flash cart --- Cart_Reader/Cart_Reader.ino | 12 + Cart_Reader/GB.ino | 14 +- Cart_Reader/GBSmart.ino | 750 ++++++++++++++++++++++++++++++++++++ 3 files changed, 773 insertions(+), 3 deletions(-) create mode 100644 Cart_Reader/GBSmart.ino diff --git a/Cart_Reader/Cart_Reader.ino b/Cart_Reader/Cart_Reader.ino index ab40e7a..57acc33 100644 --- a/Cart_Reader/Cart_Reader.ino +++ b/Cart_Reader/Cart_Reader.ino @@ -149,6 +149,9 @@ typedef enum COLOR_T { #define mode_NES 15 #define mode_SMS 16 #define mode_SEGA_CD 17 +#define mode_GB_GBSmart 18 +#define mode_GB_GBSmart_Flash 19 +#define mode_GB_GBSmart_Game 20 // optimization-safe nop delay #define NOP __asm__ __volatile__ ("nop\n\t") @@ -1486,6 +1489,15 @@ void loop() { else if (mode == mode_SEGA_CD) { segaCDMenu(); } + else if (mode == mode_GB_GBSmart) { + gbSmartMenu(); + } + else if (mode == mode_GB_GBSmart_Flash) { + gbSmartFlashMenu(); + } + else if (mode == mode_GB_GBSmart_Game) { + gbSmartGameOptions(); + } else { display_Clear(); println_Msg(F("Menu Error")); diff --git a/Cart_Reader/GB.ino b/Cart_Reader/GB.ino index 37eb08c..0d5312b 100644 --- a/Cart_Reader/GB.ino +++ b/Cart_Reader/GB.ino @@ -17,7 +17,8 @@ uint16_t sramEndAddress = 0; static const char gbxMenuItem1[] PROGMEM = "Game Boy (Color)"; static const char gbxMenuItem2[] PROGMEM = "Game Boy Advance"; static const char gbxMenuItem3[] PROGMEM = "NPower GB Memory"; -static const char* const menuOptionsGBx[] PROGMEM = {gbxMenuItem1, gbxMenuItem2, gbxMenuItem3}; +static const char gbxMenuItem4[] PROGMEM = "GB Smart"; +static const char* const menuOptionsGBx[] PROGMEM = {gbxMenuItem1, gbxMenuItem2, gbxMenuItem3, gbxMenuItem4}; // GB menu items static const char GBMenuItem1[] PROGMEM = "Read Rom"; @@ -33,8 +34,8 @@ void gbxMenu() { // create menu with title and 3 options to choose from unsigned char gbType; // Copy menuOptions out of progmem - convertPgm(menuOptionsGBx, 3); - gbType = question_box(F("Select Game Boy"), menuOptions, 3, 0); + convertPgm(menuOptionsGBx, 4); + gbType = question_box(F("Select Game Boy"), menuOptions, 4, 0); // wait for user choice to come back from the question box menu switch (gbType) @@ -59,6 +60,13 @@ void gbxMenu() { setup_GBM(); mode = mode_GBM; break; + + case 3: + display_Clear(); + display_Update(); + setup_GBSmart(); + mode = mode_GB_GBSmart; + break; } } diff --git a/Cart_Reader/GBSmart.ino b/Cart_Reader/GBSmart.ino new file mode 100644 index 0000000..ad23732 --- /dev/null +++ b/Cart_Reader/GBSmart.ino @@ -0,0 +1,750 @@ +//****************************************** +// GB SMART MODULE +// Supports 32M cart with LH28F016SUT flash +//****************************************** +#define GB_SMART_GAMES_PER_PAGE 6 + +/****************************************** + Menu + *****************************************/ +// GB Smart menu items +static const char gbSmartMenuItem1[] PROGMEM = "Game Menu"; +static const char gbSmartMenuItem2[] PROGMEM = "Flash Menu"; +static const char gbSmartMenuItem3[] PROGMEM = "Reset"; +static const char* const menuOptionsGBSmart[] PROGMEM = {gbSmartMenuItem1, gbSmartMenuItem2, gbSmartMenuItem3}; + +static const char gbSmartFlashMenuItem1[] PROGMEM = "Read Flash"; +static const char gbSmartFlashMenuItem2[] PROGMEM = "Write Flash"; +static const char gbSmartFlashMenuItem3[] PROGMEM = "Back"; +static const char* const menuOptionsGBSmartFlash[] PROGMEM = {gbSmartFlashMenuItem1, gbSmartFlashMenuItem2, gbSmartFlashMenuItem3}; + +static const char gbSmartGameMenuItem1[] PROGMEM = "Read Game"; +static const char gbSmartGameMenuItem2[] PROGMEM = "Read SRAM"; +static const char gbSmartGameMenuItem3[] PROGMEM = "Write SRAM"; +static const char gbSmartGameMenuItem4[] PROGMEM = "Switch Game"; +static const char gbSmartGameMenuItem5[] PROGMEM = "Reset"; +static const char* const menuOptionsGBSmartGame[] PROGMEM = {gbSmartGameMenuItem1, gbSmartGameMenuItem2, gbSmartGameMenuItem3, gbSmartGameMenuItem4, gbSmartGameMenuItem5}; + +typedef struct +{ + uint8_t start_bank; + uint8_t rom_type; + uint8_t rom_size; + uint8_t sram_size; + char title[16]; +} GBSmartGameInfo; + +uint32_t gbSmartSize = 32 * 131072; +uint16_t gbSmartBanks = 256; + +uint8_t gbSmartBanksPerFlashChip = 128; +uint8_t gbSmartBanksPerFlashBlock = 4; +uint32_t gbSmartFlashBlockSize = (gbSmartBanksPerFlashBlock << 14); + +uint8_t gbSmartRomSizeGB = 0x07; +uint8_t gbSmartSramSizeGB = 0x04; +uint8_t gbSmartFlashSizeGB = 0x06; + +GBSmartGameInfo gbSmartGames[GB_SMART_GAMES_PER_PAGE]; + +byte signature[48]; +uint16_t gameMenuStartBank; + +extern boolean hasMenu; +extern byte numGames; + +void setup_GBSmart() +{ + // take from setup_GB + // Set RST(PH0) to Input + DDRH &= ~(1 << 0); + // Activate Internal Pullup Resistors + PORTH |= (1 << 0); + + // Set Address Pins to Output + //A0-A7 + DDRF = 0xFF; + //A8-A15 + DDRK = 0xFF; + + // Set Control Pins to Output CS(PH3) WR(PH5) RD(PH6) AUDIOIN(PH4) RESET(PH0) + DDRH |= (1 << 0) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6); + // Output a high signal on all pins, pins are active low therefore everything is disabled now + PORTH |= (1 << 0) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6); + + // Set Data Pins (D0-D7) to Input + DDRC = 0x00; + + delay(400); + + gbSmartRemapStartBank(0x00, 0x00, 0x00); + + getCartInfo_GB(); + + for (byte i = 0; i < 0x30; i++) + signature[i] = readByte_GB(0x0104 + i); + + gameMenuStartBank = 0x02; + hasMenu = true; + numGames = 0; + + display_Clear(); + display_Update(); +} + +void gbSmartMenu() +{ + uint8_t mainMenu; + + // Copy menuOptions out of progmem + convertPgm(menuOptionsGBSmart, 3); + mainMenu = question_box(F("GB Smart"), menuOptions, 3, 0); + + // wait for user choice to come back from the question box menu + switch (mainMenu) + { + case 0: + { + gbSmartGameMenu(); + break; + } + case 1: + { + mode = mode_GB_GBSmart_Flash; + break; + } + default: + { + asm volatile (" jmp 0"); + break; + } + } +} + +void gbSmartGameOptions() +{ + uint8_t gameSubMenu; + + convertPgm(menuOptionsGBSmartGame, 5); + gameSubMenu = question_box(F("GB Smart Game Menu"), menuOptions, 5, 0); + + switch (gameSubMenu) + { + case 0: // Read Game + { + display_Clear(); + sd.chdir("/"); + readROM_GB(); + compare_checksum_GB(); + break; + } + case 1: // Read SRAM + { + display_Clear(); + sd.chdir("/"); + readSRAM_GB(); + break; + } + case 2: // Write SRAM + { + display_Clear(); + sd.chdir("/"); + writeSRAM_GB(); + uint32_t wrErrors = verifySRAM_GB(); + if (wrErrors == 0) + { + println_Msg(F("Verified OK")); + display_Update(); + } + else + { + print_Msg(F("Error: ")); + print_Msg(wrErrors); + println_Msg(F(" bytes")); + print_Error(F("did not verify."), false); + } + break; + } + case 3: // Switch Game + { + gameMenuStartBank = 0x02; + gbSmartGameMenu(); + break; + } + default: + { + asm volatile (" jmp 0"); + break; + } + } + + if (gameSubMenu != 3) + { + println_Msg(F("")); + println_Msg(F("Press Button...")); + display_Update(); + wait(); + } +} + +void gbSmartGameMenu() +{ + uint8_t gameSubMenu = 0; +gb_smart_load_more_games: + if (gameMenuStartBank > 0xfe) + gameMenuStartBank = 0x02; + + gbSmartGetGames(); + + if (hasMenu) + { + char menuOptionsGBSmartGames[7][20]; + int i = 0; + for (; i < numGames; i++) + strncpy(menuOptionsGBSmartGames[i], gbSmartGames[i].title, 16); + + strncpy(menuOptionsGBSmartGames[i], "...", 16); + gameSubMenu = question_box(F("Select Game"), menuOptionsGBSmartGames, i + 1, 0); + + if (gameSubMenu >= i) + goto gb_smart_load_more_games; + } + else + { + gameSubMenu = 0; + } + + // copy romname + strcpy(romName, gbSmartGames[gameSubMenu].title); + + // select a game + gbSmartRemapStartBank(gbSmartGames[gameSubMenu].start_bank, gbSmartGames[gameSubMenu].rom_size, gbSmartGames[gameSubMenu].sram_size); + getCartInfo_GB(); + + mode = mode_GB_GBSmart_Game; +} + +void gbSmartFlashMenu() +{ + uint8_t flashSubMenu; + + convertPgm(menuOptionsGBSmartFlash, 3); + flashSubMenu = question_box(F("GB Smart Flash Menu"), menuOptions, 3, 0); + + switch (flashSubMenu) + { + case 0: + { + // read flash + display_Clear(); + sd.chdir("/"); + + EEPROM_readAnything(10, foldern); + sprintf(fileName, "GBS%d.bin", foldern); + sd.mkdir("GB/GBS", true); + sd.chdir("GB/GBS"); + foldern = foldern + 1; + EEPROM_writeAnything(10, foldern); + + gbSmartReadFlash(); + break; + } + case 1: + { + // write flash + display_Clear(); + + println_Msg(F("Attention")); + println_Msg(F("This will erase your")); + println_Msg(F("GB Smart Cartridge.")); + println_Msg(F("")); + println_Msg(F("Press Button")); + println_Msg(F("to continue")); + display_Update(); + wait(); + + display_Clear(); + filePath[0] = '\0'; + sd.chdir("/"); + fileBrowser(F("Select 4MB file")); + + sprintf(filePath, "%s/%s", filePath, fileName); + gbSmartWriteFlash(); + break; + } + default: + { + mode = mode_GB_GBSmart; + return; + } + } + + println_Msg(F("")); + println_Msg(F("Press Button...")); + display_Update(); + wait(); +} + +void gbSmartGetGames() +{ + static const byte menu_title[] = {0x47, 0x42, 0x31, 0x36, 0x4d}; + + // reset remap setting + gbSmartRemapStartBank(0x00, gbSmartRomSizeGB, gbSmartSramSizeGB); + + uint16_t i; + uint8_t myByte, myLength; + + // check if contain menu + hasMenu = true; + dataIn_GB(); + for (i = 0; i < 5; i++) + { + if (readByte_GB(0x0134 + i) != menu_title[i]) + { + hasMenu = false; + break; + } + } + + if (hasMenu) + { + for (i = gameMenuStartBank, numGames = 0; i < gbSmartBanks && numGames < GB_SMART_GAMES_PER_PAGE; ) + { + myLength = 0; + + // switch bank + dataOut(); + writeByte_GB(0x2100, i); + + dataIn_GB(); + // read signature + for (uint8_t j = 0x00; j < 0x30; j++) + { + if (readByte_GB(0x4104 + j) != signature[j]) + { + i += 0x02; + goto gb_smart_get_game_loop_end; + } + } + + for (uint8_t j = 0; j < 15; j++) + { + myByte = readByte_GB(0x4134 + j); + + if (((char(myByte) >= 0x30 && char(myByte) <= 0x39) || + (char(myByte) >= 0x41 && char(myByte) <= 0x7a))) + gbSmartGames[numGames].title[myLength++] = char(myByte); + } + + gbSmartGames[numGames].title[myLength] = 0x00; + gbSmartGames[numGames].start_bank = i; + gbSmartGames[numGames].rom_type = readByte_GB(0x4147); + gbSmartGames[numGames].rom_size = readByte_GB(0x4148); + gbSmartGames[numGames].sram_size = readByte_GB(0x4149); + + myByte = (2 << gbSmartGames[numGames].rom_size); + i += myByte; + numGames++; +gb_smart_get_game_loop_end:; + } + + gameMenuStartBank = i; + } + else + { + dataIn_GB(); + for (uint8_t j = 0; j < 15; j++) + { + myByte = readByte_GB(0x0134 + j); + + if (((char(myByte) >= 0x30 && char(myByte) <= 0x39) || + (char(myByte) >= 0x41 && char(myByte) <= 0x7a))) + gbSmartGames[0].title[myLength++] = char(myByte); + } + + gbSmartGames[0].title[myLength] = 0x00; + gbSmartGames[0].start_bank = 0x00; + gbSmartGames[0].rom_type = readByte_GB(0x0147); + gbSmartGames[0].rom_size = readByte_GB(0x0148); + gbSmartGames[0].sram_size = readByte_GB(0x0149); + + numGames = 1; + gameMenuStartBank = 0xfe; + } +} + +void gbSmartReadFlash() +{ + print_Msg(F("Saving as GB/GBS/")); + print_Msg(fileName); + println_Msg(F("...")); + display_Update(); + + if (!myFile.open(fileName, O_RDWR | O_CREAT)) + print_Error(F("Can't create file on SD"), true); + + // reset flash to read array state + for (int i = 0x00; i < gbSmartBanks; i += gbSmartBanksPerFlashChip) + gbSmartResetFlash(i); + + // remaps mmc to full access + gbSmartRemapStartBank(0x00, gbSmartRomSizeGB, gbSmartSramSizeGB); + + // dump fixed bank 0x00 + dataIn_GB(); + for (uint16_t addr = 0x0000; addr <= 0x3fff; addr += 512) + { + for (uint16_t c = 0; c < 512; c++) + sdBuffer[c] = readByte_GB(addr + c); + + myFile.write(sdBuffer, 512); + } + + // read rest banks + for (uint16_t bank = 0x01; bank < gbSmartBanks; bank++) + { + dataOut(); + writeByte_GB(0x2100, bank); + + dataIn_GB(); + for (uint16_t addr = 0x4000; addr <= 0x7fff; addr += 512) + { + for (uint16_t c = 0; c < 512; c++) + sdBuffer[c] = readByte_GB(addr + c); + + myFile.write(sdBuffer, 512); + } + } + + // back to initial state + writeByte_GB(0x2100, 0x01); + + myFile.close(); + println_Msg(""); + println_Msg(F("Finished reading")); + display_Update(); +} + +void gbSmartWriteFlash() +{ + for (int bank = 0x00; bank < gbSmartBanks; bank += gbSmartBanksPerFlashChip) + { + display_Clear(); + + print_Msg(F("Erasing...")); + display_Update(); + + gbSmartEraseFlash(bank); + gbSmartResetFlash(bank); + + println_Msg(F("Done")); + print_Msg(F("Blankcheck...")); + display_Update(); + + if (!gbSmartBlankCheckingFlash(bank)) + print_Error(F("Could not erase flash"), true); + + println_Msg(F("Passed")); + display_Update(); + + // write full chip + gbSmartWriteFlash(bank); + + // reset chip + gbSmartWriteFlashByte(0x0000, 0xff); + } + + print_Msg(F("Verifying...")); + display_Update(); + + writeErrors = gbSmartVerifyFlash(); + if (writeErrors == 0) + { + println_Msg(F("OK")); + display_Update(); + } + else + { + print_Msg(F("Error: ")); + print_Msg(writeErrors); + println_Msg(F(" bytes ")); + print_Error(F("did not verify."), true); + } +} + +void gbSmartWriteFlash(uint32_t start_bank) +{ + if (!myFile.open(filePath, O_READ)) + print_Error(F("Can't open file on SD"), true); + + // switch to flash base bank + gbSmartRemapStartBank(start_bank, gbSmartFlashSizeGB, gbSmartSramSizeGB); + + myFile.seekCur((start_bank << 14)); + + print_Msg(F("Writing Bank 0x")); + print_Msg(start_bank, HEX); + print_Msg(F("...")); + display_Update(); + + // handle bank 0x00 on 0x0000 + gbSmartWriteFlashFromMyFile(0x0000); + + // handle rest banks on 0x4000 + for (uint8_t bank = 0x01; bank < gbSmartBanksPerFlashChip; bank++) + { + dataOut(); + writeByte_GB(0x2100, bank); + + gbSmartWriteFlashFromMyFile(0x4000); + } + + myFile.close(); + println_Msg(""); +} + +void gbSmartWriteFlashFromMyFile(uint32_t addr) +{ + for (uint16_t i = 0; i < 16384; i += 256) + { + myFile.read(sdBuffer, 256); + + // sequence load to page + dataOut(); + gbSmartWriteFlashByte(addr, 0xe0); + gbSmartWriteFlashByte(addr, 0xff); + gbSmartWriteFlashByte(addr, 0x00); // BCH should be 0x00 + + // fill page buffer + for (int d = 0; d < 256; d++) + gbSmartWriteFlashByte(d, sdBuffer[d]); + + // start flashing page + gbSmartWriteFlashByte(addr, 0x0c); + gbSmartWriteFlashByte(addr, 0xff); + gbSmartWriteFlashByte(addr + i, 0x00); // BCH should be 0x00 + + // waiting for finishing + dataIn_GB(); + while ((readByte_GB(addr + i) & 0x80) == 0x00); + } + + // blink LED + PORTB ^= (1 << 4); +} + +uint32_t gbSmartVerifyFlash() +{ + uint32_t verified = 0; + + if (!myFile.open(filePath, O_READ)) + { + verified = 0xffffffff; + print_Error(F("Can't open file on SD"), false); + } + else + { + // remaps mmc to full access + gbSmartRemapStartBank(0x00, gbSmartRomSizeGB, gbSmartSramSizeGB); + + // verify bank 0x00 + dataIn_GB(); + for (uint16_t addr = 0x0000; addr <= 0x3fff; addr += 512) + { + myFile.read(sdBuffer, 512); + + for (uint16_t c = 0; c < 512; c++) + { + if (readByte_GB(addr + c) != sdBuffer[c]) + verified++; + } + } + + // verify rest banks + for (uint16_t bank = 0x01; bank < gbSmartBanks; bank++) + { + dataOut(); + writeByte_GB(0x2100, bank); + + dataIn_GB(); + for (uint16_t addr = 0x4000; addr <= 0x7fff; addr += 512) + { + myFile.read(sdBuffer, 512); + + for (uint16_t c = 0; c < 512; c++) + { + if (readByte_GB(addr + c) != sdBuffer[c]) + verified++; + } + } + } + + // back to initial state + writeByte_GB(0x2100, 0x01); + + myFile.close(); + } + + return verified; +} + +byte gbSmartBlankCheckingFlash(uint8_t flash_start_bank) +{ + gbSmartRemapStartBank(flash_start_bank, gbSmartFlashSizeGB, gbSmartSramSizeGB); + + // check first bank + dataIn_GB(); + for (uint16_t addr = 0x0000; addr <= 0x3fff; addr++) + { + if (readByte_GB(addr) != 0xff) + return 0; + } + + // check rest banks + for (uint16_t bank = 0x01; bank < gbSmartBanksPerFlashChip; bank++) + { + dataOut(); + writeByte_GB(0x2100, bank); + + dataIn_GB(); + for (uint16_t addr = 0x4000; addr <= 0x7fff; addr++) + { + if (readByte_GB(addr) != 0xff) + return 0; + } + } + + return 1; +} + +void gbSmartResetFlash(uint8_t flash_start_bank) +{ + gbSmartRemapStartBank(flash_start_bank, gbSmartFlashSizeGB, gbSmartSramSizeGB); + + dataOut(); + gbSmartWriteFlashByte(0x0, 0xff); +} + +void gbSmartEraseFlash(uint8_t flash_start_bank) +{ + gbSmartRemapStartBank(flash_start_bank, gbSmartFlashSizeGB, gbSmartSramSizeGB); + + // handling first flash block + dataOut(); + gbSmartWriteFlashByte(0x0000, 0x20); + gbSmartWriteFlashByte(0x0000, 0xd0); + + dataIn_GB(); + while ((readByte_GB(0x0000) & 0x80) == 0x00); + + // blink LED + PORTB ^= (1 << 4); + + // rest of flash block + for (uint32_t ba = gbSmartBanksPerFlashBlock; ba < gbSmartBanksPerFlashChip; ba += gbSmartBanksPerFlashBlock) + { + dataOut(); + writeByte_GB(0x2100, ba); + + gbSmartWriteFlashByte(0x4000, 0x20); + gbSmartWriteFlashByte(0x4000, 0xd0); + + dataIn_GB(); + while ((readByte_GB(0x4000) & 0x80) == 0x00); + + // blink LED + PORTB ^= (1 << 4); + } +} + +void gbSmartWriteFlashByte(uint32_t myAddress, uint8_t myData) +{ + PORTF = myAddress & 0xff; + PORTK = (myAddress >> 8) & 0xff; + PORTC = myData; + + // wait for 62.5 x 4 = 250ns + __asm__("nop\n\tnop\n\tnop\n\tnop\n\t"); + + // Pull FLASH_WE (PH4) low + PORTH &= ~(1 << 4); + + // pull low for another 250ns + __asm__("nop\n\tnop\n\tnop\n\tnop\n\t"); + + // Pull FLASH_WE (PH4) high + PORTH |= (1 << 4); + + // pull high for another 250ns + __asm__("nop\n\tnop\n\tnop\n\tnop\n\t"); +} + +// rom_start_bank = 0x00 means back to original state +void gbSmartRemapStartBank(uint8_t rom_start_bank, uint8_t rom_size, uint8_t sram_size) +{ + rom_start_bank &= 0xfe; + + dataOut(); + + // clear base bank setting + writeByte_GB(0x1000, 0xa5); + writeByte_GB(0x7000, 0x00); + writeByte_GB(0x1000, 0x98); + writeByte_GB(0x2000, rom_start_bank); + + if (rom_start_bank > 1) + { + // start set new base bank + writeByte_GB(0x1000, 0xa5); + + dataIn_GB(); + rom_start_bank = gbSmartGetResizeParam(rom_size, sram_size); + + dataOut(); + writeByte_GB(0x7000, rom_start_bank); + writeByte_GB(0x1000, 0x98); + + writeByte_GB(0x2100, 0x01); + } + + dataIn_GB(); +} + +// Get magic number for 0x7000 register. +// Use for setting correct rom and sram size +// Code logic is take from SmartCard32M V1.3 menu code, +// see 0x2db2 to 0x2e51 (0xa0 bytes) +uint8_t gbSmartGetResizeParam(uint8_t rom_size, uint8_t sram_size) +{ + if (rom_size < 0x0f) + { + rom_size &= 0x07; + rom_size ^= 0x07; + } + else + { + rom_size = 0x01; + } + + if (sram_size > 0) + { + if (sram_size > 1) + { + sram_size--; + sram_size ^= 0x03; + sram_size <<= 4; + sram_size &= 0x30; + } + else + { + sram_size = 0x20; // 2KiB treat as 8KiB + } + } + else + { + sram_size = 0x30; // no sram + } + + return (sram_size | rom_size); +}