Merge branch 'v0.2' of https://github.com/PSI-Rockin/CorgiDS into v0.2

CorgiDS/CorgiDS.pro

@@ -46,7 +46,9 @@ SOURCES += \
     ../src/bios.cpp \
     ../src/qt/audiodevice.cpp \
     ../src/disasm_thumb.cpp \
-    ../src/debugger.cpp
+    ../src/debugger.cpp \
+    ../src/slot2.cpp \
+    ../src/gba/gbarw.cpp
 
 DEFINES += QT_DEPRECATED_WARNINGS
 DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000
@@ -80,7 +82,8 @@ HEADERS += \
     ../src/qt/emuthread.hpp \
     ../src/bios.hpp \
     ../src/qt/audiodevice.hpp \
-    ../src/debugger.hpp
+    ../src/debugger.hpp \
+    ../src/slot2.hpp
 
 FORMS += \
     ../src/qt/configwindow.ui \

src/arm7rw.cpp

@@ -8,6 +8,9 @@
 
 uint32_t Emulator::arm7_read_word(uint32_t address)
 {
+    //TODO: bad hack.
+    if (gba_mode)
+        return gba_read_word(address);
     if (address >= MAIN_RAM_START && address < SHARED_WRAM_START)
         return *(uint32_t*)&main_RAM[address & MAIN_RAM_MASK];
     if (address >= ARM7_WRAM_START && address < IO_REGS_START)
@@ -77,15 +80,18 @@ uint32_t Emulator::arm7_read_word(uint32_t address)
     }
     if (address >= 0x06000000 && address < 0x07000000)
         return gpu.read_ARM7<uint32_t>(address);
