2019-12-08 18:46:51 +00:00
|
|
|
/*
|
2021-03-21 21:32:26 +00:00
|
|
|
Copyright 2016-2021 Arisotura, Raphaël Zumer
|
2019-12-08 18:46:51 +00:00
|
|
|
|
|
|
|
This file is part of melonDS.
|
|
|
|
|
|
|
|
melonDS is free software: you can redistribute it and/or modify it under
|
|
|
|
the terms of the GNU General Public License as published by the Free
|
|
|
|
Software Foundation, either version 3 of the License, or (at your option)
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
|
|
with melonDS. If not, see http://www.gnu.org/licenses/.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include "GBACart.h"
|
|
|
|
#include "CRC32.h"
|
|
|
|
#include "Platform.h"
|
|
|
|
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
namespace GBACart
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
const char SOLAR_SENSOR_GAMECODES[10][5] =
|
|
|
|
{
|
|
|
|
"U3IJ", // Bokura no Taiyou - Taiyou Action RPG (Japan)
|
|
|
|
"U3IE", // Boktai - The Sun Is in Your Hand (USA)
|
|
|
|
"U3IP", // Boktai - The Sun Is in Your Hand (Europe)
|
|
|
|
"U32J", // Zoku Bokura no Taiyou - Taiyou Shounen Django (Japan)
|
|
|
|
"U32E", // Boktai 2 - Solar Boy Django (USA)
|
|
|
|
"U32P", // Boktai 2 - Solar Boy Django (Europe)
|
|
|
|
"U33J", // Shin Bokura no Taiyou - Gyakushuu no Sabata (Japan)
|
|
|
|
"A3IJ" // Boktai - The Sun Is in Your Hand (USA) (Sample)
|
2019-12-09 09:53:45 +00:00
|
|
|
};
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
|
|
|
|
bool CartInserted;
|
|
|
|
u8* CartROM;
|
|
|
|
u32 CartROMSize;
|
|
|
|
u32 CartCRC;
|
|
|
|
u32 CartID;
|
|
|
|
|
|
|
|
CartCommon* Cart;
|
|
|
|
|
2021-05-04 10:58:59 +00:00
|
|
|
u16 OpenBusDecay;
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
|
|
|
|
CartCommon::CartCommon()
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
CartCommon::~CartCommon()
|
|
|
|
{
|
|
|
|
}
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartCommon::DoSavestate(Savestate* file)
|
|
|
|
{
|
|
|
|
file->Section("GBCS");
|
|
|
|
}
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartCommon::LoadSave(const char* path, u32 type)
|
|
|
|
{
|
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartCommon::RelocateSave(const char* path, bool write)
|
|
|
|
{
|
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
int CartCommon::SetInput(int num, bool pressed)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
u16 CartCommon::ROMRead(u32 addr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartCommon::ROMWrite(u32 addr, u16 val)
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
u8 CartCommon::SRAMRead(u32 addr)
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
return 0;
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartCommon::SRAMWrite(u32 addr, u8 val)
|
2019-12-22 20:49:23 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
|
|
|
|
CartGame::CartGame(u8* rom, u32 len) : CartCommon()
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
ROM = rom;
|
|
|
|
ROMLength = len;
|
|
|
|
|
|
|
|
memset(&GPIO, 0, sizeof(GPIO));
|
|
|
|
|
|
|
|
SRAM = nullptr;
|
|
|
|
SRAMFile = nullptr;
|
2019-12-09 09:53:45 +00:00
|
|
|
SRAMLength = 0;
|
|
|
|
SRAMType = S_NULL;
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState = {};
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
CartGame::~CartGame()
|
|
|
|
{
|
|
|
|
if (SRAMFile) fclose(SRAMFile);
|
|
|
|
if (SRAM) delete[] SRAM;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CartGame::DoSavestate(Savestate* file)
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
CartCommon::DoSavestate(file);
|
|
|
|
|
|
|
|
file->Var16(&GPIO.control);
|
|
|
|
file->Var16(&GPIO.data);
|
|
|
|
file->Var16(&GPIO.direction);
|
2019-12-19 05:12:36 +00:00
|
|
|
|
|
|
|
// logic mostly copied from NDSCart_SRAM
|
|
|
|
|
|
|
|
u32 oldlen = SRAMLength;
|
|
|
|
|
|
|
|
file->Var32(&SRAMLength);
|
2019-12-22 16:45:11 +00:00
|
|
|
|
2019-12-19 05:12:36 +00:00
|
|
|
if (SRAMLength != oldlen)
|
|
|
|
{
|
2019-12-22 16:45:11 +00:00
|
|
|
// reallocate save memory
|
2019-12-19 05:12:36 +00:00
|
|
|
if (oldlen) delete[] SRAM;
|
|
|
|
if (SRAMLength) SRAM = new u8[SRAMLength];
|
|
|
|
}
|
|
|
|
if (SRAMLength)
|
|
|
|
{
|
2019-12-22 16:45:11 +00:00
|
|
|
// fill save memory if data is present
|
2019-12-19 05:12:36 +00:00
|
|
|
file->VarArray(SRAM, SRAMLength);
|
|
|
|
}
|
2019-12-22 16:45:11 +00:00
|
|
|
else
|
|
|
|
{
|
2019-12-22 18:58:27 +00:00
|
|
|
// no save data, clear the current state
|
2019-12-22 16:45:11 +00:00
|
|
|
SRAMType = SaveType::S_NULL;
|
2019-12-22 18:58:27 +00:00
|
|
|
if (SRAMFile) fclose(SRAMFile);
|
2021-04-24 22:48:02 +00:00
|
|
|
SRAM = nullptr;
|
|
|
|
SRAMFile = nullptr;
|
2019-12-22 16:45:11 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-19 05:12:36 +00:00
|
|
|
|
|
|
|
// persist some extra state info
|
|
|
|
file->Var8(&SRAMFlashState.bank);
|
|
|
|
file->Var8(&SRAMFlashState.cmd);
|
|
|
|
file->Var8(&SRAMFlashState.device);
|
|
|
|
file->Var8(&SRAMFlashState.manufacturer);
|
|
|
|
file->Var8(&SRAMFlashState.state);
|
|
|
|
|
|
|
|
file->Var8((u8*)&SRAMType);
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartGame::LoadSave(const char* path, u32 type)
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
|
|
|
if (SRAM) delete[] SRAM;
|
|
|
|
|
|
|
|
strncpy(SRAMPath, path, 1023);
|
|
|
|
SRAMPath[1023] = '\0';
|
2019-12-09 09:53:45 +00:00
|
|
|
SRAMLength = 0;
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2019-12-09 12:06:39 +00:00
|
|
|
FILE* f = Platform::OpenFile(SRAMPath, "r+b");
|
2019-12-08 18:46:51 +00:00
|
|
|
if (f)
|
|
|
|
{
|
|
|
|
fseek(f, 0, SEEK_END);
|
|
|
|
SRAMLength = (u32)ftell(f);
|
|
|
|
SRAM = new u8[SRAMLength];
|
|
|
|
|
|
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
fread(SRAM, SRAMLength, 1, f);
|
|
|
|
|
2019-12-09 12:06:39 +00:00
|
|
|
SRAMFile = f;
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
|
|
|
|
switch (SRAMLength)
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
2019-12-09 09:53:45 +00:00
|
|
|
case 512:
|
|
|
|
SRAMType = S_EEPROM4K;
|
|
|
|
break;
|
|
|
|
case 8192:
|
|
|
|
SRAMType = S_EEPROM64K;
|
|
|
|
break;
|
|
|
|
case 32768:
|
|
|
|
SRAMType = S_SRAM256K;
|
|
|
|
break;
|
|
|
|
case 65536:
|
|
|
|
SRAMType = S_FLASH512K;
|
|
|
|
break;
|
|
|
|
case 128*1024:
|
|
|
|
SRAMType = S_FLASH1M;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
SRAMType = S_NULL;
|
|
|
|
break;
|
2021-05-03 12:36:21 +00:00
|
|
|
default:
|
|
|
|
printf("!! BAD GBA SAVE LENGTH %d\n", SRAMLength);
|
2019-12-09 09:53:45 +00:00
|
|
|
}
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2019-12-09 09:53:45 +00:00
|
|
|
if (SRAMType == S_FLASH512K)
|
|
|
|
{
|
|
|
|
// Panasonic 64K chip
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.device = 0x1B;
|
|
|
|
SRAMFlashState.manufacturer = 0x32;
|
2019-12-09 09:53:45 +00:00
|
|
|
}
|
|
|
|
else if (SRAMType == S_FLASH1M)
|
|
|
|
{
|
2019-12-09 11:09:30 +00:00
|
|
|
// Sanyo 128K chip
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.device = 0x13;
|
|
|
|
SRAMFlashState.manufacturer = 0x62;
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartGame::RelocateSave(const char* path, bool write)
|
2019-12-08 18:46:51 +00:00
|
|
|
{
|
|
|
|
if (!write)
|
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
LoadSave(path, 0); // lazy
|
2019-12-08 18:46:51 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
strncpy(SRAMPath, path, 1023);
|
|
|
|
SRAMPath[1023] = '\0';
|
|
|
|
|
2019-12-09 12:06:39 +00:00
|
|
|
FILE *f = Platform::OpenFile(path, "r+b");
|
2019-12-08 18:46:51 +00:00
|
|
|
if (!f)
|
|
|
|
{
|
|
|
|
printf("GBACart_SRAM::RelocateSave: failed to create new file. fuck\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-12-09 12:06:39 +00:00
|
|
|
SRAMFile = f;
|
|
|
|
fwrite(SRAM, SRAMLength, 1, SRAMFile);
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
u16 CartGame::ROMRead(u32 addr)
|
|
|
|
{
|
|
|
|
addr &= 0x01FFFFFF;
|
|
|
|
|
|
|
|
if (addr >= 0xC4 && addr < 0xCA)
|
|
|
|
{
|
|
|
|
if (GPIO.control & 0x1)
|
|
|
|
{
|
|
|
|
switch (addr)
|
|
|
|
{
|
|
|
|
case 0xC4: return GPIO.data;
|
|
|
|
case 0xC6: return GPIO.direction;
|
|
|
|
case 0xC8: return GPIO.control;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CHECKME: does ROM mirror?
|
|
|
|
if (addr < ROMLength)
|
|
|
|
return *(u16*)&ROM[addr];
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CartGame::ROMWrite(u32 addr, u16 val)
|
|
|
|
{
|
|
|
|
addr &= 0x01FFFFFF;
|
|
|
|
|
|
|
|
switch (addr)
|
|
|
|
{
|
|
|
|
case 0xC4:
|
|
|
|
GPIO.data &= ~GPIO.direction;
|
|
|
|
GPIO.data |= val & GPIO.direction;
|
|
|
|
ProcessGPIO();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xC6:
|
|
|
|
GPIO.direction = val;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0xC8:
|
|
|
|
GPIO.control = val;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
printf("Unknown GBA GPIO write 0x%02X @ 0x%04X\n", val, addr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u8 CartGame::SRAMRead(u32 addr)
|
|
|
|
{
|
|
|
|
addr &= 0xFFFF;
|
|
|
|
|
|
|
|
switch (SRAMType)
|
|
|
|
{
|
|
|
|
case S_EEPROM4K:
|
|
|
|
case S_EEPROM64K:
|
|
|
|
return SRAMRead_EEPROM(addr);
|
|
|
|
|
|
|
|
case S_FLASH512K:
|
|
|
|
case S_FLASH1M:
|
|
|
|
return SRAMRead_FLASH(addr);
|
|
|
|
|
|
|
|
case S_SRAM256K:
|
|
|
|
return SRAMRead_SRAM(addr);
|
2021-05-03 12:36:21 +00:00
|
|
|
default:
|
|
|
|
break;
|
2021-04-24 22:48:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0xFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CartGame::SRAMWrite(u32 addr, u8 val)
|
|
|
|
{
|
|
|
|
addr &= 0xFFFF;
|
|
|
|
|
|
|
|
switch (SRAMType)
|
|
|
|
{
|
|
|
|
case S_EEPROM4K:
|
|
|
|
case S_EEPROM64K:
|
|
|
|
return SRAMWrite_EEPROM(addr, val);
|
|
|
|
|
|
|
|
case S_FLASH512K:
|
|
|
|
case S_FLASH1M:
|
|
|
|
return SRAMWrite_FLASH(addr, val);
|
|
|
|
|
|
|
|
case S_SRAM256K:
|
|
|
|
return SRAMWrite_SRAM(addr, val);
|
2021-05-03 12:36:21 +00:00
|
|
|
default:
|
|
|
|
break;
|
2021-04-24 22:48:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CartGame::ProcessGPIO()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
u8 CartGame::SRAMRead_EEPROM(u32 addr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CartGame::SRAMWrite_EEPROM(u32 addr, u8 val)
|
|
|
|
{
|
|
|
|
// TODO: could be used in homebrew?
|
|
|
|
}
|
|
|
|
|
2019-12-10 14:57:10 +00:00
|
|
|
// mostly ported from DeSmuME
|
2021-04-24 22:48:02 +00:00
|
|
|
u8 CartGame::SRAMRead_FLASH(u32 addr)
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
if (SRAMFlashState.cmd == 0) // no cmd
|
2019-12-09 11:09:30 +00:00
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
return *(u8*)&SRAM[addr + 0x10000 * SRAMFlashState.bank];
|
2019-12-09 11:09:30 +00:00
|
|
|
}
|
|
|
|
|
2019-12-10 21:36:00 +00:00
|
|
|
switch (SRAMFlashState.cmd)
|
2019-12-09 11:09:30 +00:00
|
|
|
{
|
|
|
|
case 0x90: // chip ID
|
2019-12-10 21:36:00 +00:00
|
|
|
if (addr == 0x0000) return SRAMFlashState.manufacturer;
|
|
|
|
if (addr == 0x0001) return SRAMFlashState.device;
|
2019-12-09 11:09:30 +00:00
|
|
|
break;
|
|
|
|
case 0xF0: // terminate command (TODO: break if non-Macronix chip and not at the end of an ID call?)
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
|
|
|
SRAMFlashState.cmd = 0;
|
2019-12-09 11:09:30 +00:00
|
|
|
break;
|
2019-12-10 14:57:10 +00:00
|
|
|
case 0xA0: // write command
|
|
|
|
break; // ignore here, handled in Write_Flash()
|
2019-12-09 11:09:30 +00:00
|
|
|
case 0xB0: // bank switching (128K only)
|
2019-12-10 14:57:10 +00:00
|
|
|
break; // ignore here, handled in Write_Flash()
|
2019-12-09 11:09:30 +00:00
|
|
|
default:
|
2019-12-10 21:36:00 +00:00
|
|
|
printf("GBACart_SRAM::Read_Flash: unknown command 0x%02X @ 0x%04X\n", SRAMFlashState.cmd, addr);
|
2019-12-09 11:09:30 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-12-09 09:53:45 +00:00
|
|
|
return 0xFF;
|
|
|
|
}
|
|
|
|
|
2019-12-10 14:57:10 +00:00
|
|
|
// mostly ported from DeSmuME
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartGame::SRAMWrite_FLASH(u32 addr, u8 val)
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
switch (SRAMFlashState.state)
|
2019-12-09 11:10:26 +00:00
|
|
|
{
|
|
|
|
case 0x00:
|
|
|
|
if (addr == 0x5555)
|
|
|
|
{
|
|
|
|
if (val == 0xF0)
|
|
|
|
{
|
|
|
|
// reset
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
|
|
|
SRAMFlashState.cmd = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (val == 0xAA)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 1;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (addr == 0x0000)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
if (SRAMFlashState.cmd == 0xB0)
|
2019-12-09 11:10:26 +00:00
|
|
|
{
|
|
|
|
// bank switching
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.bank = val;
|
|
|
|
SRAMFlashState.cmd = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 0x01:
|
|
|
|
if (addr == 0x2AAA && val == 0x55)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 2;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0x02:
|
|
|
|
if (addr == 0x5555)
|
|
|
|
{
|
|
|
|
// send command
|
|
|
|
switch (val)
|
|
|
|
{
|
|
|
|
case 0x80: // erase
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0x80;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0x90: // chip ID
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0x90;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0xA0: // write
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
default:
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.cmd = val;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
// erase
|
|
|
|
case 0x80:
|
|
|
|
if (addr == 0x5555 && val == 0xAA)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0x81;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0x81:
|
|
|
|
if (addr == 0x2AAA && val == 0x55)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0x82;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0x82:
|
|
|
|
if (val == 0x30)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
u32 start_addr = addr + 0x10000 * SRAMFlashState.bank;
|
2019-12-09 11:10:26 +00:00
|
|
|
memset((u8*)&SRAM[start_addr], 0xFF, 0x1000);
|
|
|
|
|
2019-12-09 12:06:39 +00:00
|
|
|
if (SRAMFile)
|
2019-12-09 11:10:26 +00:00
|
|
|
{
|
2019-12-09 12:06:39 +00:00
|
|
|
fseek(SRAMFile, start_addr, SEEK_SET);
|
|
|
|
fwrite((u8*)&SRAM[start_addr], 1, 0x1000, SRAMFile);
|
2019-12-09 11:10:26 +00:00
|
|
|
}
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
|
|
|
SRAMFlashState.cmd = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
// chip ID
|
|
|
|
case 0x90:
|
|
|
|
if (addr == 0x5555 && val == 0xAA)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0x91;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0x91:
|
|
|
|
if (addr == 0x2AAA && val == 0x55)
|
|
|
|
{
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0x92;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
break;
|
|
|
|
case 0x92:
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
|
|
|
SRAMFlashState.cmd = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-12-10 21:36:00 +00:00
|
|
|
if (SRAMFlashState.cmd == 0xA0) // write
|
2019-12-09 11:10:26 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
SRAMWrite_SRAM(addr + 0x10000 * SRAMFlashState.bank, val);
|
2019-12-10 21:36:00 +00:00
|
|
|
SRAMFlashState.state = 0;
|
|
|
|
SRAMFlashState.cmd = 0;
|
2019-12-09 11:10:26 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("GBACart_SRAM::Write_Flash: unknown write 0x%02X @ 0x%04X (state: 0x%02X)\n",
|
2019-12-10 21:36:00 +00:00
|
|
|
val, addr, SRAMFlashState.state);
|
2019-12-09 09:53:45 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
u8 CartGame::SRAMRead_SRAM(u32 addr)
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (addr >= SRAMLength) return 0xFF;
|
|
|
|
|
|
|
|
return SRAM[addr];
|
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartGame::SRAMWrite_SRAM(u32 addr, u8 val)
|
|
|
|
{
|
|
|
|
if (addr >= SRAMLength) return;
|
|
|
|
|
|
|
|
u8 prev = *(u8*)&SRAM[addr];
|
2019-12-09 12:06:39 +00:00
|
|
|
if (prev != val)
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
2019-12-09 12:06:39 +00:00
|
|
|
*(u8*)&SRAM[addr] = val;
|
|
|
|
|
|
|
|
if (SRAMFile)
|
|
|
|
{
|
|
|
|
fseek(SRAMFile, addr, SEEK_SET);
|
|
|
|
fwrite((u8*)&SRAM[addr], 1, 1, SRAMFile);
|
|
|
|
}
|
2019-12-09 09:53:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
const int CartGameSolarSensor::kLuxLevels[11] = {0, 5, 11, 18, 27, 42, 62, 84, 109, 139, 183};
|
2019-12-09 09:53:45 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
CartGameSolarSensor::CartGameSolarSensor(u8* rom, u32 len) : CartGame(rom, len)
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
LightEdge = false;
|
|
|
|
LightCounter = 0;
|
|
|
|
LightSample = 0xFF;
|
|
|
|
LightLevel = 0;
|
2019-12-09 09:53:45 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
CartGameSolarSensor::~CartGameSolarSensor()
|
2019-12-09 09:53:45 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartGameSolarSensor::DoSavestate(Savestate* file)
|
2019-12-08 22:56:22 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
CartGame::DoSavestate(file);
|
2019-12-08 22:56:22 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
file->Var8((u8*)&LightEdge);
|
|
|
|
file->Var8(&LightCounter);
|
|
|
|
file->Var8(&LightSample);
|
|
|
|
file->Var8(&LightLevel);
|
2019-12-08 22:56:22 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
int CartGameSolarSensor::SetInput(int num, bool pressed)
|
2019-12-08 22:56:22 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (!pressed) return -1;
|
2019-12-08 22:56:22 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
if (num == Input_SolarSensorDown)
|
|
|
|
{
|
|
|
|
if (LightLevel > 0)
|
|
|
|
LightLevel--;
|
2019-12-08 22:56:22 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
return LightLevel;
|
|
|
|
}
|
|
|
|
else if (num == Input_SolarSensorUp)
|
|
|
|
{
|
|
|
|
if (LightLevel < 10)
|
|
|
|
LightLevel++;
|
2019-12-08 22:56:22 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
return LightLevel;
|
|
|
|
}
|
2019-12-08 22:56:22 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
return -1;
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void CartGameSolarSensor::ProcessGPIO()
|
2019-12-10 21:36:38 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (GPIO.data & 4) return; // Boktai chip select
|
|
|
|
if (GPIO.data & 2) // Reset
|
|
|
|
{
|
|
|
|
u8 prev = LightSample;
|
|
|
|
LightCounter = 0;
|
|
|
|
LightSample = (0xFF - (0x16 + kLuxLevels[LightLevel]));
|
|
|
|
printf("Solar sensor reset (sample: 0x%02X -> 0x%02X)\n", prev, LightSample);
|
|
|
|
}
|
|
|
|
if (GPIO.data & 1 && LightEdge) LightCounter++;
|
2019-12-10 21:36:38 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
LightEdge = !(GPIO.data & 1);
|
2019-12-10 21:36:38 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
bool sendBit = LightCounter >= LightSample;
|
|
|
|
if (GPIO.control & 1)
|
|
|
|
{
|
|
|
|
GPIO.data = (GPIO.data & GPIO.direction) | ((sendBit << 3) & ~GPIO.direction & 0xF);
|
|
|
|
}
|
|
|
|
}
|
2019-12-08 18:46:51 +00:00
|
|
|
|
|
|
|
|
|
|
|
bool Init()
|
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
CartROM = nullptr;
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
Cart = nullptr;
|
2019-12-08 18:46:51 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DeInit()
|
|
|
|
{
|
|
|
|
if (CartROM) delete[] CartROM;
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) delete Cart;
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Reset()
|
|
|
|
{
|
2019-12-22 20:49:23 +00:00
|
|
|
// Do not reset cartridge ROM.
|
|
|
|
// Prefer keeping the inserted cartridge on reset.
|
|
|
|
// This allows resetting a DS game without losing GBA state,
|
|
|
|
// and resetting to firmware without the slot being emptied.
|
|
|
|
// The Stop function will clear the cartridge state via Eject().
|
2021-05-04 10:58:59 +00:00
|
|
|
|
|
|
|
// OpenBusDecay doesn't need to be reset, either, as it will be set
|
|
|
|
// through NDS::SetGBASlotTimings().
|
2019-12-22 20:49:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Eject()
|
|
|
|
{
|
|
|
|
if (CartROM) delete[] CartROM;
|
|
|
|
|
2019-12-08 18:46:51 +00:00
|
|
|
CartInserted = false;
|
|
|
|
CartROM = NULL;
|
|
|
|
CartROMSize = 0;
|
2021-01-22 18:20:32 +00:00
|
|
|
CartCRC = 0;
|
|
|
|
CartID = 0;
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) delete Cart;
|
|
|
|
Cart = nullptr;
|
|
|
|
|
2019-12-22 20:49:23 +00:00
|
|
|
Reset();
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DoSavestate(Savestate* file)
|
|
|
|
{
|
2019-12-19 05:12:36 +00:00
|
|
|
file->Section("GBAC"); // Game Boy Advance Cartridge
|
|
|
|
|
|
|
|
// logic mostly copied from NDSCart
|
|
|
|
|
|
|
|
// first we need to reload the cart itself,
|
|
|
|
// since unlike with DS, it's not loaded in advance
|
|
|
|
|
|
|
|
file->Var32(&CartROMSize);
|
2019-12-22 20:49:23 +00:00
|
|
|
if (!CartROMSize) // no GBA cartridge state? nothing to do here
|
|
|
|
{
|
|
|
|
// do eject the cartridge if something is inserted
|
|
|
|
Eject();
|
|
|
|
return;
|
|
|
|
}
|
2019-12-19 05:12:36 +00:00
|
|
|
|
2019-12-22 18:58:27 +00:00
|
|
|
u32 oldCRC = CartCRC;
|
|
|
|
file->Var32(&CartCRC);
|
2019-12-22 20:49:23 +00:00
|
|
|
|
2019-12-22 18:58:27 +00:00
|
|
|
if (CartCRC != oldCRC)
|
2019-12-19 05:12:36 +00:00
|
|
|
{
|
2019-12-22 18:58:27 +00:00
|
|
|
// delete and reallocate ROM so that it is zero-padded to its full length
|
|
|
|
if (CartROM) delete[] CartROM;
|
2019-12-19 05:12:36 +00:00
|
|
|
CartROM = new u8[CartROMSize];
|
2019-12-22 18:58:27 +00:00
|
|
|
}
|
2019-12-19 05:12:36 +00:00
|
|
|
|
2019-12-22 18:58:27 +00:00
|
|
|
// only save/load the cartridge header
|
|
|
|
//
|
|
|
|
// GBA connectivity on DS mainly involves identifying the title currently
|
|
|
|
// inserted, reading save data, and issuing commands intercepted here
|
|
|
|
// (e.g. solar sensor signals). we don't know of any case where GBA ROM is
|
|
|
|
// read directly from DS software. therefore, it is more practical, both
|
|
|
|
// from the development and user experience perspectives, to avoid dealing
|
|
|
|
// with file dependencies, and store a small portion of ROM data that should
|
|
|
|
// satisfy the needs of all known software that reads from the GBA slot.
|
|
|
|
//
|
|
|
|
// note: in case of a state load, only the cartridge header is restored, but
|
|
|
|
// the rest of the ROM data is only cleared (zero-initialized) if the CRC
|
|
|
|
// differs. Therefore, loading the GBA cartridge associated with the save state
|
|
|
|
// in advance will maintain access to the full ROM contents.
|
|
|
|
file->VarArray(CartROM, 192);
|
2019-12-19 05:12:36 +00:00
|
|
|
|
|
|
|
CartInserted = true; // known, because CartROMSize > 0
|
|
|
|
file->Var32(&CartCRC);
|
|
|
|
file->Var32(&CartID);
|
|
|
|
|
|
|
|
// now do the rest
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) Cart->DoSavestate(file);
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2021-01-22 10:22:32 +00:00
|
|
|
void LoadROMCommon(const char *sram)
|
|
|
|
{
|
|
|
|
char gamecode[5] = { '\0' };
|
|
|
|
memcpy(&gamecode, CartROM + 0xAC, 4);
|
2021-04-24 22:48:02 +00:00
|
|
|
printf("GBA game code: %s\n", gamecode);
|
2021-01-22 10:22:32 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
bool solarsensor = false;
|
2021-05-03 12:36:21 +00:00
|
|
|
for (size_t i = 0; i < sizeof(SOLAR_SENSOR_GAMECODES)/sizeof(SOLAR_SENSOR_GAMECODES[0]); i++)
|
2021-01-22 10:22:32 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (strcmp(gamecode, SOLAR_SENSOR_GAMECODES[i]) == 0)
|
|
|
|
solarsensor = true;
|
2021-01-22 10:22:32 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
if (solarsensor)
|
2021-01-22 10:22:32 +00:00
|
|
|
{
|
|
|
|
printf("GBA solar sensor support detected!\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
CartCRC = CRC32(CartROM, CartROMSize);
|
2021-04-24 22:48:02 +00:00
|
|
|
printf("GBA ROM CRC32: %08X\n", CartCRC);
|
2021-01-22 10:22:32 +00:00
|
|
|
|
|
|
|
CartInserted = true;
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
if (solarsensor)
|
|
|
|
Cart = new CartGameSolarSensor(CartROM, CartROMSize);
|
|
|
|
else
|
|
|
|
Cart = new CartGame(CartROM, CartROMSize);
|
|
|
|
|
2021-01-22 10:22:32 +00:00
|
|
|
// save
|
2021-04-24 22:48:02 +00:00
|
|
|
printf("GBA save file: %s\n", sram);
|
|
|
|
|
|
|
|
// TODO: have a list of sorts like in NDSCart? to determine the savemem type
|
|
|
|
if (Cart) Cart->LoadSave(sram, 0);
|
2021-01-22 10:22:32 +00:00
|
|
|
}
|
|
|
|
|
2019-12-08 18:46:51 +00:00
|
|
|
bool LoadROM(const char* path, const char* sram)
|
|
|
|
{
|
|
|
|
FILE* f = Platform::OpenFile(path, "rb");
|
|
|
|
if (!f)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-12-08 22:13:56 +00:00
|
|
|
if (CartInserted)
|
|
|
|
{
|
|
|
|
Reset();
|
|
|
|
}
|
|
|
|
|
2019-12-08 18:46:51 +00:00
|
|
|
fseek(f, 0, SEEK_END);
|
|
|
|
u32 len = (u32)ftell(f);
|
|
|
|
|
|
|
|
CartROMSize = 0x200;
|
|
|
|
while (CartROMSize < len)
|
|
|
|
CartROMSize <<= 1;
|
|
|
|
|
|
|
|
CartROM = new u8[CartROMSize];
|
|
|
|
memset(CartROM, 0, CartROMSize);
|
|
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
fread(CartROM, 1, len, f);
|
|
|
|
fclose(f);
|
|
|
|
|
2021-01-22 10:22:32 +00:00
|
|
|
LoadROMCommon(sram);
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-01-22 10:22:32 +00:00
|
|
|
return true;
|
|
|
|
}
|
2019-12-08 18:46:51 +00:00
|
|
|
|
2021-01-22 10:22:32 +00:00
|
|
|
bool LoadROM(const u8* romdata, u32 filelength, const char *sram)
|
|
|
|
{
|
|
|
|
CartROMSize = 0x200;
|
|
|
|
while (CartROMSize < filelength)
|
|
|
|
CartROMSize <<= 1;
|
|
|
|
|
|
|
|
CartROM = new u8[CartROMSize];
|
|
|
|
memcpy(CartROM, romdata, filelength);
|
|
|
|
|
|
|
|
LoadROMCommon(sram);
|
2019-12-08 18:46:51 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RelocateSave(const char* path, bool write)
|
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) Cart->RelocateSave(path, write);
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|
|
|
|
|
2019-12-10 21:36:38 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
int SetInput(int num, bool pressed)
|
|
|
|
{
|
|
|
|
if (Cart) return Cart->SetInput(num, pressed);
|
2019-12-10 22:43:25 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
return -1;
|
2019-12-10 22:43:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-05-04 10:58:59 +00:00
|
|
|
void SetOpenBusDecay(u16 val)
|
|
|
|
{
|
|
|
|
OpenBusDecay = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
u16 ROMRead(u32 addr)
|
2019-12-10 22:43:25 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) return Cart->ROMRead(addr);
|
2019-12-10 22:43:25 +00:00
|
|
|
|
2021-05-04 10:58:59 +00:00
|
|
|
return ((addr >> 1) & 0xFFFF) | OpenBusDecay;
|
2019-12-10 22:43:25 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void ROMWrite(u32 addr, u16 val)
|
2019-12-11 01:28:40 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) Cart->ROMWrite(addr, val);
|
2019-12-11 01:28:40 +00:00
|
|
|
}
|
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
u8 SRAMRead(u32 addr)
|
2019-12-10 22:43:25 +00:00
|
|
|
{
|
2021-04-24 22:48:02 +00:00
|
|
|
if (Cart) return Cart->SRAMRead(addr);
|
2019-12-10 22:43:25 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
return 0xFF;
|
|
|
|
}
|
2019-12-10 22:43:25 +00:00
|
|
|
|
2021-04-24 22:48:02 +00:00
|
|
|
void SRAMWrite(u32 addr, u8 val)
|
|
|
|
{
|
|
|
|
if (Cart) Cart->SRAMWrite(addr, val);
|
2019-12-10 21:36:38 +00:00
|
|
|
}
|
|
|
|
|
2019-12-08 18:46:51 +00:00
|
|
|
}
|