mirror of https://github.com/sanni/cartreader.git
4812 lines
144 KiB
C++
4812 lines
144 KiB
C++
//******************************************
|
||
// NINTENDO 64 MODULE
|
||
//******************************************
|
||
#ifdef ENABLE_N64
|
||
|
||
/******************************************
|
||
Defines
|
||
*****************************************/
|
||
// These two macros toggle the eepDataPin/ControllerDataPin between input and output
|
||
// External 1K pull-up resistor from eepDataPin to VCC required
|
||
// 0x10 = 00010000 -> Port H Pin 4
|
||
#define N64_HIGH DDRH &= ~0x10
|
||
#define N64_LOW DDRH |= 0x10
|
||
// Read the current state(0/1) of the eepDataPin
|
||
#define N64_QUERY (PINH & 0x10)
|
||
|
||
/******************************************
|
||
Variables
|
||
*****************************************/
|
||
// Received N64 Eeprom data bits, 1 page
|
||
int eepPages;
|
||
|
||
// N64 Controller
|
||
struct {
|
||
char stick_x;
|
||
char stick_y;
|
||
} N64_status;
|
||
//stings that hold the buttons
|
||
String button = "N/A";
|
||
String lastbutton = "N/A";
|
||
|
||
// Rom base address
|
||
unsigned long romBase = 0x10000000;
|
||
|
||
// Flashram type
|
||
byte flashramType = 1;
|
||
boolean MN63F81MPN = false;
|
||
|
||
//ControllerTest
|
||
bool quit = 1;
|
||
|
||
#ifdef OPTION_N64_SAVESUMMARY
|
||
String CRC1 = "";
|
||
String CRC2 = "";
|
||
#endif
|
||
|
||
#if !defined(ENABLE_FLASH)
|
||
unsigned long flashSize;
|
||
#endif
|
||
|
||
static const char N64_EEP_FILENAME_FMT[] PROGMEM = "%s.eep";
|
||
static const char N64_SAVE_DIRNAME_FMT[] PROGMEM = "N64/SAVE/%s/%d";
|
||
|
||
/******************************************
|
||
Menu
|
||
*****************************************/
|
||
// N64 start menu
|
||
static const char n64MenuItem1[] PROGMEM = "Game Cartridge";
|
||
static const char n64MenuItem2[] PROGMEM = "Controller";
|
||
static const char n64MenuItem3[] PROGMEM = "Flash Repro";
|
||
static const char n64MenuItem4[] PROGMEM = "Flash Gameshark";
|
||
static const char n64MenuItem5[] PROGMEM = "Flash Xplorer 64";
|
||
static const char* const menuOptionsN64[] PROGMEM = { n64MenuItem1, n64MenuItem2, n64MenuItem3, n64MenuItem4, n64MenuItem5, FSTRING_RESET };
|
||
|
||
// N64 controller menu items
|
||
static const char N64ContMenuItem1[] PROGMEM = "Test Controller";
|
||
static const char N64ContMenuItem2[] PROGMEM = "Read ControllerPak";
|
||
static const char N64ContMenuItem3[] PROGMEM = "Write ControllerPak";
|
||
static const char* const menuOptionsN64Controller[] PROGMEM = { N64ContMenuItem1, N64ContMenuItem2, N64ContMenuItem3, FSTRING_RESET };
|
||
|
||
// N64 cart menu items
|
||
static const char N64CartMenuItem4[] PROGMEM = "Force Savetype";
|
||
static const char* const menuOptionsN64Cart[] PROGMEM = { FSTRING_READ_ROM, FSTRING_READ_SAVE, FSTRING_WRITE_SAVE, N64CartMenuItem4, FSTRING_RESET };
|
||
|
||
// N64 CRC32 error menu items
|
||
static const char N64CRCMenuItem1[] PROGMEM = "No";
|
||
static const char N64CRCMenuItem2[] PROGMEM = "Yes and keep old";
|
||
static const char N64CRCMenuItem3[] PROGMEM = "Yes and delete old";
|
||
static const char* const menuOptionsN64CRC[] PROGMEM = { N64CRCMenuItem1, N64CRCMenuItem2, N64CRCMenuItem3, FSTRING_RESET };
|
||
|
||
// Rom menu
|
||
static const char N64RomItem1[] PROGMEM = "4 MB";
|
||
static const char N64RomItem2[] PROGMEM = "8 MB";
|
||
static const char N64RomItem3[] PROGMEM = "12 MB";
|
||
static const char N64RomItem4[] PROGMEM = "16 MB";
|
||
static const char N64RomItem5[] PROGMEM = "32 MB";
|
||
static const char N64RomItem6[] PROGMEM = "64 MB";
|
||
static const char N64RomItem7[] PROGMEM = "128 MB";
|
||
static const char* const romOptionsN64[] PROGMEM = { N64RomItem1, N64RomItem2, N64RomItem3, N64RomItem4, N64RomItem5, N64RomItem6, N64RomItem7 };
|
||
|
||
// Save menu
|
||
static const char N64SaveItem1[] PROGMEM = "None";
|
||
static const char N64SaveItem2[] PROGMEM = "4K EEPROM";
|
||
static const char N64SaveItem3[] PROGMEM = "16K EEPROM";
|
||
static const char N64SaveItem4[] PROGMEM = "SRAM";
|
||
static const char N64SaveItem5[] PROGMEM = "FLASH";
|
||
static const char* const saveOptionsN64[] PROGMEM = { N64SaveItem1, N64SaveItem2, N64SaveItem3, N64SaveItem4, N64SaveItem5 };
|
||
|
||
// Repro write buffer menu
|
||
static const char N64BufferItem1[] PROGMEM = "No buffer";
|
||
static const char N64BufferItem2[] PROGMEM = "32 Byte";
|
||
static const char N64BufferItem3[] PROGMEM = "64 Byte";
|
||
static const char N64BufferItem4[] PROGMEM = "128 Byte";
|
||
static const char* const bufferOptionsN64[] PROGMEM = { N64BufferItem1, N64BufferItem2, N64BufferItem3, N64BufferItem4 };
|
||
|
||
// Repro sector size menu
|
||
static const char N64SectorItem1[] PROGMEM = "8 KB";
|
||
static const char N64SectorItem2[] PROGMEM = "32 KB";
|
||
static const char N64SectorItem3[] PROGMEM = "64 KB";
|
||
static const char N64SectorItem4[] PROGMEM = "128 KB";
|
||
static const char* const sectorOptionsN64[] PROGMEM = { N64SectorItem1, N64SectorItem2, N64SectorItem3, N64SectorItem4 };
|
||
|
||
// N64 start menu
|
||
void n64Menu() {
|
||
// create menu with title and 6 options to choose from
|
||
unsigned char n64Dev;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(menuOptionsN64, 6);
|
||
n64Dev = question_box(F("Select N64 device"), menuOptions, 6, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (n64Dev) {
|
||
case 0:
|
||
display_Clear();
|
||
display_Update();
|
||
setup_N64_Cart();
|
||
printCartInfo_N64();
|
||
mode = CORE_N64_CART;
|
||
break;
|
||
|
||
case 1:
|
||
display_Clear();
|
||
display_Update();
|
||
setup_N64_Controller();
|
||
mode = CORE_N64_CONTROLLER;
|
||
break;
|
||
|
||
case 2:
|
||
display_Clear();
|
||
display_Update();
|
||
setup_N64_Cart();
|
||
flashRepro_N64();
|
||
printCartInfo_N64();
|
||
mode = CORE_N64_CART;
|
||
break;
|
||
|
||
case 3:
|
||
display_Clear();
|
||
display_Update();
|
||
setup_N64_Cart();
|
||
flashGameshark_N64();
|
||
printCartInfo_N64();
|
||
mode = CORE_N64_CART;
|
||
break;
|
||
|
||
case 4:
|
||
display_Clear();
|
||
display_Update();
|
||
setup_N64_Cart();
|
||
flashXplorer_N64();
|
||
mode = CORE_N64_CART;
|
||
print_STR(press_button_STR, 1);
|
||
display_Update();
|
||
wait();
|
||
resetArduino();
|
||
break;
|
||
|
||
case 5:
|
||
resetArduino();
|
||
break;
|
||
}
|
||
}
|
||
|
||
// N64 Controller Menu
|
||
void n64ControllerMenu() {
|
||
// create menu with title and 4 options to choose from
|
||
unsigned char mainMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(menuOptionsN64Controller, 4);
|
||
mainMenu = question_box(F("N64 Controller"), menuOptions, 4, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (mainMenu) {
|
||
case 0:
|
||
resetController();
|
||
display_Clear();
|
||
display_Update();
|
||
#if (defined(ENABLE_OLED) || defined(ENABLE_LCD))
|
||
controllerTest_Display();
|
||
#elif defined(ENABLE_SERIAL)
|
||
controllerTest_Serial();
|
||
#endif
|
||
quit = 1;
|
||
break;
|
||
|
||
case 1:
|
||
resetController();
|
||
checkController();
|
||
display_Clear();
|
||
display_Update();
|
||
readMPK();
|
||
verifyCRC();
|
||
validateMPK();
|
||
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:
|
||
resetController();
|
||
checkController();
|
||
display_Clear();
|
||
display_Update();
|
||
// Change to root
|
||
filePath[0] = '\0';
|
||
sd.chdir("/");
|
||
// Launch file browser
|
||
fileBrowser(F("Select mpk file"));
|
||
display_Clear();
|
||
display_Update();
|
||
writeMPK();
|
||
delay(500);
|
||
verifyMPK();
|
||
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:
|
||
resetArduino();
|
||
break;
|
||
}
|
||
}
|
||
|
||
// N64 Cartridge Menu
|
||
void n64CartMenu() {
|
||
// create menu with title and 4 options to choose from
|
||
unsigned char mainMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(menuOptionsN64Cart, 5);
|
||
mainMenu = question_box(F("N64 Cart Reader"), menuOptions, 5, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (mainMenu) {
|
||
case 0:
|
||
display_Clear();
|
||
sd.chdir("/");
|
||
#ifndef OPTION_N64_FASTCRC
|
||
// Dumping ROM slow
|
||
readRom_N64();
|
||
sd.chdir("/");
|
||
compareCRC("n64.txt", 0, 1, 0);
|
||
#else
|
||
// Dumping ROM fast
|
||
compareCRC("n64.txt", readRom_N64(), 1, 0);
|
||
#endif
|
||
|
||
#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:
|
||
sd.chdir("/");
|
||
display_Clear();
|
||
|
||
if (saveType == 1) {
|
||
println_Msg(F("Reading SRAM..."));
|
||
display_Update();
|
||
readSram(32768, 1);
|
||
} else if (saveType == 4) {
|
||
getFramType();
|
||
println_Msg(F("Reading FLASH..."));
|
||
display_Update();
|
||
readFram(flashramType);
|
||
} else if ((saveType == 5) || (saveType == 6)) {
|
||
println_Msg(F("Reading EEPROM..."));
|
||
display_Update();
|
||
readEeprom();
|
||
} else {
|
||
print_Error(F("Savetype 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();
|
||
break;
|
||
|
||
case 2:
|
||
filePath[0] = '\0';
|
||
sd.chdir("/");
|
||
if (saveType == 1) {
|
||
// Launch file browser
|
||
fileBrowser(F("Select sra file"));
|
||
display_Clear();
|
||
|
||
writeSram(32768);
|
||
writeErrors = verifySram(32768, 1);
|
||
if (writeErrors == 0) {
|
||
println_Msg(F("SRAM verified OK"));
|
||
display_Update();
|
||
} else {
|
||
print_STR(error_STR, 0);
|
||
print_Msg(writeErrors);
|
||
print_STR(_bytes_STR, 1);
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
} else if (saveType == 4) {
|
||
// Launch file browser
|
||
fileBrowser(F("Select fla file"));
|
||
display_Clear();
|
||
getFramType();
|
||
writeFram(flashramType);
|
||
print_STR(verifying_STR, 0);
|
||
display_Update();
|
||
writeErrors = verifyFram(flashramType);
|
||
if (writeErrors == 0) {
|
||
println_Msg(FS(FSTRING_OK));
|
||
display_Update();
|
||
} else {
|
||
println_Msg("");
|
||
print_STR(error_STR, 0);
|
||
print_Msg(writeErrors);
|
||
print_STR(_bytes_STR, 1);
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
} else if ((saveType == 5) || (saveType == 6)) {
|
||
// Launch file browser
|
||
fileBrowser(F("Select eep file"));
|
||
display_Clear();
|
||
|
||
writeEeprom();
|
||
writeErrors = verifyEeprom();
|
||
|
||
if (writeErrors == 0) {
|
||
println_Msg(F("EEPROM verified OK"));
|
||
display_Update();
|
||
} else {
|
||
print_STR(error_STR, 0);
|
||
print_Msg(writeErrors);
|
||
print_STR(_bytes_STR, 1);
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
} else {
|
||
display_Clear();
|
||
print_Error(F("Save Type Error"));
|
||
}
|
||
// 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:
|
||
// create submenu with title and 6 options to choose from
|
||
unsigned char N64SaveMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(saveOptionsN64, 5);
|
||
N64SaveMenu = question_box(F("Select save type"), menuOptions, 5, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (N64SaveMenu) {
|
||
case 0:
|
||
// None
|
||
saveType = 0;
|
||
break;
|
||
|
||
case 1:
|
||
// 4K EEPROM
|
||
saveType = 5;
|
||
eepPages = 64;
|
||
break;
|
||
|
||
case 2:
|
||
// 16K EEPROM
|
||
saveType = 6;
|
||
eepPages = 256;
|
||
break;
|
||
|
||
case 3:
|
||
// SRAM
|
||
saveType = 1;
|
||
break;
|
||
|
||
case 4:
|
||
// FLASHRAM
|
||
saveType = 4;
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case 4:
|
||
resetArduino();
|
||
break;
|
||
}
|
||
}
|
||
|
||
/******************************************
|
||
Setup
|
||
*****************************************/
|
||
void setup_N64_Controller() {
|
||
// Request 3.3V
|
||
setVoltage(VOLTS_SET_3V3);
|
||
|
||
// Output a low signal
|
||
PORTH &= ~(1 << 4);
|
||
// Set Controller Data Pin(PH4) to Input
|
||
DDRH &= ~(1 << 4);
|
||
}
|
||
|
||
void setup_N64_Cart() {
|
||
// Request 3.3V
|
||
setVoltage(VOLTS_SET_3V3);
|
||
|
||
// Set Address Pins to Output and set them low
|
||
//A0-A7
|
||
DDRF = 0xFF;
|
||
PORTF = 0x00;
|
||
//A8-A15
|
||
DDRK = 0xFF;
|
||
PORTK = 0x00;
|
||
|
||
// Set Control Pins to Output RESET(PH0) WR(PH5) RD(PH6) aleL(PC0) aleH(PC1)
|
||
DDRH |= (1 << 0) | (1 << 5) | (1 << 6);
|
||
DDRC |= (1 << 0) | (1 << 1);
|
||
// Pull RESET(PH0) low until we are ready
|
||
PORTH &= ~(1 << 0);
|
||
// Output a high signal on WR(PH5) RD(PH6), pins are active low therefore everything is disabled now
|
||
PORTH |= (1 << 5) | (1 << 6);
|
||
// Pull aleL(PC0) low and aleH(PC1) high
|
||
PORTC &= ~(1 << 0);
|
||
PORTC |= (1 << 1);
|
||
|
||
#ifdef ENABLE_CLOCKGEN
|
||
// Adafruit Clock Generator
|
||
|
||
initializeClockOffset();
|
||
|
||
if (!i2c_found) {
|
||
display_Clear();
|
||
print_FatalError(F("Clock Generator not found"));
|
||
}
|
||
|
||
// Set Eeprom clock to 2Mhz
|
||
clockgen.set_freq(200000000ULL, SI5351_CLK1);
|
||
|
||
// Start outputting Eeprom clock
|
||
clockgen.output_enable(SI5351_CLK1, 1); // Eeprom clock
|
||
|
||
#else
|
||
// Set Eeprom Clock Pin(PH1) to Output
|
||
DDRH |= (1 << 1);
|
||
// Output a high signal
|
||
PORTH |= (1 << 1);
|
||
#endif
|
||
|
||
// Set Eeprom Data Pin(PH4) to Input
|
||
DDRH &= ~(1 << 4);
|
||
// Activate Internal Pullup Resistors
|
||
//PORTH |= (1 << 4);
|
||
|
||
// Set sram base address
|
||
sramBase = 0x08000000;
|
||
|
||
#ifdef ENABLE_CLOCKGEN
|
||
// Wait for clock generator
|
||
clockgen.update_status();
|
||
#endif
|
||
|
||
// Wait until all is stable
|
||
delay(300);
|
||
|
||
// Pull RESET(PH0) high to start eeprom
|
||
PORTH |= (1 << 0);
|
||
}
|
||
|
||
/******************************************
|
||
Low level functions
|
||
*****************************************/
|
||
// Switch Cartridge address/data pins to write
|
||
void adOut_N64() {
|
||
//A0-A7
|
||
DDRF = 0xFF;
|
||
PORTF = 0x00;
|
||
//A8-A15
|
||
DDRK = 0xFF;
|
||
PORTK = 0x00;
|
||
}
|
||
|
||
// Switch Cartridge address/data pins to read
|
||
void adIn_N64() {
|
||
//A0-A7
|
||
DDRF = 0x00;
|
||
//A8-A15
|
||
DDRK = 0x00;
|
||
//Enable internal pull-up resistors
|
||
//PORTF = 0xFF;
|
||
//PORTK = 0xFF;
|
||
}
|
||
|
||
// Set Cartridge address
|
||
void setAddress_N64(unsigned long myAddress) {
|
||
// Set address pins to output
|
||
adOut_N64();
|
||
|
||
// Split address into two words
|
||
word myAdrLowOut = myAddress & 0xFFFF;
|
||
word myAdrHighOut = myAddress >> 16;
|
||
|
||
// Switch WR(PH5) RD(PH6) ale_L(PC0) ale_H(PC1) to high (since the pins are active low)
|
||
PORTH |= (1 << 5) | (1 << 6);
|
||
PORTC |= (1 << 1);
|
||
__asm__("nop\n\t");
|
||
PORTC |= (1 << 0);
|
||
|
||
// Output high part to address pins
|
||
PORTF = myAdrHighOut & 0xFF;
|
||
PORTK = (myAdrHighOut >> 8) & 0xFF;
|
||
|
||
// Leave ale_H high for additional 62.5ns
|
||
__asm__("nop\n\t");
|
||
|
||
// Pull ale_H(PC1) low
|
||
PORTC &= ~(1 << 1);
|
||
|
||
// Output low part to address pins
|
||
PORTF = myAdrLowOut & 0xFF;
|
||
PORTK = (myAdrLowOut >> 8) & 0xFF;
|
||
|
||
// Leave ale_L high for ~125ns
|
||
__asm__("nop\n\t"
|
||
"nop\n\t");
|
||
|
||
// Pull ale_L(PC0) low
|
||
PORTC &= ~(1 << 0);
|
||
|
||
// Wait ~600ns just to be sure address is set
|
||
__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");
|
||
|
||
// Set data pins to input
|
||
adIn_N64();
|
||
}
|
||
|
||
// Read one word out of the cartridge
|
||
word readWord_N64() {
|
||
// Pull read(PH6) low
|
||
PORTH &= ~(1 << 6);
|
||
|
||
// Wait ~310ns
|
||
__asm__("nop\n\t"
|
||
"nop\n\t"
|
||
"nop\n\t"
|
||
"nop\n\t"
|
||
"nop\n\t");
|
||
|
||
// Join bytes from PINF and PINK into a word
|
||
word tempWord = ((PINK & 0xFF) << 8) | (PINF & 0xFF);
|
||
|
||
// Pull read(PH6) high
|
||
PORTH |= (1 << 6);
|
||
|
||
// Wait 62.5ns
|
||
__asm__("nop\n\t");
|
||
return tempWord;
|
||
}
|
||
|
||
// Write one word to data pins of the cartridge
|
||
void writeWord_N64(word myWord) {
|
||
// Set address pins to output
|
||
adOut_N64();
|
||
|
||
// Output word to AD0-AD15
|
||
PORTF = myWord & 0xFF;
|
||
PORTK = (myWord >> 8) & 0xFF;
|
||
|
||
// Wait ~62.5ns
|
||
__asm__("nop\n\t");
|
||
|
||
// Pull write(PH5) low
|
||
PORTH &= ~(1 << 5);
|
||
|
||
// Wait ~310ns
|
||
__asm__("nop\n\t"
|
||
"nop\n\t"
|
||
"nop\n\t"
|
||
"nop\n\t"
|
||
"nop\n\t");
|
||
|
||
// Pull write(PH5) high
|
||
PORTH |= (1 << 5);
|
||
|
||
// Wait ~125ns
|
||
__asm__("nop\n\t"
|
||
"nop\n\t");
|
||
|
||
// Set data pins to input
|
||
adIn_N64();
|
||
}
|
||
|
||
/******************************************
|
||
N64 Controller CRC Functions
|
||
*****************************************/
|
||
static word addrCRC(word address) {
|
||
const char n64_address_crc_table[] = { 0x15, 0x1F, 0x0B, 0x16, 0x19, 0x07, 0x0E, 0x1C, 0x0D, 0x1A, 0x01 };
|
||
const char* cur_xor = n64_address_crc_table;
|
||
byte crc = 0;
|
||
for (word mask = 0x0020; mask; mask <<= 1, cur_xor++) {
|
||
if (address & mask) {
|
||
crc ^= *cur_xor;
|
||
}
|
||
}
|
||
return (address & 0xFFE0) | crc;
|
||
}
|
||
|
||
static uint8_t dataCRC(uint8_t* data) {
|
||
uint8_t ret = 0;
|
||
for (uint8_t i = 0; i <= 32; i++) {
|
||
for (uint8_t mask = 0x80; mask; mask >>= 1) {
|
||
uint8_t tmp = ret & 0x80 ? 0x85 : 0;
|
||
ret <<= 1;
|
||
if (i < 32) {
|
||
if (data[i] & mask) {
|
||
ret |= 0x1;
|
||
}
|
||
}
|
||
ret ^= tmp;
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
// Macro producing a delay loop waiting an number of cycles multiple of 3, with
|
||
// a range of 3 to 768 cycles (187.5ns to 48us). It takes 6 bytes to do so
|
||
// (3 instructions) making it the same size as the equivalent 3-cycles NOP
|
||
// delay. For shorter delays or non-multiple-of-3-cycle delays, add your own
|
||
// NOPs.
|
||
#define N64_DELAY_LOOP(cycle_count) \
|
||
do { \
|
||
byte i; \
|
||
__asm__ __volatile__("\n" \
|
||
"\tldi %[i], %[loop_count]\n" \
|
||
".delay_loop_%=:\n" \
|
||
"\tdec %[i]\n" \
|
||
"\tbrne .delay_loop_%=\n" \
|
||
: [i] "=r"(i) \
|
||
: [loop_count] "i"(cycle_count / 3) \
|
||
: "cc"); \
|
||
} while (0)
|
||
|
||
/******************************************
|
||
N64 Controller Protocol Functions
|
||
*****************************************/
|
||
void sendJoyBus(const byte* buffer, char length) {
|
||
// Implemented in assembly as there is very little wiggle room, timing-wise.
|
||
// Overall structure:
|
||
// outer_loop:
|
||
// mask = 0x80
|
||
// cur_byte = *(buffer++)
|
||
// inner_loop:
|
||
// falling edge
|
||
// if (cur_byte & mask) {
|
||
// wait 1us starting at the falling edge
|
||
// rising edge
|
||
// wait 2us starting at the rising edge
|
||
// } else {
|
||
// wait 3us starting at the falling edge
|
||
// rising edge
|
||
// }
|
||
// inner_common_codepath:
|
||
// mask >>= 1
|
||
// if (mask == 0)
|
||
// goto outer_loop_trailer
|
||
// wait +1us from the rising edge
|
||
// goto inner_loop
|
||
// outer_loop_trailer:
|
||
// length -= 1
|
||
// if (length == 0)
|
||
// goto stop_bit
|
||
// wait +1us from the rising edge
|
||
// goto outer_loop
|
||
// stop_bit:
|
||
// wait +1us from the rising edge
|
||
// falling edge
|
||
// wait 1us from the falling edge
|
||
// rising edge
|
||
|
||
byte mask, cur_byte, scratch;
|
||
// Note on DDRH: retrieve the current DDRH value, and pre-compute the values
|
||
// to write in order to drive the line high or low. This saves 3 cycles per
|
||
// transition: sts (2 cycles) instead of lds, or/and, sts (2 + 1 + 2 cycles).
|
||
// This means that no other code may run in parallel, but this function anyway
|
||
// requires interrupts to be disabled in order to work in the expected amount
|
||
// of time.
|
||
const byte line_low = DDRH | 0x10;
|
||
const byte line_high = line_low & 0xef;
|
||
__asm__ __volatile__("\n"
|
||
".outer_loop_%=:\n"
|
||
// mask = 0x80
|
||
"\tldi %[mask], 0x80\n" // 1
|
||
// load byte to send from memory
|
||
"\tld %[cur_byte], Z+\n" // 2
|
||
".inner_loop_%=:\n"
|
||
// Falling edge
|
||
"\tsts %[out_byte], %[line_low]\n" // 2
|
||
// Test cur_byte & mask, without clobbering either
|
||
"\tmov %[scratch], %[cur_byte]\n" // 1
|
||
"\tand %[scratch], %[mask]\n" // 1
|
||
"\tbreq .bit_is_0_%=\n" // bit is 1: 1, bit is 0: 2
|
||
|
||
// bit is a 1
|
||
// Stay low for 1us (16 cycles).
|
||
// Time before: 3 cycles (mov, and, breq-false).
|
||
// Time after: sts (2 cycles).
|
||
// So 11 to go, so 3 3-cycles iterations and 2 nop.
|
||
"\tldi %[scratch], 3\n" // 1
|
||
".delay_1_low_%=:\n"
|
||
"\tdec %[scratch]\n" // 1
|
||
"\tbrne .delay_1_low_%=\n" // exit: 1, loop: 2
|
||
"\tnop\n" // 1
|
||
"\tnop\n" // 1
|
||
// Rising edge
|
||
"\tsts %[out_byte], %[line_high]\n" // 2
|
||
// Wait for 2us (32 cycles) to sync with the bot_is_0 codepath.
|
||
// Time before: 0 cycles.
|
||
// Time after: 2 cycles (rjmp).
|
||
// So 30 to go, so 10 3-cycles iterations and 0 nop.
|
||
"\tldi %[scratch], 10\n" // 1
|
||
".delay_1_high_%=:\n"
|
||
"\tdec %[scratch]\n" // 1
|
||
"\tbrne .delay_1_high_%=\n" // exit: 1, loop: 2
|
||
"\trjmp .inner_common_path_%=\n" // 2
|
||
|
||
".bit_is_0_%=:\n"
|
||
// bit is a 0
|
||
// Stay high for 3us (48 cycles).
|
||
// Time before: 4 cycles (mov, and, breq-true).
|
||
// Time after: 2 cycles (sts).
|
||
// So 42 to go, so 14 3-cycles iterations, and 0 nop.
|
||
"\tldi %[scratch], 14\n" // 1
|
||
".delay_0_low_%=:\n"
|
||
"\tdec %[scratch]\n" // 1
|
||
"\tbrne .delay_0_low_%=\n" // exit: 1, loop: 2
|
||
// Rising edge
|
||
"\tsts %[out_byte], %[line_high]\n" // 2
|
||
|
||
// codepath common to both possible values
|
||
".inner_common_path_%=:\n"
|
||
"\tnop\n" // 1
|
||
"\tlsr %[mask]\n" // 1
|
||
"\tbreq .outer_loop_trailer_%=\n" // mask!=0: 1, mask==0: 2
|
||
// Stay high for 1us (16 cycles).
|
||
// Time before: 3 cycles (nop, lsr, breq-false).
|
||
// Time after: 4 cycles (rjmp, sts)
|
||
// So 9 to go, so 3 3-cycles iterations and 0 nop.
|
||
"\tldi %[scratch], 3\n" // 1
|
||
".delay_common_high_%=:\n"
|
||
"\tdec %[scratch]\n" // 1
|
||
"\tbrne .delay_common_high_%=\n" // exit: 1, loop: 2
|
||
"\trjmp .inner_loop_%=\n" // 2
|
||
|
||
".outer_loop_trailer_%=:\n"
|
||
"\tdec %[length]\n" // 1
|
||
"\tbreq .stop_bit_%=\n" // length!=0: 1, length==0: 2
|
||
// Stay high for 1us (16 cycles).
|
||
// Time before: 6 cycles (lsr, nop, breq-true, dec, breq-false).
|
||
// Time after: 7 cycles (rjmp, ldi, ld, sts).
|
||
// So 3 to go, so 3 nop (for simplicity).
|
||
"\tnop\n" // 1
|
||
"\tnop\n" // 1
|
||
"\tnop\n" // 1
|
||
"\trjmp .outer_loop_%=\n" // 2
|
||
// Done sending data, send a stop bit.
|
||
".stop_bit_%=:\n"
|
||
// Stay high for 1us (16 cycles).
|
||
// Time before: 7 cycles (lsr, nop, breq-true, dec, breq-true).
|
||
// Time after: 2 cycles (sts).
|
||
// So 7 to go, so 2 3-cycles iterations and 1 nop.
|
||
"\tldi %[scratch], 2\n" // 1
|
||
".delay_stop_high_%=:\n"
|
||
"\tdec %[scratch]\n" // 1
|
||
"\tbrne .delay_stop_high_%=\n" // exit: 1, loop: 2
|
||
"\tnop\n"
|
||
"\tsts %[out_byte], %[line_low]\n" // 2
|
||
// Stay low for 1us (16 cycles).
|
||
// Time before: 0 cycles.
|
||
// Time after: 2 cycles (sts).
|
||
// So 14 to go, so 4 3-cycles iterations and 2 nop.
|
||
"\tldi %[scratch], 5\n" // 1
|
||
".delay_stop_low_%=:\n"
|
||
"\tdec %[scratch]\n" // 1
|
||
"\tbrne .delay_stop_low_%=\n" // exit: 1, loop: 2
|
||
"\tnop\n"
|
||
"\tnop\n"
|
||
"\tsts %[out_byte], %[line_high]\n" // 2
|
||
// Notes on arguments:
|
||
// - mask and scratch are used wth "ldi", which can only work on registers
|
||
// 16 to 31, so tag these with "a" rather than the generic "r"
|
||
// - mark all output-only arguments as early-clobber ("&"), as input
|
||
// registers are used throughout all iterations and both sets must be
|
||
// strictly distinct
|
||
// - tag buffer with "z", to use the "ld r?, Z+" instruction (load from
|
||
// 16bits RAM address and postincrement, in 2 cycles).
|
||
// XXX: any pointer register pair would do, but mapping to Z explicitly
|
||
// because I cannot find a way to get one of "X", "Y" or "Z" to appear
|
||
// when expanding "%[buffer]", causing the assembler to reject the
|
||
// instruction. Pick Z as it is the only call-used such register,
|
||
// avoiding the need to preserve any value a caller may have set it to.
|
||
: [buffer] "+z"(buffer),
|
||
[length] "+r"(length),
|
||
[cur_byte] "=&r"(cur_byte),
|
||
[mask] "=&a"(mask),
|
||
[scratch] "=&a"(scratch)
|
||
: [line_low] "r"(line_low),
|
||
[line_high] "r"(line_high),
|
||
[out_byte] "i"(&DDRH)
|
||
: "cc", "memory");
|
||
}
|
||
|
||
word recvJoyBus(byte* output, byte byte_count) {
|
||
// listen for expected byte_count bytes of data back from the controller
|
||
// return the number of bytes not (fully) received if the delay for a signal
|
||
// edge takes too long.
|
||
|
||
// Implemented in assembly as there is very little wiggle room, timing-wise.
|
||
// Overall structure:
|
||
// mask = 0x80
|
||
// cur_byte = 0
|
||
// read_loop:
|
||
// wait for falling edge
|
||
// wait for a bit more than 1us
|
||
// if input:
|
||
// cur_byte |= mask
|
||
// mask >>= 1
|
||
// if (mask == 0)
|
||
// if (--byte_count == 0)
|
||
// goto read_end
|
||
// append cur_byte to output
|
||
// mask = 0x80
|
||
// cur_byte = 0
|
||
// wait for data high
|
||
// goto read_loop
|
||
// read_end:
|
||
// return byte_count
|
||
|
||
byte mask, cur_byte, timeout, scratch;
|
||
__asm__ __volatile__("\n"
|
||
"\tldi %[mask], 0x80\n"
|
||
"\tclr %[cur_byte]\n"
|
||
".read_loop_%=:\n"
|
||
// Wait for input to be low. Time out if it takes more than ~27us (~7 bits
|
||
// worth of time) for it to go low.
|
||
// Takes 5 cycles to exit on input-low iteration (lds, sbrs-false, rjmp).
|
||
// Takes 7 cycles to loop on input-high iteration (lds, sbrs-true, dec,
|
||
// brne-true).
|
||
"\tldi %[timeout], 0x3f\n" // 1
|
||
".read_wait_falling_edge_%=:\n"
|
||
"\tlds %[scratch], %[in_byte]\n" // 2
|
||
"\tsbrs %[scratch], %[in_bit]\n" // low: 1, high: 2
|
||
"\trjmp .read_input_low_%=\n" // 2
|
||
"\tdec %[timeout]\n" // 1
|
||
"\tbrne .read_wait_falling_edge_%=\n" // timeout==0: 1, timeout!=0: 2
|
||
"\trjmp .read_end_%=\n" // 2
|
||
|
||
".read_input_low_%=:\n"
|
||
// Wait for 1500 us (24 cycles) before reading input.
|
||
// As it takes from 5 to 7 cycles for the prevous loop to exit,
|
||
// this means this loop exits from 1812.5us to 1937.5us after the falling
|
||
// edge, so at least 812.5us after a 1-bit rising edge, and at least
|
||
// 1062.5us before a 0-bit rising edge.
|
||
// This also leaves us with up to 2062.5us (33 cycles) to update cur_byte,
|
||
// possibly moving on to the next byte, waiting for a high input, and
|
||
// waiting for the next falling edge.
|
||
// Time taken until waiting for input high for non-last byte:
|
||
// - shift to current byte:
|
||
// - 1: 4 cycles (lds, sbrc-false, or)
|
||
// - 0: 4 cycles (lds, sbrc-true)
|
||
// - byte done: 8 cycles (lsr, brne-false, st, dec, brne-false, ldi, clr)
|
||
// - byte not done: 3 cycles (lsr, brne-true)
|
||
// Total: 7 to 12 cycles, so there are at least 21 cycles left until the
|
||
// next bit.
|
||
"\tldi %[timeout], 8\n" // 1
|
||
".read_wait_low_%=:\n"
|
||
"\tdec %[timeout]\n" // 1
|
||
"\tbrne .read_wait_low_%=\n" // timeout=0: 1, timeout!=0: 2
|
||
|
||
// Sample input
|
||
"\tlds %[scratch], %[in_byte]\n" // 2
|
||
// Add to cur_byte
|
||
"\tsbrc %[scratch], %[in_bit]\n" // high: 1, low: 2
|
||
"\tor %[cur_byte], %[mask]\n" // 1
|
||
// Shift mask
|
||
"\tlsr %[mask]\n"
|
||
"\tbrne .read_wait_input_high_init_%=\n" // mask==0: 1, mask!=0: 2
|
||
// A wole byte was read, store in output
|
||
"\tst Z+, %[cur_byte]\n" // 2
|
||
// Decrement byte count
|
||
"\tdec %[byte_count]\n" // 1
|
||
// Are we done reading ?
|
||
"\tbreq .read_end_%=\n" // byte_count!=0: 1, byte_count==0: 2
|
||
// No, prepare for reading another
|
||
"\tldi %[mask], 0x80\n"
|
||
"\tclr %[cur_byte]\n"
|
||
|
||
// Wait for rising edge
|
||
".read_wait_input_high_init_%=:"
|
||
"\tldi %[timeout], 0x3f\n" // 1
|
||
".read_wait_input_high_%=:\n"
|
||
"\tlds %[scratch], %[in_byte]\n" // 2
|
||
"\tsbrc %[scratch], %[in_bit]\n" // high: 1, low: 2
|
||
"\trjmp .read_loop_%=\n" // 2
|
||
"\tdec %[timeout]\n" // 1
|
||
"\tbrne .read_wait_input_high_%=\n" // timeout==0: 1, timeout!=0: 2
|
||
"\trjmp .read_end_%=\n" // 2
|
||
".read_end_%=:\n"
|
||
: [output] "+z"(output),
|
||
[byte_count] "+r"(byte_count),
|
||
[mask] "=&a"(mask),
|
||
[cur_byte] "=&r"(cur_byte),
|
||
[timeout] "=&a"(timeout),
|
||
[scratch] "=&a"(scratch)
|
||
: [in_byte] "i"(&PINH),
|
||
[in_bit] "i"(4)
|
||
: "cc", "memory");
|
||
return byte_count;
|
||
}
|
||
|
||
/******************************************
|
||
N64 Controller Functions
|
||
*****************************************/
|
||
void get_button() {
|
||
// Command to send to the gamecube
|
||
// The last bit is rumble, flip it to rumble
|
||
const byte command[] = { 0x01 };
|
||
byte response[4];
|
||
|
||
// don't want interrupts getting in the way
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
recvJoyBus(response, sizeof(response));
|
||
// end of time sensitive code
|
||
interrupts();
|
||
|
||
// These are 8 bit values centered at 0x80 (128)
|
||
N64_status.stick_x = response[2];
|
||
N64_status.stick_y = response[3];
|
||
|
||
// Buttons (A,B,Z,S,DU,DD,DL,DR,0,0,L,R,CU,CD,CL,CR)
|
||
if (response[0] & 0x80)
|
||
button = F("A");
|
||
else if (response[0] & 0x40)
|
||
button = F("B");
|
||
else if (response[0] & 0x20)
|
||
button = F("Z");
|
||
else if (response[0] & 0x10)
|
||
button = F("START");
|
||
else if (response[0] & 0x08)
|
||
button = F("D-Up");
|
||
else if (response[0] & 0x04)
|
||
button = F("D-Down");
|
||
else if (response[0] & 0x02)
|
||
button = F("D-Left");
|
||
else if (response[0] & 0x01)
|
||
button = F("D-Right");
|
||
//else if (response[1] & 0x80)
|
||
//else if (response[1] & 0x40)
|
||
else if (response[1] & 0x20)
|
||
button = F("L");
|
||
else if (response[1] & 0x10)
|
||
button = F("R");
|
||
else if (response[1] & 0x08)
|
||
button = F("C-Up");
|
||
else if (response[1] & 0x04)
|
||
button = F("C-Down");
|
||
else if (response[1] & 0x02)
|
||
button = F("C-Left");
|
||
else if (response[1] & 0x01)
|
||
button = F("C-Right");
|
||
else {
|
||
lastbutton = button;
|
||
button = F("Press a button");
|
||
}
|
||
}
|
||
|
||
|
||
/******************************************
|
||
N64 Controller Test
|
||
*****************************************/
|
||
#ifdef ENABLE_SERIAL
|
||
void controllerTest_Serial() {
|
||
while (quit) {
|
||
// Get Button and analog stick
|
||
get_button();
|
||
|
||
// Print Button
|
||
String buttonc = String("Button: " + String(button) + " ");
|
||
Serial.print(buttonc);
|
||
|
||
// Print Stick X Value
|
||
String stickx = String("X: " + String(N64_status.stick_x, DEC) + " ");
|
||
Serial.print(stickx);
|
||
|
||
// Print Stick Y Value
|
||
String sticky = String(" Y: " + String(N64_status.stick_y, DEC) + " ");
|
||
Serial.println(sticky);
|
||
|
||
if (button == "Press a button" && lastbutton == "Z") {
|
||
// Quit
|
||
Serial.println("");
|
||
quit = 0;
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#if (defined(ENABLE_LCD) || defined(ENABLE_OLED))
|
||
#define CENTER 64
|
||
// on which screens do we start
|
||
int startscreen = 1;
|
||
int test = 1;
|
||
|
||
void printSTR(String st, int x, int y) {
|
||
char buf[st.length() + 1];
|
||
|
||
if (x == CENTER) {
|
||
x = 64 - (((st.length() - 5) / 2) * 4);
|
||
}
|
||
|
||
st.toCharArray(buf, st.length() + 1);
|
||
display.drawStr(x, y, buf);
|
||
}
|
||
|
||
void nextscreen() {
|
||
if (button == "Press a button" && lastbutton == "START") {
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
if (startscreen != 4)
|
||
startscreen = startscreen + 1;
|
||
else {
|
||
startscreen = 1;
|
||
test = 1;
|
||
}
|
||
} else if (button == "Press a button" && lastbutton == "Z" && startscreen == 4) {
|
||
// Quit
|
||
quit = 0;
|
||
}
|
||
}
|
||
|
||
void controllerTest_Display() {
|
||
boolean cmode = 1;
|
||
|
||
//name of the current displayed result
|
||
String anastick = "";
|
||
|
||
// Graph
|
||
int xax = 24; // midpoint x
|
||
int yax = 24; // midpoint y
|
||
|
||
// variables to display test data of different sticks
|
||
int upx = 0;
|
||
int upy = 0;
|
||
int uprightx = 0;
|
||
int uprighty = 0;
|
||
int rightx = 0;
|
||
int righty = 0;
|
||
int downrightx = 0;
|
||
int downrighty = 0;
|
||
int downx = 0;
|
||
int downy = 0;
|
||
int downleftx = 0;
|
||
int downlefty = 0;
|
||
int leftx = 0;
|
||
int lefty = 0;
|
||
int upleftx = 0;
|
||
int uplefty = 0;
|
||
|
||
// variables to save test data
|
||
int bupx = 0;
|
||
int bupy = 0;
|
||
int buprightx = 0;
|
||
int buprighty = 0;
|
||
int brightx = 0;
|
||
int brighty = 0;
|
||
int bdownrightx = 0;
|
||
int bdownrighty = 0;
|
||
int bdownx = 0;
|
||
int bdowny = 0;
|
||
int bdownleftx = 0;
|
||
int bdownlefty = 0;
|
||
int bleftx = 0;
|
||
int blefty = 0;
|
||
int bupleftx = 0;
|
||
int buplefty = 0;
|
||
int results = 0;
|
||
int prevStickX = 0;
|
||
|
||
String stickx;
|
||
String sticky;
|
||
String stickx_old;
|
||
String sticky_old;
|
||
String button_old;
|
||
|
||
while (quit) {
|
||
// Get Button and analog stick
|
||
get_button();
|
||
|
||
switch (startscreen) {
|
||
case 1:
|
||
{
|
||
display.drawStr(32, 8, "Controller Test");
|
||
display.drawLine(0, 10, 128, 10);
|
||
|
||
// Delete old button value
|
||
if (button_old != button) {
|
||
display.setDrawColor(0);
|
||
for (byte y = 13; y < 22; y++) {
|
||
display.drawLine(0, y, 128, y);
|
||
}
|
||
display.setDrawColor(1);
|
||
}
|
||
// Print button
|
||
printSTR(" " + button + " ", CENTER, 20);
|
||
// Save value
|
||
button_old = button;
|
||
|
||
// Update stick values
|
||
stickx = String("X: " + String(N64_status.stick_x, DEC) + " ");
|
||
sticky = String("Y: " + String(N64_status.stick_y, DEC) + " ");
|
||
|
||
// Delete old stick values
|
||
if ((stickx_old != stickx) || (sticky_old != sticky)) {
|
||
display.setDrawColor(0);
|
||
for (byte y = 31; y < 38; y++) {
|
||
display.drawLine(0, y, 128, y);
|
||
}
|
||
display.setDrawColor(1);
|
||
}
|
||
|
||
// Print stick values
|
||
printSTR(stickx, 36, 38);
|
||
printSTR(sticky, 74, 38);
|
||
// Save values
|
||
stickx_old = stickx;
|
||
sticky_old = sticky;
|
||
|
||
printSTR("(Continue with START)", 16, 55);
|
||
|
||
//Update LCD
|
||
display.updateDisplay();
|
||
|
||
// go to next screen
|
||
nextscreen();
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
display.drawStr(36, 8, "Range Test");
|
||
display.drawLine(0, 9, 128, 9);
|
||
|
||
if (cmode == 0) {
|
||
// Print Stick X Value
|
||
String stickx = String("X:" + String(N64_status.stick_x, DEC) + " ");
|
||
printSTR(stickx, 22 + 54, 26);
|
||
|
||
// Print Stick Y Value
|
||
String sticky = String("Y:" + String(N64_status.stick_y, DEC) + " ");
|
||
printSTR(sticky, 22 + 54, 36);
|
||
}
|
||
|
||
// Draw Axis
|
||
display.drawPixel(10 + xax, 12 + yax);
|
||
display.drawPixel(10 + xax, 12 + yax - 80 / 4);
|
||
display.drawPixel(10 + xax, 12 + yax + 80 / 4);
|
||
display.drawPixel(10 + xax + 80 / 4, 12 + yax);
|
||
display.drawPixel(10 + xax - 80 / 4, 12 + yax);
|
||
|
||
// Draw corners
|
||
display.drawPixel(10 + xax - 68 / 4, 12 + yax - 68 / 4);
|
||
display.drawPixel(10 + xax + 68 / 4, 12 + yax + 68 / 4);
|
||
display.drawPixel(10 + xax + 68 / 4, 12 + yax - 68 / 4);
|
||
display.drawPixel(10 + xax - 68 / 4, 12 + yax + 68 / 4);
|
||
|
||
//Draw Analog Stick
|
||
if (cmode == 1) {
|
||
display.drawPixel(10 + xax + N64_status.stick_x / 4, 12 + yax - N64_status.stick_y / 4);
|
||
//Update LCD
|
||
display.updateDisplay();
|
||
} else {
|
||
display.drawCircle(10 + xax + N64_status.stick_x / 4, 12 + yax - N64_status.stick_y / 4, 2);
|
||
//Update LCD
|
||
display.updateDisplay();
|
||
display_Clear_Slow();
|
||
}
|
||
|
||
// switch mode
|
||
if (button == "Press a button" && lastbutton == "Z") {
|
||
if (cmode == 0) {
|
||
cmode = 1;
|
||
display.clearDisplay();
|
||
} else {
|
||
cmode = 0;
|
||
display.clearDisplay();
|
||
}
|
||
}
|
||
// go to next screen
|
||
nextscreen();
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
display.setDrawColor(0);
|
||
display.drawPixel(22 + prevStickX, 40);
|
||
display.setDrawColor(1);
|
||
printSTR("Skipping Test", 34, 8);
|
||
display.drawLine(0, 9, 128, 9);
|
||
display.drawFrame(22 + 0, 15, 22 + 59, 21);
|
||
if (N64_status.stick_x > 0) {
|
||
display.drawLine(22 + N64_status.stick_x, 15, 22 + N64_status.stick_x, 35);
|
||
display.drawPixel(22 + N64_status.stick_x, 40);
|
||
prevStickX = N64_status.stick_x;
|
||
}
|
||
|
||
printSTR("Try to fill the box by", 22, 45);
|
||
printSTR("slowly moving right", 22, 55);
|
||
//Update LCD
|
||
display.updateDisplay();
|
||
|
||
if (button == "Press a button" && lastbutton == "Z") {
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
// go to next screen
|
||
nextscreen();
|
||
break;
|
||
}
|
||
case 4:
|
||
{
|
||
switch (test) {
|
||
case 0: // Display results
|
||
{
|
||
switch (results) {
|
||
case 0:
|
||
{
|
||
anastick = "Your Stick";
|
||
upx = bupx;
|
||
upy = bupy;
|
||
uprightx = buprightx;
|
||
uprighty = buprighty;
|
||
rightx = brightx;
|
||
righty = brighty;
|
||
downrightx = bdownrightx;
|
||
downrighty = bdownrighty;
|
||
downx = bdownx;
|
||
downy = bdowny;
|
||
downleftx = bdownleftx;
|
||
downlefty = bdownlefty;
|
||
leftx = bleftx;
|
||
lefty = blefty;
|
||
upleftx = bupleftx;
|
||
uplefty = buplefty;
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
results = 1;
|
||
display.clearDisplay();
|
||
break;
|
||
}
|
||
printSTR(anastick, 22 + 50, 15);
|
||
|
||
display.drawStr(22 + 50, 25, "U:");
|
||
printSTR(String(upy), 100, 25);
|
||
display.drawStr(22 + 50, 35, "D:");
|
||
printSTR(String(downy), 100, 35);
|
||
display.drawStr(22 + 50, 45, "L:");
|
||
printSTR(String(leftx), 100, 45);
|
||
display.drawStr(22 + 50, 55, "R:");
|
||
printSTR(String(rightx), 100, 55);
|
||
|
||
display.drawLine(xax + upx / 4, yax - upy / 4, xax + uprightx / 4, yax - uprighty / 4);
|
||
display.drawLine(xax + uprightx / 4, yax - uprighty / 4, xax + rightx / 4, yax - righty / 4);
|
||
display.drawLine(xax + rightx / 4, yax - righty / 4, xax + downrightx / 4, yax - downrighty / 4);
|
||
display.drawLine(xax + downrightx / 4, yax - downrighty / 4, xax + downx / 4, yax - downy / 4);
|
||
display.drawLine(xax + downx / 4, yax - downy / 4, xax + downleftx / 4, yax - downlefty / 4);
|
||
display.drawLine(xax + downleftx / 4, yax - downlefty / 4, xax + leftx / 4, yax - lefty / 4);
|
||
display.drawLine(xax + leftx / 4, yax - lefty / 4, xax + upleftx / 4, yax - uplefty / 4);
|
||
display.drawLine(xax + upleftx / 4, yax - uplefty / 4, xax + upx / 4, yax - upy / 4);
|
||
|
||
display.drawPixel(xax, yax);
|
||
|
||
//Update LCD
|
||
display.updateDisplay();
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
anastick = "Original";
|
||
upx = 1;
|
||
upy = 84;
|
||
uprightx = 67;
|
||
uprighty = 68;
|
||
rightx = 83;
|
||
righty = -2;
|
||
downrightx = 67;
|
||
downrighty = -69;
|
||
downx = 3;
|
||
downy = -85;
|
||
downleftx = -69;
|
||
downlefty = -70;
|
||
leftx = -85;
|
||
lefty = 0;
|
||
upleftx = -68;
|
||
uplefty = 68;
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
results = 0;
|
||
display.clearDisplay();
|
||
break;
|
||
}
|
||
printSTR(anastick, 22 + 50, 15);
|
||
|
||
display.drawStr(22 + 50, 25, "U:");
|
||
printSTR(String(upy), 100, 25);
|
||
display.drawStr(22 + 50, 35, "D:");
|
||
printSTR(String(downy), 100, 35);
|
||
display.drawStr(22 + 50, 45, "L:");
|
||
printSTR(String(leftx), 100, 45);
|
||
display.drawStr(22 + 50, 55, "R:");
|
||
printSTR(String(rightx), 100, 55);
|
||
|
||
display.drawLine(xax + upx / 4, yax - upy / 4, xax + uprightx / 4, yax - uprighty / 4);
|
||
display.drawLine(xax + uprightx / 4, yax - uprighty / 4, xax + rightx / 4, yax - righty / 4);
|
||
display.drawLine(xax + rightx / 4, yax - righty / 4, xax + downrightx / 4, yax - downrighty / 4);
|
||
display.drawLine(xax + downrightx / 4, yax - downrighty / 4, xax + downx / 4, yax - downy / 4);
|
||
display.drawLine(xax + downx / 4, yax - downy / 4, xax + downleftx / 4, yax - downlefty / 4);
|
||
display.drawLine(xax + downleftx / 4, yax - downlefty / 4, xax + leftx / 4, yax - lefty / 4);
|
||
display.drawLine(xax + leftx / 4, yax - lefty / 4, xax + upleftx / 4, yax - uplefty / 4);
|
||
display.drawLine(xax + upleftx / 4, yax - uplefty / 4, xax + upx / 4, yax - upy / 4);
|
||
|
||
display.drawPixel(xax, yax);
|
||
|
||
//Update LCD
|
||
display.updateDisplay();
|
||
break;
|
||
}
|
||
|
||
} //results
|
||
break;
|
||
} //display results
|
||
|
||
case 1: // +y Up
|
||
{
|
||
display.drawStr(34, 26, "Hold Stick Up");
|
||
display.drawStr(34, 34, "then press A");
|
||
//display.drawBitmap(110, 60, ana1);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
bupx = N64_status.stick_x;
|
||
bupy = N64_status.stick_y;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
test = 2;
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 2: // +y+x Up-Right
|
||
{
|
||
display.drawStr(42, 26, "Up-Right");
|
||
//display.drawBitmap(110, 60, ana2);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
buprightx = N64_status.stick_x;
|
||
buprighty = N64_status.stick_y;
|
||
test = 3;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 3: // +x Right
|
||
{
|
||
display.drawStr(50, 26, "Right");
|
||
//display.drawBitmap(110, 60, ana3);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
brightx = N64_status.stick_x;
|
||
brighty = N64_status.stick_y;
|
||
test = 4;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 4: // -y+x Down-Right
|
||
{
|
||
display.drawStr(38, 26, "Down-Right");
|
||
//display.drawBitmap(110, 60, ana4);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
bdownrightx = N64_status.stick_x;
|
||
bdownrighty = N64_status.stick_y;
|
||
test = 5;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 5: // -y Down
|
||
{
|
||
display.drawStr(49, 26, "Down");
|
||
//display.drawBitmap(110, 60, ana5);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
bdownx = N64_status.stick_x;
|
||
bdowny = N64_status.stick_y;
|
||
test = 6;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 6: // -y-x Down-Left
|
||
{
|
||
display.drawStr(39, 26, "Down-Left");
|
||
//display.drawBitmap(110, 60, ana6);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
bdownleftx = N64_status.stick_x;
|
||
bdownlefty = N64_status.stick_y;
|
||
test = 7;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 7: // -x Left
|
||
{
|
||
display.drawStr(51, 26, "Left");
|
||
//display.drawBitmap(110, 60, ana7);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
bleftx = N64_status.stick_x;
|
||
blefty = N64_status.stick_y;
|
||
test = 8;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case 8: // +y+x Up-Left
|
||
{
|
||
display.drawStr(43, 26, "Up-Left");
|
||
//display.drawBitmap(110, 60, ana8);
|
||
|
||
if (button == "Press a button" && lastbutton == "A") {
|
||
bupleftx = N64_status.stick_x;
|
||
buplefty = N64_status.stick_y;
|
||
test = 0;
|
||
// reset button
|
||
lastbutton = "N/A";
|
||
|
||
display.clearDisplay();
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
if (test != 0) {
|
||
display.drawStr(38, 8, "Benchmark");
|
||
display.drawLine(0, 9, 128, 9);
|
||
}
|
||
display.updateDisplay();
|
||
// go to next screen
|
||
nextscreen();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
/******************************************
|
||
N64 Controller Pak Functions
|
||
(connected via Controller)
|
||
*****************************************/
|
||
// Reset the controller
|
||
void resetController() {
|
||
const byte command[] = { 0xFF };
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
interrupts();
|
||
delay(100);
|
||
}
|
||
|
||
// read 3 bytes from controller
|
||
void checkController() {
|
||
byte response[8];
|
||
const byte command[] = { 0x00 };
|
||
|
||
display_Clear();
|
||
|
||
// Check if line is HIGH
|
||
if (!N64_QUERY)
|
||
print_FatalError(F("Data line LOW"));
|
||
|
||
// don't want interrupts getting in the way
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
recvJoyBus(response, sizeof(response));
|
||
// end of time sensitive code
|
||
interrupts();
|
||
|
||
if (response[0] != 0x05)
|
||
print_FatalError(F("Controller not found"));
|
||
if (response[2] != 0x01)
|
||
print_FatalError(F("Controller Pak not found"));
|
||
}
|
||
|
||
// read 32bytes from controller pak and calculate CRC
|
||
byte readBlock(byte* output, word myAddress) {
|
||
byte response_crc;
|
||
// Calculate the address CRC
|
||
word myAddressCRC = addrCRC(myAddress);
|
||
const byte command[] = { 0x02, (byte)(myAddressCRC >> 8), (byte)(myAddressCRC & 0xff) };
|
||
word error;
|
||
|
||
// don't want interrupts getting in the way
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
error = recvJoyBus(output, 32);
|
||
if (error == 0)
|
||
error = recvJoyBus(&response_crc, 1);
|
||
// end of time sensitive code
|
||
interrupts();
|
||
|
||
if (error) {
|
||
myFile.close();
|
||
println_Msg(F("Controller Pak was"));
|
||
println_Msg(F("not dumped due to a"));
|
||
print_FatalError(F("read timeout"));
|
||
}
|
||
|
||
// Compare with computed CRC
|
||
if (response_crc != dataCRC(output)) {
|
||
display_Clear();
|
||
// Close the file:
|
||
myFile.close();
|
||
println_Msg(F("Controller Pak was"));
|
||
println_Msg(F("not dumped due to a"));
|
||
print_FatalError(F("protocol CRC error"));
|
||
}
|
||
|
||
return response_crc;
|
||
}
|
||
|
||
// reads the MPK file to the sd card
|
||
void readMPK() {
|
||
// Change to root
|
||
sd.chdir("/");
|
||
// Make MPK directory
|
||
sd.mkdir("N64/MPK", true);
|
||
// Change to MPK directory
|
||
sd.chdir("N64/MPK");
|
||
|
||
// Get name, add extension and convert to char array for sd lib
|
||
EEPROM_readAnything(0, foldern);
|
||
sprintf(fileName, "%d", foldern);
|
||
strcat(fileName, ".mpk");
|
||
|
||
// write new folder number back to eeprom
|
||
foldern = foldern + 1;
|
||
EEPROM_writeAnything(0, foldern);
|
||
|
||
//open crc file on sd card
|
||
sprintf(filePath, "%d", foldern - 1);
|
||
strcat(filePath, ".crc");
|
||
FsFile crcFile;
|
||
if (!crcFile.open(filePath, O_RDWR | O_CREAT)) {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
|
||
//open mpk file on sd card
|
||
if (!myFile.open(fileName, O_RDWR | O_CREAT)) {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
|
||
print_Msg(F("Saving N64/MPK/"));
|
||
println_Msg(fileName);
|
||
display_Update();
|
||
|
||
// Dummy write because first write to file takes 1 second and messes up timing
|
||
blinkLED();
|
||
myFile.write(0xFF);
|
||
myFile.rewind();
|
||
blinkLED();
|
||
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(0x7FFF);
|
||
draw_progressbar(0, totalProgressBar);
|
||
|
||
// Controller paks, which all have 32kB of space, are mapped between 0x0000 – 0x7FFF
|
||
for (word currSdBuffer = 0x0000; currSdBuffer < 0x8000; currSdBuffer += 512) {
|
||
// Read 32 byte block into sdBuffer
|
||
for (word currBlock = 0; currBlock < sizeof(sdBuffer); currBlock += 32) {
|
||
// Read one block of the Controller Pak into array myBlock and write CRC of that block to crc file
|
||
crcFile.write(readBlock(&sdBuffer[currBlock], currSdBuffer + currBlock));
|
||
|
||
// Real N64 has about 627us pause between banks, add a bit extra delay
|
||
if (currBlock < 479)
|
||
delayMicroseconds(800);
|
||
}
|
||
// This will take 1300us
|
||
blinkLED();
|
||
myFile.write(sdBuffer, sizeof(sdBuffer));
|
||
// Blink led
|
||
blinkLED();
|
||
// Update progress bar
|
||
processedProgressBar += 512;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
crcFile.close();
|
||
}
|
||
|
||
// verifies if read was successful
|
||
void verifyCRC() {
|
||
writeErrors = 0;
|
||
|
||
print_STR(verifying_STR, 1);
|
||
display_Update();
|
||
|
||
//open CRC file on sd card
|
||
FsFile crcFile;
|
||
if (!crcFile.open(filePath, O_READ)) {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
|
||
//open MPK file on sd card
|
||
if (!myFile.open(fileName, O_READ)) {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(0x7FFF);
|
||
draw_progressbar(0, totalProgressBar);
|
||
|
||
// Controller paks, which all have 32kB of space, are mapped between 0x0000 – 0x7FFF
|
||
for (word currSdBuffer = 0x0000; currSdBuffer < 0x8000; currSdBuffer += 512) {
|
||
// Read 32 bytes into SD buffer
|
||
myFile.read(sdBuffer, 512);
|
||
|
||
// Compare 32 byte block CRC to CRC from file
|
||
for (word currBlock = 0; currBlock < 512; currBlock += 32) {
|
||
// Calculate CRC of block and compare against crc file
|
||
if (dataCRC(&sdBuffer[currBlock]) != crcFile.read())
|
||
writeErrors++;
|
||
}
|
||
|
||
// Blink led
|
||
blinkLED();
|
||
// Update progress bar
|
||
processedProgressBar += 512;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
crcFile.close();
|
||
|
||
if (writeErrors == 0) {
|
||
println_Msg(F("Saved successfully"));
|
||
sd.remove(filePath);
|
||
display_Update();
|
||
} else {
|
||
print_STR(error_STR, 0);
|
||
print_Msg(writeErrors);
|
||
println_Msg(F(" blocks "));
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
}
|
||
|
||
// Calculates the checksum of the header
|
||
boolean checkHeader(byte* buf) {
|
||
word sum = 0;
|
||
word buf_sum = (buf[28] << 8) + buf[29];
|
||
|
||
// first 28 bytes are the header, then comes the checksum(word) followed by the reverse checksum(0xFFF2 - checksum)
|
||
for (byte i = 0; i < 28; i += 2) {
|
||
sum += (buf[i] << 8) + buf[i + 1];
|
||
}
|
||
|
||
return sum == buf_sum;
|
||
}
|
||
|
||
// verifies if Controller Pak holds valid header data
|
||
void validateMPK() {
|
||
byte writeErrors = 0;
|
||
boolean failed = false;
|
||
SdFile mpk_file;
|
||
byte buf[256];
|
||
|
||
//open file on sd card
|
||
if (!mpk_file.open(fileName, O_READ)) {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
|
||
// Read first 256 byte which contains the header including checksum and reverse checksum and three copies of it
|
||
mpk_file.read(buf, sizeof(buf));
|
||
|
||
//Check all four header copies
|
||
writeErrors = 0;
|
||
if (!checkHeader(&buf[0x20]))
|
||
writeErrors++;
|
||
if (!checkHeader(&buf[0x60]))
|
||
writeErrors++;
|
||
if (!checkHeader(&buf[0x80]))
|
||
writeErrors++;
|
||
if (!checkHeader(&buf[0xC0]))
|
||
writeErrors++;
|
||
if (writeErrors)
|
||
failed = true;
|
||
|
||
print_Msg(F("HDR: "));
|
||
print_Msg(4 - writeErrors);
|
||
print_Msg(F("/4 - "));
|
||
display_Update();
|
||
|
||
// Check both TOC copies
|
||
writeErrors = 0;
|
||
|
||
// Read 2nd and 3rd 256 byte page with TOC info
|
||
for (word currSdBuffer = 0x100; currSdBuffer < 0x300; currSdBuffer += 256) {
|
||
byte sum = 0;
|
||
|
||
// Read 256 bytes into SD buffer
|
||
mpk_file.read(buf, sizeof(buf));
|
||
|
||
// Calculate TOC checksum
|
||
for (byte i = 5; i < 128; i++) {
|
||
sum += buf[(i << 1) + 1];
|
||
}
|
||
if (buf[1] != sum)
|
||
writeErrors++;
|
||
}
|
||
if (writeErrors)
|
||
failed = true;
|
||
print_Msg(F("ToC: "));
|
||
print_Msg(2 - writeErrors);
|
||
println_Msg(F("/2"));
|
||
|
||
print_Msg(F("Consistency check "));
|
||
if (failed) {
|
||
errorLvl = 1;
|
||
print_Msg(F("failed"));
|
||
} else {
|
||
errorLvl = 0;
|
||
print_Msg(F("passed"));
|
||
}
|
||
display_Update();
|
||
|
||
// Close the file:
|
||
mpk_file.close();
|
||
}
|
||
|
||
void writeMPK() {
|
||
// 3 command bytes, 32 data bytes
|
||
byte command[3 + 32];
|
||
command[0] = 0x03;
|
||
|
||
// Create filepath
|
||
sprintf(filePath, "%s/%s", filePath, fileName);
|
||
print_Msg(F("Writing "));
|
||
print_Msg(filePath);
|
||
println_Msg(F("..."));
|
||
display_Update();
|
||
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
|
||
//Initialize progress bar
|
||
uint32_t totalProgressBar = 0x7FFF;
|
||
draw_progressbar(0, totalProgressBar);
|
||
|
||
for (word address = 0x0000; address < 0x8000; address += 32) {
|
||
myFile.read(command + 3, sizeof(command) - 3);
|
||
|
||
word address_with_crc = addrCRC(address);
|
||
command[1] = (byte)(address_with_crc >> 8);
|
||
command[2] = (byte)(address_with_crc & 0xff);
|
||
|
||
// don't want interrupts getting in the way
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
// Enable interrupts
|
||
interrupts();
|
||
|
||
// Real N64 has about 627us pause between banks, add a bit extra delay
|
||
delayMicroseconds(650);
|
||
|
||
if ((address & 0x1FF) == 0) {
|
||
// Blink led
|
||
// Update progress bar
|
||
blinkLED();
|
||
draw_progressbar(address, totalProgressBar);
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
} else {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
}
|
||
|
||
// verifies if write was successful
|
||
void verifyMPK() {
|
||
byte block[32];
|
||
writeErrors = 0;
|
||
|
||
print_STR(verifying_STR, 1);
|
||
display_Update();
|
||
|
||
//open file on sd card
|
||
if (!myFile.open(filePath, O_READ)) {
|
||
print_FatalError(open_file_STR);
|
||
}
|
||
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(0x7FFF);
|
||
draw_progressbar(0, totalProgressBar);
|
||
|
||
// Controller paks, which all have 32kB of space, are mapped between 0x0000 – 0x7FFF
|
||
for (word currSdBuffer = 0x0000; currSdBuffer < 0x8000; currSdBuffer += sizeof(sdBuffer)) {
|
||
// Read 512 bytes into SD buffer
|
||
myFile.read(sdBuffer, sizeof(sdBuffer));
|
||
|
||
// Compare 32 byte block
|
||
for (word currBlock = 0; currBlock < sizeof(sdBuffer); currBlock += 32) {
|
||
// Read one block of the Controller Pak
|
||
readBlock(block, currSdBuffer + currBlock);
|
||
|
||
// Check against file on SD card
|
||
for (byte currByte = 0; currByte < 32; currByte++) {
|
||
if (sdBuffer[currBlock + currByte] != block[currByte]) {
|
||
writeErrors++;
|
||
}
|
||
}
|
||
// Real N64 has about 627us pause between banks, add a bit extra delay
|
||
if (currBlock < 479)
|
||
delayMicroseconds(1500);
|
||
}
|
||
|
||
// Blink led
|
||
blinkLED();
|
||
// Update progress bar
|
||
processedProgressBar += 512;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
}
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
if (writeErrors == 0) {
|
||
println_Msg(F("Written successfully"));
|
||
display_Update();
|
||
} else {
|
||
print_STR(error_STR, 0);
|
||
print_Msg(writeErrors);
|
||
print_STR(_bytes_STR, 1);
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
}
|
||
|
||
/******************************************
|
||
N64 Cartridge functions
|
||
*****************************************/
|
||
void printCartInfo_N64() {
|
||
// Check cart
|
||
getCartInfo_N64();
|
||
|
||
// Print start page
|
||
if (cartSize != 0) {
|
||
display_Clear();
|
||
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: "));
|
||
print_Msg(cartSize);
|
||
println_Msg(F(" MB"));
|
||
print_Msg(F("Save Type: "));
|
||
switch (saveType) {
|
||
case 1:
|
||
println_Msg(F("SRAM"));
|
||
break;
|
||
case 4:
|
||
println_Msg(F("FLASH"));
|
||
break;
|
||
case 5:
|
||
println_Msg(F("4K EEPROM"));
|
||
eepPages = 64;
|
||
break;
|
||
case 6:
|
||
println_Msg(F("16K EEPROM"));
|
||
eepPages = 256;
|
||
break;
|
||
default:
|
||
println_Msg(F("None/Unknown"));
|
||
break;
|
||
}
|
||
|
||
print_Msg(F("CRC1: "));
|
||
println_Msg(checksumStr);
|
||
|
||
// Wait for user input
|
||
println_Msg(FS(FSTRING_SPACE));
|
||
// Prints string out of the common strings array either with or without newline
|
||
print_STR(press_button_STR, 1);
|
||
display_Update();
|
||
wait();
|
||
} else {
|
||
// Display error
|
||
display_Clear();
|
||
println_Msg(F("GAMEPAK ERROR"));
|
||
println_Msg("");
|
||
print_Msg(F("Title: "));
|
||
println_Msg(romName);
|
||
print_Msg(F("Serial: "));
|
||
println_Msg(cartID);
|
||
print_Msg(F("CRC1: "));
|
||
println_Msg(checksumStr);
|
||
display_Update();
|
||
|
||
strcpy(romName, "GPERROR");
|
||
print_Error(F("Cartridge unknown"));
|
||
println_Msg("");
|
||
// Prints string out of the common strings array either with or without newline
|
||
print_STR(press_button_STR, 1);
|
||
display_Update();
|
||
wait();
|
||
|
||
// Set cartsize manually
|
||
unsigned char N64RomMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(romOptionsN64, 7);
|
||
N64RomMenu = question_box(F("Select ROM size"), menuOptions, 7, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (N64RomMenu) {
|
||
case 0:
|
||
// 4MB
|
||
cartSize = 4;
|
||
break;
|
||
|
||
case 1:
|
||
// 8MB
|
||
cartSize = 8;
|
||
break;
|
||
|
||
case 2:
|
||
// 12MB
|
||
cartSize = 12;
|
||
break;
|
||
|
||
case 3:
|
||
// 16MB
|
||
cartSize = 16;
|
||
break;
|
||
|
||
case 4:
|
||
// 32MB
|
||
cartSize = 32;
|
||
break;
|
||
|
||
case 5:
|
||
// 64MB
|
||
cartSize = 64;
|
||
break;
|
||
|
||
case 6:
|
||
// 128MB
|
||
cartSize = 128;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* look-up the calculated crc in the file n64.txt on sd card
|
||
boolean searchCRC(char crcStr[9]) {
|
||
boolean result = 0;
|
||
char tempStr2[2];
|
||
char tempStr1[9];
|
||
char tempStr[5];
|
||
|
||
// Change to root dir
|
||
sd.chdir("/");
|
||
|
||
if (myFile.open("n64.txt", O_READ)) {
|
||
// Loop through file
|
||
while (myFile.available()) {
|
||
// Read 8 bytes into String, do it one at a time so byte order doesn't get mixed up
|
||
sprintf(tempStr1, "%c", myFile.read());
|
||
for (byte i = 0; i < 7; i++) {
|
||
sprintf(tempStr2, "%c", myFile.read());
|
||
strcat(tempStr1, tempStr2);
|
||
}
|
||
|
||
// Check if string is a match
|
||
if (strcasecmp(tempStr1, crcStr) == 0) {
|
||
// Skip the , in the file
|
||
myFile.seekCur(1);
|
||
|
||
// Read 4 bytes into String, do it one at a time so byte order doesn't get mixed up
|
||
sprintf(tempStr, "%c", myFile.read());
|
||
for (byte i = 0; i < 3; i++) {
|
||
sprintf(tempStr2, "%c", myFile.read());
|
||
strcat(tempStr, tempStr2);
|
||
}
|
||
|
||
if (strcmp(tempStr, cartID) == 0) {
|
||
result = 1;
|
||
break;
|
||
}
|
||
else {
|
||
result = 0;
|
||
break;
|
||
}
|
||
}
|
||
// If no match, empty string, advance by 12 and try again
|
||
else {
|
||
myFile.seekCur(12);
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
return result;
|
||
}
|
||
else {
|
||
print_FatalError(F("n64.txt missing"));
|
||
}
|
||
}*/
|
||
|
||
// look-up cart id in file n64.txt on sd card
|
||
void getCartInfo_N64() {
|
||
char tempStr[9];
|
||
int read_bytes;
|
||
|
||
// cart not in list
|
||
cartSize = 0;
|
||
saveType = 0;
|
||
|
||
// Read cart id
|
||
idCart();
|
||
|
||
display_Clear();
|
||
println_Msg(F("Searching database..."));
|
||
display_Update();
|
||
|
||
if (myFile.open("n64.txt", O_READ)) {
|
||
// Loop through file
|
||
while (myFile.available()) {
|
||
// Skip first line with name
|
||
skip_line(&myFile);
|
||
|
||
// Skip over the CRC32 checksum
|
||
myFile.seekCur(9);
|
||
|
||
// Read 8 bytes into String
|
||
read_bytes = myFile.read(tempStr, 8);
|
||
tempStr[read_bytes == -1 ? 0 : read_bytes] = 0;
|
||
|
||
// Check if string is a match
|
||
if (strcmp(tempStr, checksumStr) == 0) {
|
||
// Skip the , in the file
|
||
myFile.seekCur(1);
|
||
|
||
read_bytes = myFile.read(tempStr, 2);
|
||
tempStr[read_bytes == -1 ? 0 : read_bytes] = 0;
|
||
cartSize = atoi(tempStr);
|
||
|
||
// Skip the , in the file
|
||
myFile.seekCur(1);
|
||
|
||
// Read the next ascii character and subtract 48 to convert to decimal
|
||
saveType = myFile.read() - 48;
|
||
|
||
// End loop
|
||
break;
|
||
}
|
||
// If no match skip to next entry
|
||
else {
|
||
// skip rest of line
|
||
myFile.seekCur(7);
|
||
// skip third empty line
|
||
skip_line(&myFile);
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
} else {
|
||
print_FatalError(F("n64.txt missing"));
|
||
}
|
||
}
|
||
|
||
// Read rom ID
|
||
void idCart() {
|
||
// Set the address
|
||
setAddress_N64(romBase);
|
||
// Read first 64 bytes of rom
|
||
for (int c = 0; c < 64; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
|
||
// CRC1
|
||
sprintf(checksumStr, "%02X%02X%02X%02X", sdBuffer[0x10], sdBuffer[0x11], sdBuffer[0x12], sdBuffer[0x13]);
|
||
|
||
// Get cart id
|
||
cartID[0] = sdBuffer[0x3B];
|
||
cartID[1] = sdBuffer[0x3C];
|
||
cartID[2] = sdBuffer[0x3D];
|
||
cartID[3] = sdBuffer[0x3E];
|
||
|
||
// Get rom version
|
||
romVersion = sdBuffer[0x3F];
|
||
|
||
// If name consists out of all japanese characters use cart id
|
||
if (buildRomName(romName, &sdBuffer[0x20], 20) == 0) {
|
||
strcpy(romName, cartID);
|
||
}
|
||
|
||
#ifdef OPTION_N64_SAVESUMMARY
|
||
// Get CRC1
|
||
for (int i = 0; i < 4; i++) {
|
||
if (sdBuffer[0x10 + i] < 0x10) {
|
||
CRC1 += '0';
|
||
}
|
||
CRC1 += String(sdBuffer[0x10 + i], HEX);
|
||
}
|
||
|
||
// Get CRC2
|
||
for (int i = 0; i < 4; i++) {
|
||
if (sdBuffer[0x14 + i] < 0x10) {
|
||
CRC2 += '0';
|
||
}
|
||
CRC2 += String(sdBuffer[0x14 + i], HEX);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
// Write Eeprom to cartridge
|
||
void writeEeprom() {
|
||
if ((saveType == 5) || (saveType == 6)) {
|
||
|
||
// Create filepath
|
||
sprintf(filePath, "%s/%s", filePath, fileName);
|
||
println_Msg(F("Writing..."));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
// 2 command bytes and 8 data bytes
|
||
byte command[2 + 8];
|
||
command[0] = 0x05;
|
||
|
||
// Note: eepPages can be 256, so page must be able to get to 256 for the
|
||
// loop to exit. So it is not possible to use command[1] directly as loop
|
||
// counter.
|
||
for (int page = 0; page < eepPages; page++) {
|
||
command[1] = page;
|
||
// TODO: read 512 bytes in a 512 + 2 bytes buffer, and move the command start 32 bytes at a time
|
||
myFile.read(command + 2, sizeof(command) - 2);
|
||
// Disable interrupts for more uniform clock pulses
|
||
|
||
// Blink led
|
||
blinkLED();
|
||
if (page)
|
||
delay(50); // Wait 50ms between pages when writing
|
||
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
interrupts();
|
||
}
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
print_STR(done_STR, 1);
|
||
display_Update();
|
||
delay(600);
|
||
} else {
|
||
print_FatalError(sd_error_STR);
|
||
}
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
}
|
||
|
||
boolean readEepromPageList(byte* output, byte page_number, byte page_count) {
|
||
byte command[] = { 0x04, page_number };
|
||
|
||
// Disable interrupts for more uniform clock pulses
|
||
while (page_count--) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
noInterrupts();
|
||
sendJoyBus(command, sizeof(command));
|
||
// XXX: is it possible to read more than 8 bytes at a time ?
|
||
if (recvJoyBus(output, 8) > 0) {
|
||
// If any missing bytes error out
|
||
interrupts();
|
||
return 0;
|
||
break;
|
||
}
|
||
interrupts();
|
||
|
||
if (page_count)
|
||
delayMicroseconds(600); // wait 600us between pages when reading
|
||
|
||
command[1]++;
|
||
output += 8;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
// Dump Eeprom to SD
|
||
void readEeprom() {
|
||
if ((saveType == 5) || (saveType == 6)) {
|
||
// Get name, add extension and convert to char array for sd lib
|
||
snprintf_P(fileName, sizeof(fileName), N64_EEP_FILENAME_FMT, romName);
|
||
|
||
// create a new folder for the save file
|
||
EEPROM_readAnything(0, foldern);
|
||
snprintf_P(folder, sizeof(folder), N64_SAVE_DIRNAME_FMT, romName, foldern);
|
||
sd.mkdir(folder, true);
|
||
sd.chdir(folder);
|
||
|
||
// 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);
|
||
}
|
||
|
||
for (int i = 0; i < eepPages; i += sizeof(sdBuffer) / 8) {
|
||
// If any missing bytes error out
|
||
if (readEepromPageList(sdBuffer, i, sizeof(sdBuffer) / 8) == 0) {
|
||
println_Msg(FS(FSTRING_EMPTY));
|
||
print_STR(error_STR, 0);
|
||
println_Msg(F("no data received"));
|
||
println_Msg(FS(FSTRING_EMPTY));
|
||
break;
|
||
}
|
||
// Write 64 pages at once to the SD card
|
||
myFile.write(sdBuffer, sizeof(sdBuffer));
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
print_Msg(F("Saved to "));
|
||
print_Msg(folder);
|
||
println_Msg(F("/"));
|
||
display_Update();
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
}
|
||
|
||
// Check if a write succeeded, returns 0 if all is ok and number of errors if not
|
||
unsigned long verifyEeprom() {
|
||
unsigned long writeErrors;
|
||
|
||
if ((saveType == 5) || (saveType == 6)) {
|
||
writeErrors = 0;
|
||
|
||
display_Clear();
|
||
print_Msg(F("Verifying against "));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
for (int i = 0; i < eepPages; i += sizeof(sdBuffer) / 8) {
|
||
readEepromPageList(sdBuffer, i, sizeof(sdBuffer) / 8);
|
||
// Check sdBuffer content against file on sd card
|
||
for (size_t c = 0; c < sizeof(sdBuffer); c++) {
|
||
if (myFile.read() != sdBuffer[c]) {
|
||
writeErrors++;
|
||
}
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
} else {
|
||
// SD Error
|
||
writeErrors = 999999;
|
||
print_FatalError(sd_error_STR);
|
||
}
|
||
// Return 0 if verified ok, or number of errors
|
||
return writeErrors;
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
/******************************************
|
||
SRAM functions
|
||
*****************************************/
|
||
// Write sram to cartridge
|
||
void writeSram(unsigned long sramSize) {
|
||
if (saveType == 1) {
|
||
// Create filepath
|
||
sprintf(filePath, "%s/%s", filePath, fileName);
|
||
println_Msg(F("Writing..."));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
for (unsigned long currByte = sramBase; currByte < (sramBase + sramSize); currByte += 512) {
|
||
|
||
// Read save from SD into buffer
|
||
myFile.read(sdBuffer, 512);
|
||
|
||
// Set the address for the next 512 bytes
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < 512; c += 2) {
|
||
// Join bytes to word
|
||
word myWord = ((sdBuffer[c] & 0xFF) << 8) | (sdBuffer[c + 1] & 0xFF);
|
||
|
||
// Write word
|
||
writeWord_N64(myWord);
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
print_STR(done_STR, 1);
|
||
display_Update();
|
||
} else {
|
||
print_FatalError(sd_error_STR);
|
||
}
|
||
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
}
|
||
|
||
// Read sram and save to the SD card
|
||
void readSram(unsigned long sramSize, byte flashramType) {
|
||
int offset = 512;
|
||
int bufferSize = 512;
|
||
if (flashramType == 2) {
|
||
offset = 64;
|
||
bufferSize = 128;
|
||
}
|
||
|
||
// Get name, add extension and convert to char array for sd lib
|
||
const char* suffix;
|
||
|
||
if (saveType == 4) {
|
||
suffix = "fla";
|
||
} else if (saveType == 1) {
|
||
suffix = "sra";
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
createFolder("N64", "SAVE", romName, suffix);
|
||
|
||
// 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 currByte = sramBase; currByte < (sramBase + (sramSize / flashramType)); currByte += offset) {
|
||
// Set the address
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < bufferSize; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
myFile.write(sdBuffer, bufferSize);
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
print_Msg(F("Saved to "));
|
||
print_Msg(folder);
|
||
println_Msg(F("/"));
|
||
display_Update();
|
||
}
|
||
|
||
unsigned long verifySram(unsigned long sramSize, byte flashramType) {
|
||
writeErrors = 0;
|
||
|
||
int offset = 512;
|
||
int bufferSize = 512;
|
||
if (flashramType == 2) {
|
||
offset = 64;
|
||
bufferSize = 128;
|
||
}
|
||
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
for (unsigned long currByte = sramBase; currByte < (sramBase + (sramSize / flashramType)); currByte += offset) {
|
||
// Set the address
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < bufferSize; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
// Check sdBuffer content against file on sd card
|
||
for (int i = 0; i < bufferSize; i++) {
|
||
if (myFile.read() != sdBuffer[i]) {
|
||
writeErrors++;
|
||
}
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
} else {
|
||
print_FatalError(sd_error_STR);
|
||
}
|
||
// Return 0 if verified ok, or number of errors
|
||
return writeErrors;
|
||
}
|
||
|
||
/******************************************
|
||
Flashram functions
|
||
*****************************************/
|
||
// Send a command to the flashram command register
|
||
void sendFramCmd(unsigned long myCommand) {
|
||
// Split command into two words
|
||
word myComLowOut = myCommand & 0xFFFF;
|
||
word myComHighOut = myCommand >> 16;
|
||
|
||
// Set address to command register
|
||
setAddress_N64(0x08010000);
|
||
// Send command
|
||
writeWord_N64(myComHighOut);
|
||
writeWord_N64(myComLowOut);
|
||
}
|
||
|
||
// Init fram
|
||
void initFram() {
|
||
// FRAM_EXECUTE_CMD
|
||
sendFramCmd(0xD2000000);
|
||
delay(10);
|
||
// FRAM_EXECUTE_CMD
|
||
sendFramCmd(0xD2000000);
|
||
delay(10);
|
||
//FRAM_STATUS_MODE_CMD
|
||
sendFramCmd(0xE1000000);
|
||
delay(10);
|
||
}
|
||
|
||
void writeFram(byte flashramType) {
|
||
if (saveType == 4) {
|
||
// Erase fram
|
||
eraseFram();
|
||
|
||
// Check if empty
|
||
if (blankcheck_N64(flashramType) == 0) {
|
||
println_Msg(FS(FSTRING_OK));
|
||
display_Update();
|
||
} else {
|
||
println_Msg(F("FAIL"));
|
||
display_Update();
|
||
}
|
||
|
||
// Create filepath
|
||
sprintf(filePath, "%s/%s", filePath, fileName);
|
||
print_Msg(F("Writing "));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
// Init fram
|
||
initFram();
|
||
|
||
// Write all 8 fram banks
|
||
print_Msg(F("Bank "));
|
||
for (byte bank = 0; bank < 8; bank++) {
|
||
print_Msg(bank);
|
||
print_Msg(FS(FSTRING_SPACE));
|
||
display_Update();
|
||
|
||
// Write one bank of 128*128 bytes
|
||
for (byte offset = 0; offset < 128; offset++) {
|
||
// Read save from SD into buffer
|
||
myFile.read(sdBuffer, 128);
|
||
|
||
// FRAM_WRITE_MODE_CMD
|
||
sendFramCmd(0xB4000000);
|
||
delay(1);
|
||
|
||
// Set the address for the next 128 bytes
|
||
setAddress_N64(0x08000000);
|
||
|
||
// Send 128 bytes, 64 words
|
||
for (byte c = 0; c < 128; c += 2) {
|
||
// Join two bytes into one word
|
||
word myWord = ((sdBuffer[c] & 0xFF) << 8) | (sdBuffer[c + 1] & 0xFF);
|
||
// Write word
|
||
writeWord_N64(myWord);
|
||
}
|
||
// Delay between each "DMA"
|
||
delay(1);
|
||
|
||
//FRAM_WRITE_OFFSET_CMD + offset
|
||
sendFramCmd((0xA5000000 | (((bank * 128) + offset) & 0xFFFF)));
|
||
delay(1);
|
||
|
||
// FRAM_EXECUTE_CMD
|
||
sendFramCmd(0xD2000000);
|
||
while (waitForFram(flashramType)) {
|
||
delay(1);
|
||
}
|
||
}
|
||
// Delay between banks
|
||
delay(20);
|
||
}
|
||
println_Msg("");
|
||
// Close the file:
|
||
myFile.close();
|
||
} else {
|
||
print_FatalError(sd_error_STR);
|
||
}
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
}
|
||
|
||
// Delete all 8 flashram banks
|
||
void eraseFram() {
|
||
if (saveType == 4) {
|
||
print_Msg(F("Erasing..."));
|
||
display_Update();
|
||
|
||
// Init fram
|
||
initFram();
|
||
|
||
// Erase fram
|
||
// 0x4B00007F 0x4B0000FF 0x4B00017F 0x4B0001FF 0x4B00027F 0x4B0002FF 0x4B00037F 0x4B0003FF
|
||
for (unsigned long bank = 0x4B00007F; bank < 0x4B00047F; bank += 0x80) {
|
||
sendFramCmd(bank);
|
||
delay(10);
|
||
// FRAM_ERASE_MODE_CMD
|
||
sendFramCmd(0x78000000);
|
||
delay(10);
|
||
// FRAM_EXECUTE_CMD
|
||
sendFramCmd(0xD2000000);
|
||
while (waitForFram(flashramType)) {
|
||
delay(1);
|
||
}
|
||
}
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
}
|
||
|
||
// Read flashram
|
||
void readFram(byte flashramType) {
|
||
if (saveType == 4) {
|
||
// Put flashram into read mode
|
||
// FRAM_READ_MODE_CMD
|
||
sendFramCmd(0xF0000000);
|
||
// Read Flashram
|
||
readSram(131072, flashramType);
|
||
} else {
|
||
print_FatalError(F("Savetype Error"));
|
||
}
|
||
}
|
||
|
||
// Verify flashram
|
||
unsigned long verifyFram(byte flashramType) {
|
||
// Put flashram into read mode
|
||
// FRAM_READ_MODE_CMD
|
||
sendFramCmd(0xF0000000);
|
||
writeErrors = verifySram(131072, flashramType);
|
||
return writeErrors;
|
||
}
|
||
|
||
// Blankcheck flashram
|
||
unsigned long blankcheck_N64(byte flashramType) {
|
||
writeErrors = 0;
|
||
|
||
int offset = 512;
|
||
int bufferSize = 512;
|
||
if (flashramType == 2) {
|
||
offset = 64;
|
||
bufferSize = 128;
|
||
}
|
||
|
||
// Put flashram into read mode
|
||
// FRAM_READ_MODE_CMD
|
||
sendFramCmd(0xF0000000);
|
||
|
||
// Read Flashram
|
||
for (unsigned long currByte = sramBase; currByte < (sramBase + (131072 / flashramType)); currByte += offset) {
|
||
// Set the address for the next 512 bytes
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < bufferSize; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
// Check sdBuffer content against file on sd card
|
||
for (int i = 0; i < bufferSize; i++) {
|
||
if (0xFF != sdBuffer[i]) {
|
||
writeErrors++;
|
||
}
|
||
}
|
||
}
|
||
// Return 0 if verified ok, or number of errors
|
||
return writeErrors;
|
||
}
|
||
|
||
// Wait until current operation is done
|
||
byte waitForFram(byte flashramType) {
|
||
byte framStatus = 0;
|
||
byte statusMXL1100[] = { 0x11, 0x11, 0x80, 0x01, 0x00, 0xC2, 0x00, 0x1E };
|
||
byte statusMXL1101[] = { 0x11, 0x11, 0x80, 0x01, 0x00, 0xC2, 0x00, 0x1D };
|
||
byte statusMN63F81[] = { 0x11, 0x11, 0x80, 0x01, 0x00, 0x32, 0x00, 0xF1 };
|
||
|
||
// FRAM_STATUS_MODE_CMD
|
||
sendFramCmd(0xE1000000);
|
||
delay(1);
|
||
|
||
// Set address to Fram status register
|
||
setAddress_N64(0x08000000);
|
||
|
||
// Read Status
|
||
for (byte c = 0; c < 8; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
|
||
if (flashramType == 2) {
|
||
for (byte c = 0; c < 8; c++) {
|
||
if (statusMXL1100[c] != sdBuffer[c]) {
|
||
framStatus = 1;
|
||
}
|
||
}
|
||
} else if (flashramType == 1) {
|
||
//MX29L1101
|
||
if (MN63F81MPN == false) {
|
||
for (byte c = 0; c < 8; c++) {
|
||
if (statusMXL1101[c] != sdBuffer[c]) {
|
||
framStatus = 1;
|
||
}
|
||
}
|
||
}
|
||
//MN63F81MPN
|
||
else if (MN63F81MPN == true) {
|
||
for (byte c = 0; c < 8; c++) {
|
||
if (statusMN63F81[c] != sdBuffer[c]) {
|
||
framStatus = 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return framStatus;
|
||
}
|
||
|
||
// Get flashram type
|
||
void getFramType() {
|
||
|
||
// FRAM_STATUS_MODE_CMD
|
||
sendFramCmd(0xE1000000);
|
||
delay(10);
|
||
|
||
// Set address to Fram status register
|
||
setAddress_N64(0x08000000);
|
||
|
||
// Read Status
|
||
for (byte c = 0; c < 8; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
//MX29L1100
|
||
if (sdBuffer[7] == 0x1e) {
|
||
flashramType = 2;
|
||
println_Msg(F("Type: MX29L1100"));
|
||
display_Update();
|
||
}
|
||
//MX29L1101
|
||
else if (sdBuffer[7] == 0x1d) {
|
||
flashramType = 1;
|
||
MN63F81MPN = false;
|
||
println_Msg(F("Type: MX29L1101"));
|
||
display_Update();
|
||
}
|
||
//MN63F81MPN
|
||
else if (sdBuffer[7] == 0xf1) {
|
||
flashramType = 1;
|
||
MN63F81MPN = true;
|
||
println_Msg(F("Type: MN63F81MPN"));
|
||
display_Update();
|
||
}
|
||
// 29L1100KC-15B0 compat MX29L1101
|
||
else if ((sdBuffer[7] == 0x8e) || (sdBuffer[7] == 0x84)) {
|
||
flashramType = 1;
|
||
MN63F81MPN = false;
|
||
println_Msg(F("Type: 29L1100KC-15B0"));
|
||
println_Msg(F("(compat. MX29L1101)"));
|
||
display_Update();
|
||
}
|
||
// Type unknown
|
||
else {
|
||
for (byte c = 0; c < 8; c++) {
|
||
print_Msg(sdBuffer[c], HEX);
|
||
print_Msg(F(", "));
|
||
}
|
||
print_FatalError(F("Flashram unknown"));
|
||
}
|
||
}
|
||
|
||
/******************************************
|
||
Rom functions
|
||
*****************************************/
|
||
// Read rom and save to the SD card
|
||
#ifndef OPTION_N64_FASTCRC
|
||
// dumping rom slow
|
||
void readRom_N64() {
|
||
// Get name, add extension and convert to char array for sd lib
|
||
createFolder("N64", "ROM", romName, "Z64");
|
||
|
||
// 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)*1024 * 1024;
|
||
draw_progressbar(0, totalProgressBar);
|
||
|
||
for (unsigned long currByte = romBase; currByte < (romBase + (cartSize * 1024 * 1024)); currByte += 512) {
|
||
// Blink led
|
||
if ((currByte & 0x3FFF) == 0)
|
||
blinkLED();
|
||
|
||
// Set the address for the next 512 bytes
|
||
setAddress_N64(currByte);
|
||
|
||
for (word c = 0; c < 512; c += 2) {
|
||
word myWord = readWord_N64();
|
||
sdBuffer[c] = myWord >> 8;
|
||
sdBuffer[c + 1] = myWord & 0xFF;
|
||
}
|
||
myFile.write(sdBuffer, 512);
|
||
|
||
processedProgressBar += 512;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
}
|
||
#else
|
||
// dumping rom fast
|
||
uint32_t readRom_N64() {
|
||
// Get name, add extension and convert to char array for sd lib
|
||
createFolder("N64", "ROM", romName, "Z64");
|
||
|
||
// 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);
|
||
}
|
||
|
||
byte buffer[1024];
|
||
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(cartSize)*1024 * 1024;
|
||
draw_progressbar(0, totalProgressBar);
|
||
|
||
// prepare crc32
|
||
uint32_t oldcrc32 = 0xFFFFFFFF;
|
||
|
||
// run combined dumper + crc32 routine for better performance, as N64 ROMs are quite large for an 8bit micro
|
||
// currently dumps + checksums a 32MB cart in 170 seconds (down from 347 seconds)
|
||
for (unsigned long currByte = romBase; currByte < (romBase + (cartSize * 1024 * 1024)); currByte += 1024) {
|
||
// Blink led
|
||
if (currByte % 16384 == 0)
|
||
blinkLED();
|
||
|
||
// Set the address for the first 512 bytes to dump
|
||
setAddress_N64(currByte);
|
||
// Wait 62.5ns (safety)
|
||
NOP;
|
||
|
||
for (int c = 0; c < 512; c += 2) {
|
||
// Pull read(PH6) low
|
||
PORTH &= ~(1 << 6);
|
||
// Wait ~310ns
|
||
NOP;
|
||
NOP;
|
||
NOP;
|
||
NOP;
|
||
NOP;
|
||
|
||
// data on PINK and PINF is valid now, read into sd card buffer
|
||
buffer[c] = PINK; // hiByte
|
||
buffer[c + 1] = PINF; // loByte
|
||
|
||
// Pull read(PH6) high
|
||
PORTH |= (1 << 6);
|
||
|
||
// crc32 update
|
||
UPDATE_CRC(oldcrc32, buffer[c]);
|
||
UPDATE_CRC(oldcrc32, buffer[c + 1]);
|
||
}
|
||
|
||
// Set the address for the next 512 bytes to dump
|
||
setAddress_N64(currByte + 512);
|
||
// Wait 62.5ns (safety)
|
||
NOP;
|
||
|
||
for (int c = 512; c < 1024; c += 2) {
|
||
// Pull read(PH6) low
|
||
PORTH &= ~(1 << 6);
|
||
// Wait ~310ns
|
||
NOP;
|
||
NOP;
|
||
NOP;
|
||
NOP;
|
||
NOP;
|
||
|
||
// data on PINK and PINF is valid now, read into sd card buffer
|
||
buffer[c] = PINK; // hiByte
|
||
buffer[c + 1] = PINF; // loByte
|
||
|
||
// Pull read(PH6) high
|
||
PORTH |= (1 << 6);
|
||
|
||
// crc32 update
|
||
UPDATE_CRC(oldcrc32, buffer[c]);
|
||
UPDATE_CRC(oldcrc32, buffer[c + 1]);
|
||
}
|
||
|
||
processedProgressBar += 1024;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
// write out 1024 bytes to file
|
||
myFile.write(buffer, 1024);
|
||
}
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
|
||
// Return checksum
|
||
return oldcrc32;
|
||
}
|
||
#endif
|
||
|
||
#ifdef OPTION_N64_SAVESUMMARY
|
||
// Save an info.txt with information on the dumped rom to the SD card
|
||
void savesummary_N64(boolean checkfound, char crcStr[9], unsigned long timeElapsed) {
|
||
// Open file on sd card
|
||
if (!myFile.open("N64/ROM/n64log.txt", O_RDWR | O_CREAT | O_APPEND)) {
|
||
print_FatalError(sd_error_STR);
|
||
}
|
||
|
||
//Write the info
|
||
myFile.print(F("Name\t: "));
|
||
myFile.println(romName);
|
||
|
||
myFile.print(F("ID\t: "));
|
||
myFile.println(cartID);
|
||
|
||
myFile.print(F("ROM CRC1: "));
|
||
myFile.println(CRC1);
|
||
|
||
myFile.print(F("ROM CRC2: "));
|
||
myFile.println(CRC2);
|
||
|
||
myFile.print(F("Size\t: "));
|
||
myFile.print(cartSize);
|
||
|
||
myFile.println(F(" MB"));
|
||
myFile.print(F("Save\t: "));
|
||
|
||
switch (saveType) {
|
||
case 1:
|
||
myFile.println(F("SRAM"));
|
||
break;
|
||
case 4:
|
||
myFile.println(F("FLASH"));
|
||
break;
|
||
case 5:
|
||
myFile.println(F("4K EEPROM"));
|
||
break;
|
||
case 6:
|
||
myFile.println(F("16K EEPROM"));
|
||
break;
|
||
default:
|
||
myFile.println(F("None/Unknown"));
|
||
break;
|
||
}
|
||
|
||
myFile.print(F("Version\t: 1."));
|
||
myFile.println(romVersion);
|
||
|
||
myFile.print(F("Saved To: "));
|
||
myFile.println(folder);
|
||
|
||
#ifdef ENABLE_RTC
|
||
myFile.print(F("Dumped\t: "));
|
||
myFile.println(RTCStamp());
|
||
#endif
|
||
|
||
myFile.print(F("CRC\t: "));
|
||
myFile.print(crcStr);
|
||
|
||
if (checkfound) {
|
||
// Dump was a known good rom
|
||
// myFile.println(F("Checksum matches"));
|
||
myFile.println(" [Match]");
|
||
} else {
|
||
// myFile.println(F("Checksum not found"));
|
||
myFile.println(" [No Match]");
|
||
}
|
||
|
||
myFile.print(F("Time\t: "));
|
||
myFile.println(timeElapsed);
|
||
|
||
myFile.println(FS(FSTRING_SPACE));
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
}
|
||
#endif
|
||
|
||
/******************************************
|
||
N64 Repro Flashrom Functions
|
||
*****************************************/
|
||
void flashRepro_N64() {
|
||
unsigned long sectorSize = 0;
|
||
byte bufferSize = 0;
|
||
// Check flashrom ID's
|
||
idFlashrom_N64();
|
||
|
||
// If the ID is known continue
|
||
if (cartSize != 0) {
|
||
// Print flashrom name
|
||
if ((flashid == 0x227E) && (strcmp(cartID, "2201") == 0)) {
|
||
print_Msg(F("Spansion S29GL256N"));
|
||
if (cartSize == 64)
|
||
println_Msg(F(" x2"));
|
||
else
|
||
println_Msg("");
|
||
} else if ((flashid == 0x227E) && (strcmp(cartID, "2101") == 0)) {
|
||
print_Msg(F("Spansion S29GL128N"));
|
||
} else if ((flashid == 0x227E) && (strcmp(cartID, "2100") == 0)) {
|
||
print_Msg(F("ST M29W128GL"));
|
||
} else if ((flashid == 0x22C9) || (flashid == 0x22CB)) {
|
||
print_Msg(F("Macronix MX29LV640"));
|
||
if (cartSize == 16)
|
||
println_Msg(F(" x2"));
|
||
else
|
||
println_Msg("");
|
||
} else if (flashid == 0x8816)
|
||
println_Msg(F("Intel 4400L0ZDQ0"));
|
||
else if (flashid == 0x7E7E)
|
||
println_Msg(F("Fujitsu MSP55LV100S"));
|
||
else if ((flashid == 0x227E) && (strcmp(cartID, "2301") == 0))
|
||
println_Msg(F("Fujitsu MSP55LV512"));
|
||
else if ((flashid == 0x227E) && (strcmp(cartID, "3901") == 0))
|
||
println_Msg(F("Intel 512M29EW"));
|
||
|
||
// Print info
|
||
print_Msg(F("ID: "));
|
||
print_Msg(flashid_str);
|
||
print_Msg(F(" Size: "));
|
||
print_Msg(cartSize);
|
||
println_Msg(F("MB"));
|
||
println_Msg("");
|
||
println_Msg(F("This will erase your"));
|
||
println_Msg(F("Repro Cartridge."));
|
||
println_Msg(F("Attention: Use 3.3V!"));
|
||
println_Msg("");
|
||
// Prints string out of the common strings array either with or without newline
|
||
print_STR(press_button_STR, 1);
|
||
display_Update();
|
||
wait();
|
||
} else {
|
||
println_Msg(F("Unknown flashrom"));
|
||
print_Msg(F("ID: "));
|
||
print_Msg(vendorID);
|
||
print_Msg(FS(FSTRING_SPACE));
|
||
print_Msg(flashid_str);
|
||
print_Msg(FS(FSTRING_SPACE));
|
||
println_Msg(cartID);
|
||
println_Msg(FS(FSTRING_SPACE));
|
||
println_Msg(F("Press button for"));
|
||
println_Msg(F("manual config"));
|
||
println_Msg(F("This will erase your"));
|
||
println_Msg(F("Repro Cartridge."));
|
||
println_Msg(F("Attention: Use 3.3V!"));
|
||
display_Update();
|
||
wait();
|
||
|
||
// clear IDs
|
||
sprintf(vendorID, "%s", "CONF");
|
||
flashid = 0;
|
||
sprintf(flashid_str, "%s", "CONF");
|
||
sprintf(cartID, "%s", "CONF");
|
||
|
||
// Set cartsize manually
|
||
unsigned char N64RomMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(romOptionsN64, 7);
|
||
N64RomMenu = question_box(F("Select flash size"), menuOptions, 7, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (N64RomMenu) {
|
||
case 0:
|
||
// 4MB
|
||
cartSize = 4;
|
||
break;
|
||
|
||
case 1:
|
||
// 8MB
|
||
cartSize = 8;
|
||
break;
|
||
|
||
case 2:
|
||
// 12MB
|
||
cartSize = 12;
|
||
break;
|
||
|
||
case 3:
|
||
// 16MB
|
||
cartSize = 16;
|
||
break;
|
||
|
||
case 4:
|
||
// 32MB
|
||
cartSize = 32;
|
||
break;
|
||
|
||
case 5:
|
||
// 64MB
|
||
cartSize = 64;
|
||
break;
|
||
|
||
case 6:
|
||
// 128MB
|
||
cartSize = 128;
|
||
break;
|
||
}
|
||
|
||
// Set flash buffer manually
|
||
unsigned char N64BufferMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(bufferOptionsN64, 4);
|
||
N64BufferMenu = question_box(F("Select buffer size"), menuOptions, 4, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (N64BufferMenu) {
|
||
case 0:
|
||
// no buffer
|
||
bufferSize = 0;
|
||
break;
|
||
|
||
case 1:
|
||
// 32 byte buffer
|
||
bufferSize = 32;
|
||
break;
|
||
|
||
case 2:
|
||
// 64 byte buffer
|
||
bufferSize = 64;
|
||
break;
|
||
|
||
case 3:
|
||
// 128 byte buffer
|
||
bufferSize = 128;
|
||
break;
|
||
}
|
||
|
||
// Set sector size manually
|
||
unsigned char N64SectorMenu;
|
||
// Copy menuOptions out of progmem
|
||
convertPgm(sectorOptionsN64, 4);
|
||
N64SectorMenu = question_box(F("Select sector size"), menuOptions, 4, 0);
|
||
|
||
// wait for user choice to come back from the question box menu
|
||
switch (N64SectorMenu) {
|
||
case 0:
|
||
// 8KB sectors
|
||
sectorSize = 0x2000;
|
||
break;
|
||
|
||
case 1:
|
||
// 32KB sectors
|
||
sectorSize = 0x8000;
|
||
break;
|
||
|
||
case 2:
|
||
// 64KB sectors
|
||
sectorSize = 0x10000;
|
||
break;
|
||
|
||
case 3:
|
||
// 128KB sectors
|
||
sectorSize = 0x20000;
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Launch file browser
|
||
filePath[0] = '\0';
|
||
sd.chdir("/");
|
||
fileBrowser(F("Select z64 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 / 1048576);
|
||
println_Msg(F("MB"));
|
||
display_Update();
|
||
|
||
// Compare file size to flashrom size
|
||
if ((fileSize / 1048576) > cartSize) {
|
||
print_FatalError(file_too_big_STR);
|
||
}
|
||
|
||
// Erase needed sectors
|
||
if (flashid == 0x227E) {
|
||
// Spansion S29GL256N or Fujitsu MSP55LV512 with 0x20000 sector size and 32 byte buffer
|
||
eraseSector_N64(0x20000);
|
||
} else if (flashid == 0x7E7E) {
|
||
// Fujitsu MSP55LV100S
|
||
eraseMSP55LV100_N64();
|
||
} else if ((flashid == 0x8813) || (flashid == 0x8816)) {
|
||
// Intel 4400L0ZDQ0
|
||
eraseIntel4400_N64();
|
||
resetIntel4400_N64();
|
||
} else if ((flashid == 0x22C9) || (flashid == 0x22CB)) {
|
||
// Macronix MX29LV640, C9 is top boot and CB is bottom boot block
|
||
eraseSector_N64(0x8000);
|
||
} else {
|
||
eraseFlashrom_N64();
|
||
}
|
||
|
||
// Check if erase was successful
|
||
if (blankcheckFlashrom_N64()) {
|
||
// Write flashrom
|
||
println_Msg(FS(FSTRING_OK));
|
||
print_Msg(F("Writing "));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
|
||
if ((strcmp(cartID, "3901") == 0) && (flashid == 0x227E)) {
|
||
// Intel 512M29EW(64MB) with 0x20000 sector size and 128 byte buffer
|
||
writeFlashBuffer_N64(0x20000, 128);
|
||
} else if ((strcmp(cartID, "2100") == 0) && (flashid == 0x227E)) {
|
||
// ST M29W128GH(16MB) with 0x20000 sector size and 64 byte buffer
|
||
writeFlashBuffer_N64(0x20000, 64);
|
||
} else if (flashid == 0x227E) {
|
||
// Spansion S29GL128N/S29GL256N or Fujitsu MSP55LV512 with 0x20000 sector size and 32 byte buffer
|
||
writeFlashBuffer_N64(0x20000, 32);
|
||
} else if (flashid == 0x7E7E) {
|
||
//Fujitsu MSP55LV100S
|
||
writeMSP55LV100_N64(0x20000);
|
||
} else if ((flashid == 0x22C9) || (flashid == 0x22CB)) {
|
||
// Macronix MX29LV640 without buffer and 0x8000 sector size
|
||
writeFlashrom_N64(0x8000);
|
||
} else if ((flashid == 0x8813) || (flashid == 0x8816)) {
|
||
// Intel 4400L0ZDQ0
|
||
writeIntel4400_N64();
|
||
resetIntel4400_N64();
|
||
} else if (sectorSize) {
|
||
if (bufferSize) {
|
||
writeFlashBuffer_N64(sectorSize, bufferSize);
|
||
} else {
|
||
writeFlashrom_N64(sectorSize);
|
||
}
|
||
} else {
|
||
print_FatalError(F("sectorSize not set"));
|
||
}
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
|
||
// Verify
|
||
print_STR(verifying_STR, 0);
|
||
display_Update();
|
||
writeErrors = verifyFlashrom_N64();
|
||
if (writeErrors == 0) {
|
||
println_Msg(FS(FSTRING_OK));
|
||
display_Update();
|
||
} else {
|
||
print_Msg(writeErrors);
|
||
print_Msg(F(" bytes "));
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
} else {
|
||
// Close the file
|
||
myFile.close();
|
||
print_Error(F("failed"));
|
||
}
|
||
} else {
|
||
print_Error(F("Can't open file"));
|
||
}
|
||
|
||
// 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();
|
||
}
|
||
|
||
// Reset to read mode
|
||
void resetIntel4400_N64() {
|
||
for (unsigned long currPartition = 0; currPartition < (cartSize * 0x100000); currPartition += 0x20000) {
|
||
setAddress_N64(romBase + currPartition);
|
||
writeWord_N64(0xFF);
|
||
}
|
||
}
|
||
|
||
// Reset Fujitsu MSP55LV100S
|
||
void resetMSP55LV100_N64(unsigned long flashBase) {
|
||
// Send reset Command
|
||
setAddress_N64(flashBase);
|
||
writeWord_N64(0xF0F0);
|
||
delay(100);
|
||
}
|
||
|
||
// Common reset command
|
||
void resetFlashrom_N64(unsigned long flashBase) {
|
||
// Send reset Command
|
||
setAddress_N64(flashBase);
|
||
writeWord_N64(0xF0);
|
||
delay(100);
|
||
}
|
||
|
||
void idFlashrom_N64() {
|
||
// Set size to 0 if no ID is found
|
||
cartSize = 0;
|
||
|
||
// Send flashrom ID command
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(romBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0x90);
|
||
|
||
// Read 1 byte vendor ID
|
||
setAddress_N64(romBase);
|
||
sprintf(vendorID, "%02X", readWord_N64());
|
||
// Read 2 bytes flashrom ID
|
||
flashid = readWord_N64();
|
||
sprintf(flashid_str, "%04X", flashid);
|
||
// Read 2 bytes secondary flashrom ID
|
||
setAddress_N64(romBase + 0x1C);
|
||
sprintf(cartID, "%04X", ((readWord_N64() << 8) | (readWord_N64() & 0xFF)));
|
||
|
||
// Spansion S29GL256N(32MB/64MB) with either one or two flashrom chips
|
||
if ((strcmp(cartID, "2201") == 0) && (flashid == 0x227E)) {
|
||
cartSize = 32;
|
||
|
||
// Reset flashrom
|
||
resetFlashrom_N64(romBase);
|
||
|
||
// Test for second flashrom chip at 0x2000000 (32MB)
|
||
setAddress_N64(romBase + 0x2000000 + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(romBase + 0x2000000 + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + 0x2000000 + (0x555 << 1));
|
||
writeWord_N64(0x90);
|
||
|
||
char tempID[5];
|
||
setAddress_N64(romBase + 0x2000000);
|
||
// Read manufacturer ID
|
||
readWord_N64();
|
||
// Read flashrom ID
|
||
sprintf(tempID, "%04X", readWord_N64());
|
||
|
||
// Check if second flashrom chip is present
|
||
if (strcmp(tempID, "227E") == 0) {
|
||
cartSize = 64;
|
||
}
|
||
resetFlashrom_N64(romBase + 0x2000000);
|
||
}
|
||
|
||
// Macronix MX29LV640(8MB/16MB) with either one or two flashrom chips
|
||
else if ((flashid == 0x22C9) || (flashid == 0x22CB)) {
|
||
cartSize = 8;
|
||
|
||
resetFlashrom_N64(romBase + 0x800000);
|
||
|
||
// Test for second flashrom chip at 0x800000 (8MB)
|
||
setAddress_N64(romBase + 0x800000 + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(romBase + 0x800000 + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + 0x800000 + (0x555 << 1));
|
||
writeWord_N64(0x90);
|
||
|
||
char tempID[5];
|
||
setAddress_N64(romBase + 0x800000);
|
||
// Read manufacturer ID
|
||
readWord_N64();
|
||
// Read flashrom ID
|
||
sprintf(tempID, "%04X", readWord_N64());
|
||
|
||
// Check if second flashrom chip is present
|
||
if ((strcmp(tempID, "22C9") == 0) || (strcmp(tempID, "22CB") == 0)) {
|
||
cartSize = 16;
|
||
}
|
||
resetFlashrom_N64(romBase + 0x800000);
|
||
}
|
||
|
||
// Intel 4400L0ZDQ0 (64MB)
|
||
else if (flashid == 0x8816) {
|
||
// Found first flashrom chip, set to 32MB
|
||
cartSize = 32;
|
||
resetIntel4400_N64();
|
||
|
||
// Test if second half of the flashrom might be hidden
|
||
setAddress_N64(romBase + 0x2000000 + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(romBase + 0x2000000 + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + 0x2000000 + (0x555 << 1));
|
||
writeWord_N64(0x90);
|
||
|
||
// Read manufacturer ID
|
||
setAddress_N64(romBase + 0x2000000);
|
||
readWord_N64();
|
||
// Read flashrom ID
|
||
sprintf(cartID, "%04X", readWord_N64());
|
||
if (strcmp(cartID, "8813") == 0) {
|
||
cartSize = 64;
|
||
flashid = 0x8813;
|
||
strncpy(flashid_str, cartID, 5);
|
||
}
|
||
resetIntel4400_N64();
|
||
// Empty cartID string
|
||
cartID[0] = '\0';
|
||
}
|
||
|
||
//Fujitsu MSP55LV512/Spansion S29GL512N (64MB)
|
||
else if ((strcmp(cartID, "2301") == 0) && (flashid == 0x227E)) {
|
||
cartSize = 64;
|
||
// Reset flashrom
|
||
resetFlashrom_N64(romBase);
|
||
}
|
||
|
||
// Spansion S29GL128N(16MB) with one flashrom chip
|
||
else if ((strcmp(cartID, "2101") == 0) && (flashid == 0x227E)) {
|
||
cartSize = 16;
|
||
// Reset flashrom
|
||
resetFlashrom_N64(romBase);
|
||
}
|
||
|
||
// ST M29W128GL(16MB) with one flashrom chip
|
||
else if ((strcmp(cartID, "2100") == 0) && (flashid == 0x227E)) {
|
||
cartSize = 16;
|
||
// Reset flashrom
|
||
resetFlashrom_N64(romBase);
|
||
}
|
||
|
||
// Intel 512M29EW(64MB) with one flashrom chip
|
||
else if ((strcmp(cartID, "3901") == 0) && (flashid == 0x227E)) {
|
||
cartSize = 64;
|
||
// Reset flashrom
|
||
resetFlashrom_N64(romBase);
|
||
}
|
||
|
||
// Unknown 227E type
|
||
else if (flashid == 0x227E) {
|
||
cartSize = 0;
|
||
// Reset flashrom
|
||
resetFlashrom_N64(romBase);
|
||
}
|
||
|
||
//Test for Fujitsu MSP55LV100S (64MB)
|
||
else {
|
||
// Send flashrom ID command
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(romBase + (0x2AA << 1));
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0x9090);
|
||
|
||
setAddress_N64(romBase);
|
||
// Read 1 byte vendor ID
|
||
readWord_N64();
|
||
// Read 2 bytes flashrom ID
|
||
sprintf(cartID, "%04X", readWord_N64());
|
||
|
||
if (strcmp(cartID, "7E7E") == 0) {
|
||
resetMSP55LV100_N64(romBase);
|
||
cartSize = 64;
|
||
flashid = 0x7E7E;
|
||
strncpy(flashid_str, cartID, 5);
|
||
}
|
||
}
|
||
if ((flashid == 0x1240) && (strcmp(cartID, "1240") == 0)) {
|
||
print_FatalError(F("Please reseat cartridge"));
|
||
}
|
||
}
|
||
|
||
// Erase Intel flashrom
|
||
void eraseIntel4400_N64() {
|
||
unsigned long flashBase = romBase;
|
||
|
||
print_Msg(F("Erasing..."));
|
||
display_Update();
|
||
|
||
// 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 command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x60);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
// Erase command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x20);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
|
||
// Read the status register
|
||
setAddress_N64(flashBase + currBlock);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(flashBase + currBlock);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
|
||
// Erase up to 255 blocks with 64kwords each
|
||
for (unsigned long currBlock = 0x20000; currBlock < lastBlock; currBlock += 0x1FFFF) {
|
||
// Unlock block command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x60);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
// Erase command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x20);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
|
||
// Read the status register
|
||
setAddress_N64(flashBase + currBlock);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(flashBase + currBlock);
|
||
statusReg = readWord_N64();
|
||
}
|
||
|
||
// Blink led
|
||
blinkLED();
|
||
}
|
||
|
||
// Check if we should erase the second chip too
|
||
if ((cartSize = 64) && (fileSize > 0x2000000)) {
|
||
// Switch base address to second chip
|
||
flashBase = romBase + 0x2000000;
|
||
|
||
// 255 blocks with 64kwords each
|
||
for (unsigned long currBlock = 0x0; currBlock < 0x1FDFFFF; currBlock += 0x1FFFF) {
|
||
// Unlock block command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x60);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
// Erase command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x20);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
|
||
// Read the status register
|
||
setAddress_N64(flashBase + currBlock);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(flashBase + currBlock);
|
||
statusReg = readWord_N64();
|
||
}
|
||
|
||
// Blink led
|
||
blinkLED();
|
||
}
|
||
|
||
// 4 blocks with 16kword each
|
||
for (unsigned long currBlock = 0x1FE0000; currBlock < 0x1FFFFFF; currBlock += 0x8000) {
|
||
// Unlock block command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x60);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
// Erase command
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0x20);
|
||
setAddress_N64(flashBase + currBlock);
|
||
writeWord_N64(0xD0);
|
||
|
||
// Read the status register
|
||
setAddress_N64(flashBase + currBlock);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(flashBase + currBlock);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Erase Fujutsu MSP55LV100S
|
||
void eraseMSP55LV100_N64() {
|
||
unsigned long flashBase = romBase;
|
||
unsigned long sectorSize = 0x20000;
|
||
|
||
print_Msg(F("Erasing..."));
|
||
display_Update();
|
||
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += sectorSize) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
// Send Erase Command to first chip
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0x8080);
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(romBase + currSector);
|
||
writeWord_N64(0x3030);
|
||
|
||
// Read the status register
|
||
setAddress_N64(romBase + currSector);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(romBase + currSector);
|
||
statusReg = readWord_N64();
|
||
}
|
||
|
||
// Read the status register
|
||
setAddress_N64(romBase + currSector);
|
||
statusReg = readWord_N64();
|
||
while ((statusReg | 0x7FFF) != 0xFFFF) {
|
||
setAddress_N64(romBase + currSector);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
|
||
// Common chip erase command
|
||
void eraseFlashrom_N64() {
|
||
print_Msg(F("Chip erase..."));
|
||
display_Update();
|
||
|
||
// Send Erase Command
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(romBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0x80);
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(romBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + (0x555 << 1));
|
||
writeWord_N64(0x10);
|
||
|
||
// Read the status register
|
||
setAddress_N64(romBase);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(romBase);
|
||
statusReg = readWord_N64();
|
||
// Blink led
|
||
blinkLED();
|
||
delay(500);
|
||
}
|
||
}
|
||
|
||
// Common sector erase command
|
||
void eraseSector_N64(unsigned long sectorSize) {
|
||
unsigned long flashBase = romBase;
|
||
|
||
print_Msg(F("Sector erase..."));
|
||
display_Update();
|
||
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += sectorSize) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
// Spansion S29GL256N(32MB/64MB) with two flashrom chips
|
||
if ((currSector == 0x2000000) && (strcmp(cartID, "2201") == 0) && (flashid == 0x227E)) {
|
||
// Change to second chip
|
||
flashBase = romBase + 0x2000000;
|
||
}
|
||
// Macronix MX29LV640(8MB/16MB) with two flashrom chips
|
||
else if ((currSector == 0x800000) && ((flashid == 0x22C9) || (flashid == 0x22CB))) {
|
||
flashBase = romBase + 0x800000;
|
||
}
|
||
|
||
// Send Erase Command
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0x80);
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
setAddress_N64(romBase + currSector);
|
||
writeWord_N64(0x30);
|
||
|
||
// Read the status register
|
||
setAddress_N64(romBase + currSector);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(romBase + currSector);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
|
||
boolean blankcheckFlashrom_N64() {
|
||
for (unsigned long currByte = romBase; currByte < romBase + fileSize; currByte += 512) {
|
||
// Blink led
|
||
if (currByte % 131072 == 0)
|
||
blinkLED();
|
||
|
||
// Set the address
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < 512; c += 2) {
|
||
if (readWord_N64() != 0xFFFF) {
|
||
return 0;
|
||
}
|
||
}
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
// Write Intel flashrom
|
||
void writeIntel4400_N64() {
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += 131072) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
// Write to flashrom
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < 131072; currSdBuffer += 512) {
|
||
// Fill SD buffer
|
||
myFile.read(sdBuffer, 512);
|
||
|
||
// Write 32 words at a time
|
||
for (int currWriteBuffer = 0; currWriteBuffer < 512; currWriteBuffer += 64) {
|
||
// Buffered program command
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
writeWord_N64(0xE8);
|
||
|
||
// Check Status register
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
statusReg = readWord_N64();
|
||
}
|
||
|
||
// Write word count (minus 1)
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
writeWord_N64(0x1F);
|
||
|
||
// Write buffer
|
||
for (byte currByte = 0; currByte < 64; currByte += 2) {
|
||
// Join two bytes into one word
|
||
word currWord = ((sdBuffer[currWriteBuffer + currByte] & 0xFF) << 8) | (sdBuffer[currWriteBuffer + currByte + 1] & 0xFF);
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + currByte);
|
||
writeWord_N64(currWord);
|
||
}
|
||
|
||
// Write Buffer to Flash
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + 62);
|
||
writeWord_N64(0xD0);
|
||
|
||
// Read the status register at last written address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + 62);
|
||
statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != 0xFFFF) {
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + 62);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Write Fujitsu MSP55LV100S flashrom consisting out of two MSP55LV512 flashroms one used for the high byte the other for the low byte
|
||
void writeMSP55LV100_N64(unsigned long sectorSize) {
|
||
unsigned long flashBase = romBase;
|
||
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += sectorSize) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
// Write to flashrom
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < sectorSize; currSdBuffer += 512) {
|
||
// Fill SD buffer
|
||
myFile.read(sdBuffer, 512);
|
||
|
||
// Write 32 bytes at a time
|
||
for (int currWriteBuffer = 0; currWriteBuffer < 512; currWriteBuffer += 32) {
|
||
|
||
// 2 unlock commands
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x5555);
|
||
|
||
// Write buffer load command at sector address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
writeWord_N64(0x2525);
|
||
// Write word count (minus 1) at sector address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
writeWord_N64(0x0F0F);
|
||
|
||
// Define variable before loop so we can use it later when reading the status register
|
||
word currWord;
|
||
|
||
for (byte currByte = 0; currByte < 32; currByte += 2) {
|
||
// Join two bytes into one word
|
||
currWord = ((sdBuffer[currWriteBuffer + currByte] & 0xFF) << 8) | (sdBuffer[currWriteBuffer + currByte + 1] & 0xFF);
|
||
|
||
// Load Buffer Words
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + currByte);
|
||
writeWord_N64(currWord);
|
||
}
|
||
|
||
// Write Buffer to Flash
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + 30);
|
||
writeWord_N64(0x2929);
|
||
|
||
// Read the status register at last written address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + 30);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0x7F7F) != (currWord | 0x7F7F)) {
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + 30);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Write Spansion S29GL256N flashrom using the 32 byte write buffer
|
||
void writeFlashBuffer_N64(unsigned long sectorSize, byte bufferSize) {
|
||
unsigned long flashBase = romBase;
|
||
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += sectorSize) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
// Spansion S29GL256N(32MB/64MB) with two flashrom chips
|
||
if ((currSector == 0x2000000) && (strcmp(cartID, "2201") == 0)) {
|
||
flashBase = romBase + 0x2000000;
|
||
}
|
||
|
||
// Write to flashrom
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < sectorSize; currSdBuffer += 512) {
|
||
// Fill SD buffer
|
||
myFile.read(sdBuffer, 512);
|
||
|
||
// Write 32 bytes at a time
|
||
for (int currWriteBuffer = 0; currWriteBuffer < 512; currWriteBuffer += bufferSize) {
|
||
|
||
// 2 unlock commands
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
|
||
// Write buffer load command at sector address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
writeWord_N64(0x25);
|
||
// Write word count (minus 1) at sector address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer);
|
||
writeWord_N64((bufferSize / 2) - 1);
|
||
|
||
// Define variable before loop so we can use it later when reading the status register
|
||
word currWord = 0;
|
||
|
||
for (byte currByte = 0; currByte < bufferSize; currByte += 2) {
|
||
// Join two bytes into one word
|
||
currWord = ((sdBuffer[currWriteBuffer + currByte] & 0xFF) << 8) | (sdBuffer[currWriteBuffer + currByte + 1] & 0xFF);
|
||
|
||
// Load Buffer Words
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + currByte);
|
||
writeWord_N64(currWord);
|
||
}
|
||
|
||
// Write Buffer to Flash
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + bufferSize - 2);
|
||
writeWord_N64(0x29);
|
||
|
||
// Read the status register at last written address
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + bufferSize - 2);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != (currWord | 0xFF7F)) {
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currWriteBuffer + bufferSize - 2);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Write MX29LV640 flashrom without write buffer
|
||
void writeFlashrom_N64(unsigned long sectorSize) {
|
||
unsigned long flashBase = romBase;
|
||
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += sectorSize) {
|
||
// Blink led
|
||
blinkLED();
|
||
|
||
// Macronix MX29LV640(8MB/16MB) with two flashrom chips
|
||
if (currSector == 0x800000) {
|
||
flashBase = romBase + 0x800000;
|
||
}
|
||
|
||
// Write to flashrom
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < sectorSize; 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] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
// 2 unlock commands
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xAA);
|
||
setAddress_N64(flashBase + (0x2AA << 1));
|
||
writeWord_N64(0x55);
|
||
// Program command
|
||
setAddress_N64(flashBase + (0x555 << 1));
|
||
writeWord_N64(0xA0);
|
||
// Write word
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currByte);
|
||
writeWord_N64(currWord);
|
||
|
||
// Read the status register
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currByte);
|
||
word statusReg = readWord_N64();
|
||
while ((statusReg | 0xFF7F) != (currWord | 0xFF7F)) {
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currByte);
|
||
statusReg = readWord_N64();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
unsigned long verifyFlashrom_N64() {
|
||
// 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] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
// Read flash
|
||
setAddress_N64(romBase + currSector + currSdBuffer + currByte);
|
||
// Compare both
|
||
if (readWord_N64() != currWord) {
|
||
writeErrors++;
|
||
// Abord if too many errors
|
||
if (writeErrors > 20) {
|
||
print_Msg(F("More than "));
|
||
// Close the file:
|
||
myFile.close();
|
||
return writeErrors;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
return writeErrors;
|
||
} else {
|
||
print_STR(open_file_STR, 1);
|
||
display_Update();
|
||
return 9999;
|
||
}
|
||
}
|
||
|
||
/******************************************
|
||
N64 Gameshark Flash Functions
|
||
*****************************************/
|
||
void flashGameshark_N64() {
|
||
// Check flashrom ID's
|
||
unlockGSAddressRanges();
|
||
idGameshark_N64();
|
||
|
||
// Check for SST 29LE010 (0808)/SST 28LF040 (0404)/AMTEL AT29LV010A (3535)/SST 29EE010 (0707)
|
||
// !!!! This has been confirmed to allow reading of v1.02, v1.04-v1.09, v2.0-2.21, v3.0-3.3 !!!!
|
||
// !!!! All referenced eeproms/flashroms are confirmed as being writable with this process. !!!!
|
||
// !!!! !!!!
|
||
// !!!! PROCEED AT YOUR OWN RISK !!!!
|
||
// !!!! !!!!
|
||
// !!!! SST 29EE010 may have a 5V requirement for writing however dumping works at 3V. As such it is not !!!!
|
||
// !!!! advised to write to a cart with this chip until further testing can be completed. !!!!
|
||
|
||
if (flashid == 0x0808 || flashid == 0x0404 || flashid == 0x3535 || flashid == 0x0707) {
|
||
backupGameshark_N64();
|
||
println_Msg("");
|
||
println_Msg(F("This will erase your"));
|
||
println_Msg(F("Gameshark cartridge"));
|
||
println_Msg(F("Attention: Use 3.3V!"));
|
||
println_Msg(F("Power OFF if Unsure!"));
|
||
// 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 z64 file"));
|
||
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();
|
||
display_Clear();
|
||
print_Msg(F("File size: "));
|
||
print_Msg(fileSize / 1024);
|
||
println_Msg(F(" KB"));
|
||
display_Update();
|
||
|
||
// Compare file size to flashrom size for 1 Mbit eeproms
|
||
if (fileSize > 262144 && (flashid == 0x0808 || flashid == 0x3535 || flashid == 0x0707)) {
|
||
print_FatalError(file_too_big_STR);
|
||
}
|
||
|
||
// Compare file size to flashrom size for 1 Mbit eeproms
|
||
if (fileSize > 1048576 && flashid == 0x0404) {
|
||
print_FatalError(file_too_big_STR);
|
||
}
|
||
|
||
// SST 29LE010, chip erase not needed as this eeprom automaticly erases during the write cycle
|
||
eraseGameshark_N64();
|
||
blankCheck_N64();
|
||
|
||
// Write flashrom
|
||
print_Msg(F("Writing "));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
writeGameshark_N64();
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
|
||
// Verify
|
||
print_STR(verifying_STR, 0);
|
||
display_Update();
|
||
writeErrors = verifyGameshark_N64();
|
||
|
||
if (writeErrors == 0) {
|
||
display_Clear();
|
||
display_Update();
|
||
println_Msg(F("Verfied OK"));
|
||
println_Msg(FS(FSTRING_EMPTY));
|
||
println_Msg(F("Turn Cart Reader off now"));
|
||
display_Update();
|
||
while (1)
|
||
;
|
||
} else {
|
||
display_Clear();
|
||
display_Update();
|
||
println_Msg(F("Verification Failed"));
|
||
println_Msg(writeErrors);
|
||
print_Msg(F(" bytes "));
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
} else {
|
||
print_Error(F("Can't open file"));
|
||
}
|
||
}
|
||
|
||
// 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 unlockGSAddressRanges() {
|
||
// This enables using the 0x1EEx_xxxx, 0x1EFx_xxxx, and 0x1ECx_xxxx address ranges, necessary for writing to all supported chips
|
||
setAddress_N64(0x10400400);
|
||
writeWord_N64(0x1E);
|
||
writeWord_N64(0x1E);
|
||
}
|
||
|
||
//Test for SST 29LE010 or SST 28LF040 (0404) or AMTEL AT29LV010A (3535) or SST 29EE010 (0707)
|
||
void idGameshark_N64() {
|
||
flashid = 0x0;
|
||
//Send flashrom ID command
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0x9090);
|
||
|
||
setAddress_N64(0x1EC00000);
|
||
// Read 1 byte vendor ID
|
||
readWord_N64();
|
||
// Read 2 bytes flashrom ID
|
||
flashid = readWord_N64();
|
||
|
||
if (flashid == 0x0808 || flashid == 0x3535 || flashid == 0x0707) {
|
||
flashSize = 262144;
|
||
} else if (flashid == 0x0404) {
|
||
//Set SST 28LF040 flashrom size
|
||
flashSize = 1048574;
|
||
} else {
|
||
println_Msg(F("Check cart connection"));
|
||
println_Msg(F("Unknown Flash ID"));
|
||
sprintf(flashid_str, "%04X", flashid);
|
||
print_STR(press_button_STR, 1);
|
||
display_Update();
|
||
wait();
|
||
mainMenu();
|
||
}
|
||
sprintf(flashid_str, "%04X", flashid);
|
||
// Reset flashrom
|
||
resetGameshark_N64();
|
||
}
|
||
|
||
void resetGameshark_N64() {
|
||
if (flashid == 0x0808 || flashid == 0x3535 || flashid == 0x0707) {
|
||
// Send reset command for SST 29LE010 / AMTEL AT29LV010A / SST 29EE010
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xF0F0);
|
||
delay(100);
|
||
} else if (flashid == 0x0404) {
|
||
// Send reset command for SST 28LF040
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xFFFF);
|
||
delay(300);
|
||
}
|
||
}
|
||
|
||
// Read rom and save to the SD card
|
||
void backupGameshark_N64() {
|
||
// create a new folder
|
||
EEPROM_readAnything(0, foldern);
|
||
sprintf(fileName, "GS%d", foldern);
|
||
strcat(fileName, ".z64");
|
||
sd.mkdir("N64/ROM/Gameshark", true);
|
||
sd.chdir("N64/ROM/Gameshark");
|
||
|
||
display_Clear();
|
||
print_Msg(F("Saving "));
|
||
print_Msg(fileName);
|
||
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 currByte = romBase + 0xEC00000; currByte < (romBase + 0xEC00000 + flashSize); currByte += 512) {
|
||
// Blink led
|
||
if (currByte % 16384 == 0)
|
||
blinkLED();
|
||
|
||
// Set the address for the next 512 bytes
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < 512; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
myFile.write(sdBuffer, 512);
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
}
|
||
|
||
void eraseGameshark_N64() {
|
||
println_Msg(F("Erasing..."));
|
||
display_Update();
|
||
|
||
// Send chip erase to SST 29LE010 / AMTEL AT29LV010A / SST 29EE010
|
||
if (flashid == 0x0808 || flashid == 0x3535 || flashid == 0x0707) {
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0x8080);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0x1010);
|
||
|
||
delay(20);
|
||
}
|
||
|
||
if (flashid == 0x0404) {
|
||
//Unprotect flash
|
||
setAddress_N64(0x1EF03044);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE03040);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE03044);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE00830);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EF00834);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EF00830);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE00834);
|
||
readWord_N64();
|
||
delay(1000);
|
||
|
||
//Erase flash
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0x3030);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0x3030);
|
||
delay(1000);
|
||
}
|
||
}
|
||
|
||
void blankCheck_N64() {
|
||
// Blankcheck
|
||
println_Msg(F("Blankcheck..."));
|
||
display_Update();
|
||
|
||
for (unsigned long currSector = 0; currSector < flashSize; currSector += 131072) {
|
||
// Blink led
|
||
blinkLED();
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < 131072; currSdBuffer += 512) {
|
||
for (int currByte = 0; currByte < 512; currByte += 2) {
|
||
// Read flash
|
||
setAddress_N64(romBase + 0xEC00000 + currSector + currSdBuffer + currByte);
|
||
// Compare both
|
||
if (readWord_N64() != 0xFFFF) {
|
||
println_Msg(F("Not empty"));
|
||
print_FatalError(F("Erase failed"));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void writeGameshark_N64() {
|
||
// Write Gameshark with 2x SST 29LE010 / AMTEL AT29LV010A / SST 29EE010 Eeproms
|
||
if (flashid == 0x0808 || flashid == 0x3535 || flashid == 0x0707) {
|
||
// Each 29LE010 has 1024 pages, each 128 bytes in size
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(fileSize);
|
||
draw_progressbar(0, totalProgressBar);
|
||
myFile.seek(0);
|
||
for (unsigned long currPage = 0; currPage < fileSize / 2; currPage += 128) {
|
||
// Fill SD buffer with twice the amount since we flash 2 chips
|
||
myFile.read(sdBuffer, 256);
|
||
|
||
//Send page write command to both flashroms
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xA0A0);
|
||
|
||
// Write 1 page each, one flashrom gets the low byte, the other the high byte.
|
||
for (unsigned long currByte = 0; currByte < 256; currByte += 2) {
|
||
// Set address
|
||
setAddress_N64(romBase + 0xEC00000 + (currPage * 2) + currByte);
|
||
// Join two bytes into one word
|
||
word currWord = ((sdBuffer[currByte] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
// Send byte data
|
||
writeWord_N64(currWord);
|
||
}
|
||
processedProgressBar += 256;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
blinkLED();
|
||
delay(30);
|
||
}
|
||
}
|
||
|
||
if (flashid == 0x0404) {
|
||
// Write Gameshark with 2x SST 28LF040
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(fileSize);
|
||
draw_progressbar(0, totalProgressBar);
|
||
myFile.seek(0);
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += 16384) {
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < 16384; currSdBuffer += 256) {
|
||
// Fill SD buffer
|
||
myFile.read(sdBuffer, 256);
|
||
for (unsigned long currByte = 0; currByte < 256; currByte += 2) {
|
||
|
||
// Send byte program command
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0xAAAA);
|
||
setAddress_N64(0x1EE05554);
|
||
writeWord_N64(0x5555);
|
||
setAddress_N64(0x1EF0AAA8);
|
||
writeWord_N64(0x1010);
|
||
|
||
// Set address
|
||
setAddress_N64(romBase + 0xEC00000 + currSector + currSdBuffer + currByte);
|
||
|
||
// Join two bytes into one word
|
||
word currWord = ((sdBuffer[currByte] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
|
||
// Send byte data
|
||
writeWord_N64(currWord);
|
||
delayMicroseconds(60);
|
||
}
|
||
processedProgressBar += 256;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
blinkLED();
|
||
}
|
||
}
|
||
|
||
//Protect flash
|
||
setAddress_N64(0x1EF03044);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE03040);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE03044);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE00830);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EF00834);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EF00830);
|
||
readWord_N64();
|
||
setAddress_N64(0x1EE00814);
|
||
readWord_N64();
|
||
delay(1000);
|
||
}
|
||
}
|
||
|
||
unsigned long verifyGameshark_N64() {
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(fileSize);
|
||
println_Msg(FS(FSTRING_EMPTY));
|
||
draw_progressbar(0, totalProgressBar);
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
writeErrors = 0;
|
||
|
||
for (unsigned long currSector = 0; currSector < fileSize; currSector += 131072) {
|
||
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] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
// Read flash
|
||
setAddress_N64(romBase + 0xEC00000 + currSector + currSdBuffer + currByte);
|
||
// Compare both
|
||
if (readWord_N64() != currWord) {
|
||
writeErrors++;
|
||
}
|
||
}
|
||
processedProgressBar += 512;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
blinkLED();
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
return writeErrors;
|
||
} else {
|
||
print_STR(open_file_STR, 1);
|
||
display_Update();
|
||
return 9999;
|
||
}
|
||
}
|
||
|
||
/******************************************
|
||
XPLORER 64 Functions
|
||
*****************************************/
|
||
void flashXplorer_N64() {
|
||
// Check flashrom ID's
|
||
idXplorer_N64();
|
||
|
||
if (flashid == 0x0808) {
|
||
backupXplorer_N64();
|
||
println_Msg("");
|
||
println_Msg(F("This will erase your"));
|
||
println_Msg(F("Xplorer64 cartridge"));
|
||
println_Msg(F("Attention: Use 3.3V!"));
|
||
println_Msg(F("Power OFF if Unsure!"));
|
||
// 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 XP64 rom file"));
|
||
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();
|
||
display_Clear();
|
||
print_Msg(F("File size: "));
|
||
print_Msg(fileSize / 1024);
|
||
println_Msg(F(" KB"));
|
||
display_Update();
|
||
|
||
// Compare file size to flashrom size
|
||
if (fileSize > 262144) {
|
||
print_FatalError(file_too_big_STR);
|
||
}
|
||
|
||
// SST 29LE010, chip erase not needed as this eeprom automaticly erases during the write cycle
|
||
eraseXplorer_N64();
|
||
blankCheck_XP64();
|
||
|
||
// Write flashrom
|
||
display_Clear();
|
||
print_Msg(F("Writing "));
|
||
println_Msg(filePath);
|
||
display_Update();
|
||
writeXplorer_N64();
|
||
|
||
// Close the file:
|
||
myFile.close();
|
||
|
||
// Verify
|
||
print_STR(verifying_STR, 0);
|
||
display_Update();
|
||
writeErrors = verifyXplorer_N64();
|
||
|
||
if (writeErrors == 0) {
|
||
display_Clear();
|
||
display_Update();
|
||
println_Msg(F("Verfied OK"));
|
||
println_Msg(FS(FSTRING_EMPTY));
|
||
println_Msg(F("Turn Cart Reader off now"));
|
||
display_Update();
|
||
while (1);
|
||
} else {
|
||
display_Clear();
|
||
display_Update();
|
||
println_Msg(F("Verification Failed"));
|
||
println_Msg(writeErrors);
|
||
print_Msg(F(" bytes "));
|
||
print_Error(did_not_verify_STR);
|
||
}
|
||
} else {
|
||
print_Error(F("Can't open file"));
|
||
}
|
||
}
|
||
|
||
// 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();
|
||
}
|
||
|
||
//Test for SST 29LE010
|
||
void idXplorer_N64() {
|
||
flashid = 0x0;
|
||
//Send flashrom ID command
|
||
oddXPaddrWrite(0x1040AAAA, 0xAAAA);
|
||
evenXPaddrWrite(0x10405555, 0x5555);
|
||
oddXPaddrWrite(0x1040AAAA, 0x9090);
|
||
|
||
setAddress_N64(0x10760000);
|
||
readWord_N64();
|
||
setAddress_N64(0x10400D88);
|
||
flashid = readWord_N64();
|
||
setAddress_N64(0x10740000);
|
||
readWord_N64();
|
||
|
||
if (flashid != 0x0808) {
|
||
println_Msg(F("Check cart connection"));
|
||
println_Msg(F("Unknown Flash ID"));
|
||
sprintf(flashid_str, "%04X", flashid);
|
||
print_STR(press_button_STR, 1);
|
||
display_Update();
|
||
wait();
|
||
mainMenu();
|
||
}
|
||
sprintf(flashid_str, "%04X", flashid);
|
||
// Reset flashrom
|
||
resetXplorer_N64();
|
||
}
|
||
|
||
void resetXplorer_N64() {
|
||
// Send reset command for SST 29LE010
|
||
oddXPaddrWrite(0x1040AAAA, 0xAAAA);
|
||
evenXPaddrWrite(0x10405555, 0x5555);
|
||
oddXPaddrWrite(0x1040AAAA, 0xF0F0);
|
||
delay(100);
|
||
}
|
||
|
||
// Read rom and save to the SD card
|
||
void backupXplorer_N64() {
|
||
// create a new folder
|
||
EEPROM_readAnything(0, foldern);
|
||
sprintf(fileName, "XP64-%d", foldern);
|
||
strcat(fileName, ".z64");
|
||
sd.mkdir("N64/ROM/XPLORER64", true);
|
||
sd.chdir("N64/ROM/XPLORER64");
|
||
|
||
display_Clear();
|
||
print_Msg(F("Saving "));
|
||
print_Msg(fileName);
|
||
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 currByte = 0x10400000; currByte <= 0x1043FFFF; currByte += 512) {
|
||
// Blink led
|
||
if (currByte % 16384 == 0)
|
||
blinkLED();
|
||
|
||
// Set the address for the next 512 bytes
|
||
setAddress_N64(currByte);
|
||
|
||
for (int c = 0; c < 512; c += 2) {
|
||
// split word
|
||
word myWord = readWord_N64();
|
||
byte loByte = myWord & 0xFF;
|
||
byte hiByte = myWord >> 8;
|
||
|
||
// write to buffer
|
||
sdBuffer[c] = hiByte;
|
||
sdBuffer[c + 1] = loByte;
|
||
}
|
||
myFile.write(sdBuffer, 512);
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
println_Msg(F("Done."));
|
||
}
|
||
|
||
unsigned long unscramble(unsigned long addr) {
|
||
unsigned long result = (((addr >> 4) & 0x001) | ((addr >> 8) & 0x002) |
|
||
((~addr >> 9) & 0x004) | ((addr >> 3) & 0x008) |
|
||
((addr >> 6) & 0x010) | ((addr >> 2) & 0x020) |
|
||
((~addr << 5) & 0x0C0) | ((~addr << 8) & 0x100) |
|
||
((~addr << 6) & 0x200) | ((~addr << 2) & 0x400) |
|
||
((addr << 6) & 0x800) | (addr & 0x1F000));
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
unsigned long scramble(unsigned long addr) {
|
||
unsigned long result = (((~addr >> 8) & 0x001) | ((~addr >> 5) & 0x006) |
|
||
((~addr >> 6) & 0x008) | ((addr << 4) & 0x010) |
|
||
((addr >> 6) & 0x020) | ((addr << 3) & 0x040) |
|
||
((addr << 2) & 0x080) | ((~addr >> 2) & 0x100) |
|
||
((addr << 8) & 0x200) | ((addr << 6) & 0x400) |
|
||
((~addr << 9) & 0x800) | (addr & 0x1F000));
|
||
|
||
return result;
|
||
}
|
||
|
||
|
||
void oddXPaddrWrite(unsigned long addr, word data) {
|
||
unsigned long oddAddr = (0x10400000 + ((unscramble((addr & 0xFFFFF) / 2) - 1) * 2));
|
||
setAddress_N64(0x10770000);
|
||
readWord_N64();
|
||
readWord_N64();
|
||
setAddress_N64(oddAddr);
|
||
writeWord_N64(data);
|
||
writeWord_N64(data);
|
||
setAddress_N64(0x10740000);
|
||
readWord_N64();
|
||
readWord_N64();
|
||
|
||
}
|
||
|
||
void evenXPaddrWrite(unsigned long addr, word data) {
|
||
unsigned long evenAddr = (0x10400000 + (unscramble((addr & 0xFFFFF) / 2) * 2));
|
||
setAddress_N64(0x10760000);
|
||
readWord_N64();
|
||
readWord_N64();
|
||
setAddress_N64(evenAddr);
|
||
writeWord_N64(data);
|
||
writeWord_N64(data);
|
||
setAddress_N64(0x10740000);
|
||
readWord_N64();
|
||
readWord_N64();
|
||
}
|
||
|
||
void eraseXplorer_N64() {
|
||
println_Msg(F("Erasing..."));
|
||
display_Update();
|
||
|
||
// Send chip erase to SST 29LE010
|
||
oddXPaddrWrite(0x1040AAAA, 0xAAAA);
|
||
evenXPaddrWrite(0x10405555, 0x5555);
|
||
oddXPaddrWrite(0x1040AAAA, 0x8080);
|
||
oddXPaddrWrite(0x1040AAAA, 0xAAAA);
|
||
evenXPaddrWrite(0x10405555, 0x5555);
|
||
oddXPaddrWrite(0x1040AAAA,0x1010);
|
||
|
||
delay(20);
|
||
}
|
||
|
||
void blankCheck_XP64() {
|
||
// Blankcheck
|
||
println_Msg(F("Blankcheck..."));
|
||
display_Update();
|
||
|
||
for (unsigned long currSector = 0; currSector < 262144; currSector += 131072) {
|
||
// Blink led
|
||
blinkLED();
|
||
for (unsigned long currSdBuffer = 0; currSdBuffer < 131072; currSdBuffer += 512) {
|
||
for (int currByte = 0; currByte < 512; currByte += 2) {
|
||
// Read flash
|
||
setAddress_N64(0x10400000 + currSector + currSdBuffer + currByte);
|
||
// Compare both
|
||
if (readWord_N64() != 0xFFFF) {
|
||
println_Msg(F("Not empty"));
|
||
print_FatalError(F("Erase failed"));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void writeXplorer_N64() {
|
||
// Write Xplorer64 with 2x SST 29LE010
|
||
// Each 29LE010 has 1024 pages, each 128 bytes in size
|
||
//Initialize progress bar
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(fileSize);
|
||
draw_progressbar(0, totalProgressBar);
|
||
for (unsigned long currPage = 0; currPage < fileSize / 2; currPage += 128) {
|
||
|
||
// Fill SD buffer with data in the order it will be expected by the CPLD
|
||
for (unsigned long i = 0; i < 256; i += 2) {
|
||
unsigned long unscrambled_address = (unscramble(((currPage*2) + i) / 2) * 2);
|
||
myFile.seek(unscrambled_address);
|
||
myFile.read(&sdBuffer[i], 1);
|
||
myFile.seek(unscrambled_address + 1);
|
||
myFile.read(&sdBuffer[i + 1], 1);
|
||
}
|
||
|
||
//Send page write command to both flashroms
|
||
oddXPaddrWrite(0x1040AAAA, 0xAAAA);
|
||
evenXPaddrWrite(0x10405555, 0x5555);
|
||
oddXPaddrWrite(0x1040AAAA, 0xA0A0);
|
||
|
||
// Write 1 page each, one flashrom gets the low byte, the other the high byte.
|
||
for (unsigned long currByte = 0; currByte < 256; currByte += 2) {
|
||
// Join two bytes into one word
|
||
word currWord = ((sdBuffer[currByte] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
// Set address
|
||
if ((((currByte/2) >> 4) & 0x1) == 0) {
|
||
evenXPaddrWrite(0x10400000 + (currPage*2) + currByte, currWord);
|
||
} else {
|
||
oddXPaddrWrite(0x10400000 + (currPage*2) + currByte, currWord);
|
||
}
|
||
}
|
||
processedProgressBar += 256;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
blinkLED();
|
||
}
|
||
}
|
||
|
||
unsigned long verifyXplorer_N64() {
|
||
uint32_t processedProgressBar = 0;
|
||
uint32_t totalProgressBar = (uint32_t)(262144);
|
||
println_Msg(FS(FSTRING_EMPTY));
|
||
draw_progressbar(0, totalProgressBar);
|
||
// Open file on sd card
|
||
if (myFile.open(filePath, O_READ)) {
|
||
myFile.seek(0);
|
||
writeErrors = 0;
|
||
|
||
for (unsigned long currSector = 0; currSector < 262144; currSector += 131072) {
|
||
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] & 0xFF) << 8) | (sdBuffer[currByte + 1] & 0xFF);
|
||
// Read flash
|
||
setAddress_N64(romBase + 0x400000 + currSector + currSdBuffer + currByte);
|
||
// Compare both
|
||
if (readWord_N64() != currWord) {
|
||
writeErrors++;
|
||
}
|
||
}
|
||
processedProgressBar += 512;
|
||
draw_progressbar(processedProgressBar, totalProgressBar);
|
||
blinkLED();
|
||
}
|
||
}
|
||
// Close the file:
|
||
myFile.close();
|
||
return writeErrors;
|
||
} else {
|
||
print_STR(open_file_STR, 1);
|
||
display_Update();
|
||
return 9999;
|
||
}
|
||
}
|
||
|
||
#endif
|
||
|
||
//******************************************
|
||
// End of File
|
||
//******************************************
|