cartreader/Cart_Reader/NGP.ino

379 lines
9.3 KiB
Arduino
Raw Normal View History

//******************************************
// NGP MODULE
//******************************************
#ifdef enable_NGP
static const char ngpMenuItem1[] PROGMEM = "Read Rom";
static const char ngpMenuItem2[] PROGMEM = "Read chip info";
//static const char ngpMenuItemReset[] PROGMEM = "Reset"; (stored in common strings array)
static const char* const menuOptionsNGP[] PROGMEM = { ngpMenuItem1, ngpMenuItem2, string_reset2 };
2021-08-19 17:38:16 +02:00
static const char ngpRomItem1[] PROGMEM = "4 Mbits / 512 KB";
static const char ngpRomItem2[] PROGMEM = "8 Mbits / 1 MB";
static const char ngpRomItem3[] PROGMEM = "16 Mbits / 2 MB";
static const char ngpRomItem4[] PROGMEM = "32 Mbits / 4 MB";
static const char* const ngpRomOptions[] PROGMEM = { ngpRomItem1, ngpRomItem2, ngpRomItem3, ngpRomItem4 };
char ngpRomVersion[3];
uint8_t ngpSystemType;
uint8_t manufacturerID;
uint8_t deviceID;
void setup_NGP() {
// A0 - A7
DDRF = 0xff;
// A8 - A15
DDRK = 0xff;
// A16 - A20
DDRL = 0xff;
// D0 - D7
DDRC = 0x00;
// controls
// /CE0: PH3
// /CE1: PH0
// /OE: PH6
// /WE: PH5
// PWR: PH4
DDRH |= ((1 << 0) | (1 << 3) | (1 << 5) | (1 << 6));
DDRH &= ~(1 << 4);
PORTH |= ((1 << 0) | (1 << 3) | (1 << 4) | (1 << 5) | (1 << 6));
2021-08-19 21:09:19 +02:00
println_Msg(F("Initializing..."));
display_Update();
2021-10-14 09:53:07 +02:00
if (getCartInfo_NGP())
printCartInfo_NGP();
2021-08-19 21:09:19 +02:00
else
print_Error(F("Cartridge read error"), true);
}
void ngpMenu() {
uint8_t mainMenu;
convertPgm(menuOptionsNGP, 3);
mainMenu = question_box(F("NGP Menu"), menuOptions, 3, 0);
switch (mainMenu) {
case 0:
sd.chdir("/");
readROM_NGP(filePath, FILEPATH_LENGTH);
sd.chdir("/");
break;
case 1:
scanChip_NGP();
break;
case 2:
resetArduino();
break;
}
println_Msg(F(""));
// Prints string out of the common strings array either with or without newline
print_STR(press_button_STR, 1);
display_Update();
wait();
}
bool getCartInfo_NGP() {
uint8_t* tmp;
// enter autoselect mode
dataOut();
writeByte_NGP(0x555, 0xaa);
writeByte_NGP(0x2aa, 0x55);
writeByte_NGP(0x555, 0x90);
dataIn();
cartSize = 0;
2021-10-14 09:53:07 +02:00
// get chip manufacturer and device IDs
manufacturerID = readByte_NGP(0);
deviceID = readByte_NGP(1);
tmp = (uint8_t*)&romSize;
*(tmp + 0) = deviceID;
*(tmp + 1) = manufacturerID;
switch (romSize) {
case 0xffff: return false; break; // detection error (no cart inserted or hw problem)
case 0x98ab: cartSize = 524288; break; // 4 Mbits - Toshiba
case 0x204c: cartSize = 524288; break; // 4 Mbits - STMicroelectronics ?
case 0x982c: cartSize = 1048576; break; // 8 Mbits - Toshiba
case 0xec2c: cartSize = 1048576; break; // 8 Mbits - Samsung
case 0x982f: cartSize = 2097152; break; // 16 Mbits - Toshiba
case 0xec2f: cartSize = 2097152; break; // 16 Mbits - Samsung
}
// reset to read mode
dataOut();
writeByte_NGP(0x0, 0xf0);
// confirm NGP cart recognition
2021-08-19 17:38:16 +02:00
dataIn();
for (uint32_t addr = 0; addr < 28; addr++)
sdBuffer[addr] = readByte_NGP(addr);
if (memcmp_P(sdBuffer, PSTR("COPYRIGHT BY SNK CORPORATION"), 28) != 0 && memcmp_P(sdBuffer, PSTR(" LICENSED BY SNK CORPORATION"), 28) != 0)
return false;
// get app ID
snprintf(cartID, 5, "%02X%02X", readByte_NGP(0x21), readByte_NGP(0x20));
2021-10-14 09:53:07 +02:00
2021-08-19 17:38:16 +02:00
// force rom size to 32 Mbits for few titles
if (strcmp(cartID, "0060") == 0 || strcmp(cartID, "0061") == 0 || strcmp(cartID, "0069") == 0)
cartSize = 4194304;
2021-10-14 09:53:07 +02:00
// get app version
snprintf(ngpRomVersion, 3, "%02X", readByte_NGP(0x22));
2021-10-14 09:53:07 +02:00
// get app system compatibility
ngpSystemType = readByte_NGP(0x23);
// get app name
for (uint32_t i = 0; i < 17; i++)
romName[i] = readByte_NGP(0x24 + i);
return true;
}
void printCartInfo_NGP() {
display_Clear();
println_Msg(F("NGP Cart Info"));
print_Msg(F("Name: "));
println_Msg(romName);
print_Msg(F("App ID: "));
println_Msg(cartID);
print_Msg(F("App version: "));
println_Msg(ngpRomVersion);
print_Msg(F("System: "));
if (ngpSystemType == 0x0)
2021-08-01 23:33:59 +02:00
println_Msg(F("NGPMonochrome"));
else if (ngpSystemType == 0x10)
2021-08-01 23:33:59 +02:00
println_Msg(F("NGPColor"));
else
2021-08-01 23:33:59 +02:00
println_Msg(F("Unknown"));
print_Msg(F("ROM Size: "));
if (cartSize == 0) {
println_Msg(F("Unknown"));
} else {
print_Msg((cartSize >> 17));
println_Msg(F(" Mbits"));
}
2021-08-01 23:33:59 +02:00
// Prints string out of the common strings array either with or without newline
print_STR(press_button_STR, 1);
display_Update();
wait();
}
void readROM_NGP(char* outPathBuf, size_t bufferSize) {
// Set cartsize manually if chip ID is unknown
if (cartSize == 0) {
unsigned char ngpRomMenu;
2021-10-14 09:53:07 +02:00
// Copy menuOptions out of progmem
convertPgm(ngpRomOptions, 4);
ngpRomMenu = question_box(F("Select ROM size"), menuOptions, 4, 0);
// wait for user choice to come back from the question box menu
switch (ngpRomMenu) {
case 0: cartSize = 524288; break;
case 1: cartSize = 1048576; break;
case 2: cartSize = 2097152; break;
case 3: cartSize = 4194304; break;
}
}
2021-10-14 09:53:07 +02:00
// generate fullname of rom file
snprintf(fileName, FILENAME_LENGTH, "%s.ngp", romName);
// create a new folder for storing rom file
EEPROM_readAnything(0, foldern);
snprintf(folder, sizeof(folder), "NGP/ROM/%s/%d", romName, foldern);
sd.mkdir(folder, true);
sd.chdir(folder);
// filling output file path to buffer
if (outPathBuf != NULL && bufferSize > 0)
snprintf(outPathBuf, bufferSize, "%s/%s", folder, fileName);
display_Clear();
print_STR(saving_to_STR, 0);
print_Msg(folder);
println_Msg(F("/..."));
display_Update();
// open file on sdcard
if (!myFile.open(fileName, O_RDWR | O_CREAT))
print_Error(create_file_STR, true);
// write new folder number back to EEPROM
foldern++;
EEPROM_writeAnything(0, foldern);
// back to read mode
dataOut();
writeByte_NGP(0x0, 0xf0);
// read rom
dataIn();
uint32_t progress = 0;
draw_progressbar(0, cartSize);
for (uint32_t addr = 0; addr < cartSize; addr += 512) {
// blink LED
if ((addr & ((1 << 14) - 1)) == 0)
2021-10-26 17:13:42 +02:00
blinkLED();
// read block
for (uint32_t i = 0; i < 512; i++)
sdBuffer[i] = readByte_NGP(addr + i);
myFile.write(sdBuffer, 512);
progress += 512;
draw_progressbar(progress, cartSize);
}
myFile.close();
}
void scanChip_NGP() {
display_Clear();
// generate name of report file
2021-10-14 09:53:07 +02:00
snprintf(fileName, FILENAME_LENGTH, "%s.txt", romName);
// create a new folder to save report file
EEPROM_readAnything(0, foldern);
snprintf(folder, sizeof(folder), "NGP/ROM/%s/%d", romName, foldern);
sd.mkdir(folder, true);
sd.chdir(folder);
print_Msg(F("Saving chip report to "));
print_Msg(folder);
println_Msg(F("/..."));
display_Update();
// open file on sdcard
if (!myFile.open(fileName, O_RDWR | O_CREAT))
print_Error(create_file_STR, true);
// write new folder number back to EEPROM
foldern++;
EEPROM_writeAnything(0, foldern);
// write software info to report file
myFile.println("Name: " + String(romName));
myFile.println("App ID: " + String(cartID));
myFile.println("App version: " + String(ngpRomVersion));
myFile.println("");
// write chip info to report file
2021-10-14 09:53:07 +02:00
myFile.println("Chip manufacturer ID : 0x" + String(manufacturerID, HEX));
myFile.println("Chip device ID : 0x" + String(deviceID, HEX));
myFile.println("");
2021-10-14 09:53:07 +02:00
if (cartSize == 0)
myFile.println("Cart size unknown");
else {
// enter autoselect mode
dataOut();
writeByte_NGP(0x555, 0xaa);
writeByte_NGP(0x2aa, 0x55);
writeByte_NGP(0x555, 0x90);
dataIn();
uint32_t addrMax;
uint8_t sectorID = 0;
// For 32Mbits carts, skip the 2nd 16Mbits chip
2021-10-14 09:53:07 +02:00
if (cartSize == 4194304) {
myFile.println("Warning: this cart is 32Mbits. Only the first 16Mbits chip will be scanned.");
myFile.println("");
addrMax = 2097152;
} else
addrMax = cartSize;
2021-10-14 09:53:07 +02:00
myFile.println("Sector | Start address | Status");
2021-10-14 09:53:07 +02:00
// browse sectors
2021-10-14 09:53:07 +02:00
for (uint32_t addr = 0; addr < addrMax; addr += 0x1000) {
if ((addr % 0x10000 == 0) || (addr == addrMax - 0x8000) || (addr == addrMax - 0x6000) || (addr == addrMax - 0x4000)) {
2021-10-14 09:53:07 +02:00
myFile.print("#" + String(sectorID) + " | 0x" + String(addr, HEX) + " | ");
// check the protection status
2021-10-14 09:53:07 +02:00
if (readByte_NGP(addr + 0x2) == 0)
myFile.println("unprotected");
else
myFile.println("protected");
2021-10-14 09:53:07 +02:00
sectorID += 1;
}
}
myFile.close();
writeByte_NGP(0x00, 0xf0);
}
}
void writeByte_NGP(uint32_t addr, uint8_t data) {
PORTF = addr & 0xff;
PORTK = (addr >> 8) & 0xff;
PORTL = (addr >> 16) & 0x1f;
PORTC = data;
// which chip to select
// 0x000000 - 0x1fffff -> /CE0
// 0x200000 - 0x3fffff -> /CE1
data = (addr & 0x00200000 ? (1 << 0) : (1 << 3));
PORTH &= ~data;
PORTH &= ~(1 << 5);
NOP;
PORTH |= data;
PORTH |= (1 << 5);
NOP;
NOP;
}
uint8_t readByte_NGP(uint32_t addr) {
uint8_t data;
PORTF = addr & 0xff;
PORTK = (addr >> 8) & 0xff;
PORTL = (addr >> 16) & 0x1f;
// which chip to select
// 0x000000 - 0x1fffff -> /CE0
// 0x200000 - 0x3fffff -> /CE1
data = (addr & 0x00200000 ? (1 << 0) : (1 << 3));
PORTH &= ~data;
PORTH &= ~(1 << 6);
NOP;
NOP;
NOP;
data = PINC;
PORTH |= data;
PORTH |= (1 << 6);
return data;
}
#endif
//******************************************
// End of File
//******************************************