mirror of https://github.com/sanni/cartreader.git
2636 lines
69 KiB
C++
2636 lines
69 KiB
C++
//******************************************
|
|
// GAME BOY ADVANCE MODULE
|
|
//******************************************
|
|
#ifdef ENABLE_GBX
|
|
|
|
/******************************************
|
|
Menu
|
|
*****************************************/
|
|
// GBA menu items
|
|
static const char GBAMenuItem4[] PROGMEM = "Force Savetype";
|
|
static const char GBAMenuItem5[] PROGMEM = "Flash Repro";
|
|
static const char* const menuOptionsGBA[] PROGMEM = { FSTRING_READ_ROM, FSTRING_READ_SAVE, FSTRING_WRITE_SAVE, GBAMenuItem4, GBAMenuItem5, FSTRING_RESET };
|
|
|
|
// Rom menu
|
|
static const char GBARomItem1[] PROGMEM = "1 MB";
|
|
static const char GBARomItem2[] PROGMEM = "2 MB";
|
|
static const char GBARomItem3[] PROGMEM = "4 MB";
|
|
static const char GBARomItem4[] PROGMEM = "8 MB";
|
|
static const char GBARomItem5[] PROGMEM = "16 MB";
|
|
static const char GBARomItem6[] PROGMEM = "32 MB";
|
|
static const char* const romOptionsGBA[] PROGMEM = { GBARomItem1, GBARomItem2, GBARomItem3, GBARomItem4, GBARomItem5, GBARomItem6 };
|
|
|
|
// Save menu
|
|
static const char GBASaveItem1[] PROGMEM = "4K EEPROM";
|
|
static const char GBASaveItem2[] PROGMEM = "64K EEPROM";
|
|
static const char GBASaveItem3[] PROGMEM = "256K SRAM/FRAM";
|
|
static const char GBASaveItem4[] PROGMEM = "512K SRAM/FRAM";
|
|
static const char GBASaveItem5[] PROGMEM = "512K FLASH";
|
|
static const char GBASaveItem6[] PROGMEM = "1M FLASH";
|
|
static const char* const saveOptionsGBA[] PROGMEM = { GBASaveItem1, GBASaveItem2, GBASaveItem3, GBASaveItem4, GBASaveItem5, GBASaveItem6 };
|
|
|
|
void gbaMenu() {
|
|
// create menu with title and 4 options to choose from
|
|
unsigned char mainMenu;
|
|
// Copy menuOptions out of progmem
|
|
convertPgm(menuOptionsGBA, 6);
|
|
mainMenu = question_box(F("GBA Cart Reader"), menuOptions, 6, 0);
|
|
|
|
// wait for user choice to come back from the question box menu
|
|
switch (mainMenu) {
|
|
case 0:
|
|
// Read rom
|
|
if (cartSize == 0) {
|
|
const byte romOptionsGBASize[] = { 1, 2, 4, 8, 16, 32 };
|
|
// create submenu with title and 4 options to choose from
|
|
unsigned char GBARomMenu;
|
|
// Copy menuOptions out of progmem
|
|
convertPgm(romOptionsGBA, 6);
|
|
GBARomMenu = question_box(F("Select ROM size"), menuOptions, 6, 0);
|
|
|
|
// wait for user choice to come back from the question box menu
|
|
cartSize = romOptionsGBASize[GBARomMenu];
|
|
}
|
|
if (cartSize < 128) // Don't multiply cartSize on second dump
|
|
cartSize *= 0x100000;
|
|
display_Clear();
|
|
// Change working dir to root
|
|
sd.chdir("/");
|
|
readROM_GBA();
|
|
sd.chdir("/");
|
|
// Internal Checksum
|
|
compare_checksum_GBA();
|
|
// CRC32
|
|
compareCRC("gba.txt", 0, 1, 0);
|
|
#ifdef ENABLE_GLOBAL_LOG
|
|
save_log();
|
|
#endif
|
|
// Prints string out of the common strings array either with or without newline
|
|
print_STR(press_button_STR, 1);
|
|
display_Update();
|
|
wait();
|
|
break;
|
|
|
|
case 1:
|
|
// Read save
|
|
display_Clear();
|
|
sd.chdir("/");
|
|
switch (getSaveType()) {
|
|
case 1:
|
|
// 4K EEPROM
|
|
readEeprom_GBA(4);
|
|
break;
|
|
|
|
case 2:
|
|
// 64K EEPROM
|
|
readEeprom_GBA(64);
|
|
break;
|
|
|
|
case 3:
|
|
// 256K SRAM/FRAM
|
|
readSRAM_GBA(1, 32768, 0);
|
|
break;
|
|
|
|
case 4:
|
|
// 512K FLASH
|
|
readFLASH_GBA(1, 65536, 0);
|
|
break;
|
|
|
|
case 5:
|
|
// 1M FLASH (divided into two banks)
|
|
switchBank_GBA(0x0);
|
|
setROM_GBA();
|
|
readFLASH_GBA(1, 65536, 0);
|
|
switchBank_GBA(0x1);
|
|
setROM_GBA();
|
|
readFLASH_GBA(0, 65536, 65536);
|
|
break;
|
|
|
|
case 6:
|
|
// 512K SRAM/FRAM
|
|
readSRAM_GBA(1, 65536, 0);
|
|
break;
|
|
}
|
|
setROM_GBA();
|
|
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();
|
|
break;
|
|
|
|
case 2:
|
|
// Write save
|
|
display_Clear();
|
|
sd.chdir("/");
|
|
switch (getSaveType()) {
|
|
case 1:
|
|
// 4K EEPROM
|
|
writeEeprom_GBA(4);
|
|
verifyEEP_GBA(4);
|
|
setROM_GBA();
|
|
break;
|
|
|
|
case 2:
|
|
// 64K EEPROM
|
|
writeEeprom_GBA(64);
|
|
verifyEEP_GBA(64);
|
|
break;
|
|
|
|
case 3:
|
|
// 256K SRAM/FRAM
|
|
writeSRAM_GBA(1, 32768, 0);
|
|
verifySRAM_GBA(32768, 0);
|
|
break;
|
|
|
|
case 4:
|
|
// 512K FLASH
|
|
idFlash_GBA();
|
|
resetFLASH_GBA();
|
|
|
|
if (flashid == 0x1F3D) {
|
|
printFlashTypeAndWait(F("Atmel AT29LV512"));
|
|
} else if (flashid == 0xBFD4) {
|
|
printFlashTypeAndWait(F("SST 39VF512"));
|
|
} else if (flashid == 0xC21C) {
|
|
printFlashTypeAndWait(F("Macronix MX29L512"));
|
|
} else if (flashid == 0x321B) {
|
|
printFlashTypeAndWait(F("Panasonic MN63F805MNP"));
|
|
} else {
|
|
printFlashTypeAndWait(F("Unknown"));
|
|
//print_FatalError(FSTRING_EMPTY);
|
|
}
|
|
|
|
if (flashid == 0x1F3D) { // Atmel
|
|
writeFLASH_GBA(1, 65536, 0, 1);
|
|
verifyFLASH_GBA(65536, 0);
|
|
} else {
|
|
eraseFLASH_GBA();
|
|
if (blankcheckFLASH_GBA(65536)) {
|
|
writeFLASH_GBA(1, 65536, 0, 0);
|
|
verifyFLASH_GBA(65536, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
// 1M FLASH
|
|
idFlash_GBA();
|
|
resetFLASH_GBA();
|
|
|
|
if (flashid == 0xC209) {
|
|
printFlashTypeAndWait(F("Macronix MX29L010"));
|
|
} else if (flashid == 0x6213) {
|
|
printFlashTypeAndWait(F("SANYO LE26FV10N1TS"));
|
|
} else {
|
|
printFlashTypeAndWait(F("Unknown"));
|
|
//print_FatalError(FSTRING_EMPTY);
|
|
}
|
|
|
|
eraseFLASH_GBA();
|
|
// 131072 bytes are divided into two 65536 byte banks
|
|
for (byte bank = 0; bank < 2; bank++) {
|
|
switchBank_GBA(bank);
|
|
setROM_GBA();
|
|
if (!blankcheckFLASH_GBA(65536))
|
|
break;
|
|
writeFLASH_GBA(!bank, 65536, bank ? 65536 : 0, 0);
|
|
if (verifyFLASH_GBA(65536, bank ? 65536 : 0))
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 6:
|
|
// 512K SRAM/FRAM
|
|
writeSRAM_GBA(1, 65536, 0);
|
|
verifySRAM_GBA(65536, 0);
|
|
break;
|
|
}
|
|
setROM_GBA();
|
|
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();
|
|
break;
|
|
|
|
case 3:
|
|
display_Clear();
|
|
saveType = 0;
|
|
saveType = getSaveType();
|
|
display_Clear();
|
|
break;
|
|
|
|
case 4:
|
|
display_Clear();
|
|
flashRepro_GBA();
|
|
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();
|
|
resetArduino();
|
|
break;
|
|
|
|
case 5:
|
|
resetArduino();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/******************************************
|
|
Setup
|
|
*****************************************/
|
|
void setup_GBA() {
|
|
// Request 3.3V
|
|
setVoltage(VOLTS_SET_3V3);
|
|
|
|
setROM_GBA();
|
|
|
|
// Get cart info
|
|
getCartInfo_GBA();
|
|
display_Clear();
|
|
|
|
// Print start page
|
|
print_Msg(F("Title: "));
|
|
println_Msg(romName);
|
|
print_Msg(F("Serial: "));
|
|
println_Msg(cartID);
|
|
print_Msg(F("Revision: "));
|
|
println_Msg(romVersion);
|
|
print_Msg(F("ROM Size: "));
|
|
if (cartSize == 0)
|
|
println_Msg(F("Unknown"));
|
|
else {
|
|
print_Msg(cartSize);
|
|
println_Msg(F(" MB"));
|
|
}
|
|
print_Msg(F("Save Type: "));
|
|
switch (saveType) {
|
|
case 0:
|
|
println_Msg(F("None/Unknown"));
|
|
break;
|
|
|
|
case 1:
|
|
println_Msg(F("4K EEPROM"));
|
|
break;
|
|
|
|
case 2:
|
|
println_Msg(F("64K EEPROM"));
|
|
break;
|
|
|
|
case 3:
|
|
println_Msg(F("256K SRAM"));
|
|
break;
|
|
|
|
case 4:
|
|
println_Msg(F("512K FLASH"));
|
|
break;
|
|
|
|
case 5:
|
|
println_Msg(F("1M FLASH"));
|
|
break;
|
|
}
|
|
print_Msg(F("Header Checksum: "));
|
|
println_Msg(checksumStr);
|
|
|
|
// Wait for user input
|
|
println_Msg("");
|
|
// Prints string out of the common strings array either with or without newline
|
|
print_STR(press_button_STR, 1);
|
|
display_Update();
|
|
wait();
|
|
}
|
|
|
|
/******************************************
|
|
Low level functions
|
|
*****************************************/
|
|
static byte getSaveType() {
|
|
if (saveType == 0) {
|
|
const byte saveOptionsGBAType[] = { 1, 2, 3, 6, 4, 5 };
|
|
// create submenu with title and 6 options to choose from
|
|
unsigned char GBASaveMenu;
|
|
// Copy menuOptions out of progmem
|
|
convertPgm(saveOptionsGBA, 6);
|
|
GBASaveMenu = question_box(F("Select save type"), menuOptions, 6, 0);
|
|
// wait for user choice to come back from the question box menu
|
|
saveType = saveOptionsGBAType[GBASaveMenu];
|
|
}
|
|
return saveType;
|
|
}
|
|
|
|
static void printFlashTypeAndWait(const __FlashStringHelper* caption) {
|
|
print_Msg(F("FLASH ID: "));
|
|
println_Msg(flashid_str);
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(F("FLASH Type: "));
|
|
println_Msg(caption);
|
|
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();
|
|
display_Clear();
|
|
display_Update();
|
|
}
|
|
|
|
void setROM_GBA() {
|
|
// CS_SRAM(PH0)
|
|
DDRH |= (1 << 0);
|
|
PORTH |= (1 << 0);
|
|
// CS_ROM(PH3)
|
|
DDRH |= (1 << 3);
|
|
PORTH |= (1 << 3);
|
|
// WR(PH5)
|
|
DDRH |= (1 << 5);
|
|
PORTH |= (1 << 5);
|
|
// RD(PH6)
|
|
DDRH |= (1 << 6);
|
|
PORTH |= (1 << 6);
|
|
// AD0-AD7
|
|
DDRF = 0xFF;
|
|
// AD8-AD15
|
|
DDRK = 0xFF;
|
|
// AD16-AD23
|
|
DDRC = 0xFF;
|
|
// Wait
|
|
delay(500);
|
|
}
|
|
|
|
word readWord_GBA(unsigned long myAddress) {
|
|
// Set address/data ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
DDRC = 0xFF;
|
|
|
|
// Divide address by two to get word addressing
|
|
myAddress = myAddress >> 1;
|
|
|
|
// Output address to address pins,
|
|
PORTF = myAddress;
|
|
PORTK = myAddress >> 8;
|
|
PORTC = myAddress >> 16;
|
|
|
|
// Pull CS(PH3) to LOW
|
|
PORTH &= ~(1 << 3);
|
|
|
|
// Set address/data ports to input
|
|
PORTF = 0x0;
|
|
PORTK = 0x0;
|
|
DDRF = 0x0;
|
|
DDRK = 0x0;
|
|
|
|
// Pull RD(PH6) to LOW
|
|
PORTH &= ~(1 << 6);
|
|
|
|
// Delay here or read error with repro
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
word myWord = (PINK << 8) | PINF;
|
|
|
|
// Switch RD(PH6) to HIGH
|
|
PORTH |= (1 << 6);
|
|
|
|
// Switch CS_ROM(PH3) to HIGH
|
|
PORTH |= (1 << 3);
|
|
|
|
return myWord;
|
|
}
|
|
|
|
void writeWord_GBA(unsigned long myAddress, word myWord) {
|
|
// Set address/data ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
DDRC = 0xFF;
|
|
|
|
// Divide address by two to get word addressing
|
|
myAddress = myAddress >> 1;
|
|
|
|
// Output address to address pins,
|
|
PORTF = myAddress;
|
|
PORTK = myAddress >> 8;
|
|
PORTC = myAddress >> 16;
|
|
|
|
// Pull CS(PH3) to LOW
|
|
PORTH &= ~(1 << 3);
|
|
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Output data
|
|
PORTF = myWord & 0xFF;
|
|
PORTK = myWord >> 8;
|
|
|
|
// Pull WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Switch WR(PH5) to HIGH
|
|
PORTH |= (1 << 5);
|
|
|
|
// Switch CS_ROM(PH3) to HIGH
|
|
PORTH |= (1 << 3);
|
|
}
|
|
|
|
// This function swaps bit at positions p1 and p2 in an integer n
|
|
word swapBits(word n, word p1, word p2) {
|
|
// Move p1'th to rightmost side
|
|
word bit1 = (n >> p1) & 1;
|
|
|
|
// Move p2'th to rightmost side
|
|
word bit2 = (n >> p2) & 1;
|
|
|
|
// XOR the two bits */
|
|
word x = (bit1 ^ bit2);
|
|
|
|
// Put the xor bit back to their original positions
|
|
x = (x << p1) | (x << p2);
|
|
|
|
// XOR 'x' with the original number so that the two sets are swapped
|
|
word result = n ^ x;
|
|
|
|
return result;
|
|
}
|
|
|
|
// Some repros have D0 and D1 switched
|
|
word readWord_GAB(unsigned long myAddress) {
|
|
word tempWord = swapBits(readWord_GBA(myAddress), 0, 1);
|
|
return tempWord;
|
|
}
|
|
|
|
void writeWord_GAB(unsigned long myAddress, word myWord) {
|
|
writeWord_GBA(myAddress, swapBits(myWord, 0, 1));
|
|
}
|
|
|
|
byte readByte_GBA(uint16_t myAddress) {
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
// Set data port to input
|
|
DDRC = 0x0;
|
|
|
|
// Output address to address pins,
|
|
PORTF = myAddress;
|
|
PORTK = myAddress >> 8;
|
|
|
|
// Pull OE_SRAM(PH6) to LOW
|
|
PORTH &= ~(1 << 6);
|
|
// Pull CE_SRAM(PH0) to LOW
|
|
PORTH &= ~(1 << 0);
|
|
|
|
// Hold address for at least 25ns and wait 150ns before access
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read byte
|
|
byte tempByte = PINC;
|
|
|
|
// Pull CE_SRAM(PH0) HIGH
|
|
PORTH |= (1 << 0);
|
|
// Pull OE_SRAM(PH6) HIGH
|
|
PORTH |= (1 << 6);
|
|
|
|
return tempByte;
|
|
}
|
|
|
|
void writeByte_GBA(uint16_t myAddress, byte myData) {
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
// Set data port to output
|
|
DDRC = 0xFF;
|
|
|
|
// Output address to address pins
|
|
PORTF = myAddress;
|
|
PORTK = myAddress >> 8;
|
|
// Output data to data pins
|
|
PORTC = myData;
|
|
|
|
// Wait till output is stable
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Pull WE_SRAM(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Pull CE_SRAM(PH0) to LOW
|
|
PORTH &= ~(1 << 0);
|
|
|
|
// Leave WR low for at least 60ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Pull CE_SRAM(PH0) HIGH
|
|
PORTH |= (1 << 0);
|
|
// Pull WE_SRAM(PH5) HIGH
|
|
PORTH |= (1 << 5);
|
|
|
|
// Leave WR high for at least 50ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
}
|
|
|
|
/******************************************
|
|
GBA ROM Functions
|
|
*****************************************/
|
|
// Compute the checksum of rom header
|
|
// "header" must contain at least the rom's first 188 bytes
|
|
byte checksumHeader_GBA(const byte* header) {
|
|
byte result = 0x00;
|
|
for (byte n = 0xA0; n < 0xBD; n++) {
|
|
result -= header[n];
|
|
}
|
|
return result - 0x19;
|
|
}
|
|
|
|
// Read info out of rom header
|
|
void getCartInfo_GBA() {
|
|
char saveTypeStr[14];
|
|
|
|
// Read Header into array
|
|
for (int currWord = 0; currWord < 192; currWord += 2) {
|
|
word tempWord = readWord_GBA(currWord);
|
|
|
|
sdBuffer[currWord] = tempWord & 0xFF;
|
|
sdBuffer[currWord + 1] = (tempWord >> 8) & 0xFF;
|
|
}
|
|
|
|
// Compare Nintendo logo against known checksum, 156 bytes starting at 0x04
|
|
word logoChecksum = 0;
|
|
for (int currByte = 0x4; currByte < 0xA0; currByte++) {
|
|
logoChecksum += sdBuffer[currByte];
|
|
}
|
|
|
|
if (logoChecksum != 0x4B1B) {
|
|
display_Clear();
|
|
print_Error(F("CARTRIDGE ERROR"));
|
|
strcpy(romName, "ERROR");
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(F("Press Button to"));
|
|
println_Msg(F("ignore or powercycle"));
|
|
println_Msg(F("to try again"));
|
|
display_Update();
|
|
wait();
|
|
} else {
|
|
char tempStr[5];
|
|
tempStr[4] = 0;
|
|
|
|
// cart not in list
|
|
cartSize = 0;
|
|
saveType = 0;
|
|
|
|
// Get cart ID
|
|
cartID[0] = char(sdBuffer[0xAC]);
|
|
cartID[1] = char(sdBuffer[0xAD]);
|
|
cartID[2] = char(sdBuffer[0xAE]);
|
|
cartID[3] = char(sdBuffer[0xAF]);
|
|
|
|
display_Clear();
|
|
println_Msg(F("Searching database..."));
|
|
display_Update();
|
|
|
|
//go to root
|
|
sd.chdir();
|
|
if (myFile.open("gba.txt", O_READ)) {
|
|
char gamename[100];
|
|
|
|
#ifdef ENABLE_GLOBAL_LOG
|
|
// Disable log to prevent unnecessary logging
|
|
dont_log = true;
|
|
#endif
|
|
|
|
// Loop through file
|
|
while (myFile.available()) {
|
|
// Skip first line with name
|
|
skip_line(&myFile);
|
|
|
|
// Skip over the CRC checksum
|
|
myFile.seekCur(9);
|
|
|
|
// Read 4 bytes into String, do it one at a time so byte order doesn't get mixed up
|
|
for (byte i = 0; i < 4; i++) {
|
|
tempStr[i] = char(myFile.read());
|
|
}
|
|
|
|
// Check if string is a match
|
|
if (strcmp(tempStr, cartID) == 0) {
|
|
// Rewind to start of entry
|
|
rewind_line(myFile);
|
|
|
|
// Display database
|
|
while (myFile.available()) {
|
|
display_Clear();
|
|
|
|
// Read game name
|
|
get_line(gamename, &myFile, 96);
|
|
|
|
// Skip over the CRC checksum
|
|
myFile.seekCur(9);
|
|
|
|
// Read 4 bytes into String, do it one at a time so byte order doesn't get mixed up
|
|
for (byte i = 0; i < 4; i++) {
|
|
tempStr[i] = char(myFile.read());
|
|
}
|
|
|
|
// Skip the , in the file
|
|
myFile.seekCur(1);
|
|
|
|
// Read the next ascii character and subtract 48 to convert to decimal
|
|
cartSize = ((myFile.read() - 48) * 10) + (myFile.read() - 48);
|
|
|
|
// Skip the , in the file
|
|
myFile.seekCur(1);
|
|
|
|
// Read save type into string
|
|
get_line(saveTypeStr, &myFile, 14);
|
|
|
|
// skip third empty line
|
|
skip_line(&myFile);
|
|
|
|
// Print current database entry
|
|
println_Msg(gamename);
|
|
print_Msg(F("Serial: "));
|
|
println_Msg(tempStr);
|
|
print_Msg(F("ROM Size: "));
|
|
print_Msg(cartSize);
|
|
println_Msg(F(" MB"));
|
|
print_Msg(F("Save Lib: "));
|
|
println_Msg(saveTypeStr);
|
|
|
|
printInstructions();
|
|
|
|
uint8_t b = 0;
|
|
while (1) {
|
|
// Check button input
|
|
b = checkButton();
|
|
|
|
// Next
|
|
if (b == 1) {
|
|
// Break out of loop to read next entry
|
|
break;
|
|
}
|
|
|
|
// Previous
|
|
else if (b == 2) {
|
|
rewind_line(myFile, 6);
|
|
break;
|
|
}
|
|
|
|
// Selection made
|
|
else if (b == 3) {
|
|
// Close file and break to exit both loops
|
|
myFile.close();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// If no match advance and try again
|
|
else {
|
|
// skip rest of line
|
|
skip_line(&myFile);
|
|
// skip third empty line
|
|
skip_line(&myFile);
|
|
}
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
|
|
#ifdef ENABLE_GLOBAL_LOG
|
|
// Enable log again
|
|
dont_log = false;
|
|
#endif
|
|
} else {
|
|
print_FatalError(F("GBA.txt missing"));
|
|
}
|
|
|
|
// Get name
|
|
buildRomName(romName, &sdBuffer[0xA0], 12);
|
|
|
|
// Get ROM version
|
|
romVersion = sdBuffer[0xBC];
|
|
|
|
// Calculate Checksum
|
|
byte calcChecksum = checksumHeader_GBA(sdBuffer);
|
|
|
|
// Convert checksum from header into string
|
|
// (used in compare_checksum_GBA... it should just exchange an integer
|
|
// instead)
|
|
sprintf(checksumStr, "%02X", sdBuffer[0xBD]);
|
|
|
|
// Compare checksum
|
|
if (sdBuffer[0xBD] != calcChecksum) {
|
|
char calcChecksumStr[3];
|
|
display_Clear();
|
|
print_Msg(F("Result: "));
|
|
// Turn into string
|
|
sprintf(calcChecksumStr, "%02X", calcChecksum);
|
|
println_Msg(calcChecksumStr);
|
|
print_Error(F("Checksum Error"));
|
|
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();
|
|
}
|
|
|
|
/* Convert saveTypeStr to saveType
|
|
Save types in ROM
|
|
EEPROM_Vnnn EEPROM 512 bytes or 8 Kbytes (4Kbit or 64Kbit)
|
|
SRAM_Vnnn SRAM 32 Kbytes (256Kbit)
|
|
SRAM_F_Vnnn FRAM 32 Kbytes (256Kbit)
|
|
FLASH_Vnnn FLASH 64 Kbytes (512Kbit) (ID used in older files)
|
|
FLASH512_Vnnn FLASH 64 Kbytes (512Kbit) (ID used in newer files)
|
|
FLASH1M_Vnnn FLASH 128 Kbytes (1Mbit)
|
|
|
|
Save types in Cart Reader Code
|
|
0 = Unknown or no save
|
|
1 = 4K EEPROM
|
|
2 = 64K EEPROM
|
|
3 = 256K SRAM
|
|
4 = 512K FLASH
|
|
5 = 1M FLASH
|
|
6 = 512K SRAM
|
|
*/
|
|
|
|
if (saveTypeStr[0] == 'N') {
|
|
saveType = 0;
|
|
} else if (saveTypeStr[0] == 'E') {
|
|
// Test if 4kbit or 64kbit EEPROM
|
|
|
|
// Disable interrupts for more uniform clock pulses
|
|
noInterrupts();
|
|
// Fill sd Buffer
|
|
readBlock_EEP(0, 64);
|
|
interrupts();
|
|
delay(1000);
|
|
// Enable ROM again
|
|
setROM_GBA();
|
|
|
|
saveType = 1;
|
|
|
|
// Reading 4kbit EEPROM as 64kbit just gives the same 8 bytes repeated
|
|
for (int currByte = 0; currByte < 512 - 8; currByte++) {
|
|
if (sdBuffer[currByte] != sdBuffer[currByte + 8]) {
|
|
saveType = 2;
|
|
break;
|
|
}
|
|
}
|
|
} else if (saveTypeStr[0] == 'S') {
|
|
saveType = 3;
|
|
} else if ((saveTypeStr[0] == 'F') && (saveTypeStr[5] == '1')) {
|
|
saveType = 5;
|
|
} else if (saveTypeStr[0] == 'F') {
|
|
saveType = 4;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Dump ROM
|
|
void readROM_GBA() {
|
|
// Get name, add extension and convert to char array for sd lib
|
|
createFolder("GBA", "ROM", romName, "gba");
|
|
|
|
//clear the screen
|
|
display_Clear();
|
|
print_STR(saving_to_STR, 0);
|
|
print_Msg(folder);
|
|
println_Msg(F("/..."));
|
|
display_Update();
|
|
|
|
// write new folder number back to eeprom
|
|
foldern = foldern + 1;
|
|
EEPROM_writeAnything(0, foldern);
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
|
|
print_FatalError(create_file_STR);
|
|
}
|
|
|
|
//Initialize progress bar
|
|
uint32_t processedProgressBar = 0;
|
|
uint32_t totalProgressBar = (uint32_t)(cartSize);
|
|
draw_progressbar(0, totalProgressBar);
|
|
|
|
// Read rom
|
|
for (unsigned long myAddress = 0; myAddress < cartSize; myAddress += 512) {
|
|
// Blink led
|
|
if (myAddress % 16384 == 0)
|
|
blinkLED();
|
|
|
|
for (int currWord = 0; currWord < 512; currWord += 2) {
|
|
word tempWord = readWord_GBA(myAddress + currWord);
|
|
sdBuffer[currWord] = tempWord & 0xFF;
|
|
sdBuffer[currWord + 1] = (tempWord >> 8) & 0xFF;
|
|
}
|
|
|
|
// Write to SD
|
|
myFile.write(sdBuffer, 512);
|
|
|
|
processedProgressBar += 512;
|
|
draw_progressbar(processedProgressBar, totalProgressBar);
|
|
}
|
|
|
|
// Fix unmapped ROM area of cartridges with 32 MB ROM + EEPROM save type
|
|
if ((cartSize == 0x2000000) && ((saveType == 1) || (saveType == 2))) {
|
|
byte padding_byte[256];
|
|
char tempStr[32];
|
|
myFile.seek(0x1FFFEFF);
|
|
myFile.read(padding_byte, 1);
|
|
sprintf(tempStr, "Fixing ROM padding (0x%02X)", padding_byte[0]);
|
|
println_Msg(tempStr);
|
|
memset(padding_byte + 1, padding_byte[0], 255);
|
|
myFile.write(padding_byte, 256);
|
|
}
|
|
|
|
// Close the file:
|
|
myFile.close();
|
|
}
|
|
|
|
// Calculate the checksum of the dumped rom
|
|
boolean compare_checksum_GBA() {
|
|
print_Msg(F("Checksum: "));
|
|
display_Update();
|
|
|
|
strcpy(fileName, romName);
|
|
strcat(fileName, ".gba");
|
|
|
|
// last used rom folder
|
|
EEPROM_readAnything(0, foldern);
|
|
sprintf(folder, "GBA/ROM/%s/%d", romName, foldern - 1);
|
|
sd.chdir(folder);
|
|
|
|
// If file exists
|
|
if (myFile.open(fileName, O_READ)) {
|
|
// Read rom header
|
|
myFile.read(sdBuffer, 512);
|
|
myFile.close();
|
|
|
|
// Calculate Checksum and turn into string
|
|
char calcChecksumStr[3];
|
|
sprintf(calcChecksumStr, "%02X", checksumHeader_GBA(sdBuffer));
|
|
print_Msg(calcChecksumStr);
|
|
|
|
if (strcmp(calcChecksumStr, checksumStr) == 0) {
|
|
println_Msg(F(" -> OK"));
|
|
display_Update();
|
|
return 1;
|
|
} else {
|
|
print_Msg(F(" != "));
|
|
println_Msg(checksumStr);
|
|
print_Error(F("Invalid Checksum"));
|
|
return 0;
|
|
}
|
|
}
|
|
// Else show error
|
|
else {
|
|
print_Error(F("Failed to open rom"));
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************
|
|
GBA SRAM SAVE Functions
|
|
*****************************************/
|
|
void readSRAM_GBA(boolean browseFile, uint32_t sramSize, uint32_t pos) {
|
|
if (browseFile) {
|
|
// Get name, add extension and convert to char array for sd lib
|
|
createFolder("GBA", "SAVE", romName, "srm");
|
|
|
|
// Save location
|
|
print_STR(saving_to_STR, 0);
|
|
print_Msg(folder);
|
|
println_Msg(F("/..."));
|
|
display_Update();
|
|
// write new folder number back to eeprom
|
|
foldern = foldern + 1;
|
|
EEPROM_writeAnything(0, foldern);
|
|
}
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
|
|
print_FatalError(sd_error_STR);
|
|
}
|
|
|
|
// Seek to a new position in the file
|
|
if (pos != 0)
|
|
myFile.seekCur(pos);
|
|
|
|
for (uint32_t currAddress = 0; currAddress < sramSize; currAddress += 512) {
|
|
for (int c = 0; c < 512; c++) {
|
|
// Read byte
|
|
sdBuffer[c] = readByte_GBA(currAddress + c);
|
|
}
|
|
|
|
// Write sdBuffer to file
|
|
myFile.write(sdBuffer, 512);
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
|
|
// Signal end of process
|
|
print_STR(done_STR, 1);
|
|
display_Update();
|
|
}
|
|
|
|
void writeSRAM_GBA(boolean browseFile, uint32_t sramSize, uint32_t pos) {
|
|
if (browseFile) {
|
|
filePath[0] = '\0';
|
|
sd.chdir("/");
|
|
fileBrowser(F("Select srm file"));
|
|
// Create filepath
|
|
sprintf(filePath, "%s/%s", filePath, fileName);
|
|
display_Clear();
|
|
}
|
|
|
|
//open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
|
|
// Seek to a new position in the file
|
|
if (pos != 0)
|
|
myFile.seekCur(pos);
|
|
|
|
for (uint32_t currAddress = 0; currAddress < sramSize; currAddress += 512) {
|
|
//fill sdBuffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int c = 0; c < 512; c++) {
|
|
// Write byte
|
|
writeByte_GBA(currAddress + c, sdBuffer[c]);
|
|
}
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
println_Msg(F("SRAM writing finished"));
|
|
display_Update();
|
|
|
|
} else {
|
|
print_Error(FS(FSTRING_FILE_DOESNT_EXIST));
|
|
}
|
|
}
|
|
|
|
unsigned long verifySRAM_GBA(unsigned long sramSize, uint32_t pos) {
|
|
//open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
// Variable for errors
|
|
writeErrors = 0;
|
|
|
|
// Seek to a new position in the file
|
|
if (pos != 0)
|
|
myFile.seekCur(pos);
|
|
|
|
for (unsigned long currAddress = 0; currAddress < sramSize; currAddress += 512) {
|
|
//fill sdBuffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int c = 0; c < 512; c++) {
|
|
// Read byte
|
|
if (readByte_GBA(currAddress + c) != sdBuffer[c]) {
|
|
writeErrors++;
|
|
}
|
|
}
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
|
|
if (writeErrors == 0) {
|
|
println_Msg(F("Verified OK"));
|
|
display_Update();
|
|
} else {
|
|
print_STR(error_STR, 0);
|
|
print_Msg(writeErrors);
|
|
print_STR(_bytes_STR, 1);
|
|
print_Error(did_not_verify_STR);
|
|
}
|
|
|
|
return writeErrors;
|
|
} else {
|
|
print_Error(F("Can't open file"));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/******************************************
|
|
GBA FRAM SAVE Functions
|
|
*****************************************/
|
|
// MB85R256 FRAM (Ferroelectric Random Access Memory) 32,768 words x 8 bits
|
|
void readFRAM_GBA(unsigned long framSize) {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_SRAM(PH5)
|
|
PORTH |= (1 << 3) | (1 << 5);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
|
|
// Output a LOW signal on CE_SRAM(PH0) and OE_SRAM(PH6)
|
|
PORTH &= ~((1 << 0) | (1 << 6));
|
|
|
|
// Get name, add extension and convert to char array for sd lib
|
|
createFolder("GBA", "SAVE", romName, "srm");
|
|
|
|
// Save location
|
|
print_STR(saving_to_STR, 0);
|
|
print_Msg(folder);
|
|
println_Msg(F("/..."));
|
|
display_Update();
|
|
// write new folder number back to eeprom
|
|
foldern = foldern + 1;
|
|
EEPROM_writeAnything(0, foldern);
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
|
|
print_FatalError(sd_error_STR);
|
|
}
|
|
for (unsigned long currAddress = 0; currAddress < framSize; currAddress += 512) {
|
|
for (int c = 0; c < 512; c++) {
|
|
// Pull OE_SRAM(PH6) HIGH
|
|
PORTH |= (1 << 6);
|
|
|
|
// Set address
|
|
PORTF = (currAddress + c) & 0xFF;
|
|
PORTK = ((currAddress + c) >> 8) & 0xFF;
|
|
|
|
// Arduino running at 16Mhz -> one nop = 62.5ns
|
|
// Leave CS_SRAM HIGH for at least 85ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Pull OE_SRAM(PH6) LOW
|
|
PORTH &= ~(1 << 6);
|
|
|
|
// Hold address for at least 25ns and wait 150ns before access
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read byte
|
|
sdBuffer[c] = PINC;
|
|
}
|
|
// Write sdBuffer to file
|
|
myFile.write(sdBuffer, 512);
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
|
|
// Signal end of process
|
|
print_STR(done_STR, 1);
|
|
display_Update();
|
|
}
|
|
|
|
// Write file to SRAM
|
|
void writeFRAM_GBA(boolean browseFile, unsigned long framSize) {
|
|
// Output a HIGH signal on CS_ROM(PH3) and OE_SRAM(PH6)
|
|
PORTH |= (1 << 3) | (1 << 6);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
|
|
// Set data port to output
|
|
DDRC = 0xFF;
|
|
|
|
// Output a LOW signal on CE_SRAM(PH0) and WE_SRAM(PH5)
|
|
PORTH &= ~((1 << 0) | (1 << 5));
|
|
|
|
if (browseFile) {
|
|
filePath[0] = '\0';
|
|
sd.chdir("/");
|
|
fileBrowser(F("Select srm file"));
|
|
// Create filepath
|
|
sprintf(filePath, "%s/%s", filePath, fileName);
|
|
display_Clear();
|
|
} else
|
|
sprintf(filePath, "%s", fileName);
|
|
|
|
//open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
for (unsigned long currAddress = 0; currAddress < framSize; currAddress += 512) {
|
|
//fill sdBuffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int c = 0; c < 512; c++) {
|
|
// Output Data on PORTC
|
|
PORTC = sdBuffer[c];
|
|
|
|
// Arduino running at 16Mhz -> one nop = 62.5ns
|
|
// Data setup time 50ns
|
|
__asm__("nop\n\t");
|
|
|
|
// Pull WE_SRAM (PH5) HIGH
|
|
PORTH |= (1 << 5);
|
|
|
|
// Set address
|
|
PORTF = (currAddress + c) & 0xFF;
|
|
PORTK = ((currAddress + c) >> 8) & 0xFF;
|
|
|
|
// Leave WE_SRAM (PH5) HIGH for at least 85ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Pull WE_SRAM (PH5) LOW
|
|
PORTH &= ~(1 << 5);
|
|
|
|
// Hold address for at least 25ns and wait 150ns before next write
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
}
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
println_Msg(F("SRAM writing finished"));
|
|
display_Update();
|
|
|
|
} else {
|
|
print_Error(FS(FSTRING_FILE_DOESNT_EXIST));
|
|
}
|
|
}
|
|
|
|
// Check if the SRAM was written without any error
|
|
unsigned long verifyFRAM_GBA(unsigned long framSize) {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_SRAM(PH5)
|
|
PORTH |= (1 << 3) | (1 << 5);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
|
|
// Output a LOW signal on CE_SRAM(PH0) and OE_SRAM(PH6)
|
|
PORTH &= ~((1 << 0) | (1 << 6));
|
|
|
|
//open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
|
|
// Variable for errors
|
|
writeErrors = 0;
|
|
|
|
for (unsigned long currAddress = 0; currAddress < framSize; currAddress += 512) {
|
|
//fill sdBuffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int c = 0; c < 512; c++) {
|
|
// Pull OE_SRAM(PH6) HIGH
|
|
PORTH |= (1 << 6);
|
|
|
|
// Set address
|
|
PORTF = (currAddress + c) & 0xFF;
|
|
PORTK = ((currAddress + c) >> 8) & 0xFF;
|
|
|
|
// Arduino running at 16Mhz -> one nop = 62.5ns
|
|
// Leave CS_SRAM HIGH for at least 85ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Pull OE_SRAM(PH6) LOW
|
|
PORTH &= ~(1 << 6);
|
|
|
|
// Hold address for at least 25ns and wait 150ns before access
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read byte
|
|
if (PINC != sdBuffer[c]) {
|
|
writeErrors++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Close the file:
|
|
myFile.close();
|
|
return writeErrors;
|
|
} else {
|
|
print_Error(F("Can't open file"));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/******************************************
|
|
GBA FLASH SAVE Functions
|
|
*****************************************/
|
|
void initOutputFlash_GBA() {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_FLASH(PH5) and OE_FLASH(PH6)
|
|
PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
// Set data pins to output
|
|
DDRC = 0xFF;
|
|
|
|
// Output a LOW signal on CE_FLASH(PH0)
|
|
PORTH &= ~(1 << 0);
|
|
}
|
|
|
|
// SST 39VF512 Flashrom
|
|
void idFlash_GBA() {
|
|
initOutputFlash_GBA();
|
|
|
|
// ID command sequence
|
|
writeByteFlash_GBA(0x5555, 0xaa);
|
|
writeByteFlash_GBA(0x2aaa, 0x55);
|
|
writeByteFlash_GBA(0x5555, 0x90);
|
|
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
|
|
// Output a LOW signal on OE_FLASH(PH6)
|
|
PORTH &= ~(1 << 6);
|
|
|
|
// Wait 150ns before reading ID
|
|
// Arduino running at 16Mhz -> one nop = 62.5ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read the two id bytes into a string
|
|
flashid = readByteFlash_GBA(0) << 8;
|
|
flashid |= readByteFlash_GBA(1);
|
|
sprintf(flashid_str, "%04X", flashid);
|
|
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
}
|
|
|
|
// Reset FLASH
|
|
void resetFLASH_GBA() {
|
|
initOutputFlash_GBA();
|
|
|
|
// Reset command sequence
|
|
writeByteFlash_GBA(0x5555, 0xAA);
|
|
writeByteFlash_GBA(0x2AAA, 0x55);
|
|
writeByteFlash_GBA(0x5555, 0xf0);
|
|
writeByteFlash_GBA(0x5555, 0xf0);
|
|
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
|
|
// Wait
|
|
delay(100);
|
|
}
|
|
|
|
byte readByteFlash_GBA(uint16_t myAddress) {
|
|
// Set address
|
|
PORTF = myAddress & 0xFF;
|
|
PORTK = (myAddress >> 8) & 0xFF;
|
|
|
|
// Wait until byte is ready to read
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read byte
|
|
byte tempByte = PINC;
|
|
|
|
// Arduino running at 16Mhz -> one nop = 62.5ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
return tempByte;
|
|
}
|
|
|
|
void writeByteFlash_GBA(uint16_t myAddress, byte myData) {
|
|
PORTF = myAddress & 0xFF;
|
|
PORTK = (myAddress >> 8) & 0xFF;
|
|
PORTC = myData;
|
|
|
|
// Arduino running at 16Mhz -> one nop = 62.5ns
|
|
// Wait till output is stable
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Switch WE_FLASH(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
|
|
// Leave WE low for at least 40ns
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Switch WE_FLASH(PH5) to HIGH
|
|
PORTH |= (1 << 5);
|
|
|
|
// Leave WE high for a bit
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
}
|
|
|
|
// Erase FLASH
|
|
void eraseFLASH_GBA() {
|
|
initOutputFlash_GBA();
|
|
|
|
// Erase command sequence
|
|
writeByteFlash_GBA(0x5555, 0xaa);
|
|
writeByteFlash_GBA(0x2aaa, 0x55);
|
|
writeByteFlash_GBA(0x5555, 0x80);
|
|
writeByteFlash_GBA(0x5555, 0xaa);
|
|
writeByteFlash_GBA(0x2aaa, 0x55);
|
|
writeByteFlash_GBA(0x5555, 0x10);
|
|
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
|
|
// Wait until all is erased
|
|
delay(500);
|
|
}
|
|
|
|
boolean blankcheckFLASH_GBA(uint32_t flashSize) {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_FLASH(PH5)
|
|
PORTH |= (1 << 3) | (1 << 5);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
// Set address to 0
|
|
PORTF = 0x00;
|
|
PORTK = 0x00;
|
|
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
// Disable Pullups
|
|
//PORTC = 0x00;
|
|
|
|
boolean blank = 1;
|
|
|
|
// Output a LOW signal on CE_FLASH(PH0)
|
|
PORTH &= ~(1 << 0);
|
|
|
|
// Output a LOW signal on OE_FLASH(PH6)
|
|
PORTH &= ~(1 << 6);
|
|
|
|
for (uint32_t currAddress = 0; currAddress < flashSize; currAddress += 512) {
|
|
// Fill buffer
|
|
for (int c = 0; c < 512; c++) {
|
|
// Read byte
|
|
sdBuffer[c] = readByteFlash_GBA(currAddress + c);
|
|
}
|
|
// Check buffer
|
|
for (uint32_t currByte = 0; currByte < 512; currByte++) {
|
|
if (sdBuffer[currByte] != 0xFF) {
|
|
print_Error(F("Erase failed"));
|
|
currByte = 512;
|
|
currAddress = flashSize;
|
|
blank = 0;
|
|
}
|
|
}
|
|
}
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
|
|
return blank;
|
|
}
|
|
|
|
// The MX29L010 is 131072 bytes in size and has 16 sectors per bank
|
|
// each sector is 4096 bytes, there are 32 sectors total
|
|
// therefore the bank size is 65536 bytes, so we have two banks in total
|
|
void switchBank_GBA(byte bankNum) {
|
|
initOutputFlash_GBA();
|
|
|
|
// Switch bank command sequence
|
|
writeByte_GBA(0x5555, 0xAA);
|
|
writeByte_GBA(0x2AAA, 0x55);
|
|
writeByte_GBA(0x5555, 0xB0);
|
|
writeByte_GBA(0x0000, bankNum);
|
|
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
}
|
|
|
|
void readFLASH_GBA(boolean browseFile, uint32_t flashSize, uint32_t pos) {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_FLASH(PH5)
|
|
PORTH |= (1 << 3) | (1 << 5);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
// Set address to 0
|
|
PORTF = 0x00;
|
|
PORTK = 0x00;
|
|
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
|
|
if (browseFile) {
|
|
// Get name, add extension and convert to char array for sd lib
|
|
createFolder("GBA", "SAVE", romName, "fla");
|
|
|
|
// Save location
|
|
print_STR(saving_to_STR, 0);
|
|
print_Msg(folder);
|
|
println_Msg(F("/..."));
|
|
display_Update();
|
|
|
|
// write new folder number back to eeprom
|
|
foldern = foldern + 1;
|
|
EEPROM_writeAnything(0, foldern);
|
|
}
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
|
|
print_FatalError(sd_error_STR);
|
|
}
|
|
|
|
// Seek to a new position in the file
|
|
if (pos != 0)
|
|
myFile.seekCur(pos);
|
|
|
|
// Output a LOW signal on CE_FLASH(PH0)
|
|
PORTH &= ~(1 << 0);
|
|
|
|
// Output a LOW signal on OE_FLASH(PH6)
|
|
PORTH &= ~(1 << 6);
|
|
|
|
for (uint32_t currAddress = 0; currAddress < flashSize; currAddress += 512) {
|
|
for (int c = 0; c < 512; c++) {
|
|
// Read byte
|
|
sdBuffer[c] = readByteFlash_GBA(currAddress + c);
|
|
}
|
|
// Write sdBuffer to file
|
|
myFile.write(sdBuffer, 512);
|
|
}
|
|
myFile.close();
|
|
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
|
|
// Signal end of process
|
|
print_STR(done_STR, 1);
|
|
display_Update();
|
|
}
|
|
|
|
void busyCheck_GBA(uint16_t currByte) {
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
// Output a LOW signal on OE_FLASH(PH6)
|
|
PORTH &= ~(1 << 6);
|
|
// Read PINC
|
|
while (PINC != sdBuffer[currByte]) {}
|
|
// Output a HIGH signal on OE_FLASH(PH6)
|
|
PORTH |= (1 << 6);
|
|
// Set data pins to output
|
|
DDRC = 0xFF;
|
|
}
|
|
|
|
void writeFLASH_GBA(boolean browseFile, uint32_t flashSize, uint32_t pos, boolean isAtmel) {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_FLASH(PH5) and OE_FLASH(PH6)
|
|
PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
// Set data port to output
|
|
DDRC = 0xFF;
|
|
|
|
if (browseFile) {
|
|
filePath[0] = '\0';
|
|
sd.chdir("/");
|
|
fileBrowser(F("Select fla file"));
|
|
// Create filepath
|
|
sprintf(filePath, "%s/%s", filePath, fileName);
|
|
display_Clear();
|
|
}
|
|
|
|
print_Msg(F("Writing flash..."));
|
|
display_Update();
|
|
|
|
//open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
|
|
// Seek to a new position in the file
|
|
if (pos != 0)
|
|
myFile.seekCur(pos);
|
|
|
|
// Output a LOW signal on CE_FLASH(PH0)
|
|
PORTH &= ~(1 << 0);
|
|
|
|
if (!isAtmel) {
|
|
for (uint32_t currAddress = 0; currAddress < flashSize; currAddress += 512) {
|
|
//fill sdBuffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int c = 0; c < 512; c++) {
|
|
// Write command sequence
|
|
writeByteFlash_GBA(0x5555, 0xaa);
|
|
writeByteFlash_GBA(0x2aaa, 0x55);
|
|
writeByteFlash_GBA(0x5555, 0xa0);
|
|
// Write current byte
|
|
writeByteFlash_GBA(currAddress + c, sdBuffer[c]);
|
|
|
|
// Wait
|
|
busyCheck_GBA(c);
|
|
}
|
|
}
|
|
} else {
|
|
for (uint32_t currAddress = 0; currAddress < flashSize; currAddress += 128) {
|
|
//fill sdBuffer
|
|
myFile.read(sdBuffer, 128);
|
|
|
|
// Write command sequence
|
|
writeByteFlash_GBA(0x5555, 0xaa);
|
|
writeByteFlash_GBA(0x2aaa, 0x55);
|
|
writeByteFlash_GBA(0x5555, 0xa0);
|
|
for (int c = 0; c < 128; c++) {
|
|
writeByteFlash_GBA(currAddress + c, sdBuffer[c]);
|
|
}
|
|
delay(15);
|
|
}
|
|
}
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
|
|
// Close the file:
|
|
myFile.close();
|
|
print_STR(done_STR, 1);
|
|
display_Update();
|
|
|
|
} else {
|
|
println_Msg(F("Error"));
|
|
print_Error(FS(FSTRING_FILE_DOESNT_EXIST));
|
|
}
|
|
}
|
|
|
|
// Check if the Flashrom was written without any error
|
|
unsigned long verifyFLASH_GBA(uint32_t flashSize, uint32_t pos) {
|
|
// Output a HIGH signal on CS_ROM(PH3) WE_FLASH(PH5)
|
|
PORTH |= (1 << 3) | (1 << 5);
|
|
|
|
// Set address ports to output
|
|
DDRF = 0xFF;
|
|
DDRK = 0xFF;
|
|
|
|
// Set data pins to input
|
|
DDRC = 0x00;
|
|
|
|
// Output a LOW signal on CE_FLASH(PH0) and OE_FLASH(PH6)
|
|
PORTH &= ~((1 << 0) | (1 << 6));
|
|
|
|
// Signal beginning of process
|
|
print_Msg(F("Verify..."));
|
|
display_Update();
|
|
|
|
unsigned long wrError = 0;
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(filePath, O_READ)) {
|
|
print_FatalError(sd_error_STR);
|
|
}
|
|
|
|
// Seek to a new position in the file
|
|
if (pos != 0)
|
|
myFile.seekCur(pos);
|
|
|
|
for (unsigned long currAddress = 0; currAddress < flashSize; currAddress += 512) {
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int c = 0; c < 512; c++) {
|
|
// Read byte
|
|
if (sdBuffer[c] != readByteFlash_GBA(currAddress + c)) {
|
|
wrError++;
|
|
}
|
|
}
|
|
}
|
|
myFile.close();
|
|
|
|
// Set CS_FLASH(PH0) high
|
|
PORTH |= (1 << 0);
|
|
|
|
if (wrError == 0) {
|
|
println_Msg(FS(FSTRING_OK));
|
|
} else {
|
|
print_Msg(wrError);
|
|
print_Error(F(" Errors"));
|
|
}
|
|
|
|
return wrError;
|
|
}
|
|
|
|
/******************************************
|
|
GBA Eeprom SAVE Functions
|
|
*****************************************/
|
|
// Write eeprom from file
|
|
void writeEeprom_GBA(word eepSize) {
|
|
// Launch Filebrowser
|
|
filePath[0] = '\0';
|
|
sd.chdir("/");
|
|
fileBrowser(F("Select eep file"));
|
|
// Create filepath
|
|
sprintf(filePath, "%s/%s", filePath, fileName);
|
|
display_Clear();
|
|
|
|
print_Msg(F("Writing EEPROM..."));
|
|
display_Update();
|
|
|
|
//open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
for (word i = 0; i < eepSize * 16; i += 64) {
|
|
// Fill romBuffer
|
|
myFile.read(sdBuffer, 512);
|
|
// Disable interrupts for more uniform clock pulses
|
|
noInterrupts();
|
|
// Write 512 bytes
|
|
writeBlock_EEP(i, eepSize);
|
|
interrupts();
|
|
|
|
// Wait
|
|
delayMicroseconds(200);
|
|
}
|
|
|
|
// Close the file:
|
|
myFile.close();
|
|
print_STR(done_STR, 1);
|
|
display_Update();
|
|
} else {
|
|
println_Msg(F("Error"));
|
|
print_Error(FS(FSTRING_FILE_DOESNT_EXIST));
|
|
}
|
|
}
|
|
|
|
// Read eeprom to file
|
|
void readEeprom_GBA(word eepSize) {
|
|
// Get name, add extension and convert to char array for sd lib
|
|
createFolder("GBA", "SAVE", romName, "eep");
|
|
|
|
// Save location
|
|
print_STR(saving_to_STR, 0);
|
|
print_Msg(folder);
|
|
println_Msg(F("/..."));
|
|
display_Update();
|
|
|
|
// write new folder number back to eeprom
|
|
foldern = foldern + 1;
|
|
EEPROM_writeAnything(0, foldern);
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
|
|
print_FatalError(sd_error_STR);
|
|
}
|
|
|
|
// Each block contains 8 Bytes, so for a 8KB eeprom 1024 blocks need to be read
|
|
for (word currAddress = 0; currAddress < eepSize * 16; currAddress += 64) {
|
|
// Disable interrupts for more uniform clock pulses
|
|
noInterrupts();
|
|
// Fill sd Buffer
|
|
readBlock_EEP(currAddress, eepSize);
|
|
interrupts();
|
|
|
|
// Write sdBuffer to file
|
|
myFile.write(sdBuffer, 512);
|
|
|
|
// Wait
|
|
delayMicroseconds(200);
|
|
}
|
|
myFile.close();
|
|
}
|
|
|
|
// Send address as bits to eeprom
|
|
void send_GBA(word currAddr, word numBits) {
|
|
for (word addrBit = numBits; addrBit > 0; addrBit--) {
|
|
// If you want the k-th bit of n, then do
|
|
// (n & ( 1 << k )) >> k
|
|
if (((currAddr & (1 << (addrBit - 1))) >> (addrBit - 1))) {
|
|
// Set A0(PF0) to High
|
|
PORTF |= (1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Set WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
} else {
|
|
// Set A0(PF0) to Low
|
|
PORTF &= ~(1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Set WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write 512K eeprom block
|
|
void writeBlock_EEP(word startAddr, word eepSize) {
|
|
// Setup
|
|
// Set CS_ROM(PH3) WR(PH5) RD(PH6) to Output
|
|
DDRH |= (1 << 3) | (1 << 5) | (1 << 6);
|
|
// Set A0(PF0) to Output
|
|
DDRF |= (1 << 0);
|
|
// Set A23/D7(PC7) to Output
|
|
DDRC |= (1 << 7);
|
|
|
|
// Set CS_ROM(PH3) WR(PH5) RD(PH6) to High
|
|
PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
|
|
// Set A0(PF0) to High
|
|
PORTF |= (1 << 0);
|
|
// Set A23/D7(PC7) to High
|
|
PORTC |= (1 << 7);
|
|
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Write 64*8=512 bytes
|
|
for (word currAddr = startAddr; currAddr < startAddr + 64; currAddr++) {
|
|
// Set CS_ROM(PH3) to LOW
|
|
PORTH &= ~(1 << 3);
|
|
|
|
// Send write request "10"
|
|
// Set A0(PF0) to High
|
|
PORTF |= (1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Set WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
// Set A0(PF0) to LOW
|
|
PORTF &= ~(1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Set WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
|
|
// Send either 6 or 14 bit address
|
|
if (eepSize == 4) {
|
|
send_GBA(currAddr, 6);
|
|
} else {
|
|
send_GBA(currAddr, 14);
|
|
}
|
|
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Send data
|
|
for (byte currByte = 0; currByte < 8; currByte++) {
|
|
send_GBA(sdBuffer[(currAddr - startAddr) * 8 + currByte], 8);
|
|
}
|
|
|
|
// Send stop bit
|
|
// Set A0(PF0) to LOW
|
|
PORTF &= ~(1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
|
|
// Set CS_ROM(PH3) to High
|
|
PORTH |= (1 << 3);
|
|
|
|
// Wait until done
|
|
// Set A0(PF0) to Input
|
|
DDRF &= ~(1 << 0);
|
|
|
|
do {
|
|
// Set CS_ROM(PH3) RD(PH6) to LOW
|
|
PORTH &= ~((1 << 3) | (1 << 6));
|
|
// Set CS_ROM(PH3) RD(PH6) to High
|
|
PORTH |= (1 << 3) | (1 << 6);
|
|
} while ((PINF & 0x1) == 0);
|
|
|
|
// Set A0(PF0) to Output
|
|
DDRF |= (1 << 0);
|
|
}
|
|
}
|
|
|
|
// Reads 512 bytes from eeprom
|
|
void readBlock_EEP(word startAddress, word eepSize) {
|
|
// Setup
|
|
// Set CS_ROM(PH3) WR(PH5) RD(PH6) to Output
|
|
DDRH |= (1 << 3) | (1 << 5) | (1 << 6);
|
|
// Set A0(PF0) to Output
|
|
DDRF |= (1 << 0);
|
|
// Set A23/D7(PC7) to Output
|
|
DDRC |= (1 << 7);
|
|
|
|
// Set CS_ROM(PH3) WR(PH5) RD(PH6) to High
|
|
PORTH |= (1 << 3) | (1 << 5) | (1 << 6);
|
|
// Set A0(PF0) to High
|
|
PORTF |= (1 << 0);
|
|
// Set A23/D7(PC7) to High
|
|
PORTC |= (1 << 7);
|
|
|
|
__asm__("nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read 64*8=512 bytes
|
|
for (word currAddr = startAddress; currAddr < startAddress + 64; currAddr++) {
|
|
// Set CS_ROM(PH3) to LOW
|
|
PORTH &= ~(1 << 3);
|
|
|
|
// Send read request "11"
|
|
// Set A0(PF0) to High
|
|
PORTF |= (1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Set WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// Set WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
|
|
// Send either 6 or 14 bit address
|
|
if (eepSize == 4) {
|
|
send_GBA(currAddr, 6);
|
|
} else {
|
|
send_GBA(currAddr, 14);
|
|
}
|
|
|
|
// Send stop bit
|
|
// Set A0(PF0) to LOW
|
|
PORTF &= ~(1 << 0);
|
|
// Set WR(PH5) to LOW
|
|
PORTH &= ~(1 << 5);
|
|
// WR(PH5) to High
|
|
PORTH |= (1 << 5);
|
|
|
|
// Set CS_ROM(PH3) to High
|
|
PORTH |= (1 << 3);
|
|
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read data
|
|
// Set A0(PF0) to Input
|
|
DDRF &= ~(1 << 0);
|
|
// Set CS_ROM(PH3) to low
|
|
PORTH &= ~(1 << 3);
|
|
|
|
// Array that holds the bits
|
|
bool tempBits[65];
|
|
|
|
// Ignore the first 4 bits
|
|
for (byte i = 0; i < 4; i++) {
|
|
// Set RD(PH6) to LOW
|
|
PORTH &= ~(1 << 6);
|
|
// Set RD(PH6) to High
|
|
PORTH |= (1 << 6);
|
|
}
|
|
|
|
// Read the remaining 64bits into array
|
|
for (byte currBit = 0; currBit < 64; currBit++) {
|
|
// Set RD(PH6) to LOW
|
|
PORTH &= ~(1 << 6);
|
|
// Set RD(PH6) to High
|
|
PORTH |= (1 << 6);
|
|
|
|
// Read bit from A0(PF0)
|
|
tempBits[currBit] = (PINF & 0x1);
|
|
}
|
|
|
|
// Set CS_ROM(PH3) to High
|
|
PORTH |= (1 << 3);
|
|
// Set A0(PF0) to High
|
|
PORTF |= (1 << 0);
|
|
// Set A0(PF0) to Output
|
|
DDRF |= (1 << 0);
|
|
|
|
// OR 8 bits into one byte for a total of 8 bytes
|
|
for (byte j = 0; j < 64; j += 8) {
|
|
sdBuffer[((currAddr - startAddress) * 8) + (j / 8)] = tempBits[0 + j] << 7 | tempBits[1 + j] << 6 | tempBits[2 + j] << 5 | tempBits[3 + j] << 4 | tempBits[4 + j] << 3 | tempBits[5 + j] << 2 | tempBits[6 + j] << 1 | tempBits[7 + j];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check if the SRAM was written without any error
|
|
unsigned long verifyEEP_GBA(word eepSize) {
|
|
unsigned long wrError = 0;
|
|
|
|
//open file on sd card
|
|
if (!myFile.open(filePath, O_READ)) {
|
|
print_FatalError(sd_error_STR);
|
|
}
|
|
|
|
// Fill sd Buffer
|
|
for (word currAddress = 0; currAddress < eepSize * 16; currAddress += 64) {
|
|
// Disable interrupts for more uniform clock pulses
|
|
noInterrupts();
|
|
readBlock_EEP(currAddress, eepSize);
|
|
interrupts();
|
|
|
|
// Compare
|
|
for (int currByte = 0; currByte < 512; currByte++) {
|
|
if (sdBuffer[currByte] != myFile.read()) {
|
|
wrError++;
|
|
}
|
|
}
|
|
}
|
|
myFile.close();
|
|
|
|
if (wrError == 0) {
|
|
println_Msg(F("Verified OK"));
|
|
display_Update();
|
|
} else {
|
|
print_STR(error_STR, 0);
|
|
print_Msg(wrError);
|
|
print_STR(_bytes_STR, 1);
|
|
print_Error(did_not_verify_STR);
|
|
}
|
|
|
|
return wrError;
|
|
}
|
|
|
|
/******************************************
|
|
GBA REPRO Functions (32MB Intel 4000L0YBQ0 and 16MB MX29GL128E)
|
|
*****************************************/
|
|
// Reset to read mode
|
|
void resetIntel_GBA(unsigned long partitionSize) {
|
|
for (unsigned long currPartition = 0; currPartition < cartSize; currPartition += partitionSize) {
|
|
writeWord_GBA(currPartition, 0xFFFF);
|
|
}
|
|
}
|
|
|
|
void resetMX29GL128E_GBA() {
|
|
writeWord_GAB(0, 0xF0);
|
|
}
|
|
|
|
boolean sectorCheckMX29GL128E_GBA() {
|
|
boolean sectorProtect = 0;
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(0xAAA, 0x90);
|
|
for (unsigned long currSector = 0x0; currSector < 0xFFFFFF; currSector += 0x20000) {
|
|
if (readWord_GAB(currSector + 0x04) != 0x0)
|
|
sectorProtect = 1;
|
|
}
|
|
resetMX29GL128E_GBA();
|
|
return sectorProtect;
|
|
}
|
|
|
|
void idFlashrom_GBA() {
|
|
// Send Intel ID command to flashrom
|
|
writeWord_GBA(0, 0x90);
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read flashrom ID
|
|
flashid = readWord_GBA(0x2) & 0xFF00;
|
|
flashid |= readWord_GBA(0x4) & 0xFF;
|
|
sprintf(flashid_str, "%04X", flashid);
|
|
|
|
// Intel Strataflash
|
|
if (flashid == 0x8802 || (flashid == 0x8816)) {
|
|
cartSize = 0x2000000;
|
|
} else {
|
|
// Send swapped MX29GL128E/MSP55LV128 ID command to flashrom
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(0xAAA, 0x90);
|
|
__asm__("nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t"
|
|
"nop\n\t");
|
|
|
|
// Read flashrom ID
|
|
flashid = readWord_GAB(0x2);
|
|
sprintf(flashid_str, "%04X", flashid);
|
|
|
|
// MX29GL128E or MSP55LV128
|
|
if (flashid == 0x227E) {
|
|
// MX is 0xC2 and MSP is 0x4 or 0x1
|
|
romType = (readWord_GAB(0x0) & 0xFF);
|
|
cartSize = 0x1000000;
|
|
resetMX29GL128E_GBA();
|
|
} else {
|
|
println_Msg(F("Error"));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(F("Unknown Flash"));
|
|
print_Msg(F("Flash ID: "));
|
|
println_Msg(flashid_str);
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
print_FatalError(F("Check voltage"));
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean blankcheckFlashrom_GBA() {
|
|
for (unsigned long currSector = 0; currSector < fileSize; currSector += 0x20000) {
|
|
// Blink led
|
|
blinkLED();
|
|
|
|
for (unsigned long currByte = 0; currByte < 0x20000; currByte += 2) {
|
|
if (readWord_GBA(currSector + currByte) != 0xFFFF) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void eraseIntel4000_GBA() {
|
|
// If the game is smaller than 16Mbit only erase the needed blocks
|
|
unsigned long lastBlock = 0xFFFFFF;
|
|
if (fileSize < 0xFFFFFF)
|
|
lastBlock = fileSize;
|
|
|
|
// Erase 4 blocks with 16kwords each
|
|
for (unsigned long currBlock = 0x0; currBlock < 0x1FFFF; currBlock += 0x8000) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
}
|
|
|
|
// Erase 126 blocks with 64kwords each
|
|
for (unsigned long currBlock = 0x20000; currBlock < lastBlock; currBlock += 0x1FFFF) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
// Blink led
|
|
blinkLED();
|
|
}
|
|
|
|
// Erase the second chip
|
|
if (fileSize > 0xFFFFFF) {
|
|
// 126 blocks with 64kwords each
|
|
for (unsigned long currBlock = 0x1000000; currBlock < 0x1FDFFFF; currBlock += 0x1FFFF) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
// Blink led
|
|
blinkLED();
|
|
}
|
|
|
|
// 4 blocks with 16kword each
|
|
for (unsigned long currBlock = 0x1FE0000; currBlock < 0x1FFFFFF; currBlock += 0x8000) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
// Blink led
|
|
blinkLED();
|
|
}
|
|
}
|
|
}
|
|
|
|
void eraseIntel4400_GBA() {
|
|
// If the game is smaller than 32Mbit only erase the needed blocks
|
|
unsigned long lastBlock = 0x1FFFFFF;
|
|
if (fileSize < 0x1FFFFFF)
|
|
lastBlock = fileSize;
|
|
|
|
// Erase 4 blocks with 16kwords each
|
|
for (unsigned long currBlock = 0x0; currBlock < 0x1FFFF; currBlock += 0x8000) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
}
|
|
|
|
// Erase 255 blocks with 64kwords each
|
|
for (unsigned long currBlock = 0x20000; currBlock < lastBlock; currBlock += 0x1FFFF) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
// Blink led
|
|
blinkLED();
|
|
}
|
|
|
|
/* No need to erase the second chip as max rom size is 32MB
|
|
if (fileSize > 0x2000000) {
|
|
// 255 blocks with 64kwords each
|
|
for (unsigned long currBlock = 0x2000000; currBlock < 0x3FDFFFF; currBlock += 0x1FFFF) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
// Blink led
|
|
blinkLED();
|
|
}
|
|
|
|
// 4 blocks with 16kword each
|
|
for (unsigned long currBlock = 0x3FE0000; currBlock < 0x3FFFFFF; currBlock += 0x8000) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock, 0x60);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Erase Command
|
|
writeWord_GBA(currBlock, 0x20);
|
|
writeWord_GBA(currBlock, 0xD0);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GBA(currBlock);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock);
|
|
}
|
|
// Blink led
|
|
blinkLED();
|
|
}
|
|
}*/
|
|
}
|
|
|
|
void sectorEraseMSP55LV128_GBA() {
|
|
unsigned long lastSector = 0xFFFFFF;
|
|
|
|
// Erase 256 sectors with 64kbytes each
|
|
unsigned long currSector;
|
|
for (currSector = 0x0; currSector < lastSector; currSector += 0x10000) {
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(0xAAA, 0x80);
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(currSector, 0x30);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GAB(currSector);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GAB(currSector);
|
|
}
|
|
// Blink LED
|
|
blinkLED();
|
|
}
|
|
}
|
|
|
|
void sectorEraseMX29GL128E_GBA() {
|
|
unsigned long lastSector = 0xFFFFFF;
|
|
|
|
// Erase 128 sectors with 128kbytes each
|
|
unsigned long currSector;
|
|
for (currSector = 0x0; currSector < lastSector; currSector += 0x20000) {
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(0xAAA, 0x80);
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(currSector, 0x30);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GAB(currSector);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GAB(currSector);
|
|
}
|
|
// Blink LED
|
|
blinkLED();
|
|
}
|
|
}
|
|
|
|
void writeIntel4000_GBA() {
|
|
for (unsigned long currBlock = 0; currBlock < fileSize; currBlock += 0x20000) {
|
|
// Blink led
|
|
blinkLED();
|
|
|
|
// Write to flashrom
|
|
for (unsigned long currSdBuffer = 0; currSdBuffer < 0x20000; currSdBuffer += 512) {
|
|
// Fill SD buffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
// Write 32 words at a time
|
|
for (int currWriteBuffer = 0; currWriteBuffer < 512; currWriteBuffer += 64) {
|
|
// Unlock Block
|
|
writeWord_GBA(currBlock + currSdBuffer + currWriteBuffer, 0x60);
|
|
writeWord_GBA(currBlock + currSdBuffer + currWriteBuffer, 0xD0);
|
|
|
|
// Buffered program command
|
|
writeWord_GBA(currBlock + currSdBuffer + currWriteBuffer, 0xE8);
|
|
|
|
// Check Status register
|
|
word statusReg = readWord_GBA(currBlock + currSdBuffer + currWriteBuffer);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock + currSdBuffer + currWriteBuffer);
|
|
}
|
|
|
|
// Write word count (minus 1)
|
|
writeWord_GBA(currBlock + currSdBuffer + currWriteBuffer, 0x1F);
|
|
|
|
// Write buffer
|
|
for (byte currByte = 0; currByte < 64; currByte += 2) {
|
|
// Join two bytes into one word
|
|
word currWord = ((sdBuffer[currWriteBuffer + currByte + 1] & 0xFF) << 8) | (sdBuffer[currWriteBuffer + currByte] & 0xFF);
|
|
writeWord_GBA(currBlock + currSdBuffer + currWriteBuffer + currByte, currWord);
|
|
}
|
|
|
|
// Write Buffer to Flash
|
|
writeWord_GBA(currBlock + currSdBuffer + currWriteBuffer + 62, 0xD0);
|
|
|
|
// Read the status register at last written address
|
|
statusReg = readWord_GBA(currBlock + currSdBuffer + currWriteBuffer + 62);
|
|
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
|
statusReg = readWord_GBA(currBlock + currSdBuffer + currWriteBuffer + 62);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void writeMSP55LV128_GBA() {
|
|
for (unsigned long currSector = 0; currSector < fileSize; currSector += 0x10000) {
|
|
// Blink led
|
|
blinkLED();
|
|
|
|
// Write to flashrom
|
|
for (unsigned long currSdBuffer = 0; currSdBuffer < 0x10000; currSdBuffer += 512) {
|
|
// Fill SD buffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
// Write 16 words at a time
|
|
for (int currWriteBuffer = 0; currWriteBuffer < 512; currWriteBuffer += 32) {
|
|
// Write Buffer command
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(currSector, 0x25);
|
|
|
|
// Write word count (minus 1)
|
|
writeWord_GAB(currSector, 0xF);
|
|
|
|
// Write buffer
|
|
word currWord;
|
|
for (byte currByte = 0; currByte < 32; currByte += 2) {
|
|
// Join two bytes into one word
|
|
currWord = ((sdBuffer[currWriteBuffer + currByte + 1] & 0xFF) << 8) | (sdBuffer[currWriteBuffer + currByte] & 0xFF);
|
|
writeWord_GBA(currSector + currSdBuffer + currWriteBuffer + currByte, currWord);
|
|
}
|
|
|
|
// Confirm write buffer
|
|
writeWord_GAB(currSector, 0x29);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GAB(currSector + currSdBuffer + currWriteBuffer + 30);
|
|
|
|
while ((statusReg | 0xFF7F) != (currWord | 0xFF7F)) {
|
|
statusReg = readWord_GAB(currSector + currSdBuffer + currWriteBuffer + 30);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void writeMX29GL128E_GBA() {
|
|
for (unsigned long currSector = 0; currSector < fileSize; currSector += 0x20000) {
|
|
// Blink led
|
|
blinkLED();
|
|
|
|
// Write to flashrom
|
|
for (unsigned long currSdBuffer = 0; currSdBuffer < 0x20000; currSdBuffer += 512) {
|
|
// Fill SD buffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
// Write 32 words at a time
|
|
for (int currWriteBuffer = 0; currWriteBuffer < 512; currWriteBuffer += 64) {
|
|
// Write Buffer command
|
|
writeWord_GAB(0xAAA, 0xAA);
|
|
writeWord_GAB(0x555, 0x55);
|
|
writeWord_GAB(currSector, 0x25);
|
|
|
|
// Write word count (minus 1)
|
|
writeWord_GAB(currSector, 0x1F);
|
|
|
|
// Write buffer
|
|
word currWord;
|
|
for (byte currByte = 0; currByte < 64; currByte += 2) {
|
|
// Join two bytes into one word
|
|
currWord = ((sdBuffer[currWriteBuffer + currByte + 1] & 0xFF) << 8) | (sdBuffer[currWriteBuffer + currByte] & 0xFF);
|
|
writeWord_GBA(currSector + currSdBuffer + currWriteBuffer + currByte, currWord);
|
|
}
|
|
|
|
// Confirm write buffer
|
|
writeWord_GAB(currSector, 0x29);
|
|
|
|
// Read the status register
|
|
word statusReg = readWord_GAB(currSector + currSdBuffer + currWriteBuffer + 62);
|
|
|
|
while ((statusReg | 0xFF7F) != (currWord | 0xFF7F)) {
|
|
statusReg = readWord_GAB(currSector + currSdBuffer + currWriteBuffer + 62);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
boolean verifyFlashrom_GBA() {
|
|
// Open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
writeErrors = 0;
|
|
|
|
for (unsigned long currSector = 0; currSector < fileSize; currSector += 131072) {
|
|
// Blink led
|
|
blinkLED();
|
|
for (unsigned long currSdBuffer = 0; currSdBuffer < 131072; currSdBuffer += 512) {
|
|
// Fill SD buffer
|
|
myFile.read(sdBuffer, 512);
|
|
|
|
for (int currByte = 0; currByte < 512; currByte += 2) {
|
|
// Join two bytes into one word
|
|
word currWord = ((sdBuffer[currByte + 1] & 0xFF) << 8) | (sdBuffer[currByte] & 0xFF);
|
|
|
|
// Compare both
|
|
if (readWord_GBA(currSector + currSdBuffer + currByte) != currWord) {
|
|
writeErrors++;
|
|
myFile.close();
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Close the file:
|
|
myFile.close();
|
|
if (writeErrors == 0) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
print_FatalError(open_file_STR);
|
|
return 9999;
|
|
}
|
|
}
|
|
|
|
void flashRepro_GBA() {
|
|
// Check flashrom ID's
|
|
idFlashrom_GBA();
|
|
|
|
if ((flashid == 0x8802) || (flashid == 0x8816) || (flashid == 0x227E)) {
|
|
print_Msg(F("ID: "));
|
|
print_Msg(flashid_str);
|
|
print_Msg(F(" Size: "));
|
|
print_Msg(cartSize / 0x100000);
|
|
println_Msg(F("MB"));
|
|
// MX29GL128E or MSP55LV128(N)
|
|
if (flashid == 0x227E) {
|
|
// MX is 0xC2 and MSP55LV128 is 0x4 and MSP55LV128N 0x1
|
|
if (romType == 0xC2) {
|
|
println_Msg(F("Macronix MX29GL128E"));
|
|
} else if ((romType == 0x1) || (romType == 0x4)) {
|
|
println_Msg(F("Fujitsu MSP55LV128N"));
|
|
} else if ((romType == 0x89)) {
|
|
println_Msg(F("Intel PC28F256M29"));
|
|
} else if ((romType == 0x20)) {
|
|
println_Msg(F("ST M29W128GH"));
|
|
} else {
|
|
print_Msg(F("romType: 0x"));
|
|
println_Msg(romType, HEX);
|
|
print_FatalError(F("Unknown manufacturer"));
|
|
}
|
|
}
|
|
// Intel 4000L0YBQ0
|
|
else if (flashid == 0x8802) {
|
|
println_Msg(F("Intel 4000L0YBQ0"));
|
|
}
|
|
// Intel 4400L0ZDQ0
|
|
else if (flashid == 0x8816) {
|
|
println_Msg(F("Intel 4400L0ZDQ0"));
|
|
}
|
|
println_Msg("");
|
|
println_Msg(F("This will erase your"));
|
|
println_Msg(F("Repro Cartridge."));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg("");
|
|
// Prints string out of the common strings array either with or without newline
|
|
print_STR(press_button_STR, 1);
|
|
display_Update();
|
|
wait();
|
|
|
|
// Launch file browser
|
|
filePath[0] = '\0';
|
|
sd.chdir("/");
|
|
fileBrowser(F("Select gba file"));
|
|
display_Clear();
|
|
display_Update();
|
|
|
|
// Create filepath
|
|
sprintf(filePath, "%s/%s", filePath, fileName);
|
|
|
|
// Open file on sd card
|
|
if (myFile.open(filePath, O_READ)) {
|
|
// Get rom size from file
|
|
fileSize = myFile.fileSize();
|
|
print_Msg(F("File size: "));
|
|
print_Msg(fileSize / 0x100000);
|
|
println_Msg(F("MB"));
|
|
display_Update();
|
|
|
|
// Erase needed sectors
|
|
if (flashid == 0x8802) {
|
|
println_Msg(F("Erasing..."));
|
|
display_Update();
|
|
eraseIntel4000_GBA();
|
|
resetIntel_GBA(0x200000);
|
|
} else if (flashid == 0x8816) {
|
|
println_Msg(F("Erasing..."));
|
|
display_Update();
|
|
eraseIntel4400_GBA();
|
|
resetIntel_GBA(0x200000);
|
|
} else if (flashid == 0x227E) {
|
|
//if (sectorCheckMX29GL128E_GBA()) {
|
|
//print_FatalError(F("Sector Protected"));
|
|
//}
|
|
//else {
|
|
println_Msg(F("Erasing..."));
|
|
display_Update();
|
|
if ((romType == 0xC2) || (romType == 0x89) || (romType == 0x20)) {
|
|
//MX29GL128E
|
|
//PC28F256M29 (0x89)
|
|
sectorEraseMX29GL128E_GBA();
|
|
} else if ((romType == 0x1) || (romType == 0x4)) {
|
|
//MSP55LV128(N)
|
|
sectorEraseMSP55LV128_GBA();
|
|
}
|
|
//}
|
|
}
|
|
/* Skip blankcheck to save time
|
|
print_Msg(F("Blankcheck..."));
|
|
display_Update();
|
|
if (blankcheckFlashrom_GBA()) {
|
|
println_Msg(FS(FSTRING_OK));
|
|
*/
|
|
|
|
//Write flashrom
|
|
print_Msg(F("Writing "));
|
|
println_Msg(filePath);
|
|
display_Update();
|
|
if ((flashid == 0x8802) || (flashid == 0x8816)) {
|
|
writeIntel4000_GBA();
|
|
} else if (flashid == 0x227E) {
|
|
if ((romType == 0xC2) || (romType == 0x89) || (romType == 0x20)) {
|
|
//MX29GL128E (0xC2)
|
|
//PC28F256M29 (0x89)
|
|
writeMX29GL128E_GBA();
|
|
} else if ((romType == 0x1) || (romType == 0x4)) {
|
|
//MSP55LV128(N)
|
|
writeMSP55LV128_GBA();
|
|
}
|
|
}
|
|
|
|
// Close the file:
|
|
myFile.close();
|
|
|
|
// Verify
|
|
print_STR(verifying_STR, 0);
|
|
display_Update();
|
|
if (flashid == 0x8802) {
|
|
// Don't know the correct size so just take some guesses
|
|
resetIntel_GBA(0x8000);
|
|
delay(1000);
|
|
resetIntel_GBA(0x100000);
|
|
delay(1000);
|
|
resetIntel_GBA(0x200000);
|
|
delay(1000);
|
|
} else if (flashid == 0x8816) {
|
|
resetIntel_GBA(0x200000);
|
|
delay(1000);
|
|
}
|
|
|
|
else if (flashid == 0x227E) {
|
|
resetMX29GL128E_GBA();
|
|
delay(1000);
|
|
}
|
|
if (verifyFlashrom_GBA() == 1) {
|
|
println_Msg(FS(FSTRING_OK));
|
|
display_Update();
|
|
} else {
|
|
print_FatalError(F("ERROR"));
|
|
}
|
|
/* Skipped blankcheck
|
|
}
|
|
else {
|
|
print_FatalError(F("failed"));
|
|
}
|
|
*/
|
|
} else {
|
|
print_FatalError(open_file_STR);
|
|
}
|
|
} else {
|
|
println_Msg(F("Error"));
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
println_Msg(F("Unknown Flash"));
|
|
print_Msg(F("Flash ID: "));
|
|
println_Msg(flashid_str);
|
|
println_Msg(FS(FSTRING_EMPTY));
|
|
print_FatalError(F("Check voltage"));
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
//******************************************
|
|
// End of File
|
|
//******************************************
|