-    if (address >= GBA_ROM_START)
-        return 0xFFFFFFFF;
+    if (address >= GBA_ROM_START && address < GBA_RAM_START)
+        return slot2.read<uint32_t>(address);
     printf("\n(7) Unrecognized word read from $%08X", address);
     //exit(2);
     return 0;
 }
 
 uint16_t Emulator::arm7_read_halfword(uint32_t address)
 {
+    //TODO: bad hack.
+    if (gba_mode)
+        return gba_read_halfword(address);
     if (address < 0x4000)
     {
         if (arm7.get_PC() > 0x4000)
@@ -193,15 +199,18 @@ uint16_t Emulator::arm7_read_halfword(uint32_t address)
         return wifi.read(address);
     if (address >= 0x06000000 && address < 0x07000000)
         return gpu.read_ARM7<uint16_t>(address);
-    if (address >= GBA_ROM_START)
-        return 0xFFFF;
+    if (address >= GBA_ROM_START && address < GBA_RAM_START)
+        return slot2.read<uint16_t>(address);
     printf("\n(7) Unrecognized halfword read from $%08X", address);
     //exit(2);
     return 0;
 }
 
 uint8_t Emulator::arm7_read_byte(uint32_t address)
 {
+    //TODO: bad hack.
+    if (gba_mode)
+        return gba_read_byte(address);
     if (address >= MAIN_RAM_START && address < SHARED_WRAM_START)
         return main_RAM[address & MAIN_RAM_MASK];
     if (address >= ARM7_WRAM_START && address < IO_REGS_START)
@@ -253,17 +262,20 @@ uint8_t Emulator::arm7_read_byte(uint32_t address)
     }
     if (address >= 0x04000400 && address < 0x04000500)
         return spu.read_channel_byte(address);
+    if (address >= GBA_ROM_START && address < GBA_RAM_START)
+        return slot2.read<uint8_t>(address);
     printf("\n(7) Unrecognized byte read from $%08X", address);
     //exit(2);
     return 0;
 }
 
 void Emulator::arm7_write_word(uint32_t address, uint32_t word)
 {
-    if (address == 0x027E0014)
+    //TODO: bad hack.
+    if (gba_mode)
     {
-        printf("\n(7) Write of $%08X to $%08X", word, address);
-        //exit(0);
+        gba_write_word(address, word);
+        return;
     }
     if (address >= MAIN_RAM_START && address < SHARED_WRAM_START)
     {
@@ -413,6 +425,12 @@ void Emulator::arm7_write_word(uint32_t address, uint32_t word)
 
 void Emulator::arm7_write_halfword(uint32_t address, uint16_t halfword)
 {
+    //TODO: bad hack.
+    if (gba_mode)
+    {
+        gba_write_halfword(address, halfword);
+        return;
+    }
     if (address >= MAIN_RAM_START && address < SHARED_WRAM_START)
     {
         *(uint16_t*)&main_RAM[address & MAIN_RAM_MASK] = halfword;
@@ -581,6 +599,12 @@ void Emulator::arm7_write_halfword(uint32_t address, uint16_t halfword)
 
 void Emulator::arm7_write_byte(uint32_t address, uint8_t byte)
 {
+    //TODO: bad hack.
+    if (gba_mode)
+    {
+        gba_write_byte(address, byte);
+        return;
+    }
     if (address >= MAIN_RAM_START && address < SHARED_WRAM_START)
     {
         main_RAM[address & MAIN_RAM_MASK] = byte;
@@ -639,6 +663,9 @@ void Emulator::arm7_write_byte(uint32_t address, uint8_t byte)
         case 0x04000301:
             switch (byte)
             {
+                case 0x40:
+                    start_gba_mode(true);
+                    break;
                 case 0x80:
                     arm7.halt();
                     /*printf("\nHalted ARM7");

src/arm9rw.cpp

@@ -154,8 +154,8 @@ uint32_t Emulator::arm9_read_word(uint32_t address)
         return gpu.read_lcdc<uint32_t>(address);
     if (address >= OAM_START && address < GBA_ROM_START)
         return gpu.read_OAM<uint32_t>(address);
-    if (address >= GBA_ROM_START)
-        return 0xFFFFFFFF;
+    if (address >= GBA_ROM_START && address < GBA_RAM_START)
+        return slot2.read<uint32_t>(address);
     //Ignore reads from NULL
     printf("\n(9) Unrecognized word read from $%08X", address);
     //exit(1);
@@ -321,8 +321,8 @@ uint16_t Emulator::arm9_read_halfword(uint32_t address)
         return gpu.read_objb<uint16_t>(address);
     if (address >= VRAM_LCDC_A && address < VRAM_LCDC_END)
         return gpu.read_lcdc<uint16_t>(address);
-    if (address >= GBA_ROM_START)
-        return 0xFFFF;
+    if (address >= GBA_ROM_START && address < GBA_RAM_START)
+        return slot2.read<uint16_t>(address);
     printf("\n(9) Unrecognized halfword read from $%08X", address);
     return 0;
     //exit(1);
@@ -398,8 +398,8 @@ uint8_t Emulator::arm9_read_byte(uint32_t address)
         return gpu.read_lcdc<uint8_t>(address);
     if (address >= OAM_START && address < GBA_ROM_START)
         return gpu.read_OAM<uint8_t>(address);
-    if (address >= GBA_ROM_START)
-        return 0xFF;
+    if (address >= GBA_ROM_START && address < GBA_RAM_START)
+        return slot2.read<uint8_t>(address);
     printf("\n(9) Unrecognized byte read from $%08X", address);
     //exit(1);
     return 0;

src/config.cpp

@@ -12,7 +12,9 @@ namespace Config
     std::string arm9_bios_path;
     std::string firmware_path;
     std::string savelist_path;
+    std::string gba_bios_path;
     bool direct_boot_enabled;
+    bool gba_direct_boot;
     bool pause_when_unfocused;
 
     bool bg_enable[4];

src/config.hpp

@@ -14,7 +14,9 @@ namespace Config
     extern std::string arm9_bios_path;
     extern std::string firmware_path;
     extern std::string savelist_path;
+    extern std::string gba_bios_path;
     extern bool direct_boot_enabled;
+    extern bool gba_direct_boot;
     extern bool pause_when_unfocused;
 
     extern bool bg_enable[4];

src/emulator.cpp

@@ -75,6 +75,7 @@ void Emulator::power_on()
 {
     for (int i = 0; i < 4; i++)
         Config::bg_enable[i] = true;
+    gba_mode = false;
     cycle_count = 0;
     arm9.power_on();
     arm7.power_on();
@@ -161,12 +162,22 @@ int Emulator::load_ROM(string ROM_file_name)
 
 void Emulator::load_bios7(uint8_t *bios)
 {
-    memcpy(arm7_bios, bios, 16384 * sizeof(uint8_t));
+    memcpy(arm7_bios, bios, BIOS7_SIZE);
 }
 
 void Emulator::load_bios9(uint8_t *bios)
 {
-    memcpy(arm9_bios, bios, 4096 * sizeof(uint8_t));
+    memcpy(arm9_bios, bios, BIOS9_SIZE);
+}
+
+void Emulator::load_bios_gba(uint8_t *bios)
+{
+    memcpy(gba_bios, bios, BIOS_GBA_SIZE);
+}
+
+void Emulator::load_slot2(uint8_t *data, uint64_t size)
+{
+    slot2.load_data(data, size);
 }
 
 void Emulator::load_firmware(uint8_t *firmware)
@@ -184,7 +195,7 @@ int Emulator::load_firmware()
         return 1;
     }
 
-    arm9_bios_file.read((char*)arm9_bios, 4096 * sizeof(uint8_t));
+    arm9_bios_file.read((char*)arm9_bios, BIOS9_SIZE);
     printf("ARM9 BIOS loaded successfully.\n");
 
     arm9_bios_file.close();
@@ -197,11 +208,23 @@ int Emulator::load_firmware()
         return 1;
     }
 
-    arm7_bios_file.read((char*)arm7_bios, 16384 * sizeof(uint8_t));
+    arm7_bios_file.read((char*)arm7_bios, BIOS7_SIZE);
     printf("ARM7 BIOS loaded successfully.\n");
 
     arm7_bios_file.close();
 
+    ifstream gba_bios_file(Config::gba_bios_path, ios::in | ios::binary);
+    if (!gba_bios_file.is_open())
+    {
+        printf("Warning: failed to load GBA BIOS\n");
+    }
+    else
+    {
+        gba_bios_file.read((char*)gba_bios, BIOS_GBA_SIZE);
+        gba_bios_file.close();
+        printf("GBA BIOS loaded successfully.\n");
+    }
+
     return spi.init(Config::firmware_path);
 }
 
@@ -312,6 +335,36 @@ void Emulator::run()
     cart.save_check();
 }
 
+void Emulator::run_gba()
+{
+    gpu.start_frame();
+    while (!gpu.is_frame_complete())
+    {
+        arm7.execute();
+    }
+}
+
+bool Emulator::is_gba()
+{
+    return gba_mode;
+}
+
+//Only use throw_exception when emulation has started
+void Emulator::start_gba_mode(bool throw_exception)
+{
+    gba_mode = true;
+    arm7.jp(0, true);
+    debug();
+    //Allocate VRAM C and D as 256 KB work RAM
+    gpu.set_VRAMCNT_C(0x82);
+    gpu.set_VRAMCNT_D(0x86);
+    if (throw_exception)
+    {
+        //Signal to the emulation thread that emulation has switched from NDS to GBA
+        throw "!";
+    }
+}
+
 uint64_t Emulator::get_timestamp()
 {
     return system_timestamp;

src/emulator.hpp

@@ -15,6 +15,7 @@
 #include "interrupts.hpp"
 #include "ipc.hpp"
 #include "rtc.hpp"
+#include "slot2.hpp"
 #include "spi.hpp"
 #include "spu.hpp"
 #include "timers.hpp"
@@ -75,16 +76,20 @@ class Emulator
         NDS_DMA dma;
         GPU gpu;
         RealTimeClock rtc;
+        Slot2Device slot2;
         SPI_Bus spi;
         SPU spu;
         NDS_Timing timers;
         WiFi wifi;
+
+        bool gba_mode;
 
         uint8_t main_RAM[1024 * 1024 * 4]; //4 MB
         uint8_t shared_WRAM[1024 * 32]; //32 KB
         uint8_t arm7_WRAM[1024 * 64]; //64 KB
         uint8_t arm9_bios[BIOS9_SIZE];
         uint8_t arm7_bios[BIOS7_SIZE];
+        uint8_t gba_bios[BIOS_GBA_SIZE];
 
         //Scheduling
         uint64_t system_timestamp;
@@ -136,9 +141,11 @@ class Emulator
         Emulator();
         int init();
         int load_firmware();
+        void load_bios_gba(uint8_t* bios);
         void load_bios7(uint8_t* bios);
         void load_bios9(uint8_t* bios);
         void load_firmware(uint8_t* firmware);
+        void load_slot2(uint8_t* data, uint64_t size);
         void load_save_database(std::string name);
         int load_ROM(std::string ROM_name);
 
@@ -149,8 +156,12 @@ class Emulator
         void direct_boot();
         void debug();
         void run();
+        void run_gba();
         bool requesting_interrupt(int cpu_id);
 
+        bool is_gba();
+        void start_gba_mode(bool throw_exception);
+
         uint64_t get_timestamp();
 
         void get_upper_frame(uint32_t* buffer);
@@ -188,6 +199,13 @@ class Emulator
         void arm7_write_word(uint32_t address, uint32_t word);
         void arm7_write_halfword(uint32_t address, uint16_t halfword);
         void arm7_write_byte(uint32_t address, uint8_t byte);
+
+        uint32_t gba_read_word(uint32_t address);
+        uint16_t gba_read_halfword(uint32_t address);
+        uint8_t gba_read_byte(uint32_t address);
+        void gba_write_word(uint32_t address, uint32_t word);
+        void gba_write_halfword(uint32_t address, uint16_t halfword);
+        void gba_write_byte(uint32_t address, uint8_t byte);
 
         void cart_copy_keybuffer(uint8_t* buffer);
         void cart_write_header(uint32_t address, uint16_t halfword);