aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorArisotura <thetotalworm@gmail.com>2020-01-28 21:32:29 +0100
committerGitHub <noreply@github.com>2020-01-28 21:32:29 +0100
commit12732aa51b25a3a952b2ef554fda18168111cdd0 (patch)
treef4b659c84263259a811b842d2dc51af9b801d6ff
parent3984491ccec4630091bbb178c7c0b22aa4e5e937 (diff)
parent22d11209b0466e3c852da543ddfc512b66735bc2 (diff)
Merge pull request #550 from rzumer/slot2
Support GBA game cartridges for DS connectivity
Diffstat
-rw-r--r--src/CMakeLists.txt1
-rw-r--r--src/GBACart.cpp773
-rw-r--r--src/GBACart.h87
-rw-r--r--src/NDS.cpp274
-rw-r--r--src/NDS.h1
-rw-r--r--src/NDSCart.cpp3
-rw-r--r--src/libui_sdl/DlgInputConfig.cpp6
-rw-r--r--src/libui_sdl/PlatformConfig.cpp32
-rw-r--r--src/libui_sdl/PlatformConfig.h2
-rw-r--r--src/libui_sdl/main.cpp195
10 files changed, 1257 insertions, 117 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a1110f1..03a4bfe 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -10,6 +10,7 @@ add_library(core STATIC
CP15.cpp
CRC32.cpp
DMA.cpp
+ GBACart.cpp
GPU.cpp
GPU2D.cpp
GPU3D.cpp
diff --git a/src/GBACart.cpp b/src/GBACart.cpp
new file mode 100644
index 0000000..4d44d3a
--- /dev/null
+++ b/src/GBACart.cpp
@@ -0,0 +1,773 @@
+/*
+ Copyright 2019 Arisotura, Raphaël Zumer
+
+ 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"
+
+
+namespace GBACart_SRAM
+{
+
+enum SaveType {
+ S_NULL,
+ S_EEPROM4K,
+ S_EEPROM64K,
+ S_SRAM256K,
+ S_FLASH512K,
+ S_FLASH1M
+};
+
+// from DeSmuME
+struct FlashProperties
+{
+ u8 state;
+ u8 cmd;
+ u8 device;
+ u8 manufacturer;
+ u8 bank;
+};
+
+u8* SRAM;
+FILE* SRAMFile;
+u32 SRAMLength;
+SaveType SRAMType;
+FlashProperties SRAMFlashState;
+
+char SRAMPath[1024];
+
+void (*WriteFunc)(u32 addr, u8 val);
+
+
+void Write_Null(u32 addr, u8 val);
+void Write_EEPROM(u32 addr, u8 val);
+void Write_SRAM(u32 addr, u8 val);
+void Write_Flash(u32 addr, u8 val);
+
+
+bool Init()
+{
+ SRAM = NULL;
+ SRAMFile = NULL;
+ return true;
+}
+
+void DeInit()
+{
+ if (SRAMFile) fclose(SRAMFile);
+ if (SRAM) delete[] SRAM;
+}
+
+void Reset()
+{
+ // do nothing, we don't want to clear GBA SRAM on reset
+}
+
+void Eject()
+{
+ if (SRAMFile) fclose(SRAMFile);
+ if (SRAM) delete[] SRAM;
+ SRAM = NULL;
+ SRAMFile = NULL;
+ SRAMLength = 0;
+ SRAMType = S_NULL;
+ SRAMFlashState = {};
+}
+
+void DoSavestate(Savestate* file)
+{
+ file->Section("GBCS"); // Game Boy [Advance] Cart Save
+
+ // logic mostly copied from NDSCart_SRAM
+
+ u32 oldlen = SRAMLength;
+
+ file->Var32(&SRAMLength);
+
+ if (SRAMLength != oldlen)
+ {
+ // reallocate save memory
+ if (oldlen) delete[] SRAM;
+ if (SRAMLength) SRAM = new u8[SRAMLength];
+ }
+ if (SRAMLength)
+ {
+ // fill save memory if data is present
+ file->VarArray(SRAM, SRAMLength);
+ }
+ else
+ {
+ // no save data, clear the current state
+ SRAMType = SaveType::S_NULL;
+ if (SRAMFile) fclose(SRAMFile);
+ SRAM = NULL;
+ SRAMFile = NULL;
+ return;
+ }
+
+ // 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);
+}
+
+void LoadSave(const char* path)
+{
+ if (SRAM) delete[] SRAM;
+
+ strncpy(SRAMPath, path, 1023);
+ SRAMPath[1023] = '\0';
+ SRAMLength = 0;
+
+ FILE* f = Platform::OpenFile(SRAMPath, "r+b");
+ 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);
+
+ SRAMFile = f;
+ }
+
+ switch (SRAMLength)
+ {
+ case 512:
+ SRAMType = S_EEPROM4K;
+ WriteFunc = Write_EEPROM;
+ break;
+ case 8192:
+ SRAMType = S_EEPROM64K;
+ WriteFunc = Write_EEPROM;
+ break;
+ case 32768:
+ SRAMType = S_SRAM256K;
+ WriteFunc = Write_SRAM;
+ break;
+ case 65536:
+ SRAMType = S_FLASH512K;
+ WriteFunc = Write_Flash;
+ break;
+ case 128*1024:
+ SRAMType = S_FLASH1M;
+ WriteFunc = Write_Flash;
+ break;
+ default:
+ printf("!! BAD SAVE LENGTH %d\n", SRAMLength);
+ case 0:
+ SRAMType = S_NULL;
+ WriteFunc = Write_Null;
+ break;
+ }
+
+ if (SRAMType == S_FLASH512K)
+ {
+ // Panasonic 64K chip
+ SRAMFlashState.device = 0x1B;
+ SRAMFlashState.manufacturer = 0x32;
+ }
+ else if (SRAMType == S_FLASH1M)
+ {
+ // Sanyo 128K chip
+ SRAMFlashState.device = 0x13;
+ SRAMFlashState.manufacturer = 0x62;
+ }
+}
+
+void RelocateSave(const char* path, bool write)
+{
+ if (!write)
+ {
+ LoadSave(path); // lazy
+ return;
+ }
+
+ strncpy(SRAMPath, path, 1023);
+ SRAMPath[1023] = '\0';
+
+ FILE *f = Platform::OpenFile(path, "r+b");
+ if (!f)
+ {
+ printf("GBACart_SRAM::RelocateSave: failed to create new file. fuck\n");
+ return;
+ }
+
+ SRAMFile = f;
+ fwrite(SRAM, SRAMLength, 1, SRAMFile);
+}
+
+// mostly ported from DeSmuME
+u8 Read_Flash(u32 addr)
+{
+ if (SRAMFlashState.cmd == 0) // no cmd
+ {
+ return *(u8*)&SRAM[addr + 0x10000 * SRAMFlashState.bank];
+ }
+
+ switch (SRAMFlashState.cmd)
+ {
+ case 0x90: // chip ID
+ if (addr == 0x0000) return SRAMFlashState.manufacturer;
+ if (addr == 0x0001) return SRAMFlashState.device;
+ break;
+ case 0xF0: // terminate command (TODO: break if non-Macronix chip and not at the end of an ID call?)
+ SRAMFlashState.state = 0;
+ SRAMFlashState.cmd = 0;
+ break;
+ case 0xA0: // write command
+ break; // ignore here, handled in Write_Flash()
+ case 0xB0: // bank switching (128K only)
+ break; // ignore here, handled in Write_Flash()
+ default:
+ printf("GBACart_SRAM::Read_Flash: unknown command 0x%02X @ 0x%04X\n", SRAMFlashState.cmd, addr);
+ break;
+ }
+
+ return 0xFF;
+}
+
+void Write_Null(u32 addr, u8 val) {}
+
+void Write_EEPROM(u32 addr, u8 val)
+{
+ // TODO: could be used in homebrew?
+}
+
+// mostly ported from DeSmuME
+void Write_Flash(u32 addr, u8 val)
+{
+ switch (SRAMFlashState.state)
+ {
+ case 0x00:
+ if (addr == 0x5555)
+ {
+ if (val == 0xF0)
+ {
+ // reset
+ SRAMFlashState.state = 0;
+ SRAMFlashState.cmd = 0;
+ return;
+ }
+ else if (val == 0xAA)
+ {
+ SRAMFlashState.state = 1;
+ return;
+ }
+ }
+ if (addr == 0x0000)
+ {
+ if (SRAMFlashState.cmd == 0xB0)
+ {
+ // bank switching
+ SRAMFlashState.bank = val;
+ SRAMFlashState.cmd = 0;
+ return;
+ }
+ }
+ break;
+ case 0x01:
+ if (addr == 0x2AAA && val == 0x55)
+ {
+ SRAMFlashState.state = 2;
+ return;
+ }
+ SRAMFlashState.state = 0;
+ break;
+ case 0x02:
+ if (addr == 0x5555)
+ {
+ // send command
+ switch (val)
+ {
+ case 0x80: // erase
+ SRAMFlashState.state = 0x80;
+ break;
+ case 0x90: // chip ID
+ SRAMFlashState.state = 0x90;
+ break;
+ case 0xA0: // write
+ SRAMFlashState.state = 0;
+ break;
+ default:
+ SRAMFlashState.state = 0;
+ break;
+ }
+
+ SRAMFlashState.cmd = val;
+ return;
+ }
+ SRAMFlashState.state = 0;
+ break;
+ // erase
+ case 0x80:
+ if (addr == 0x5555 && val == 0xAA)
+ {
+ SRAMFlashState.state = 0x81;
+ return;
+ }
+ SRAMFlashState.state = 0;
+ break;
+ case 0x81:
+ if (addr == 0x2AAA && val == 0x55)
+ {
+ SRAMFlashState.state = 0x82;
+ return;
+ }
+ SRAMFlashState.state = 0;
+ break;
+ case 0x82:
+ if (val == 0x30)
+ {
+ u32 start_addr = addr + 0x10000 * SRAMFlashState.bank;
+ memset((u8*)&SRAM[start_addr], 0xFF, 0x1000);
+
+ if (SRAMFile)
+ {
+ fseek(SRAMFile, start_addr, SEEK_SET);
+ fwrite((u8*)&SRAM[start_addr], 1, 0x1000, SRAMFile);
+ }
+ }
+ SRAMFlashState.state = 0;
+ SRAMFlashState.cmd = 0;
+ return;
+ // chip ID
+ case 0x90:
+ if (addr == 0x5555 && val == 0xAA)
+ {
+ SRAMFlashState.state = 0x91;
+ return;
+ }
+ SRAMFlashState.state = 0;
+ break;
+ case 0x91:
+ if (addr == 0x2AAA && val == 0x55)
+ {
+ SRAMFlashState.state = 0x92;
+ return;
+ }
+ SRAMFlashState.state = 0;
+ break;
+ case 0x92:
+ SRAMFlashState.state = 0;
+ SRAMFlashState.cmd = 0;
+ return;
+ default:
+ break;
+ }
+
+ if (SRAMFlashState.cmd == 0xA0) // write
+ {
+ Write_SRAM(addr + 0x10000 * SRAMFlashState.bank, val);
+ SRAMFlashState.state = 0;
+ SRAMFlashState.cmd = 0;
+ return;
+ }
+
+ printf("GBACart_SRAM::Write_Flash: unknown write 0x%02X @ 0x%04X (state: 0x%02X)\n",
+ val, addr, SRAMFlashState.state);
+}
+
+void Write_SRAM(u32 addr, u8 val)
+{
+ u8 prev = *(u8*)&SRAM[addr];
+
+ if (prev != val)
+ {
+ *(u8*)&SRAM[addr] = val;
+
+ if (SRAMFile)
+ {
+ fseek(SRAMFile, addr, SEEK_SET);
+ fwrite((u8*)&SRAM[addr], 1, 1, SRAMFile);
+ }
+ }
+}
+
+u8 Read8(u32 addr)
+{
+ if (SRAMType == S_NULL)
+ {
+ return 0xFF;
+ }
+
+ if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
+ {
+ return Read_Flash(addr);
+ }
+
+ return *(u8*)&SRAM[addr];
+}
+
+u16 Read16(u32 addr)
+{
+ if (SRAMType == S_NULL)
+ {
+ return 0xFFFF;
+ }
+
+ if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
+ {
+ u16 val = Read_Flash(addr + 0) |
+ (Read_Flash(addr + 1) << 8);
+ return val;
+ }
+
+ return *(u16*)&SRAM[addr];
+}
+
+u32 Read32(u32 addr)
+{
+ if (SRAMType == S_NULL)
+ {
+ return 0xFFFFFFFF;
+ }
+
+ if (SRAMType == S_FLASH512K || SRAMType == S_FLASH1M)
+ {
+ u32 val = Read_Flash(addr + 0) |
+ (Read_Flash(addr + 1) << 8) |
+ (Read_Flash(addr + 2) << 16) |
+ (Read_Flash(addr + 3) << 24);
+ return val;
+ }
+
+ return *(u32*)&SRAM[addr];
+}
+
+void Write8(u32 addr, u8 val)
+{
+ u8 prev = *(u8*)&SRAM[addr];
+
+ WriteFunc(addr, val);
+}
+
+void Write16(u32 addr, u16 val)
+{
+ u16 prev = *(u16*)&SRAM[addr];
+
+ WriteFunc(addr + 0, val & 0xFF);
+ WriteFunc(addr + 1, val >> 8 & 0xFF);
+}
+
+void Write32(u32 addr, u32 val)
+{
+ u32 prev = *(u32*)&SRAM[addr];
+
+ WriteFunc(addr + 0, val & 0xFF);
+ WriteFunc(addr + 1, val >> 8 & 0xFF);
+ WriteFunc(addr + 2, val >> 16 & 0xFF);
+ WriteFunc(addr + 3, val >> 24 & 0xFF);
+}
+
+}
+
+
+namespace GBACart
+{
+
+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)
+};
+
+
+bool CartInserted;
+bool HasSolarSensor;
+u8* CartROM;
+u32 CartROMSize;
+u32 CartCRC;
+u32 CartID;
+GPIO CartGPIO; // overridden GPIO parameters
+
+
+bool Init()
+{
+ if (!GBACart_SRAM::Init()) return false;
+
+ CartROM = NULL;
+
+ return true;
+}
+
+void DeInit()
+{
+ if (CartROM) delete[] CartROM;
+
+ GBACart_SRAM::DeInit();
+}
+
+void Reset()
+{
+ // 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().
+
+ GBACart_SRAM::Reset();
+ GBACart_SolarSensor::Reset();
+}
+
+void Eject()
+{
+ if (CartROM) delete[] CartROM;
+
+ CartInserted = false;
+ HasSolarSensor = false;
+ CartROM = NULL;
+ CartROMSize = 0;
+ CartCRC = NULL;
+ CartID = NULL;
+ CartGPIO = {};
+
+ GBACart_SRAM::Eject();
+ Reset();
+}
+
+void DoSavestate(Savestate* file)
+{
+ 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);
+ if (!CartROMSize) // no GBA cartridge state? nothing to do here
+ {
+ // do eject the cartridge if something is inserted
+ Eject();
+ return;
+ }
+
+ u32 oldCRC = CartCRC;
+ file->Var32(&CartCRC);
+
+ if (CartCRC != oldCRC)
+ {
+ // delete and reallocate ROM so that it is zero-padded to its full length
+ if (CartROM) delete[] CartROM;
+ CartROM = new u8[CartROMSize];
+
+ // clear the SRAM file handle; writes will not be committed
+ if (GBACart_SRAM::SRAMFile)
+ {
+ fclose(GBACart_SRAM::SRAMFile);
+ GBACart_SRAM::SRAMFile = NULL;
+ }
+ }
+
+ // 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);
+
+ CartInserted = true; // known, because CartROMSize > 0
+ file->Var32(&CartCRC);
+ file->Var32(&CartID);
+
+ file->Var8((u8*)&HasSolarSensor);
+
+ file->Var16(&CartGPIO.control);
+ file->Var16(&CartGPIO.data);
+ file->Var16(&CartGPIO.direction);
+
+ // now do the rest
+
+ GBACart_SRAM::DoSavestate(file);
+ if (HasSolarSensor) GBACart_SolarSensor::DoSavestate(file);
+}
+
+bool LoadROM(const char* path, const char* sram)
+{
+ FILE* f = Platform::OpenFile(path, "rb");
+ if (!f)
+ {
+ return false;
+ }
+
+ if (CartInserted)
+ {
+ Reset();
+ }
+
+ fseek(f, 0, SEEK_END);
+ u32 len = (u32)ftell(f);
+
+ CartROMSize = 0x200;
+ while (CartROMSize < len)
+ CartROMSize <<= 1;
+
+ char gamecode[5] = { '\0' };
+ fseek(f, 0xAC, SEEK_SET);
+ fread(&gamecode, 1, 4, f);
+ printf("Game code: %s\n", gamecode);
+
+ for (int i = 0; i < sizeof(SOLAR_SENSOR_GAMECODES)/sizeof(SOLAR_SENSOR_GAMECODES[0]); i++)
+ {
+ if (strcmp(gamecode, SOLAR_SENSOR_GAMECODES[i]) == 0) HasSolarSensor = true;
+ }
+
+ if (HasSolarSensor)
+ {
+ printf("GBA solar sensor support detected!\n");
+ }
+
+ CartROM = new u8[CartROMSize];
+ memset(CartROM, 0, CartROMSize);
+ fseek(f, 0, SEEK_SET);
+ fread(CartROM, 1, len, f);
+
+ fclose(f);
+
+ CartCRC = CRC32(CartROM, CartROMSize);
+ printf("ROM CRC32: %08X\n", CartCRC);
+
+ CartInserted = true;
+
+ // save
+ printf("Save file: %s\n", sram);
+ GBACart_SRAM::LoadSave(sram);
+
+ return true;
+}
+
+void RelocateSave(const char* path, bool write)
+{
+ // derp herp
+ GBACart_SRAM::RelocateSave(path, write);
+}
+
+// referenced from mGBA
+void WriteGPIO(u32 addr, u16 val)
+{
+ switch (addr)
+ {
+ case 0xC4:
+ CartGPIO.data &= ~CartGPIO.direction;
+ CartGPIO.data |= val & CartGPIO.direction;
+ if (HasSolarSensor) GBACart_SolarSensor::Process(&CartGPIO);
+ break;
+ case 0xC6:
+ CartGPIO.direction = val;
+ break;
+ case 0xC8:
+ CartGPIO.control = val;
+ break;
+ default:
+ printf("Unknown GBA GPIO write 0x%02X @ 0x%04X\n", val, addr);
+ }
+
+ // write the GPIO values in the ROM (if writable)
+ if (CartGPIO.control & 1)
+ {
+ *(u16*)&CartROM[0xC4] = CartGPIO.data;
+ *(u16*)&CartROM[0xC6] = CartGPIO.direction;
+ *(u16*)&CartROM[0xC8] = CartGPIO.control;
+ }
+ else
+ {
+ // GBATEK: "in write-only mode, reads return 00h (or [possibly] other data (...))"
+ // ambiguous, but mGBA sets ROM to 00h when switching to write-only, so do the same
+ *(u16*)&CartROM[0xC4] = 0;
+ *(u16*)&CartROM[0xC6] = 0;
+ *(u16*)&CartROM[0xC8] = 0;
+ }
+}
+
+}
+
+
+namespace GBACart_SolarSensor
+{
+
+bool LightEdge;
+u8 LightCounter;
+u8 LightSample;
+u8 LightLevel; // 0-10 range
+
+// levels from mGBA
+const int GBA_LUX_LEVELS[11] = { 0, 5, 11, 18, 27, 42, 62, 84, 109, 139, 183 };
+#define LIGHT_VALUE (0xFF - (0x16 + GBA_LUX_LEVELS[LightLevel]))
+
+
+void Reset()
+{
+ LightEdge = false;
+ LightCounter = 0;
+ LightSample = 0xFF;
+ LightLevel = 0;
+}
+
+void DoSavestate(Savestate* file)
+{
+ file->Var8((u8*)&LightEdge);
+ file->Var8(&LightCounter);
+ file->Var8(&LightSample);
+ file->Var8(&LightLevel);
+}
+
+void Process(GBACart::GPIO* gpio)
+{
+ if (gpio->data & 4) return; // Boktai chip select
+ if (gpio->data & 2) // Reset
+ {
+ u8 prev = LightSample;
+ LightCounter = 0;
+ LightSample = LIGHT_VALUE;
+ printf("Solar sensor reset (sample: 0x%02X -> 0x%02X)\n", prev, LightSample);
+ }
+ if (gpio->data & 1 && LightEdge) LightCounter++;
+
+ LightEdge = !(gpio->data & 1);
+
+ bool sendBit = LightCounter >= LightSample;
+ if (gpio->control & 1)
+ {
+ gpio->data = (gpio->data & gpio->direction) | ((sendBit << 3) & ~gpio->direction & 0xF);
+ }
+}
+
+}
diff --git a/src/GBACart.h b/src/GBACart.h
new file mode 100644
index 0000000..96a05b8
--- /dev/null
+++ b/src/GBACart.h
@@ -0,0 +1,87 @@
+/*
+ Copyright 2019 Arisotura, Raphaël Zumer
+
+ 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/.
+*/
+
+#ifndef GBACART_H
+#define GBACART_H
+
+#include "types.h"
+#include "Savestate.h"
+
+
+namespace GBACart_SRAM
+{
+
+extern u8* SRAM;
+extern u32 SRAMLength;
+
+void Reset();
+void DoSavestate(Savestate* file);
+
+u8 Read8(u32 addr);
+u16 Read16(u32 addr);
+u32 Read32(u32 addr);
+
+void Write8(u32 addr, u8 val);
+void Write16(u32 addr, u16 val);
+void Write32(u32 addr, u32 val);
+
+}
+
+
+namespace GBACart
+{
+
+struct GPIO
+{
+ u16 data;
+ u16 direction;
+ u16 control;
+};
+
+extern bool CartInserted;
+extern bool HasSolarSensor;
+extern u8* CartROM;
+extern u32 CartROMSize;
+extern u32 CartCRC;
+
+bool Init();
+void DeInit();
+void Reset();
+void Eject();
+
+void DoSavestate(Savestate* file);
+bool LoadROM(const char* path, const char* sram);
+void RelocateSave(const char* path, bool write);
+
+void WriteGPIO(u32 addr, u16 val);
+
+}
+
+
+namespace GBACart_SolarSensor
+{
+
+extern u8 LightLevel;
+
+void Reset();
+void DoSavestate(Savestate* file);
+void Process(GBACart::GPIO* gpio);
+
+}
+
+#endif // GBACART_H
diff --git a/src/NDS.cpp b/src/NDS.cpp
index ceeeb79..47f96c9 100644
--- a/src/NDS.cpp
+++ b/src/NDS.cpp
@@ -22,6 +22,7 @@
#include "NDS.h"
#include "ARM.h"
#include "NDSCart.h"
+#include "GBACart.h"
#include "DMA.h"
#include "FIFO.h"
#include "GPU.h"
@@ -169,6 +170,7 @@ bool Init()
IPCFIFO7 = new FIFO<u32>(16);
if (!NDSCart::Init()) return false;
+ if (!GBACart::Init()) return false;
if (!GPU::Init()) return false;
if (!SPU::Init()) return false;
if (!SPI::Init()) return false;
@@ -190,6 +192,7 @@ void DeInit()
delete IPCFIFO7;
NDSCart::DeInit();
+ GBACart::DeInit();
GPU::DeInit();
SPU::DeInit();
SPI::DeInit();
@@ -491,6 +494,7 @@ void Reset()
RCnt = 0;
NDSCart::Reset();
+ GBACart::Reset();
GPU::Reset();
SPU::Reset();
SPI::Reset();
@@ -692,6 +696,7 @@ bool DoSavestate(Savestate* file)
ARM7->DoSavestate(file);
NDSCart::DoSavestate(file);
+ GBACart::DoSavestate(file);
GPU::DoSavestate(file);
SPU::DoSavestate(file);
SPI::DoSavestate(file);
@@ -720,6 +725,19 @@ bool LoadROM(const char* path, const char* sram, bool direct)
}
}
+bool LoadGBAROM(const char* path, const char* sram)
+{
+ if (GBACart::LoadROM(path, sram))
+ {
+ return true;
+ }
+ else
+ {
+ printf("Failed to load ROM %s\n", path);
+ return false;
+ }
+}
+
void LoadBIOS()
{
Reset();
@@ -1610,16 +1628,20 @@ u8 ARM9Read8(u32 addr)
case 0x08000000:
case 0x09000000:
- if (ExMemCnt[0] & (1<<7)) return 0xFF; // TODO: proper open bus
- //return *(u8*)&NDSCart::CartROM[addr & (NDSCart::CartROMSize-1)];
- //printf("GBA read8 %08X\n", addr);
- // TODO!!!
- return 0xFF;
+ if (ExMemCnt[0] & (1<<7)) return 0x00; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return *(u8*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
+ }
+ return 0xFF; // TODO: proper open bus
case 0x0A000000:
- if (ExMemCnt[0] & (1<<7)) return 0xFF; // TODO: proper open bus
- // TODO!!!
- return 0xFF;
+ if (ExMemCnt[0] & (1<<7)) return 0x00; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return GBACart_SRAM::Read8(addr & (GBACart_SRAM::SRAMLength-1));
+ }
+ return 0xFF; // TODO: proper open bus
}
printf("unknown arm9 read8 %08X\n", addr);
@@ -1671,16 +1693,20 @@ u16 ARM9Read16(u32 addr)
case 0x08000000:
case 0x09000000:
- if (ExMemCnt[0] & (1<<7)) return 0xFFFF; // TODO: proper open bus
- //return *(u8*)&NDSCart::CartROM[addr & (NDSCart::CartROMSize-1)];
- //printf("GBA read8 %08X\n", addr);
- // TODO!!!
- return 0xFFFF;
+ if (ExMemCnt[0] & (1<<7)) return 0x0000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return *(u16*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
+ }
+ return 0xFFFF; // TODO: proper open bus
case 0x0A000000:
- if (ExMemCnt[0] & (1<<7)) return 0xFFFF; // TODO: proper open bus
- // TODO!!!
- return 0xFFFF;
+ if (ExMemCnt[0] & (1<<7)) return 0x0000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return GBACart_SRAM::Read16(addr & (GBACart_SRAM::SRAMLength-1));
+ }
+ return 0xFFFF; // TODO: proper open bus
}
//printf("unknown arm9 read16 %08X %08X\n", addr, ARM9->R[15]);
@@ -1732,16 +1758,20 @@ u32 ARM9Read32(u32 addr)
case 0x08000000:
case 0x09000000:
- if (ExMemCnt[0] & (1<<7)) return 0xFFFFFFFF; // TODO: proper open bus
- //return *(u8*)&NDSCart::CartROM[addr & (NDSCart::CartROMSize-1)];
- //printf("GBA read8 %08X\n", addr);
- // TODO!!!
- return 0xFFFFFFFF;
+ if (ExMemCnt[0] & (1<<7)) return 0x00000000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return *(u32*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
+ }
+ return 0xFFFFFFFF; // TODO: proper open bus
case 0x0A000000:
- if (ExMemCnt[0] & (1<<7)) return 0xFFFFFFFF; // TODO: proper open bus
- // TODO!!!
- return 0xFFFFFFFF;
+ if (ExMemCnt[0] & (1<<7)) return 0x00000000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return GBACart_SRAM::Read32(addr & (GBACart_SRAM::SRAMLength-1));
+ }
+ return 0xFFFFFFFF; // TODO: proper open bus
}
printf("unknown arm9 read32 %08X | %08X %08X\n", addr, ARM9->R[15], ARM9->R[12]);
@@ -1772,6 +1802,27 @@ void ARM9Write8(u32 addr, u8 val)
case 0x07000000:
// checkme
return;
+
+ case 0x08000000:
+ case 0x09000000:
+ if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ if ((addr & 0x00FFFFFF) >= 0xC4 && (addr & 0x00FFFFFF) <= 0xC9)
+ {
+ GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
+ return;
+ }
+ }
+ break;
+
+ case 0x0A000000:
+ if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ GBACart_SRAM::Write8(addr & (GBACart_SRAM::SRAMLength-1), val);
+ }
+ return;
}
printf("unknown arm9 write8 %08X %02X\n", addr, val);
@@ -1815,6 +1866,29 @@ void ARM9Write16(u32 addr, u16 val)
if (!(PowerControl9 & ((addr & 0x400) ? (1<<9) : (1<<1)))) return;
*(u16*)&GPU::OAM[addr & 0x7FF] = val;
return;
+
+ case 0x08000000:
+ case 0x09000000:
+ if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ // Note: the lower bound is adjusted such that a write starting
+ // there will hit the first byte of the GPIO region.
+ if ((addr & 0x00FFFFFF) >= 0xC3 && (addr & 0x00FFFFFF) <= 0xC9)
+ {
+ GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
+ return;
+ }
+ }
+ break;
+
+ case 0x0A000000:
+ if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ GBACart_SRAM::Write16(addr & (GBACart_SRAM::SRAMLength-1), val);
+ }
+ return;
}
//printf("unknown arm9 write16 %08X %04X\n", addr, val);
@@ -1858,6 +1932,30 @@ void ARM9Write32(u32 addr, u32 val)
if (!(PowerControl9 & ((addr & 0x400) ? (1<<9) : (1<<1)))) return;
*(u32*)&GPU::OAM[addr & 0x7FF] = val;
return;
+
+ case 0x08000000:
+ case 0x09000000:
+ if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ // Note: the lower bound is adjusted such that a write starting
+ // there will hit the first byte of the GPIO region.
+ if ((addr & 0x00FFFFFF) >= 0xC1 && (addr & 0x00FFFFFF) <= 0xC9)
+ {
+ GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val & 0xFF);
+ GBACart::WriteGPIO((addr + 2) & (GBACart::CartROMSize-1), (val >> 16) & 0xFF);
+ return;
+ }
+ }
+ break;
+
+ case 0x0A000000:
+ if (ExMemCnt[0] & (1<<7)) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ GBACart_SRAM::Write32(addr & (GBACart_SRAM::SRAMLength-1), val);
+ }
+ return;
}
printf("unknown arm9 write32 %08X %08X | %08X\n", addr, val, ARM9->R[15]);
@@ -1935,16 +2033,20 @@ u8 ARM7Read8(u32 addr)
case 0x08000000:
case 0x09000000:
- if (!(ExMemCnt[0] & (1<<7))) return 0xFF; // TODO: proper open bus
- //return *(u8*)&NDSCart::CartROM[addr & (NDSCart::CartROMSize-1)];
- //printf("GBA read8 %08X\n", addr);
- // TODO!!!
- return 0xFF;
+ if (!(ExMemCnt[0] & (1<<7))) return 0x00; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return *(u8*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
+ }
+ return 0xFF; // TODO: proper open bus
case 0x0A000000:
- if (!(ExMemCnt[0] & (1<<7))) return 0xFF; // TODO: proper open bus
- // TODO!!!
- return 0xFF;
+ if (!(ExMemCnt[0] & (1<<7))) return 0x00; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return GBACart_SRAM::Read8(addr & (GBACart_SRAM::SRAMLength-1));
+ }
+ return 0xFF; // TODO: proper open bus
}
printf("unknown arm7 read8 %08X %08X %08X/%08X\n", addr, ARM7->R[15], ARM7->R[0], ARM7->R[1]);
@@ -1998,16 +2100,20 @@ u16 ARM7Read16(u32 addr)
case 0x08000000:
case 0x09000000:
- if (!(ExMemCnt[0] & (1<<7))) return 0xFFFF; // TODO: proper open bus
- //return *(u8*)&NDSCart::CartROM[addr & (NDSCart::CartROMSize-1)];
- //printf("GBA read8 %08X\n", addr);
- // TODO!!!
- return 0xFFFF;
+ if (!(ExMemCnt[0] & (1<<7))) return 0x0000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return *(u16*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
+ }
+ return 0xFFFF; // TODO: proper open bus
case 0x0A000000:
- if (!(ExMemCnt[0] & (1<<7))) return 0xFFFF; // TODO: proper open bus
- // TODO!!!
- return 0xFFFF;
+ if (!(ExMemCnt[0] & (1<<7))) return 0x0000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return GBACart_SRAM::Read16(addr & (GBACart_SRAM::SRAMLength-1));
+ }
+ return 0xFFFF; // TODO: proper open bus
}
printf("unknown arm7 read16 %08X %08X\n", addr, ARM7->R[15]);
@@ -2061,16 +2167,20 @@ u32 ARM7Read32(u32 addr)
case 0x08000000:
case 0x09000000:
- if (!(ExMemCnt[0] & (1<<7))) return 0xFFFFFFFF; // TODO: proper open bus
- //return *(u8*)&NDSCart::CartROM[addr & (NDSCart::CartROMSize-1)];
- //printf("GBA read8 %08X\n", addr);
- // TODO!!!
- return 0xFFFFFFFF;
+ if (!(ExMemCnt[0] & (1<<7))) return 0x00000000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return *(u32*)&GBACart::CartROM[addr & (GBACart::CartROMSize-1)];
+ }
+ return 0xFFFFFFFF; // TODO: proper open bus
case 0x0A000000:
- if (!(ExMemCnt[0] & (1<<7))) return 0xFFFFFFFF; // TODO: proper open bus
- // TODO!!!
- return 0xFFFFFFFF;
+ if (!(ExMemCnt[0] & (1<<7))) return 0x00000000; // deselected CPU is 00h-filled
+ if (GBACart::CartInserted)
+ {
+ return GBACart_SRAM::Read32(addr & (GBACart_SRAM::SRAMLength-1));
+ }
+ return 0xFFFFFFFF; // TODO: proper open bus
}
printf("unknown arm7 read32 %08X | %08X\n", addr, ARM7->R[15]);
@@ -2110,6 +2220,27 @@ void ARM7Write8(u32 addr, u8 val)
case 0x06800000:
GPU::WriteVRAM_ARM7<u8>(addr, val);
return;
+
+ case 0x08000000:
+ case 0x09000000:
+ if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ if ((addr & 0x00FFFFFF) >= 0xC4 && (addr & 0x00FFFFFF) <= 0xC9)
+ {
+ GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
+ return;
+ }
+ }
+ break;
+
+ case 0x0A000000:
+ if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ GBACart_SRAM::Write8(addr & (GBACart_SRAM::SRAMLength-1), val);
+ }
+ return;
}
printf("unknown arm7 write8 %08X %02X @ %08X\n", addr, val, ARM7->R[15]);
@@ -2156,6 +2287,29 @@ void ARM7Write16(u32 addr, u16 val)
case 0x06800000:
GPU::WriteVRAM_ARM7<u16>(addr, val);
return;
+
+ case 0x08000000:
+ case 0x09000000:
+ if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ // Note: the lower bound is adjusted such that a write starting
+ // there will hit the first byte of the GPIO region.
+ if ((addr & 0x00FFFFFF) >= 0xC3 && (addr & 0x00FFFFFF) <= 0xC9)
+ {
+ GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val);
+ return;
+ }
+ }
+ break;
+
+ case 0x0A000000:
+ if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ GBACart_SRAM::Write16(addr & (GBACart_SRAM::SRAMLength-1), val);
+ }
+ return;
}
//printf("unknown arm7 write16 %08X %04X @ %08X\n", addr, val, ARM7->R[15]);
@@ -2203,6 +2357,30 @@ void ARM7Write32(u32 addr, u32 val)
case 0x06800000:
GPU::WriteVRAM_ARM7<u32>(addr, val);
return;
+
+ case 0x08000000:
+ case 0x09000000:
+ if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ // Note: the lower bound is adjusted such that a write starting
+ // there will hit the first byte of the GPIO region.
+ if ((addr & 0x00FFFFFF) >= 0xC1 && (addr & 0x00FFFFFF) <= 0xC9)
+ {
+ GBACart::WriteGPIO(addr & (GBACart::CartROMSize-1), val & 0xFF);
+ GBACart::WriteGPIO((addr + 2) & (GBACart::CartROMSize-1), (val >> 16) & 0xFF);
+ return;
+ }
+ }
+ break;
+
+ case 0x0A000000:
+ if (!(ExMemCnt[0] & (1<<7))) return; // deselected CPU, skip the write
+ if (GBACart::CartInserted)
+ {
+ GBACart_SRAM::Write32(addr & (GBACart_SRAM::SRAMLength-1), val);
+ }
+ return;
}
//printf("unknown arm7 write32 %08X %08X @ %08X\n", addr, val, ARM7->R[15]);
diff --git a/src/NDS.h b/src/NDS.h
index 3243337..16c42ef 100644
--- a/src/NDS.h
+++ b/src/NDS.h
@@ -135,6 +135,7 @@ void SetARM9RegionTimings(u32 addrstart, u32 addrend, int buswidth, int nonseq,
void SetARM7RegionTimings(u32 addrstart, u32 addrend, int buswidth, int nonseq, int seq);
bool LoadROM(const char* path, const char* sram, bool direct);
+bool LoadGBAROM(const char* path, const char* sram);
void LoadBIOS();
void SetupDirectBoot();
void RelocateSave(const char* path, bool write);
diff --git a/src/NDSCart.cpp b/src/NDSCart.cpp
index 0ecd304..014ae5a 100644
--- a/src/NDSCart.cpp
+++ b/src/NDSCart.cpp
@@ -48,7 +48,6 @@ void Write_Null(u8 val, bool islast);
void Write_EEPROMTiny(u8 val, bool islast);
void Write_EEPROM(u8 val, bool islast);
void Write_Flash(u8 val, bool islast);
-void Write_Discover(u8 val, bool islast);
bool Init()
@@ -399,7 +398,7 @@ void Write(u8 val, u32 hold)
switch (CurCmd)
{
case 0x00:
- // Pokémon carts have an IR transceiver thing, and send this
+ // Pokémon carts have an IR transceiver thing, and send this
// to bypass it and access SRAM.
// TODO: design better
CurCmd = val;
diff --git a/src/libui_sdl/DlgInputConfig.cpp b/src/libui_sdl/DlgInputConfig.cpp
index a80e2ec..21394b1 100644
--- a/src/libui_sdl/DlgInputConfig.cpp
+++ b/src/libui_sdl/DlgInputConfig.cpp
@@ -71,7 +71,9 @@ char hotkeylabels[HK_MAX][32] =
"Pause/resume:",
"Reset:",
"Fast forward:",
- "Fast forward (toggle):"
+ "Fast forward (toggle):",
+ "Decrease sunlight (Boktai):",
+ "Increase sunlight (Boktai):"
};
int openedmask;
@@ -514,7 +516,7 @@ void Open(int type)
memcpy(dlg->keymap, Config::HKKeyMapping, sizeof(int)*HK_MAX);
memcpy(dlg->joymap, Config::HKJoyMapping, sizeof(int)*HK_MAX);
- dlg->win = uiNewWindow("Hotkey config - melonDS", 600, 100, 0, 0, 0);
+ dlg->win = uiNewWindow("Hotkey config - melonDS", 700, 100, 0, 0, 0);
}
uiControl(dlg->win)->UserData = dlg;
diff --git a/src/libui_sdl/PlatformConfig.cpp b/src/libui_sdl/PlatformConfig.cpp
index c8ec19f..a2eaab9 100644
--- a/src/libui_sdl/PlatformConfig.cpp
+++ b/src/libui_sdl/PlatformConfig.cpp
@@ -93,25 +93,29 @@ ConfigEntry PlatformConfigFile[] =
{"Joy_X", 0, &JoyMapping[10], -1, NULL, 0},
{"Joy_Y", 0, &JoyMapping[11], -1, NULL, 0},
- {"HKKey_Lid", 0, &HKKeyMapping[HK_Lid], 0x0D, NULL, 0},
- {"HKKey_Mic", 0, &HKKeyMapping[HK_Mic], 0x35, NULL, 0},
- {"HKKey_Pause", 0, &HKKeyMapping[HK_Pause], -1, NULL, 0},
- {"HKKey_Reset", 0, &HKKeyMapping[HK_Reset], -1, NULL, 0},
- {"HKKey_FastForward", 0, &HKKeyMapping[HK_FastForward], 0x0F, NULL, 0},
- {"HKKey_FastForwardToggle", 0, &HKKeyMapping[HK_FastForwardToggle], -1, NULL, 0},
-
- {"HKJoy_Lid", 0, &HKJoyMapping[HK_Lid], -1, NULL, 0},
- {"HKJoy_Mic", 0, &HKJoyMapping[HK_Mic], -1, NULL, 0},
- {"HKJoy_Pause", 0, &HKJoyMapping[HK_Pause], -1, NULL, 0},
- {"HKJoy_Reset", 0, &HKJoyMapping[HK_Reset], -1, NULL, 0},
- {"HKJoy_FastForward", 0, &HKJoyMapping[HK_FastForward], -1, NULL, 0},
- {"HKJoy_FastForwardToggle", 0, &HKJoyMapping[HK_FastForwardToggle], -1, NULL, 0},
+ {"HKKey_Lid", 0, &HKKeyMapping[HK_Lid], 0x0D, NULL, 0},
+ {"HKKey_Mic", 0, &HKKeyMapping[HK_Mic], 0x35, NULL, 0},
+ {"HKKey_Pause", 0, &HKKeyMapping[HK_Pause], -1, NULL, 0},
+ {"HKKey_Reset", 0, &HKKeyMapping[HK_Reset], -1, NULL, 0},
+ {"HKKey_FastForward", 0, &HKKeyMapping[HK_FastForward], 0x0F, NULL, 0},
+ {"HKKey_FastForwardToggle", 0, &HKKeyMapping[HK_FastForwardToggle], -1, NULL, 0},
+ {"HKKey_SolarSensorDecrease", 0, &HKKeyMapping[HK_SolarSensorDecrease], 0x4B, NULL, 0},
+ {"HKKey_SolarSensorIncrease", 0, &HKKeyMapping[HK_SolarSensorIncrease], 0x4D, NULL, 0},
+
+ {"HKJoy_Lid", 0, &HKJoyMapping[HK_Lid], -1, NULL, 0},
+ {"HKJoy_Mic", 0, &HKJoyMapping[HK_Mic], -1, NULL, 0},
+ {"HKJoy_Pause", 0, &HKJoyMapping[HK_Pause], -1, NULL, 0},
+ {"HKJoy_Reset", 0, &HKJoyMapping[HK_Reset], -1, NULL, 0},
+ {"HKJoy_FastForward", 0, &HKJoyMapping[HK_FastForward], -1, NULL, 0},
+ {"HKJoy_FastForwardToggle", 0, &HKJoyMapping[HK_FastForwardToggle], -1, NULL, 0},
+ {"HKJoy_SolarSensorDecrease", 0, &HKJoyMapping[HK_SolarSensorDecrease], -1, NULL, 0},
+ {"HKJoy_SolarSensorIncrease", 0, &HKJoyMapping[HK_SolarSensorIncrease], -1, NULL, 0},
{"JoystickID", 0, &JoystickID, 0, NULL, 0},
{"WindowWidth", 0, &WindowWidth, 256, NULL, 0},
{"WindowHeight", 0, &WindowHeight, 384, NULL, 0},
- {"WindowMax", 0, &WindowMaximized, 0, NULL, 0},
+ {"WindowMax", 0, &WindowMaximized, 0, NULL, 0},
{"ScreenRotation", 0, &ScreenRotation, 0, NULL, 0},
{"ScreenGap", 0, &ScreenGap, 0, NULL, 0},
diff --git a/src/libui_sdl/PlatformConfig.h b/src/libui_sdl/PlatformConfig.h
index 842e72a..682b9bc 100644
--- a/src/libui_sdl/PlatformConfig.h
+++ b/src/libui_sdl/PlatformConfig.h
@@ -29,6 +29,8 @@ enum
HK_Reset,
HK_FastForward,
HK_FastForwardToggle,
+ HK_SolarSensorDecrease,
+ HK_SolarSensorIncrease,
HK_MAX
};
diff --git a/src/libui_sdl/main.cpp b/src/libui_sdl/main.cpp
index 2742e4a..4c0d6dd 100644
--- a/src/libui_sdl/main.cpp
+++ b/src/libui_sdl/main.cpp
@@ -38,6 +38,7 @@
#include "DlgWifiSettings.h"
#include "../NDS.h"
+#include "../GBACart.h"
#include "../GPU.h"
#include "../SPU.h"
#include "../Wifi.h"
@@ -105,9 +106,9 @@ int EmuRunning;
volatile int EmuStatus;
bool RunningSomething;
-char ROMPath[1024];
-char SRAMPath[1024];
-char PrevSRAMPath[1024]; // for savestate 'undo load'
+char ROMPath[2][1024];
+char SRAMPath[2][1024];
+char PrevSRAMPath[2][1024]; // for savestate 'undo load'
bool SavestateLoaded;
@@ -184,7 +185,7 @@ void SetupScreenRects(int width, int height);
void TogglePause(void* blarg);
void Reset(void* blarg);
-void SetupSRAMPath();
+void SetupSRAMPath(int slot);
void SaveState(int slot);
void LoadState(int slot);
@@ -954,6 +955,24 @@ int EmuThreadFunc(void* burp)
if (HotkeyPressed(HK_Pause)) uiQueueMain(TogglePause, NULL);
if (HotkeyPressed(HK_Reset)) uiQueueMain(Reset, NULL);
+ if (GBACart::CartInserted && GBACart::HasSolarSensor)
+ {
+ if (HotkeyPressed(HK_SolarSensorDecrease))
+ {
+ if (GBACart_SolarSensor::LightLevel > 0) GBACart_SolarSensor::LightLevel--;
+ char msg[64];
+ sprintf(msg, "Solar sensor level set to %d", GBACart_SolarSensor::LightLevel);
+ OSD::AddMessage(0, msg);
+ }
+ if (HotkeyPressed(HK_SolarSensorIncrease))
+ {
+ if (GBACart_SolarSensor::LightLevel < 10) GBACart_SolarSensor::LightLevel++;
+ char msg[64];
+ sprintf(msg, "Solar sensor level set to %d", GBACart_SolarSensor::LightLevel);
+ OSD::AddMessage(0, msg);
+ }
+ }
+
if (EmuRunning == 1)
{
EmuStatus = 1;
@@ -1663,12 +1682,18 @@ void Reset(void* blarg)
SavestateLoaded = false;
uiMenuItemDisable(MenuItem_UndoStateLoad);
- if (ROMPath[0] == '\0')
+ if (ROMPath[0][0] == '\0')
NDS::LoadBIOS();
else
{
- SetupSRAMPath();
- NDS::LoadROM(ROMPath, SRAMPath, Config::DirectBoot);
+ SetupSRAMPath(0);
+ NDS::LoadROM(ROMPath[0], SRAMPath[0], Config::DirectBoot);
+ }
+
+ if (ROMPath[1][0] != '\0')
+ {
+ SetupSRAMPath(1);
+ NDS::LoadGBAROM(ROMPath[1], SRAMPath[1]);
}
Run();
@@ -1683,6 +1708,10 @@ void Stop(bool internal)
while (EmuStatus != 2);
RunningSomething = false;
+ // eject any inserted GBA cartridge
+ GBACart::Eject();
+ ROMPath[1][0] = '\0';
+
uiWindowSetTitle(MainWindow, "melonDS " MELONDS_VERSION);
for (int i = 0; i < 9; i++) uiMenuItemDisable(MenuItem_SaveStateSlot[i]);
@@ -1703,41 +1732,53 @@ void Stop(bool internal)
OSD::AddMessage(0xFFC040, "Shutdown");
}
-void SetupSRAMPath()
+void SetupSRAMPath(int slot)
{
- strncpy(SRAMPath, ROMPath, 1023);
- SRAMPath[1023] = '\0';
- strncpy(SRAMPath + strlen(ROMPath) - 3, "sav", 3);
+ strncpy(SRAMPath[slot], ROMPath[slot], 1023);
+ SRAMPath[slot][1023] = '\0';
+ strncpy(SRAMPath[slot] + strlen(ROMPath[slot]) - 3, "sav", 3);
}
-void TryLoadROM(char* file, int prevstatus)
+void TryLoadROM(char* file, int slot, int prevstatus)
{
char oldpath[1024];
char oldsram[1024];
- strncpy(oldpath, ROMPath, 1024);
- strncpy(oldsram, SRAMPath, 1024);
+ strncpy(oldpath, ROMPath[slot], 1024);
+ strncpy(oldsram, SRAMPath[slot], 1024);
- strncpy(ROMPath, file, 1023);
- ROMPath[1023] = '\0';
+ strncpy(ROMPath[slot], file, 1023);
+ ROMPath[slot][1023] = '\0';
- SetupSRAMPath();
+ SetupSRAMPath(0);
+ SetupSRAMPath(1);
- if (NDS::LoadROM(ROMPath, SRAMPath, Config::DirectBoot))
+ if (slot == 0 && NDS::LoadROM(ROMPath[slot], SRAMPath[slot], Config::DirectBoot))
{
SavestateLoaded = false;
uiMenuItemDisable(MenuItem_UndoStateLoad);
- strncpy(PrevSRAMPath, SRAMPath, 1024); // safety
+ // Reload the inserted GBA cartridge (if any)
+ if (ROMPath[1][0] != '\0') NDS::LoadGBAROM(ROMPath[1], SRAMPath[1]);
+
+ strncpy(PrevSRAMPath[slot], SRAMPath[slot], 1024); // safety
Run();
}
+ else if (slot == 1 && NDS::LoadGBAROM(ROMPath[slot], SRAMPath[slot]))
+ {
+ SavestateLoaded = false;
+ uiMenuItemDisable(MenuItem_UndoStateLoad);
+
+ strncpy(PrevSRAMPath[slot], SRAMPath[slot], 1024); // safety
+ if (RunningSomething) Run(); // do not start just from a GBA cart
+ }
else
{
uiMsgBoxError(MainWindow,
"Failed to load the ROM",
"Make sure the file can be accessed and isn't opened in another application.");
- strncpy(ROMPath, oldpath, 1024);
- strncpy(SRAMPath, oldsram, 1024);
+ strncpy(ROMPath[slot], oldpath, 1024);
+ strncpy(SRAMPath[slot], oldsram, 1024);
EmuRunning = prevstatus;
}
}
@@ -1750,22 +1791,22 @@ void GetSavestateName(int slot, char* filename, int len)
{
int pos;
- if (ROMPath[0] == '\0') // running firmware, no ROM
+ if (ROMPath[0][0] == '\0') // running firmware, no ROM
{
strcpy(filename, "firmware");
pos = 8;
}
else
{
- int l = strlen(ROMPath);
+ int l = strlen(ROMPath[0]);
pos = l;
- while (ROMPath[pos] != '.' && pos > 0) pos--;
+ while (ROMPath[0][pos] != '.' && pos > 0) pos--;
if (pos == 0) pos = l;
// avoid buffer overflow. shoddy
if (pos > len-5) pos = len-5;
- strncpy(&filename[0], ROMPath, pos);
+ strncpy(&filename[0], ROMPath[0], pos);
}
strcpy(&filename[pos], ".ml");
filename[pos+3] = '0'+slot;
@@ -1809,6 +1850,8 @@ void LoadState(int slot)
return;
}
+ u32 oldGBACartCRC = GBACart::CartCRC;
+
// backup
Savestate* backup = new Savestate("timewarp.mln", true);
NDS::DoSavestate(backup);
@@ -1833,21 +1876,36 @@ void LoadState(int slot)
if (!failed)
{
- if (Config::SavestateRelocSRAM && ROMPath[0]!='\0')
+ if (Config::SavestateRelocSRAM && ROMPath[0][0]!='\0')
{
- strncpy(PrevSRAMPath, SRAMPath, 1024);
+ strncpy(PrevSRAMPath[0], SRAMPath[0], 1024);
+
+ strncpy(SRAMPath[0], filename, 1019);
+ int len = strlen(SRAMPath[0]);
+ strcpy(&SRAMPath[0][len], ".sav");
+ SRAMPath[0][len+4] = '\0';
+
+ NDS::RelocateSave(SRAMPath[0], false);
+ }
- strncpy(SRAMPath, filename, 1019);
- int len = strlen(SRAMPath);
- strcpy(&SRAMPath[len], ".sav");
- SRAMPath[len+4] = '\0';
+ bool loadedPartialGBAROM = false;
- NDS::RelocateSave(SRAMPath, false);
+ // in case we have a GBA cart inserted, and the GBA ROM changes
+ // due to having loaded a save state, we do not want to reload
+ // the previous cartridge on reset, or commit writes to any
+ // loaded save file. therefore, their paths are "nulled".
+ if (GBACart::CartInserted && GBACart::CartCRC != oldGBACartCRC)
+ {
+ ROMPath[1][0] = '\0';
+ SRAMPath[1][0] = '\0';
+ loadedPartialGBAROM = true;
}
char msg[64];
- if (slot > 0) sprintf(msg, "State loaded from slot %d", slot);
- else sprintf(msg, "State loaded from file");
+ if (slot > 0) sprintf(msg, "State loaded from slot %d%s",
+ slot, loadedPartialGBAROM ? " (GBA ROM header only)" : "");
+ else sprintf(msg, "State loaded from file%s",
+ loadedPartialGBAROM ? " (GBA ROM header only)" : "");
OSD::AddMessage(0, msg);
SavestateLoaded = true;
@@ -1898,14 +1956,14 @@ void SaveState(int slot)
if (slot > 0)
uiMenuItemEnable(MenuItem_LoadStateSlot[slot-1]);
- if (Config::SavestateRelocSRAM && ROMPath[0]!='\0')
+ if (Config::SavestateRelocSRAM && ROMPath[0][0]!='\0')
{
- strncpy(SRAMPath, filename, 1019);
- int len = strlen(SRAMPath);
- strcpy(&SRAMPath[len], ".sav");
- SRAMPath[len+4] = '\0';
+ strncpy(SRAMPath[0], filename, 1019);
+ int len = strlen(SRAMPath[0]);
+ strcpy(&SRAMPath[0][len], ".sav");
+ SRAMPath[0][len+4] = '\0';
- NDS::RelocateSave(SRAMPath, true);
+ NDS::RelocateSave(SRAMPath[0], true);
}
}
@@ -1932,10 +1990,10 @@ void UndoStateLoad()
NDS::DoSavestate(backup);
delete backup;
- if (ROMPath[0]!='\0')
+ if (ROMPath[0][0]!='\0')
{
- strncpy(SRAMPath, PrevSRAMPath, 1024);
- NDS::RelocateSave(SRAMPath, false);
+ strncpy(SRAMPath[0], PrevSRAMPath[0], 1024);
+ NDS::RelocateSave(SRAMPath[0], false);
}
OSD::AddMessage(0, "State load undone");
@@ -1979,7 +2037,11 @@ void OnDropFile(uiWindow* window, char* file, void* blarg)
while (EmuStatus != 2);
}
- TryLoadROM(file, prevstatus);
+ TryLoadROM(file, 0, prevstatus);
+ }
+ else if (!strcasecmp(ext, "gba"))
+ {
+ TryLoadROM(file, 1, prevstatus);
}
}
@@ -2010,7 +2072,7 @@ void OnOpenFile(uiMenuItem* item, uiWindow* window, void* blarg)
EmuRunning = 2;
while (EmuStatus != 2);
- char* file = uiOpenFile(window, "DS ROM (*.nds)|*.nds;*.srl|Any file|*.*", Config::LastROMFolder);
+ char* file = uiOpenFile(window, "DS ROM (*.nds)|*.nds;*.srl|GBA ROM (*.gba)|*.gba|Any file|*.*", Config::LastROMFolder);
if (!file)
{
EmuRunning = prevstatus;
@@ -2021,8 +2083,17 @@ void OnOpenFile(uiMenuItem* item, uiWindow* window, void* blarg)
while (file[pos] != '/' && file[pos] != '\\' && pos > 0) pos--;
strncpy(Config::LastROMFolder, file, pos);
Config::LastROMFolder[pos] = '\0';
+ char* ext = &file[strlen(file)-3];
+
+ if (!strcasecmp(ext, "gba"))
+ {
+ TryLoadROM(file, 1, prevstatus);
+ }
+ else
+ {
+ TryLoadROM(file, 0, prevstatus);
+ }
- TryLoadROM(file, prevstatus);
uiFreeText(file);
}
@@ -2047,8 +2118,14 @@ void OnRun(uiMenuItem* item, uiWindow* window, void* blarg)
{
if (!RunningSomething)
{
- ROMPath[0] = '\0';
+ ROMPath[0][0] = '\0';
NDS::LoadBIOS();
+
+ if (ROMPath[1][0] != '\0')
+ {
+ SetupSRAMPath(1);
+ NDS::LoadGBAROM(ROMPath[1], SRAMPath[1]);
+ }
}
Run();
@@ -2867,14 +2944,30 @@ int main(int argc, char** argv)
if (!strcasecmp(ext, "nds") || !strcasecmp(ext, "srl"))
{
- strncpy(ROMPath, file, 1023);
- ROMPath[1023] = '\0';
+ strncpy(ROMPath[0], file, 1023);
+ ROMPath[0][1023] = '\0';
- SetupSRAMPath();
+ SetupSRAMPath(0);
- if (NDS::LoadROM(ROMPath, SRAMPath, Config::DirectBoot))
+ if (NDS::LoadROM(ROMPath[0], SRAMPath[0], Config::DirectBoot))
Run();
}
+
+ if (argc > 2)
+ {
+ file = argv[2];
+ ext = &file[strlen(file)-3];
+
+ if (!strcasecmp(ext, "gba"))
+ {
+ strncpy(ROMPath[1], file, 1023);
+ ROMPath[1][1023] = '\0';
+
+ SetupSRAMPath(1);
+
+ NDS::LoadGBAROM(ROMPath[1], SRAMPath[1]);
+ }
+ }
}
uiMain();