summaryrefslogtreecommitdiffstats
path: root/src/core
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/core/arm/arm_interface.h11
-rw-r--r--src/core/arm/interpreter/arm_interpreter.cpp39
-rw-r--r--src/core/arm/interpreter/arm_interpreter.h37
-rw-r--r--src/core/arm/interpreter/armemu.cpp3
-rw-r--r--src/core/arm/interpreter/armemu.h11
-rw-r--r--src/core/arm/interpreter/arminit.cpp8
-rw-r--r--src/core/arm/interpreter/armsupp.cpp68
-rw-r--r--src/core/core.cpp4
-rw-r--r--src/core/core.vcxproj21
-rw-r--r--src/core/core.vcxproj.filters69
-rw-r--r--src/core/hle/function_wrappers.h736
-rw-r--r--src/core/hle/hle.cpp120
-rw-r--r--src/core/hle/hle.h66
-rw-r--r--src/core/hle/service/apt.cpp116
-rw-r--r--src/core/hle/service/apt.h41
-rw-r--r--src/core/hle/service/gsp.cpp59
-rw-r--r--src/core/hle/service/gsp.h35
-rw-r--r--src/core/hle/service/hid.cpp33
-rw-r--r--src/core/hle/service/hid.h37
-rw-r--r--src/core/hle/service/service.cpp94
-rw-r--r--src/core/hle/service/service.h143
-rw-r--r--src/core/hle/service/srv.cpp58
-rw-r--r--src/core/hle/service/srv.h40
-rw-r--r--src/core/hle/syscall.cpp197
-rw-r--r--src/core/hle/syscall.h19
-rw-r--r--src/core/hw/hw.cpp75
-rw-r--r--src/core/hw/lcd.cpp (renamed from src/core/hw/hw_lcd.cpp)6
-rw-r--r--src/core/hw/lcd.h (renamed from src/core/hw/hw_lcd.h)0
-rw-r--r--src/core/hw/ndma.cpp48
-rw-r--r--src/core/hw/ndma.h26
-rw-r--r--src/core/mem_map.cpp27
-rw-r--r--src/core/mem_map.h92
-rw-r--r--src/core/mem_map_funcs.cpp197
-rw-r--r--src/core/system.cpp15
34 files changed, 2339 insertions, 212 deletions
diff --git a/src/core/arm/arm_interface.h b/src/core/arm/arm_interface.h
index dafde8368..eee4726db 100644
--- a/src/core/arm/arm_interface.h
+++ b/src/core/arm/arm_interface.h
@@ -43,6 +43,13 @@ public:
virtual u32 GetReg(int index) const = 0;
/**
+ * Set an ARM register
+ * @param index Register index (0-15)
+ * @param value Value to set register to
+ */
+ virtual void SetReg(int index, u32 value) = 0;
+
+ /**
* Get the current CPSR register
* @return Returns the value of the CPSR register
*/
@@ -59,11 +66,13 @@ public:
return m_num_instructions;
}
-private:
+protected:
/// Execture next instruction
virtual void ExecuteInstruction() = 0;
+private:
+
u64 m_num_instructions; ///< Number of instructions executed
DISALLOW_COPY_AND_ASSIGN(ARM_Interface);
diff --git a/src/core/arm/interpreter/arm_interpreter.cpp b/src/core/arm/interpreter/arm_interpreter.cpp
index 81f38f016..4045779d7 100644
--- a/src/core/arm/interpreter/arm_interpreter.cpp
+++ b/src/core/arm/interpreter/arm_interpreter.cpp
@@ -31,30 +31,61 @@ ARM_Interpreter::ARM_Interpreter() {
m_state->Reg[13] = 0x10000000; // Set stack pointer to the top of the stack
}
+ARM_Interpreter::~ARM_Interpreter() {
+ delete m_state;
+}
+
+/**
+ * Set the Program Counter to an address
+ * @param addr Address to set PC to
+ */
void ARM_Interpreter::SetPC(u32 pc) {
m_state->pc = m_state->Reg[15] = pc;
}
+/*
+ * Get the current Program Counter
+ * @return Returns current PC
+ */
u32 ARM_Interpreter::GetPC() const {
return m_state->pc;
}
+/**
+ * Get an ARM register
+ * @param index Register index (0-15)
+ * @return Returns the value in the register
+ */
u32 ARM_Interpreter::GetReg(int index) const {
return m_state->Reg[index];
}
+/**
+ * Set an ARM register
+ * @param index Register index (0-15)
+ * @param value Value to set register to
+ */
+void ARM_Interpreter::SetReg(int index, u32 value) {
+ m_state->Reg[index] = value;
+}
+
+/**
+ * Get the current CPSR register
+ * @return Returns the value of the CPSR register
+ */
u32 ARM_Interpreter::GetCPSR() const {
return m_state->Cpsr;
}
+/**
+ * Returns the number of clock ticks since the last reset
+ * @return Returns number of clock ticks
+ */
u64 ARM_Interpreter::GetTicks() const {
return ARMul_Time(m_state);
}
-ARM_Interpreter::~ARM_Interpreter() {
- delete m_state;
-}
-
+/// Execture next instruction
void ARM_Interpreter::ExecuteInstruction() {
m_state->step++;
m_state->cycle++;
diff --git a/src/core/arm/interpreter/arm_interpreter.h b/src/core/arm/interpreter/arm_interpreter.h
index 932046d9a..f3c86f8dd 100644
--- a/src/core/arm/interpreter/arm_interpreter.h
+++ b/src/core/arm/interpreter/arm_interpreter.h
@@ -12,22 +12,55 @@
class ARM_Interpreter : virtual public ARM_Interface {
public:
+
ARM_Interpreter();
~ARM_Interpreter();
- void ExecuteInstruction();
-
+ /**
+ * Set the Program Counter to an address
+ * @param addr Address to set PC to
+ */
void SetPC(u32 pc);
+ /*
+ * Get the current Program Counter
+ * @return Returns current PC
+ */
u32 GetPC() const;
+ /**
+ * Get an ARM register
+ * @param index Register index (0-15)
+ * @return Returns the value in the register
+ */
u32 GetReg(int index) const;
+ /**
+ * Set an ARM register
+ * @param index Register index (0-15)
+ * @param value Value to set register to
+ */
+ void SetReg(int index, u32 value);
+
+ /**
+ * Get the current CPSR register
+ * @return Returns the value of the CPSR register
+ */
u32 GetCPSR() const;
+ /**
+ * Returns the number of clock ticks since the last reset
+ * @return Returns number of clock ticks
+ */
u64 GetTicks() const;
+protected:
+
+ /// Execture next instruction
+ void ExecuteInstruction();
+
private:
+
ARMul_State* m_state;
DISALLOW_COPY_AND_ASSIGN(ARM_Interpreter);
diff --git a/src/core/arm/interpreter/armemu.cpp b/src/core/arm/interpreter/armemu.cpp
index 46c51fbe8..6074ff480 100644
--- a/src/core/arm/interpreter/armemu.cpp
+++ b/src/core/arm/interpreter/armemu.cpp
@@ -16,6 +16,8 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+#include "core/hle/hle.h"
+
#include "arm_regformat.h"
#include "armdefs.h"
#include "armemu.h"
@@ -4558,6 +4560,7 @@ ARMul_Emulate26 (ARMul_State * state)
// ARMul_OSHandleSWI (state, BITS (0, 23));
// break;
//}
+ HLE::CallSyscall(instr);
ARMul_Abort (state, ARMul_SWIV);
break;
}
diff --git a/src/core/arm/interpreter/armemu.h b/src/core/arm/interpreter/armemu.h
index 7391dea7f..7c118948a 100644
--- a/src/core/arm/interpreter/armemu.h
+++ b/src/core/arm/interpreter/armemu.h
@@ -229,6 +229,17 @@ extern ARMword isize;
} \
while (0)
+#define SETABORT_SKIPBRANCH(i, m, d) \
+ do \
+ { \
+ int SETABORT_mode = (m); \
+ \
+ ARMul_SetSPSR (state, SETABORT_mode, ARMul_GetCPSR (state)); \
+ ARMul_SetCPSR (state, ((ARMul_GetCPSR (state) & ~(EMODE | TBIT)) \
+ | (i) | SETABORT_mode)); \
+ } \
+ while (0)
+
//#ifndef MODE32
#define VECTORS 0x20
#define LEGALADDR 0x03ffffff
diff --git a/src/core/arm/interpreter/arminit.cpp b/src/core/arm/interpreter/arminit.cpp
index cdbd02f3c..a8aeecdea 100644
--- a/src/core/arm/interpreter/arminit.cpp
+++ b/src/core/arm/interpreter/arminit.cpp
@@ -530,9 +530,13 @@ ARMul_Abort (ARMul_State * state, ARMword vector)
isize);
break;
case ARMul_SWIV: /* Software Interrupt */
- SETABORT (IBIT, state->prog32Sig ? SVC32MODE : SVC26MODE,
+ // Modified SETABORT that doesn't branch to a SVC vector as we are implementing this in HLE
+ // Instead of doing normal routine, backup R15 by one instruction (this is what PC will get
+ // set to, making it the next instruction after the SVC call), and skip setting the LR.
+ SETABORT_SKIPBRANCH (IBIT, state->prog32Sig ? SVC32MODE : SVC26MODE,
isize);
- break;
+ state->Reg[15] -= 4;
+ return;
case ARMul_PrefetchAbortV: /* Prefetch Abort */
state->AbortAddr = 1;
SETABORT (IBIT, state->prog32Sig ? ABORT32MODE : SVC26MODE,
diff --git a/src/core/arm/interpreter/armsupp.cpp b/src/core/arm/interpreter/armsupp.cpp
index a0c866c15..101b9807a 100644
--- a/src/core/arm/interpreter/armsupp.cpp
+++ b/src/core/arm/interpreter/armsupp.cpp
@@ -19,6 +19,8 @@
#include "armemu.h"
//#include "ansidecl.h"
#include "skyeye_defs.h"
+#include "core/hle/hle.h"
+
unsigned xscale_cp15_cp_access_allowed (ARMul_State * state, unsigned reg,
unsigned cpnum);
//extern int skyeye_instr_debug;
@@ -734,39 +736,39 @@ ARMword
ARMul_MRC (ARMul_State * state, ARMword instr)
{
unsigned cpab;
- ARMword result = 0;
-
- //printf("SKYEYE ARMul_MRC, CPnum is %x, instr %x\n",CPNum, instr);
- if (!CP_ACCESS_ALLOWED (state, CPNum)) {
- //chy 2004-07-19 should fix in the future????!!!!
- //printf("SKYEYE ARMul_MRC,NOT ALLOWed UndefInstr CPnum is %x, instr %x\n",CPNum, instr);
- ARMul_UndefInstr (state, instr);
- return -1;
- }
-
- cpab = (state->MRC[CPNum]) (state, ARMul_FIRST, instr, &result);
- while (cpab == ARMul_BUSY) {
- ARMul_Icycles (state, 1, 0);
- if (IntPending (state)) {
- cpab = (state->MRC[CPNum]) (state, ARMul_INTERRUPT,
- instr, 0);
- return (0);
- }
- else
- cpab = (state->MRC[CPNum]) (state, ARMul_BUSY, instr,
- &result);
- }
- if (cpab == ARMul_CANT) {
- printf ("SKYEYE ARMul_MRC,CANT UndefInstr CPnum is %x, instr %x\n", CPNum, instr);
- ARMul_Abort (state, ARMul_UndefinedInstrV);
- /* Parent will destroy the flags otherwise. */
- result = ECC;
- }
- else {
- BUSUSEDINCPCN;
- ARMul_Ccycles (state, 1, 0);
- ARMul_Icycles (state, 1, 0);
- }
+ ARMword result = HLE::CallGetThreadCommandBuffer();
+
+ ////printf("SKYEYE ARMul_MRC, CPnum is %x, instr %x\n",CPNum, instr);
+ //if (!CP_ACCESS_ALLOWED (state, CPNum)) {
+ // //chy 2004-07-19 should fix in the future????!!!!
+ // //printf("SKYEYE ARMul_MRC,NOT ALLOWed UndefInstr CPnum is %x, instr %x\n",CPNum, instr);
+ // ARMul_UndefInstr (state, instr);
+ // return -1;
+ //}
+
+ //cpab = (state->MRC[CPNum]) (state, ARMul_FIRST, instr, &result);
+ //while (cpab == ARMul_BUSY) {
+ // ARMul_Icycles (state, 1, 0);
+ // if (IntPending (state)) {
+ // cpab = (state->MRC[CPNum]) (state, ARMul_INTERRUPT,
+ // instr, 0);
+ // return (0);
+ // }
+ // else
+ // cpab = (state->MRC[CPNum]) (state, ARMul_BUSY, instr,
+ // &result);
+ //}
+ //if (cpab == ARMul_CANT) {
+ // printf ("SKYEYE ARMul_MRC,CANT UndefInstr CPnum is %x, instr %x\n", CPNum, instr);
+ // ARMul_Abort (state, ARMul_UndefinedInstrV);
+ // /* Parent will destroy the flags otherwise. */
+ // result = ECC;
+ //}
+ //else {
+ // BUSUSEDINCPCN;
+ // ARMul_Ccycles (state, 1, 0);
+ // ARMul_Icycles (state, 1, 0);
+ //}
return result;
}
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 28f6b6c58..859a62c78 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -40,7 +40,7 @@ void Stop() {
/// Initialize the core
int Init() {
- NOTICE_LOG(MASTER_LOG, "Core initialized OK");
+ NOTICE_LOG(MASTER_LOG, "initialized OK");
g_disasm = new ARM_Disasm();
g_app_core = new ARM_Interpreter();
@@ -54,7 +54,7 @@ void Shutdown() {
delete g_app_core;
delete g_sys_core;
- NOTICE_LOG(MASTER_LOG, "Core shutdown OK");
+ NOTICE_LOG(MASTER_LOG, "shutdown OK");
}
} // namespace
diff --git a/src/core/core.vcxproj b/src/core/core.vcxproj
index 1800b5512..b6fc604c6 100644
--- a/src/core/core.vcxproj
+++ b/src/core/core.vcxproj
@@ -152,8 +152,16 @@
<ClCompile Include="elf\elf_reader.cpp" />
<ClCompile Include="file_sys\directory_file_system.cpp" />
<ClCompile Include="file_sys\meta_file_system.cpp" />
+ <ClCompile Include="hle\hle.cpp" />
+ <ClCompile Include="hle\service\apt.cpp" />
+ <ClCompile Include="hle\service\gsp.cpp" />
+ <ClCompile Include="hle\service\hid.cpp" />
+ <ClCompile Include="hle\service\service.cpp" />
+ <ClCompile Include="hle\service\srv.cpp" />
+ <ClCompile Include="hle\syscall.cpp" />
<ClCompile Include="hw\hw.cpp" />
- <ClCompile Include="hw\hw_lcd.cpp" />
+ <ClCompile Include="hw\lcd.cpp" />
+ <ClCompile Include="hw\ndma.cpp" />
<ClCompile Include="loader.cpp" />
<ClCompile Include="mem_map.cpp" />
<ClCompile Include="mem_map_funcs.cpp" />
@@ -182,8 +190,17 @@
<ClInclude Include="file_sys\directory_file_system.h" />
<ClInclude Include="file_sys\file_sys.h" />
<ClInclude Include="file_sys\meta_file_system.h" />
+ <ClInclude Include="hle\function_wrappers.h" />
+ <ClInclude Include="hle\hle.h" />
+ <ClInclude Include="hle\service\apt.h" />
+ <ClInclude Include="hle\service\gsp.h" />
+ <ClInclude Include="hle\service\hid.h" />
+ <ClInclude Include="hle\service\service.h" />
+ <ClInclude Include="hle\service\srv.h" />
+ <ClInclude Include="hle\syscall.h" />
<ClInclude Include="hw\hw.h" />
- <ClInclude Include="hw\hw_lcd.h" />
+ <ClInclude Include="hw\lcd.h" />
+ <ClInclude Include="hw\ndma.h" />
<ClInclude Include="loader.h" />
<ClInclude Include="mem_map.h" />
<ClInclude Include="system.h" />
diff --git a/src/core/core.vcxproj.filters b/src/core/core.vcxproj.filters
index 2efac8127..ff7877feb 100644
--- a/src/core/core.vcxproj.filters
+++ b/src/core/core.vcxproj.filters
@@ -22,6 +22,12 @@
<Filter Include="elf">
<UniqueIdentifier>{7ae34319-6d72-4d12-bc62-9b438ba9241f}</UniqueIdentifier>
</Filter>
+ <Filter Include="hle">
+ <UniqueIdentifier>{8b62769e-3e2a-4a57-a7bc-b3b2933c2bc7}</UniqueIdentifier>
+ </Filter>
+ <Filter Include="hle\service">
+ <UniqueIdentifier>{812c5189-ca49-4704-b842-3ffad09092d3}</UniqueIdentifier>
+ </Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="arm\disassembler\arm_disasm.cpp">
@@ -63,9 +69,6 @@
<ClCompile Include="hw\hw.cpp">
<Filter>hw</Filter>
</ClCompile>
- <ClCompile Include="hw\hw_lcd.cpp">
- <Filter>hw</Filter>
- </ClCompile>
<ClCompile Include="elf\elf_reader.cpp">
<Filter>elf</Filter>
</ClCompile>
@@ -75,6 +78,33 @@
<ClCompile Include="mem_map_funcs.cpp" />
<ClCompile Include="system.cpp" />
<ClCompile Include="core_timing.cpp" />
+ <ClCompile Include="hle\hle.cpp">
+ <Filter>hle</Filter>
+ </ClCompile>
+ <ClCompile Include="hle\syscall.cpp">
+ <Filter>hle</Filter>
+ </ClCompile>
+ <ClCompile Include="hle\service\service.cpp">
+ <Filter>hle\service</Filter>
+ </ClCompile>
+ <ClCompile Include="hle\service\apt.cpp">
+ <Filter>hle\service</Filter>
+ </ClCompile>
+ <ClCompile Include="hle\service\srv.cpp">
+ <Filter>hle\service</Filter>
+ </ClCompile>
+ <ClCompile Include="hle\service\gsp.cpp">
+ <Filter>hle\service</Filter>
+ </ClCompile>
+ <ClCompile Include="hle\service\hid.cpp">
+ <Filter>hle\service</Filter>
+ </ClCompile>
+ <ClCompile Include="hw\ndma.cpp">
+ <Filter>hw</Filter>
+ </ClCompile>
+ <ClCompile Include="hw\lcd.cpp">
+ <Filter>hw</Filter>
+ </ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="arm\disassembler\arm_disasm.h">
@@ -131,9 +161,6 @@
<ClInclude Include="hw\hw.h">
<Filter>hw</Filter>
</ClInclude>
- <ClInclude Include="hw\hw_lcd.h">
- <Filter>hw</Filter>
- </ClInclude>
<ClInclude Include="elf\elf_reader.h">
<Filter>elf</Filter>
</ClInclude>
@@ -148,6 +175,36 @@
<ClInclude Include="loader.h" />
<ClInclude Include="mem_map.h" />
<ClInclude Include="system.h" />
+ <ClInclude Include="hle\hle.h">
+ <Filter>hle</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\function_wrappers.h">
+ <Filter>hle</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\service\service.h">
+ <Filter>hle\service</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\syscall.h">
+ <Filter>hle</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\service\apt.h">
+ <Filter>hle\service</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\service\srv.h">
+ <Filter>hle\service</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\service\gsp.h">
+ <Filter>hle\service</Filter>
+ </ClInclude>
+ <ClInclude Include="hle\service\hid.h">
+ <Filter>hle\service</Filter>
+ </ClInclude>
+ <ClInclude Include="hw\ndma.h">
+ <Filter>hw</Filter>
+ </ClInclude>
+ <ClInclude Include="hw\lcd.h">
+ <Filter>hw</Filter>
+ </ClInclude>
</ItemGroup>
<ItemGroup>
<Text Include="CMakeLists.txt" />
diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
new file mode 100644
index 000000000..4897d3f28
--- /dev/null
+++ b/src/core/hle/function_wrappers.h
@@ -0,0 +1,736 @@
+// Copyright (c) 2012- PPSSPP Project.
+
+// This program 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, version 2.0 or later versions.
+
+// This program 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 2.0 for more details.
+
+// A copy of the GPL 2.0 should have been included with the program.
+// If not, see http://www.gnu.org/licenses/
+
+// Official git repository and contact information can be found at
+// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/mem_map.h"
+#include "core/hle/hle.h"
+
+// For easy parameter parsing and return value processing.
+
+//32bit wrappers
+template<void func()> void WrapV_V() {
+ func();
+}
+
+template<u32 func()> void WrapU_V() {
+ RETURN(func());
+}
+
+template<int func(void *, const char *)> void WrapI_VC() {
+ u32 retval = func(Memory::GetPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)));
+ RETURN(retval);
+}
+
+template<u32 func(int, void *, int)> void WrapU_IVI() {
+ u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(const char *, int, int, u32)> void WrapI_CIIU() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(int, const char *, u32, void *, void *, u32, int)> void WrapI_ICUVVUI() {
+ u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointer(PARAM(3)),Memory::GetPointer(PARAM(4)), PARAM(5), PARAM(6) );
+ RETURN(retval);
+}
+
+// Hm, do so many params get passed in registers?
+template<int func(const char *, int, const char *, int, int, int, int, int)> void WrapI_CICIIIII() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), Memory::GetCharPointer(PARAM(2)),
+ PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7));
+ RETURN(retval);
+}
+
+// Hm, do so many params get passed in registers?
+template<int func(const char *, int, int, int, int, int, int)> void WrapI_CIIIIII() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4), PARAM(5), PARAM(6));
+ RETURN(retval);
+}
+
+// Hm, do so many params get passed in registers?
+template<int func(int, int, int, int, int, int, u32)> void WrapI_IIIIIIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
+ RETURN(retval);
+}
+
+// Hm, do so many params get passed in registers?
+template<int func(int, int, int, int, int, int, int, int, u32)> void WrapI_IIIIIIIIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6), PARAM(7), PARAM(8));
+ RETURN(retval);
+}
+
+template<u32 func(int, void *)> void WrapU_IV() {
+ u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)));
+ RETURN(retval);
+}
+
+template<float func()> void WrapF_V() {
+ RETURNF(func());
+}
+
+// TODO: Not sure about the floating point parameter passing
+template<float func(int, float, u32)> void WrapF_IFU() {
+ RETURNF(func(PARAM(0), PARAMF(0), PARAM(1)));
+}
+
+template<u32 func(u32)> void WrapU_U() {
+ u32 retval = func(PARAM(0));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int)> void WrapU_UI() {
+ u32 retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(u32)> void WrapI_U() {
+ int retval = func(PARAM(0));
+ RETURN(retval);
+}
+
+template<int func(u32, int)> void WrapI_UI() {
+ int retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(u32, int, int, u32)> void WrapI_UIIU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(int, u32, int)> void WrapU_IUI() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(u32, u32)> void WrapI_UU() {
+ int retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(u32, float, float)> void WrapI_UFF() {
+ // Not sure about the float arguments.
+ int retval = func(PARAM(0), PARAMF(0), PARAMF(1));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, u32)> void WrapI_UUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, u32, int)> void WrapI_UUUI() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, u32, int, int, int,int )> void WrapI_UUUIIII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, u32, u32)> void WrapI_UUUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, u32, u32, u32)> void WrapI_UUUUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func()> void WrapI_V() {
+ int retval = func();
+ RETURN(retval);
+}
+
+template<u32 func(int)> void WrapU_I() {
+ u32 retval = func(PARAM(0));
+ RETURN(retval);
+}
+
+template<u32 func(int, int, u32)> void WrapU_IIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(int)> void WrapI_I() {
+ int retval = func(PARAM(0));
+ RETURN(retval);
+}
+
+template<void func(u32)> void WrapV_U() {
+ func(PARAM(0));
+}
+
+template<void func(int)> void WrapV_I() {
+ func(PARAM(0));
+}
+
+template<void func(u32, u32)> void WrapV_UU() {
+ func(PARAM(0), PARAM(1));
+}
+
+template<void func(int, int)> void WrapV_II() {
+ func(PARAM(0), PARAM(1));
+}
+
+template<void func(u32, const char *)> void WrapV_UC() {
+ func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
+}
+
+template<int func(u32, const char *)> void WrapI_UC() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
+ RETURN(retval);
+}
+
+template<int func(u32, const char *, int)> void WrapI_UCI() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int , int , int, int, int)> void WrapU_UIIIII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int , int , int, u32)> void WrapU_UIIIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int , int , int, int, int, int)> void WrapU_UIIIIII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32)> void WrapU_UU() {
+ u32 retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, int)> void WrapU_UUI() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, int, int)> void WrapU_UUII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(const char *, u32, u32, u32)> void WrapU_CUUU() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<void func(u32, int, u32, int, int)> void WrapV_UIUII() {
+ func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+}
+
+template<u32 func(u32, int, u32, int, int)> void WrapU_UIUII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(u32, int, u32, int, int)> void WrapI_UIUII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int, u32, int)> void WrapU_UIUI() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(u32, int, u32, int)> void WrapI_UIUI() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int, u32)> void WrapU_UIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int, u32, u32)> void WrapU_UIUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int, int)> void WrapU_UII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int, int, u32)> void WrapU_UIIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(u32, int, int, u32, u32)> void WrapI_UIIUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, int, int)> void WrapI_UUII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, int, int, int)> void WrapI_UUIII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<void func(u32, int, int, int)> void WrapV_UIII() {
+ func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+}
+
+template<void func(u32, int, int, int, int, int)> void WrapV_UIIIII() {
+ func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
+}
+
+template<void func(u32, int, int)> void WrapV_UII() {
+ func(PARAM(0), PARAM(1), PARAM(2));
+}
+
+template<u32 func(int, u32)> void WrapU_IU() {
+ int retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(int, u32)> void WrapI_IU() {
+ int retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, int)> void WrapI_UUI() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(u32, u32, int, u32)> void WrapI_UUIU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(int, int)> void WrapI_II() {
+ int retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(int, int, int)> void WrapI_III() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(int, u32, int)> void WrapI_IUI() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(int, int, int, int)> void WrapI_IIII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(u32, int, int, int)> void WrapI_UIII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(int, int, int, u32, int)> void WrapI_IIIUI() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(int, u32, u32, int, int)> void WrapI_IUUII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(int, const char *, int, u32, u32)> void WrapI_ICIUU() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(int, int, u32)> void WrapI_IIU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<void func(int, u32)> void WrapV_IU() {
+ func(PARAM(0), PARAM(1));
+}
+
+template<void func(u32, int)> void WrapV_UI() {
+ func(PARAM(0), PARAM(1));
+}
+
+template<u32 func(const char *)> void WrapU_C() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)));
+ RETURN(retval);
+}
+
+template<u32 func(const char *, const char *, const char *, u32)> void WrapU_CCCU() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)),
+ Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)),
+ PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(const char *)> void WrapI_C() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)));
+ RETURN(retval);
+}
+
+template<int func(const char *, u32)> void WrapI_CU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
+ RETURN(retval);
+}
+
+template<int func(const char *, u32, int)> void WrapI_CUI() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(int, const char *, int, u32)> void WrapI_ICIU() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(const char *, int, u32)> void WrapI_CIU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(const char *, u32, u32)> void WrapI_CUU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(const char *, u32, u32, u32)> void WrapI_CUUU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(const char *, const char*, int, int)> void WrapI_CCII() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(const char *, u32, u32, int, u32, u32)> void WrapI_CUUIUU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<int func(const char *, int, int, u32, int, int)> void WrapI_CIIUII() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<int func(const char *, int, u32, u32, u32)> void WrapI_CIUUU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(const char *, u32, u32, u32, u32, u32)> void WrapI_CUUUUU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<u32 func(const char *, u32)> void WrapU_CU() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
+ RETURN((u32) retval);
+}
+
+template<u32 func(u32, const char *)> void WrapU_UC() {
+ u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
+ RETURN(retval);
+}
+
+template<u32 func(const char *, u32, u32)> void WrapU_CUU() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
+ RETURN((u32) retval);
+}
+
+template<u32 func(int, int, int)> void WrapU_III() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(int, int)> void WrapU_II() {
+ u32 retval = func(PARAM(0), PARAM(1));
+ RETURN(retval);
+}
+
+template<u32 func(int, int, int, int)> void WrapU_IIII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(int, u32, u32)> void WrapU_IUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(int, u32, u32, u32)> void WrapU_IUUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(int, u32, u32, u32, u32)> void WrapU_IUUUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32)> void WrapU_UUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<void func(int, u32, u32)> void WrapV_IUU() {
+ func(PARAM(0), PARAM(1), PARAM(2));
+}
+
+template<void func(int, int, u32)> void WrapV_IIU() {
+ func(PARAM(0), PARAM(1), PARAM(2));
+}
+
+template<void func(u32, int, u32)> void WrapV_UIU() {
+ func(PARAM(0), PARAM(1), PARAM(2));
+}
+
+template<int func(u32, int, u32)> void WrapI_UIU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<void func(int, u32, u32, u32, u32)> void WrapV_IUUUU() {
+ func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+}
+
+template<void func(u32, u32, u32)> void WrapV_UUU() {
+ func(PARAM(0), PARAM(1), PARAM(2));
+}
+
+template<void func(u32, u32, u32, u32)> void WrapV_UUUU() {
+ func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+}
+
+template<void func(const char *, u32, int, u32)> void WrapV_CUIU() {
+ func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
+}
+
+template<int func(const char *, u32, int, u32)> void WrapI_CUIU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<void func(u32, const char *, u32, int, u32)> void WrapV_UCUIU() {
+ func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3),
+ PARAM(4));
+}
+
+template<int func(u32, const char *, u32, int, u32)> void WrapI_UCUIU() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2),
+ PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<void func(const char *, u32, int, int, u32)> void WrapV_CUIIU() {
+ func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3),
+ PARAM(4));
+}
+
+template<int func(const char *, u32, int, int, u32)> void WrapI_CUIIU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32, u32)> void WrapU_UUUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(u32, const char *, u32, u32)> void WrapU_UCUU() {
+ u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32, int)> void WrapU_UUUI() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32, int, u32)> void WrapU_UUUIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32, int, u32, int)> void WrapU_UUUIUI() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, int, u32)> void WrapU_UUIU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<u32 func(u32, int, int, int)> void WrapU_UIII() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(int, u32, u32, u32, u32)> void WrapI_IUUUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<int func(int, u32, u32, u32, u32, u32)> void WrapI_IUUUUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<int func(int, u32, int, int)> void WrapI_IUII() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+template<u32 func(u32, u32, u32, u32, u32)> void WrapU_UUUUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<void func(u32, u32, u32, u32, u32)> void WrapV_UUUUU() {
+ func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
+}
+
+template<u32 func(const char *, const char *)> void WrapU_CC() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)),
+ Memory::GetCharPointer(PARAM(1)));
+ RETURN(retval);
+}
+
+template<void func(const char *, int)> void WrapV_CI() {
+ func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
+}
+
+template<u32 func(const char *, int)> void WrapU_CI() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
+ RETURN(retval);
+}
+
+template<u32 func(const char *, int, int)> void WrapU_CII() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(const char *, int, u32, int, u32)> void WrapU_CIUIU() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template<u32 func(const char *, int, u32, int, u32, int)> void WrapU_CIUIUI() {
+ u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2),
+ PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4),
+ PARAM(5));
+ RETURN(retval);
+}
+
+template<int func(int, u32, u32, u32)> void WrapI_IUUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(int, u32, u32)> void WrapI_IUU() {
+ int retval = func(PARAM(0), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template<u32 func(u32, u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5), PARAM(6));
+ RETURN(retval);
+}
+
+template<int func(u32, int, u32, u32)> void WrapI_UIUU() {
+ u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
+ RETURN(retval);
+}
+
+template<int func(int, const char *)> void WrapI_IC() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
+ RETURN(retval);
+}
+
+template <int func(int, const char *, const char *, u32, int)> void WrapI_ICCUI() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3), PARAM(4));
+ RETURN(retval);
+}
+
+template <int func(int, const char *, const char *, int)> void WrapI_ICCI() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), Memory::GetCharPointer(PARAM(2)), PARAM(3));
+ RETURN(retval);
+}
+
+template <int func(const char *, int, int)> void WrapI_CII() {
+ int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2));
+ RETURN(retval);
+}
+
+template <int func(int, const char *, int)> void WrapI_ICI() {
+ int retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2));
+ RETURN(retval);
+}
+
+template<int func(int, void *, void *, void *, void *, u32, int)> void WrapI_IVVVVUI(){
+ u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)), Memory::GetPointer(PARAM(2)), Memory::GetPointer(PARAM(3)), Memory::GetPointer(PARAM(4)), PARAM(5), PARAM(6) );
+ RETURN(retval);
+}
+
+template<int func(int, const char *, u32, void *, int, int, int)> void WrapI_ICUVIII(){
+ u32 retval = func(PARAM(0), Memory::GetCharPointer(PARAM(1)), PARAM(2), Memory::GetPointer(PARAM(3)), PARAM(4), PARAM(5), PARAM(6));
+ RETURN(retval);
+}
+
+template<int func(void *, u32, u32, u32, u32, u32)> void WrapI_VUUUUU(){
+ u32 retval = func(Memory::GetPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
+ RETURN(retval);
+}
+
+template<int func(u32, s64)> void WrapI_US64() {
+ int retval = func(PARAM(0), PARAM64(2));
+ RETURN(retval);
+}
diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
new file mode 100644
index 000000000..5672a659f
--- /dev/null
+++ b/src/core/hle/hle.cpp
@@ -0,0 +1,120 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <vector>
+
+#include "core/mem_map.h"
+#include "core/hle/hle.h"
+#include "core/hle/syscall.h"
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace HLE {
+
+static std::vector<ModuleDef> g_module_db;
+
+u8* g_command_buffer = NULL; ///< Command buffer used for sharing between appcore and syscore
+
+// Read from memory used by CTROS HLE functions
+template <typename T>
+inline void Read(T &var, const u32 addr) {
+ if (addr >= HLE::CMD_BUFFER_ADDR && addr < HLE::CMD_BUFFER_ADDR_END) {
+ var = *((const T*)&g_command_buffer[addr & CMD_BUFFER_MASK]);
+ } else {
+ ERROR_LOG(HLE, "unknown read from address %08X", addr);
+ }
+}
+
+// Write to memory used by CTROS HLE functions
+template <typename T>
+inline void Write(u32 addr, const T data) {
+ if (addr >= HLE::CMD_BUFFER_ADDR && addr < HLE::CMD_BUFFER_ADDR_END) {
+ *(T*)&g_command_buffer[addr & CMD_BUFFER_MASK] = data;
+ } else {
+ ERROR_LOG(HLE, "unknown write to address %08X", addr);
+ }
+}
+
+u8 *GetPointer(const u32 addr) {
+ if (addr >= HLE::CMD_BUFFER_ADDR && addr < HLE::CMD_BUFFER_ADDR_END) {
+ return g_command_buffer + (addr & CMD_BUFFER_MASK);
+ } else {
+ ERROR_LOG(HLE, "unknown pointer from address %08X", addr);
+ return 0;
+ }
+}
+
+// Explicitly instantiate template functions because we aren't defining this in the header:
+
+template void Read<u64>(u64 &var, const u32 addr);
+template void Read<u32>(u32 &var, const u32 addr);
+template void Read<u16>(u16 &var, const u32 addr);
+template void Read<u8>(u8 &var, const u32 addr);
+
+template void Write<u64>(u32 addr, const u64 data);
+template void Write<u32>(u32 addr, const u32 data);
+template void Write<u16>(u32 addr, const u16 data);
+template void Write<u8>(u32 addr, const u8 data);
+
+const FunctionDef* GetSyscallInfo(u32 opcode) {
+ u32 func_num = opcode & 0xFFFFFF; // 8 bits
+ if (func_num > 0xFF) {
+ ERROR_LOG(HLE,"Unknown syscall: 0x%02X", func_num);
+ return NULL;
+ }
+ return &g_module_db[0].func_table[func_num];
+}
+
+void CallSyscall(u32 opcode) {
+ const FunctionDef *info = GetSyscallInfo(opcode);
+
+ if (!info) {
+ return;
+ }
+ if (info->func) {
+ info->func();
+ } else {
+ ERROR_LOG(HLE, "Unimplemented SysCall function %s(..)", info->name.c_str());
+ }
+}
+
+/// Returns the coprocessor (in this case, syscore) command buffer pointer
+Addr CallGetThreadCommandBuffer() {
+ // Called on insruction: mrc p15, 0, r0, c13, c0, 3
+ // Returns an address in OSHLE memory for the CPU to read/write to
+ RETURN(CMD_BUFFER_ADDR);
+ return CMD_BUFFER_ADDR;
+}
+
+void RegisterModule(std::string name, int num_functions, const FunctionDef* func_table) {
+ ModuleDef module = {name, num_functions, func_table};
+ g_module_db.push_back(module);
+}
+
+void RegisterAllModules() {
+ Syscall::Register();
+}
+
+void Init() {
+ Service::Init();
+
+ g_command_buffer = new u8[CMD_BUFFER_SIZE];
+
+ RegisterAllModules();
+
+ NOTICE_LOG(HLE, "initialized OK");
+}
+
+void Shutdown() {
+ Service::Shutdown();
+
+ delete g_command_buffer;
+
+ g_module_db.clear();
+
+ NOTICE_LOG(HLE, "shutdown OK");
+}
+
+} // namespace
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
new file mode 100644
index 000000000..628a1da89
--- /dev/null
+++ b/src/core/hle/hle.h
@@ -0,0 +1,66 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/core.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#define PARAM(n) Core::g_app_core->GetReg(n)
+#define PARAM64(n) (Core::g_app_core->GetReg(n) | ((u64)Core::g_app_core->GetReg(n + 1) << 32))
+#define RETURN(n) Core::g_app_core->SetReg(0, n)
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace HLE {
+
+enum {
+ CMD_BUFFER_ADDR = 0xA0010000, ///< Totally arbitrary unused address space
+ CMD_BUFFER_SIZE = 0x10000,
+ CMD_BUFFER_MASK = (CMD_BUFFER_SIZE - 1),
+ CMD_BUFFER_ADDR_END = (CMD_BUFFER_ADDR + CMD_BUFFER_SIZE),
+};
+
+typedef u32 Addr;
+typedef void (*Func)();
+
+struct FunctionDef {
+ u32 id;
+ Func func;
+ std::string name;
+};
+
+struct ModuleDef {
+ std::string name;
+ int num_funcs;
+ const FunctionDef* func_table;
+};
+
+// Read from memory used by CTROS HLE functions
+template <typename T>
+inline void Read(T &var, const u32 addr);
+
+// Write to memory used by CTROS HLE functions
+template <typename T>
+inline void Write(u32 addr, const T data);
+
+u8* GetPointer(const u32 Address);
+
+inline const char* GetCharPointer(const u32 address) {
+ return (const char *)GetPointer(address);
+}
+
+void RegisterModule(std::string name, int num_functions, const FunctionDef *func_table);
+
+void CallSyscall(u32 opcode);
+
+Addr CallGetThreadCommandBuffer();
+
+void Init();
+
+void Shutdown();
+
+} // namespace
diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
new file mode 100644
index 000000000..4f8d7248d
--- /dev/null
+++ b/src/core/hle/service/apt.cpp
@@ -0,0 +1,116 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+
+#include "common/log.h"
+
+#include "core/hle/hle.h"
+#include "core/hle/service/apt.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace APT_U
+
+namespace APT_U {
+
+void Initialize() {
+ NOTICE_LOG(OSHLE, "APT_U::Sync - Initialize");
+}
+
+void GetLockHandle() {
+ u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + Service::kCommandHeaderOffset);
+ cmd_buff[5] = 0x00000000; // TODO: This should be an actual mutex handle
+}
+
+const HLE::FunctionDef FunctionTable[] = {
+ {0x00010040, GetLockHandle, "GetLockHandle"},
+ {0x00020080, Initialize, "Initialize"},
+ {0x00030040, NULL, "Enable"},
+ {0x00040040, NULL, "Finalize"},
+ {0x00050040, NULL, "GetAppletManInfo"},
+ {0x00060040, NULL, "GetAppletInfo"},
+ {0x00070000, NULL, "GetLastSignaledAppletId"},
+ {0x00080000, NULL, "CountRegisteredApplet"},
+ {0x00090040, NULL, "IsRegistered"},
+ {0x000A0040, NULL, "GetAttribute"},
+ {0x000B0040, NULL, "InquireNotification"},
+ {0x000C0104, NULL, "SendParameter"},
+ {0x000D0080, NULL, "ReceiveParameter"},
+ {0x000E0080, NULL, "GlanceParameter"},
+ {0x000F0100, NULL, "CancelParameter"},
+ {0x001000C2, NULL, "DebugFunc"},
+ {0x001100C0, NULL, "MapProgramIdForDebug"},
+ {0x00120040, NULL, "SetHomeMenuAppletIdForDebug"},
+ {0x00130000, NULL, "GetPreparationState"},
+ {0x00140040, NULL, "SetPreparationState"},
+ {0x00150140, NULL, "PrepareToStartApplication"},
+ {0x00160040, NULL, "PreloadLibraryApplet"},
+ {0x00170040, NULL, "FinishPreloadingLibraryApplet"},
+ {0x00180040, NULL, "PrepareToStartLibraryApplet"},
+ {0x00190040, NULL, "PrepareToStartSystemApplet"},
+ {0x001A0000, NULL, "PrepareToStartNewestHomeMenu"},
+ {0x001B00C4, NULL, "StartApplication"},
+ {0x001C0000, NULL, "WakeupApplication"},
+ {0x001D0000, NULL, "CancelApplication"},
+ {0x001E0084, NULL, "StartLibraryApplet"},
+ {0x001F0084, NULL, "StartSystemApplet"},
+ {0x00200044, NULL, "StartNewestHomeMenu"},
+ {0x00210000, NULL, "OrderToCloseApplication"},
+ {0x00220040, NULL, "PrepareToCloseApplication"},
+ {0x00230040, NULL, "PrepareToJumpToApplication"},
+ {0x00240044, NULL, "JumpToApplication"},
+ {0x002500C0, NULL, "PrepareToCloseLibraryApplet"},
+ {0x00260000, NULL, "PrepareToCloseSystemApplet"},
+ {0x00270044, NULL, "CloseApplication"},
+ {0x00280044, NULL, "CloseLibraryApplet"},
+ {0x00290044, NULL, "CloseSystemApplet"},
+ {0x002A0000, NULL, "OrderToCloseSystemApplet"},
+ {0x002B0000, NULL, "PrepareToJumpToHomeMenu"},
+ {0x002C0044, NULL, "JumpToHomeMenu"},
+ {0x002D0000, NULL, "PrepareToLeaveHomeMenu"},
+ {0x002E0044, NULL, "LeaveHomeMenu"},
+ {0x002F0040, NULL, "PrepareToLeaveResidentApplet"},
+ {0x00300044, NULL, "LeaveResidentApplet"},
+ {0x00310100, NULL, "PrepareToDoApplicationJump"},
+ {0x00320084, NULL, "DoApplicationJump"},
+ {0x00330000, NULL, "GetProgramIdOnApplicationJump"},
+ {0x00340084, NULL, "SendDeliverArg"},
+ {0x00350080, NULL, "ReceiveDeliverArg"},
+ {0x00360040, NULL, "LoadSysMenuArg"},
+ {0x00370042, NULL, "StoreSysMenuArg"},
+ {0x00380040, NULL, "PreloadResidentApplet"},
+ {0x00390040, NULL, "PrepareToStartResidentApplet"},
+ {0x003A0044, NULL, "StartResidentApplet"},
+ {0x003B0040, NULL, "CancelLibraryApplet"},
+ {0x003C0042, NULL, "SendDspSleep"},
+ {0x003D0042, NULL, "SendDspWakeUp"},
+ {0x003E0080, NULL, "ReplySleepQuery"},
+ {0x003F0040, NULL, "ReplySleepNotificationComplete"},
+ {0x00400042, NULL, "SendCaptureBufferInfo"},
+ {0x00410040, NULL, "ReceiveCaptureBufferInfo"},
+ {0x00420080, NULL, "SleepSystem"},
+ {0x00430040, NULL, "NotifyToWait"},
+ {0x00440000, NULL, "GetSharedFont"},
+ {0x00450040, NULL, "GetWirelessRebootInfo"},
+ {0x00460104, NULL, "Wrap"},
+ {0x00470104, NULL, "Unwrap"},
+ {0x00480100, NULL, "GetProgramInfo"},
+ {0x00490180, NULL, "Reboot"},
+ {0x004A0040, NULL, "GetCaptureInfo"},
+ {0x004B00C2, NULL, "AppletUtility"},
+ {0x004C0000, NULL, "SetFatalErrDispMode"},
+ {0x004D0080, NULL, "GetAppletProgramInfo"},
+ {0x004E0000, NULL, "HardwareResetAsync"},
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface class
+
+Interface::Interface() {
+ Register(FunctionTable, ARRAY_SIZE(FunctionTable));
+}
+
+Interface::~Interface() {
+}
+
+} // namespace
diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
new file mode 100644
index 000000000..e74baac0c
--- /dev/null
+++ b/src/core/hle/service/apt.h
@@ -0,0 +1,41 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace APT_U
+
+namespace APT_U {
+
+// Application and title launching service. These services handle signaling for home/power button as
+// well. Only one session for either APT service can be open at a time, normally processes close the
+// service handle immediately once finished using the service. The commands for APT:U and APT:S are
+// exactly the same, however certain commands are only accessible with APT:S(NS module will call
+// svcBreak when the command isn't accessible). See http://3dbrew.org/wiki/NS#APT_Services.
+
+/// Interface to "APT:U" service
+class Interface : public Service::Interface {
+public:
+
+ Interface();
+
+ ~Interface();
+
+ /**
+ * Gets the string port name used by CTROS for the service
+ * @return Port name of service
+ */
+ std::string GetPortName() const {
+ return "APT:U";
+ }
+
+private:
+
+ DISALLOW_COPY_AND_ASSIGN(Interface);
+};
+
+} // namespace
diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp
new file mode 100644
index 000000000..7c80ab8b5
--- /dev/null
+++ b/src/core/hle/service/gsp.cpp
@@ -0,0 +1,59 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+
+#include "common/log.h"
+
+#include "core/hle/hle.h"
+#include "core/hle/service/gsp.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace GSP_GPU
+
+namespace GSP_GPU {
+
+const HLE::FunctionDef FunctionTable[] = {
+ {0x00010082, NULL, "WriteHWRegs"},
+ {0x00020084, NULL, "WriteHWRegsWithMask"},
+ {0x00030082, NULL, "WriteHWRegRepeat"},
+ {0x00040080, NULL, "ReadHWRegs"},
+ {0x00050200, NULL, "SetBufferSwap"},
+ {0x00060082, NULL, "SetCommandList"},
+ {0x000700C2, NULL, "RequestDma"},
+ {0x00080082, NULL, "FlushDataCache"},
+ {0x00090082, NULL, "InvalidateDataCache"},
+ {0x000A0044, NULL, "RegisterInterruptEvents"},
+ {0x000B0040, NULL, "SetLcdForceBlack"},
+ {0x000C0000, NULL, "TriggerCmdReqQueue"},
+ {0x000D0140, NULL, "SetDisplayTransfer"},
+ {0x000E0180, NULL, "SetTextureCopy"},
+ {0x000F0200, NULL, "SetMemoryFill"},
+ {0x00100040, NULL, "SetAxiConfigQoSMode"},
+ {0x00110040, NULL, "SetPerfLogMode"},
+ {0x00120000, NULL, "GetPerfLog"},
+ {0x00130042, NULL, "RegisterInterruptRelayQueue"},
+ {0x00140000, NULL, "UnregisterInterruptRelayQueue"},
+ {0x00150002, NULL, "TryAcquireRight"},
+ {0x00160042, NULL, "AcquireRight"},
+ {0x00170000, NULL, "ReleaseRight"},
+ {0x00180000, NULL, "ImportDisplayCaptureInfo"},
+ {0x00190000, NULL, "SaveVramSysArea"},
+ {0x001A0000, NULL, "RestoreVramSysArea"},
+ {0x001B0000, NULL, "ResetGpuCore"},
+ {0x001C0040, NULL, "SetLedForceOff"},
+ {0x001D0040, NULL, "SetTestCommand"},
+ {0x001E0080, NULL, "SetInternalPriorities"},
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface class
+
+Interface::Interface() {
+ Register(FunctionTable, ARRAY_SIZE(FunctionTable));
+}
+
+Interface::~Interface() {
+}
+
+} // namespace
diff --git a/src/core/hle/service/gsp.h b/src/core/hle/service/gsp.h
new file mode 100644
index 000000000..3b1846082
--- /dev/null
+++ b/src/core/hle/service/gsp.h
@@ -0,0 +1,35 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace GSP_GPU
+
+namespace GSP_GPU {
+
+/// Interface to "srv:" service
+class Interface : public Service::Interface {
+public:
+
+ Interface();
+
+ ~Interface();
+
+ /**
+ * Gets the string port name used by CTROS for the service
+ * @return Port name of service
+ */
+ std::string GetPortName() const {
+ return "gsp::Gpu";
+ }
+
+private:
+
+ DISALLOW_COPY_AND_ASSIGN(Interface);
+};
+
+} // namespace
diff --git a/src/core/hle/service/hid.cpp b/src/core/hle/service/hid.cpp
new file mode 100644
index 000000000..2d823dd16
--- /dev/null
+++ b/src/core/hle/service/hid.cpp
@@ -0,0 +1,33 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "common/log.h"
+
+#include "core/hle/hle.h"
+#include "core/hle/service/hid.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace HID_User
+
+namespace HID_User {
+
+const HLE::FunctionDef FunctionTable[] = {
+ {0x000A0000, NULL, "GetIPCHandles"},
+ {0x00110000, NULL, "EnableAccelerometer"},
+ {0x00130000, NULL, "EnableGyroscopeLow"},
+ {0x00150000, NULL, "GetGyroscopeLowRawToDpsCoefficient"},
+ {0x00160000, NULL, "GetGyroscopeLowCalibrateParam"},
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface class
+
+Interface::Interface() {
+ Register(FunctionTable, ARRAY_SIZE(FunctionTable));
+}
+
+Interface::~Interface() {
+}
+
+} // namespace
diff --git a/src/core/hle/service/hid.h b/src/core/hle/service/hid.h
new file mode 100644
index 000000000..746c1b1fc
--- /dev/null
+++ b/src/core/hle/service/hid.h
@@ -0,0 +1,37 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace HID_User
+
+// This service is used for interfacing to physical user controls... perhaps "Human Interface
+// Devices"? Uses include game pad controls, accelerometers, gyroscopes, etc.
+
+namespace HID_User {
+
+class Interface : public Service::Interface {
+public:
+
+ Interface();
+
+ ~Interface();
+
+ /**
+ * Gets the string port name used by CTROS for the service
+ * @return Port name of service
+ */
+ std::string GetPortName() const {
+ return "hid:USER";
+ }
+
+private:
+
+ DISALLOW_COPY_AND_ASSIGN(Interface);
+};
+
+} // namespace
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
new file mode 100644
index 000000000..e6605a398
--- /dev/null
+++ b/src/core/hle/service/service.cpp
@@ -0,0 +1,94 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "common/common.h"
+#include "common/log.h"
+#include "common/string_util.h"
+
+#include "core/hle/hle.h"
+#include "core/hle/service/service.h"
+#include "core/hle/service/apt.h"
+#include "core/hle/service/gsp.h"
+#include "core/hle/service/hid.h"
+#include "core/hle/service/srv.h"
+
+namespace Service {
+
+Manager* g_manager = NULL; ///< Service manager
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Service Manager class
+
+Manager::Manager() {
+}
+
+Manager::~Manager() {
+ for(Interface* service : m_services) {
+ DeleteService(service->GetPortName());
+ }
+}
+
+/// Add a service to the manager (does not create it though)
+void Manager::AddService(Interface* service) {
+ int index = m_services.size();
+ u32 new_uid = GetUIDFromIndex(index);
+
+ m_services.push_back(service);
+
+ m_port_map[service->GetPortName()] = new_uid;
+ service->m_uid = new_uid;
+}
+
+/// Removes a service from the manager, also frees memory
+void Manager::DeleteService(std::string port_name) {
+ auto service = FetchFromPortName(port_name);
+
+ m_services.erase(m_services.begin() + GetIndexFromUID(service->m_uid));
+ m_port_map.erase(port_name);
+
+ delete service;
+}
+
+/// Get a Service Interface from its UID
+Interface* Manager::FetchFromUID(u32 uid) {
+ int index = GetIndexFromUID(uid);
+ if (index < (int)m_services.size()) {
+ return m_services[index];
+ }
+ return NULL;
+}
+
+/// Get a Service Interface from its port
+Interface* Manager::FetchFromPortName(std::string port_name) {
+ auto itr = m_port_map.find(port_name);
+ if (itr == m_port_map.end()) {
+ return NULL;
+ }
+ return FetchFromUID(itr->second);
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Module interface
+
+/// Initialize ServiceManager
+void Init() {
+ g_manager = new Manager;
+
+ g_manager->AddService(new SRV::Interface);
+ g_manager->AddService(new APT_U::Interface);
+ g_manager->AddService(new GSP_GPU::Interface);
+ g_manager->AddService(new HID_User::Interface);
+
+ NOTICE_LOG(HLE, "Services initialized OK");
+}
+
+/// Shutdown ServiceManager
+void Shutdown() {
+ delete g_manager;
+ NOTICE_LOG(HLE, "Services shutdown OK");
+}
+
+
+}
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
new file mode 100644
index 000000000..9cbf8b6fa
--- /dev/null
+++ b/src/core/hle/service/service.h
@@ -0,0 +1,143 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include <map>
+#include <string>
+
+#include "common/common.h"
+#include "common/common_types.h"
+#include "core/hle/syscall.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Service
+
+namespace Service {
+
+typedef s32 NativeUID; ///< Native handle for a service
+
+static const int kMaxPortSize = 0x08; ///< Maximum size of a port name (8 characters)
+static const int kCommandHeaderOffset = 0x80; ///< Offset into command buffer of header
+
+class Manager;
+
+/// Interface to a CTROS service
+class Interface {
+ friend class Manager;
+public:
+
+ Interface() {
+ }
+
+ virtual ~Interface() {
+ }
+
+ /**
+ * Gets the UID for the serice
+ * @return UID of service in native format
+ */
+ NativeUID GetUID() const {
+ return (NativeUID)m_uid;
+ }
+
+ /**
+ * Gets the string name used by CTROS for a service
+ * @return Port name of service
+ */
+ virtual std::string GetPortName() const {
+ return "[UNKNOWN SERVICE PORT]";
+ }
+
+ /**
+ * Called when svcSendSyncRequest is called, loads command buffer and executes comand
+ * @return Return result of svcSendSyncRequest passed back to user app
+ */
+ Syscall::Result Sync() {
+ u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + kCommandHeaderOffset);
+ auto itr = m_functions.find(cmd_buff[0]);
+
+ if (itr == m_functions.end()) {
+ ERROR_LOG(OSHLE, "Unknown/unimplemented function: port = %s, command = 0x%08X!",
+ GetPortName().c_str(), cmd_buff[0]);
+ return -1;
+ }
+ if (itr->second.func == NULL) {
+ ERROR_LOG(OSHLE, "Unimplemented function: port = %s, name = %s!",
+ GetPortName().c_str(), itr->second.name.c_str());
+ return -1;
+ }
+
+ itr->second.func();
+
+ return 0; // TODO: Implement return from actual function
+ }
+
+protected:
+ /**
+ * Registers the functions in the service
+ */
+ void Register(const HLE::FunctionDef* functions, int len) {
+ for (int i = 0; i < len; i++) {
+ m_functions[functions[i].id] = functions[i];
+ }
+ }
+
+private:
+ u32 m_uid;
+ std::map<u32, HLE::FunctionDef> m_functions;
+
+ DISALLOW_COPY_AND_ASSIGN(Interface);
+};
+
+/// Simple class to manage accessing services from ports and UID handles
+class Manager {
+
+public:
+ Manager();
+
+ ~Manager();
+
+ /// Add a service to the manager (does not create it though)
+ void AddService(Interface* service);
+
+ /// Removes a service from the manager (does not delete it though)
+ void DeleteService(std::string port_name);
+
+ /// Get a Service Interface from its UID
+ Interface* FetchFromUID(u32 uid);
+
+ /// Get a Service Interface from its port
+ Interface* FetchFromPortName(std::string port_name);
+
+private:
+
+ /// Convert an index into m_services vector into a UID
+ static u32 GetUIDFromIndex(const int index) {
+ return index | 0x10000000;
+ }
+
+ /// Convert a UID into an index into m_services
+ static int GetIndexFromUID(const u32 uid) {
+ return uid & 0x0FFFFFFF;
+ }
+
+ std::vector<Interface*> m_services;
+ std::map<std::string, u32> m_port_map;
+
+ DISALLOW_COPY_AND_ASSIGN(Manager);
+};
+
+/// Initialize ServiceManager
+void Init();
+
+/// Shutdown ServiceManager
+void Shutdown();
+
+
+extern Manager* g_manager; ///< Service manager
+
+
+} // namespace
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
new file mode 100644
index 000000000..579ea4a34
--- /dev/null
+++ b/src/core/hle/service/srv.cpp
@@ -0,0 +1,58 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "core/hle/hle.h"
+#include "core/hle/service/srv.h"
+#include "core/hle/service/service.h"
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace SRV
+
+namespace SRV {
+
+void Initialize() {
+ NOTICE_LOG(OSHLE, "SRV::Sync - Initialize");
+}
+
+void GetServiceHandle() {
+ Syscall::Result res = 0;
+ u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + Service::kCommandHeaderOffset);
+
+ std::string port_name = std::string((const char*)&cmd_buff[1], 0, Service::kMaxPortSize);
+ Service::Interface* service = Service::g_manager->FetchFromPortName(port_name);
+
+ NOTICE_LOG(OSHLE, "SRV::Sync - GetHandle - port: %s, handle: 0x%08X", port_name.c_str(),
+ service->GetUID());
+
+ if (NULL != service) {
+ cmd_buff[3] = service->GetUID();
+ } else {
+ ERROR_LOG(OSHLE, "Service %s does not exist", port_name.c_str());
+ res = -1;
+ }
+ cmd_buff[1] = res;
+
+ //return res;
+}
+
+const HLE::FunctionDef FunctionTable[] = {
+ {0x00010002, Initialize, "Initialize"},
+ {0x00020000, NULL, "GetProcSemaphore"},
+ {0x00030100, NULL, "RegisterService"},
+ {0x000400C0, NULL, "UnregisterService"},
+ {0x00050100, GetServiceHandle, "GetServiceHandle"},
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface class
+
+Interface::Interface() {
+ Register(FunctionTable, ARRAY_SIZE(FunctionTable));
+}
+
+Interface::~Interface() {
+}
+
+} // namespace
diff --git a/src/core/hle/service/srv.h b/src/core/hle/service/srv.h
new file mode 100644
index 000000000..d9ac8fc88
--- /dev/null
+++ b/src/core/hle/service/srv.h
@@ -0,0 +1,40 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace SRV
+
+namespace SRV {
+
+/// Interface to "srv:" service
+class Interface : public Service::Interface {
+
+public:
+
+ Interface();
+
+ ~Interface();
+
+ /**
+ * Gets the string name used by CTROS for the service
+ * @return Port name of service
+ */
+ std::string GetPortName() const {
+ return "srv:";
+ }
+
+ /**
+ * Called when svcSendSyncRequest is called, loads command buffer and executes comand
+ * @return Return result of svcSendSyncRequest passed back to user app
+ */
+ Syscall::Result Sync();
+
+private:
+
+ DISALLOW_COPY_AND_ASSIGN(Interface);
+};
+
+} // namespace
diff --git a/src/core/hle/syscall.cpp b/src/core/hle/syscall.cpp
new file mode 100644
index 000000000..e5533a741
--- /dev/null
+++ b/src/core/hle/syscall.cpp
@@ -0,0 +1,197 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <map>
+
+#include "core/mem_map.h"
+
+#include "core/hle/function_wrappers.h"
+#include "core/hle/syscall.h"
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Syscall
+
+namespace Syscall {
+
+/// Map application or GSP heap memory
+Result ControlMemory(void* outaddr, u32 addr0, u32 addr1, u32 size, u32 operation, u32 permissions) {
+ u32 virtual_address = 0x00000000;
+
+ switch (operation) {
+
+ // Map GSP heap memory?
+ case 0x00010003:
+ virtual_address = Memory::MapBlock_HeapGSP(size, operation, permissions);
+ break;
+
+ // Unknown ControlMemory operation
+ default:
+ ERROR_LOG(OSHLE, "Unknown ControlMemory operation %08X", operation);
+ }
+
+ Core::g_app_core->SetReg(1, Memory::MapBlock_HeapGSP(size, operation, permissions));
+ return 0;
+}
+
+/// Connect to an OS service given the port name, returns the handle to the port to out
+Result ConnectToPort(void* out, const char* port_name) {
+ Service::Interface* service = Service::g_manager->FetchFromPortName(port_name);
+ Core::g_app_core->SetReg(1, service->GetUID());
+ return 0;
+}
+
+/// Synchronize to an OS service
+Result SendSyncRequest(Handle session) {
+ Service::Interface* service = Service::g_manager->FetchFromUID(session);
+ service->Sync();
+ return 0;
+}
+
+/// Close a handle
+Result CloseHandle(Handle handle) {
+ // ImplementMe
+ return 0;
+}
+
+/// Wait for a handle to synchronize, timeout after the specified nanoseconds
+Result WaitSynchronization1(Handle handle, s64 nanoseconds) {
+ // ImplementMe
+ return 0;
+}
+
+const HLE::FunctionDef Syscall_Table[] = {
+ {0x00, NULL, "Unknown"},
+ {0x01, WrapI_VUUUUU<ControlMemory>, "ControlMemory"},
+ {0x02, NULL, "QueryMemory"},
+ {0x03, NULL, "ExitProcess"},
+ {0x04, NULL, "GetProcessAffinityMask"},
+ {0x05, NULL, "SetProcessAffinityMask"},
+ {0x06, NULL, "GetProcessIdealProcessor"},
+ {0x07, NULL, "SetProcessIdealProcessor"},
+ {0x08, NULL, "CreateThread"},
+ {0x09, NULL, "ExitThread"},
+ {0x0A, NULL, "SleepThread"},
+ {0x0B, NULL, "GetThreadPriority"},
+ {0x0C, NULL, "SetThreadPriority"},
+ {0x0D, NULL, "GetThreadAffinityMask"},
+ {0x0E, NULL, "SetThreadAffinityMask"},
+ {0x0F, NULL, "GetThreadIdealProcessor"},
+ {0x10, NULL, "SetThreadIdealProcessor"},
+ {0x11, NULL, "GetCurrentProcessorNumber"},
+ {0x12, NULL, "Run"},
+ {0x13, NULL, "CreateMutex"},
+ {0x14, NULL, "ReleaseMutex"},
+ {0x15, NULL, "CreateSemaphore"},
+ {0x16, NULL, "ReleaseSemaphore"},
+ {0x17, NULL, "CreateEvent"},
+ {0x18, NULL, "SignalEvent"},
+ {0x19, NULL, "ClearEvent"},
+ {0x1A, NULL, "CreateTimer"},
+ {0x1B, NULL, "SetTimer"},
+ {0x1C, NULL, "CancelTimer"},
+ {0x1D, NULL, "ClearTimer"},
+ {0x1E, NULL, "CreateMemoryBlock"},
+ {0x1F, NULL, "MapMemoryBlock"},
+ {0x20, NULL, "UnmapMemoryBlock"},
+ {0x21, NULL, "CreateAddressArbiter"},
+ {0x22, NULL, "ArbitrateAddress"},
+ {0x23, WrapI_U<CloseHandle>, "CloseHandle"},
+ {0x24, WrapI_US64<WaitSynchronization1>, "WaitSynchronization1"},
+ {0x25, NULL, "WaitSynchronizationN"},
+ {0x26, NULL, "SignalAndWait"},
+ {0x27, NULL, "DuplicateHandle"},
+ {0x28, NULL, "GetSystemTick"},
+ {0x29, NULL, "GetHandleInfo"},
+ {0x2A, NULL, "GetSystemInfo"},
+ {0x2B, NULL, "GetProcessInfo"},
+ {0x2C, NULL, "GetThreadInfo"},
+ {0x2D, WrapI_VC<ConnectToPort>, "ConnectToPort"},
+ {0x2E, NULL, "SendSyncRequest1"},
+ {0x2F, NULL, "SendSyncRequest2"},
+ {0x30, NULL, "SendSyncRequest3"},
+ {0x31, NULL, "SendSyncRequest4"},
+ {0x32, WrapI_U<SendSyncRequest>, "SendSyncRequest"},
+ {0x33, NULL, "OpenProcess"},
+ {0x34, NULL, "OpenThread"},
+ {0x35, NULL, "GetProcessId"},
+ {0x36, NULL, "GetProcessIdOfThread"},
+ {0x37, NULL, "GetThreadId"},
+ {0x38, NULL, "GetResourceLimit"},
+ {0x39, NULL, "GetResourceLimitLimitValues"},
+ {0x3A, NULL, "GetResourceLimitCurrentValues"},
+ {0x3B, NULL, "GetThreadContext"},
+ {0x3C, NULL, "Break"},
+ {0x3D, NULL, "OutputDebugString"},
+ {0x3E, NULL, "ControlPerformanceCounter"},
+ {0x3F, NULL, "Unknown"},
+ {0x40, NULL, "Unknown"},
+ {0x41, NULL, "Unknown"},
+ {0x42, NULL, "Unknown"},
+ {0x43, NULL, "Unknown"},
+ {0x44, NULL, "Unknown"},
+ {0x45, NULL, "Unknown"},
+ {0x46, NULL, "Unknown"},
+ {0x47, NULL, "CreatePort"},
+ {0x48, NULL, "CreateSessionToPort"},
+ {0x49, NULL, "CreateSession"},
+ {0x4A, NULL, "AcceptSession"},
+ {0x4B, NULL, "ReplyAndReceive1"},
+ {0x4C, NULL, "ReplyAndReceive2"},
+ {0x4D, NULL, "ReplyAndReceive3"},
+ {0x4E, NULL, "ReplyAndReceive4"},
+ {0x4F, NULL, "ReplyAndReceive"},
+ {0x50, NULL, "BindInterrupt"},
+ {0x51, NULL, "UnbindInterrupt"},
+ {0x52, NULL, "InvalidateProcessDataCache"},
+ {0x53, NULL, "StoreProcessDataCache"},
+ {0x54, NULL, "FlushProcessDataCache"},
+ {0x55, NULL, "StartInterProcessDma"},
+ {0x56, NULL, "StopDma"},
+ {0x57, NULL, "GetDmaState"},
+ {0x58, NULL, "RestartDma"},
+ {0x59, NULL, "Unknown"},
+ {0x5A, NULL, "Unknown"},
+ {0x5B, NULL, "Unknown"},
+ {0x5C, NULL, "Unknown"},
+ {0x5D, NULL, "Unknown"},
+ {0x5E, NULL, "Unknown"},
+ {0x5F, NULL, "Unknown"},
+ {0x60, NULL, "DebugActiveProcess"},
+ {0x61, NULL, "BreakDebugProcess"},
+ {0x62, NULL, "TerminateDebugProcess"},
+ {0x63, NULL, "GetProcessDebugEvent"},
+ {0x64, NULL, "ContinueDebugEvent"},
+ {0x65, NULL, "GetProcessList"},
+ {0x66, NULL, "GetThreadList"},
+ {0x67, NULL, "GetDebugThreadContext"},
+ {0x68, NULL, "SetDebugThreadContext"},
+ {0x69, NULL, "QueryDebugProcessMemory"},
+ {0x6A, NULL, "ReadProcessMemory"},
+ {0x6B, NULL, "WriteProcessMemory"},
+ {0x6C, NULL, "SetHardwareBreakPoint"},
+ {0x6D, NULL, "GetDebugThreadParam"},
+ {0x6E, NULL, "Unknown"},
+ {0x6F, NULL, "Unknown"},
+ {0x70, NULL, "ControlProcessMemory"},
+ {0x71, NULL, "MapProcessMemory"},
+ {0x72, NULL, "UnmapProcessMemory"},
+ {0x73, NULL, "Unknown"},
+ {0x74, NULL, "Unknown"},
+ {0x75, NULL, "Unknown"},
+ {0x76, NULL, "TerminateProcess"},
+ {0x77, NULL, "Unknown"},
+ {0x78, NULL, "CreateResourceLimit"},
+ {0x79, NULL, "Unknown"},
+ {0x7A, NULL, "Unknown"},
+ {0x7B, NULL, "Unknown"},
+ {0x7C, NULL, "KernelSetState"},
+ {0x7D, NULL, "QueryProcessMemory"},
+};
+
+void Register() {
+ HLE::RegisterModule("SyscallTable", ARRAY_SIZE(Syscall_Table), Syscall_Table);
+}
+
+} // namespace
diff --git a/src/core/hle/syscall.h b/src/core/hle/syscall.h
new file mode 100644
index 000000000..7a94e0136
--- /dev/null
+++ b/src/core/hle/syscall.h
@@ -0,0 +1,19 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Syscall
+
+namespace Syscall {
+
+typedef u32 Handle;
+typedef s32 Result;
+
+void Register();
+
+} // namespace
diff --git a/src/core/hw/hw.cpp b/src/core/hw/hw.cpp
index 44625e3af..16bd70125 100644
--- a/src/core/hw/hw.cpp
+++ b/src/core/hw/hw.cpp
@@ -6,18 +6,73 @@
#include "common/log.h"
#include "core/hw/hw.h"
-#include "core/hw/hw_lcd.h"
+#include "core/hw/lcd.h"
+#include "core/hw/ndma.h"
namespace HW {
+enum {
+ ADDRESS_CONFIG = 0x10000000,
+ ADDRESS_IRQ = 0x10001000,
+ ADDRESS_NDMA = 0x10002000,
+ ADDRESS_TIMER = 0x10003000,
+ ADDRESS_CTRCARD = 0x10004000,
+ ADDRESS_CTRCARD_2 = 0x10005000,
+ ADDRESS_SDMC_NAND = 0x10006000,
+ ADDRESS_SDMC_NAND_2 = 0x10007000, // Apparently not used on retail
+ ADDRESS_PXI = 0x10008000,
+ ADDRESS_AES = 0x10009000,
+ ADDRESS_SHA = 0x1000A000,
+ ADDRESS_RSA = 0x1000B000,
+ ADDRESS_XDMA = 0x1000C000,
+ ADDRESS_SPICARD = 0x1000D800,
+ ADDRESS_CONFIG_2 = 0x10010000,
+ ADDRESS_HASH = 0x10101000,
+ ADDRESS_CSND = 0x10103000,
+ ADDRESS_DSP = 0x10140000,
+ ADDRESS_PDN = 0x10141000,
+ ADDRESS_CODEC = 0x10141000,
+ ADDRESS_SPI = 0x10142000,
+ ADDRESS_SPI_2 = 0x10143000,
+ ADDRESS_I2C = 0x10144000,
+ ADDRESS_CODEC_2 = 0x10145000,
+ ADDRESS_HID = 0x10146000,
+ ADDRESS_PAD = 0x10146000,
+ ADDRESS_PTM = 0x10146000,
+ ADDRESS_I2C_2 = 0x10148000,
+ ADDRESS_SPI_3 = 0x10160000,
+ ADDRESS_I2C_3 = 0x10161000,
+ ADDRESS_MIC = 0x10162000,
+ ADDRESS_PXI_2 = 0x10163000,
+ ADDRESS_NTRCARD = 0x10164000,
+ ADDRESS_DSP_2 = 0x10203000,
+ ADDRESS_HASH_2 = 0x10301000,
+};
+
template <typename T>
inline void Read(T &var, const u32 addr) {
- NOTICE_LOG(HW, "Hardware read from address %08X", addr);
+ switch (addr & 0xFFFFF000) {
+
+ case ADDRESS_NDMA:
+ NDMA::Read(var, addr);
+ break;
+
+ default:
+ ERROR_LOG(HW, "unknown Read%d @ 0x%08X", sizeof(var) * 8, addr);
+ }
}
template <typename T>
inline void Write(u32 addr, const T data) {
- NOTICE_LOG(HW, "Hardware write to address %08X", addr);
+ switch (addr & 0xFFFFF000) {
+
+ case ADDRESS_NDMA:
+ NDMA::Write(addr, data);
+ break;
+
+ default:
+ ERROR_LOG(HW, "unknown Write%d 0x%08X @ 0x%08X", sizeof(data) * 8, data, addr);
+ }
}
// Explicitly instantiate template functions because we aren't defining this in the header:
@@ -27,25 +82,27 @@ template void Read<u32>(u32 &var, const u32 addr);
template void Read<u16>(u16 &var, const u32 addr);
template void Read<u8>(u8 &var, const u32 addr);
-template void Write<const u64>(u32 addr, const u64 data);
-template void Write<const u32>(u32 addr, const u32 data);
-template void Write<const u16>(u32 addr, const u16 data);
-template void Write<const u8>(u32 addr, const u8 data);
+template void Write<u64>(u32 addr, const u64 data);
+template void Write<u32>(u32 addr, const u32 data);
+template void Write<u16>(u32 addr, const u16 data);
+template void Write<u8>(u32 addr, const u8 data);
/// Update hardware
void Update() {
LCD::Update();
+ NDMA::Update();
}
/// Initialize hardware
void Init() {
LCD::Init();
- NOTICE_LOG(HW, "Hardware initialized OK");
+ NDMA::Init();
+ NOTICE_LOG(HW, "initialized OK");
}
/// Shutdown hardware
void Shutdown() {
- NOTICE_LOG(HW, "Hardware shutdown OK");
+ NOTICE_LOG(HW, "shutdown OK");
}
} \ No newline at end of file
diff --git a/src/core/hw/hw_lcd.cpp b/src/core/hw/lcd.cpp
index fd783a84a..3013673f8 100644
--- a/src/core/hw/hw_lcd.cpp
+++ b/src/core/hw/lcd.cpp
@@ -6,7 +6,7 @@
#include "common/log.h"
#include "core/core.h"
-#include "core/hw/hw_lcd.h"
+#include "core/hw/lcd.h"
#include "video_core/video_core.h"
@@ -37,12 +37,12 @@ void Update() {
/// Initialize hardware
void Init() {
g_last_ticks = Core::g_app_core->GetTicks();
- NOTICE_LOG(LCD, "LCD initialized OK");
+ NOTICE_LOG(LCD, "initialized OK");
}
/// Shutdown hardware
void Shutdown() {
- NOTICE_LOG(LCD, "LCD shutdown OK");
+ NOTICE_LOG(LCD, "shutdown OK");
}
} // namespace
diff --git a/src/core/hw/hw_lcd.h b/src/core/hw/lcd.h
index 386ed6004..386ed6004 100644
--- a/src/core/hw/hw_lcd.h
+++ b/src/core/hw/lcd.h
diff --git a/src/core/hw/ndma.cpp b/src/core/hw/ndma.cpp
new file mode 100644
index 000000000..52e459ebd
--- /dev/null
+++ b/src/core/hw/ndma.cpp
@@ -0,0 +1,48 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "common/common_types.h"
+#include "common/log.h"
+
+#include "core/hw/ndma.h"
+
+namespace NDMA {
+
+template <typename T>
+inline void Read(T &var, const u32 addr) {
+ ERROR_LOG(NDMA, "unknown Read%d @ 0x%08X", sizeof(var) * 8, addr);
+}
+
+template <typename T>
+inline void Write(u32 addr, const T data) {
+ ERROR_LOG(NDMA, "unknown Write%d 0x%08X @ 0x%08X", sizeof(data) * 8, data, addr);
+}
+
+// Explicitly instantiate template functions because we aren't defining this in the header:
+
+template void Read<u64>(u64 &var, const u32 addr);
+template void Read<u32>(u32 &var, const u32 addr);
+template void Read<u16>(u16 &var, const u32 addr);
+template void Read<u8>(u8 &var, const u32 addr);
+
+template void Write<u64>(u32 addr, const u64 data);
+template void Write<u32>(u32 addr, const u32 data);
+template void Write<u16>(u32 addr, const u16 data);
+template void Write<u8>(u32 addr, const u8 data);
+
+/// Update hardware
+void Update() {
+}
+
+/// Initialize hardware
+void Init() {
+ NOTICE_LOG(LCD, "initialized OK");
+}
+
+/// Shutdown hardware
+void Shutdown() {
+ NOTICE_LOG(LCD, "shutdown OK");
+}
+
+} // namespace
diff --git a/src/core/hw/ndma.h b/src/core/hw/ndma.h
new file mode 100644
index 000000000..d8fa3d40b
--- /dev/null
+++ b/src/core/hw/ndma.h
@@ -0,0 +1,26 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace NDMA {
+
+template <typename T>
+inline void Read(T &var, const u32 addr);
+
+template <typename T>
+inline void Write(u32 addr, const T data);
+
+/// Update hardware
+void Update();
+
+/// Initialize hardware
+void Init();
+
+/// Shutdown hardware
+void Shutdown();
+
+} // namespace
diff --git a/src/core/mem_map.cpp b/src/core/mem_map.cpp
index 96f8d0440..180829239 100644
--- a/src/core/mem_map.cpp
+++ b/src/core/mem_map.cpp
@@ -1,4 +1,4 @@
-// Copyright 2014 Citra Emulator Project
+ // Copyright 2014 Citra Emulator Project
// Licensed under GPLv2
// Refer to the license.txt file included.
@@ -12,27 +12,27 @@
namespace Memory {
-
u8* g_base = NULL; ///< The base pointer to the auto-mirrored arena.
MemArena g_arena; ///< The MemArena class
-u8* g_bootrom = NULL; ///< Bootrom physical memory
-u8* g_fcram = NULL; ///< Main memory (FCRAM) pointer
+u8* g_heap_gsp = NULL; ///< GSP heap (main memory)
+u8* g_heap = NULL; ///< Application heap (main memory)
u8* g_vram = NULL; ///< Video memory (VRAM) pointer
-u8* g_scratchpad = NULL; ///< Scratchpad memory - Used for main thread stack
u8* g_physical_bootrom = NULL; ///< Bootrom physical memory
u8* g_uncached_bootrom = NULL;
u8* g_physical_fcram = NULL; ///< Main physical memory (FCRAM)
+u8* g_physical_heap_gsp = NULL;
u8* g_physical_vram = NULL; ///< Video physical memory (VRAM)
u8* g_physical_scratchpad = NULL; ///< Scratchpad memory used for main thread stack
// We don't declare the IO region in here since its handled by other means.
static MemoryView g_views[] = {
- { &g_vram, &g_physical_vram, MEM_VRAM_VADDR, MEM_VRAM_SIZE, 0 },
- { &g_fcram, &g_physical_fcram, MEM_FCRAM_VADDR, MEM_FCRAM_SIZE, MV_IS_PRIMARY_RAM },
+ {&g_vram, &g_physical_vram, VRAM_VADDR, VRAM_SIZE, 0},
+ {&g_heap_gsp, &g_physical_heap_gsp, HEAP_GSP_VADDR, HEAP_GSP_SIZE, 0},
+ {&g_heap, &g_physical_fcram, HEAP_VADDR, HEAP_SIZE, MV_IS_PRIMARY_RAM},
};
/*static MemoryView views[] =
@@ -56,14 +56,12 @@ void Init() {
for (size_t i = 0; i < ARRAY_SIZE(g_views); i++) {
if (g_views[i].flags & MV_IS_PRIMARY_RAM)
- g_views[i].size = MEM_FCRAM_SIZE;
+ g_views[i].size = FCRAM_SIZE;
}
g_base = MemoryMap_Setup(g_views, kNumMemViews, flags, &g_arena);
- g_scratchpad = new u8[MEM_SCRATCHPAD_SIZE];
-
- NOTICE_LOG(MEMMAP, "Memory system initialized. RAM at %p (mirror at 0 @ %p)", g_fcram,
+ NOTICE_LOG(MEMMAP, "initialized OK, RAM at %p (mirror at 0 @ %p)", g_heap,
g_physical_fcram);
}
@@ -72,12 +70,9 @@ void Shutdown() {
MemoryMap_Shutdown(g_views, kNumMemViews, flags, &g_arena);
g_arena.ReleaseSpace();
- delete[] g_scratchpad;
-
- g_base = NULL;
- g_scratchpad = NULL;
+ g_base = NULL;
- NOTICE_LOG(MEMMAP, "Memory system shut down.");
+ NOTICE_LOG(MEMMAP, "shutdown OK");
}
} // namespace
diff --git a/src/core/mem_map.h b/src/core/mem_map.h
index 1a3bd7234..ab1eb2606 100644
--- a/src/core/mem_map.h
+++ b/src/core/mem_map.h
@@ -4,39 +4,67 @@
#pragma once
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
#include "common/common.h"
#include "common/common_types.h"
+namespace Memory {
+
////////////////////////////////////////////////////////////////////////////////////////////////////
enum {
- MEM_BOOTROM_SIZE = 0x00010000, ///< Bootrom (super secret code/data @ 0x8000) size
- MEM_MPCORE_PRIV_SIZE = 0x00002000, ///< MPCore private memory region size
- MEM_VRAM_SIZE = 0x00600000, ///< VRAM size
- MEM_DSP_SIZE = 0x00080000, ///< DSP memory size
- MEM_AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size
- MEM_FCRAM_SIZE = 0x08000000, ///< FCRAM size... Really 0x07E00000, but power of 2
- // works much better
- MEM_SCRATCHPAD_SIZE = 0x00004000, ///< Typical stack size - TODO: Read from exheader
-
- MEM_VRAM_MASK = 0x007FFFFF,
- MEM_FCRAM_MASK = (MEM_FCRAM_SIZE - 1), ///< FCRAM mask
- MEM_SCRATCHPAD_MASK = (MEM_SCRATCHPAD_SIZE - 1), ///< Scratchpad memory mask
-
- MEM_FCRAM_PADDR = 0x20000000, ///< FCRAM physical address
- MEM_FCRAM_PADDR_END = (MEM_FCRAM_PADDR + MEM_FCRAM_SIZE), ///< FCRAM end of physical space
- MEM_FCRAM_VADDR = 0x08000000, ///< FCRAM virtual address
- MEM_FCRAM_VADDR_END = (MEM_FCRAM_VADDR + MEM_FCRAM_SIZE), ///< FCRAM end of virtual space
-
- MEM_VRAM_VADDR = 0x1F000000,
- MEM_SCRATCHPAD_VADDR = (0x10000000 - MEM_SCRATCHPAD_SIZE), ///< Scratchpad virtual address
+ BOOTROM_SIZE = 0x00010000, ///< Bootrom (super secret code/data @ 0x8000) size
+ MPCORE_PRIV_SIZE = 0x00002000, ///< MPCore private memory region size
+ VRAM_SIZE = 0x00600000, ///< VRAM size
+ DSP_SIZE = 0x00080000, ///< DSP memory size
+ AXI_WRAM_SIZE = 0x00080000, ///< AXI WRAM size
+ FCRAM_SIZE = 0x08000000, ///< FCRAM size
+ SCRATCHPAD_SIZE = 0x00004000, ///< Typical stack size - TODO: Read from exheader
+ HEAP_GSP_SIZE = 0x02000000, ///< GSP heap size... TODO: Define correctly?
+ HEAP_SIZE = FCRAM_SIZE, ///< Application heap size
+
+ HEAP_PADDR = HEAP_GSP_SIZE,
+ HEAP_PADDR_END = (HEAP_PADDR + HEAP_SIZE),
+ HEAP_VADDR = 0x08000000,
+ HEAP_VADDR_END = (HEAP_VADDR + HEAP_SIZE),
+ HEAP_GSP_VADDR = 0x14000000,
+ HEAP_GSP_VADDR_END = (HEAP_GSP_VADDR + HEAP_GSP_SIZE),
+ HEAP_GSP_PADDR = 0x00000000,
+ HEAP_GSP_PADDR_END = (HEAP_GSP_PADDR + HEAP_GSP_SIZE),
+
+ VRAM_MASK = 0x007FFFFF,
+ FCRAM_MASK = (FCRAM_SIZE - 1), ///< FCRAM mask
+ SCRATCHPAD_MASK = (SCRATCHPAD_SIZE - 1), ///< Scratchpad memory mask
+ HEAP_GSP_MASK = (HEAP_GSP_SIZE - 1),
+ HEAP_MASK = (HEAP_SIZE - 1),
+
+ FCRAM_PADDR = 0x20000000, ///< FCRAM physical address
+ FCRAM_PADDR_END = (FCRAM_PADDR + FCRAM_SIZE), ///< FCRAM end of physical space
+ FCRAM_VADDR = 0x08000000, ///< FCRAM virtual address
+ FCRAM_VADDR_END = (FCRAM_VADDR + FCRAM_SIZE), ///< FCRAM end of virtual space
+
+ VRAM_VADDR = 0x1F000000,
+ SCRATCHPAD_VADDR_END = 0x10000000,
+ SCRATCHPAD_VADDR = (SCRATCHPAD_VADDR_END - SCRATCHPAD_SIZE), ///< Stack space
};
////////////////////////////////////////////////////////////////////////////////////////////////////
-namespace Memory {
+/// Represents a block of heap memory mapped by ControlMemory
+struct HeapBlock {
+ HeapBlock() : base_address(0), address(0), size(0), operation(0), permissions(0) {
+ }
+ u32 base_address;
+ u32 address;
+ u32 size;
+ u32 operation;
+ u32 permissions;
+
+ const u32 GetVirtualAddress() const{
+ return base_address + address;
+ }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
// Base is a pointer to the base of the memory map. Yes, some MMU tricks
// are used to set up a full GC or Wii memory map in process memory. on
@@ -50,9 +78,9 @@ extern u8 *g_base;
// These are guaranteed to point to "low memory" addresses (sub-32-bit).
// 64-bit: Pointers to low-mem (sub-0x10000000) mirror
// 32-bit: Same as the corresponding physical/virtual pointers.
-extern u8* g_fcram; ///< Main memory
-extern u8* g_vram; ///< Video memory (VRAM)
-extern u8* g_scratchpad; ///< Stack memory
+extern u8* g_heap_gsp; ///< GSP heap (main memory)
+extern u8* g_heap; ///< Application heap (main memory)
+extern u8* g_vram; ///< Video memory (VRAM)
void Init();
void Shutdown();
@@ -70,4 +98,16 @@ void Write32(const u32 addr, const u32 data);
u8* GetPointer(const u32 Address);
+/**
+ * Maps a block of memory on the GSP heap
+ * @param size Size of block in bytes
+ * @param operation Control memory operation
+ * @param permissions Control memory permissions
+ */
+u32 MapBlock_HeapGSP(u32 size, u32 operation, u32 permissions);
+
+inline const char* GetCharPointer(const u32 address) {
+ return (const char *)GetPointer(address);
+}
+
} // namespace
diff --git a/src/core/mem_map_funcs.cpp b/src/core/mem_map_funcs.cpp
index 4c0e08b3f..af4cfacbd 100644
--- a/src/core/mem_map_funcs.cpp
+++ b/src/core/mem_map_funcs.cpp
@@ -2,149 +2,144 @@
// Licensed under GPLv2
// Refer to the license.txt file included.
+#include <map>
+
#include "common/common.h"
#include "core/mem_map.h"
#include "core/hw/hw.h"
+#include "hle/hle.h"
namespace Memory {
+std::map<u32, HeapBlock> g_heap_gsp_map;
+
+/// Convert a physical address to virtual address
+u32 _AddressPhysicalToVirtual(const u32 addr) {
+ // Our memory interface read/write functions assume virtual addresses. Put any physical address
+ // to virtual address translations here. This is obviously quite hacky... But we're not doing
+ // any MMU emulation yet or anything
+ if ((addr >= FCRAM_PADDR) && (addr < (FCRAM_PADDR_END))) {
+ return (addr & FCRAM_MASK) | FCRAM_VADDR;
+ }
+ return addr;
+}
+
template <typename T>
inline void _Read(T &var, const u32 addr) {
// TODO: Figure out the fastest order of tests for both read and write (they are probably different).
// TODO: Make sure this represents the mirrors in a correct way.
// Could just do a base-relative read, too.... TODO
+ const u32 vaddr = _AddressPhysicalToVirtual(addr);
+
+ // Memory allocated for HLE use that can be addressed from the emulated application
+ // The primary use of this is sharing a commandbuffer between the HLE OS (syscore) and the LLE
+ // core running the user application (appcore)
+ if (vaddr >= HLE::CMD_BUFFER_ADDR && vaddr < HLE::CMD_BUFFER_ADDR_END) {
+ HLE::Read<T>(var, vaddr);
+
// Hardware I/O register reads
// 0x10XXXXXX- is physical address space, 0x1EXXXXXX is virtual address space
- if ((addr & 0xFF000000) == 0x10000000 || (addr & 0xFF000000) == 0x1E000000) {
- HW::Read<T>(var, addr);
-
- // FCRAM virtual address reads
- } else if ((addr & 0x3E000000) == 0x08000000) {
- var = *((const T*)&g_fcram[addr & MEM_FCRAM_MASK]);
-
- // Scratchpad memory
- } else if (addr > MEM_SCRATCHPAD_VADDR && addr <= (MEM_SCRATCHPAD_VADDR + MEM_SCRATCHPAD_SIZE)) {
- var = *((const T*)&g_scratchpad[addr & MEM_SCRATCHPAD_MASK]);
-
- /*else if ((addr & 0x3F800000) == 0x04000000) {
- var = *((const T*)&m_pVRAM[addr & VRAM_MASK]);
- }*/
-
- // HACK(bunnei): There is no layer yet to translate virtual addresses to physical addresses.
- // Until we progress far enough along, we'll accept all physical address reads here. I think
- // that this is typically a corner-case from usermode software unless they are trying to do
- // bare-metal things (e.g. early 3DS homebrew writes directly to the FB @ 0x20184E60, etc.
- } else if (((addr & 0xF0000000) == MEM_FCRAM_PADDR) && (addr < (MEM_FCRAM_PADDR_END))) {
- var = *((const T*)&g_fcram[addr & MEM_FCRAM_MASK]);
+ } else if ((vaddr & 0xFF000000) == 0x10000000 || (vaddr & 0xFF000000) == 0x1E000000) {
+ HW::Read<T>(var, vaddr);
+
+ // FCRAM - GSP heap
+ } else if ((vaddr > HEAP_GSP_VADDR) && (vaddr < HEAP_GSP_VADDR_END)) {
+ var = *((const T*)&g_heap_gsp[vaddr & HEAP_GSP_MASK]);
+
+ // FCRAM - application heap
+ } else if ((vaddr > HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) {
+ var = *((const T*)&g_heap[vaddr & HEAP_MASK]);
+
+ /*else if ((vaddr & 0x3F800000) == 0x04000000) {
+ var = *((const T*)&m_pVRAM[vaddr & VRAM_MASK]);*/
} else {
- _assert_msg_(MEMMAP, false, "unknown memory read");
+ //_assert_msg_(MEMMAP, false, "unknown Read%d @ 0x%08X", sizeof(var) * 8, vaddr);
}
}
template <typename T>
inline void _Write(u32 addr, const T data) {
+ u32 vaddr = _AddressPhysicalToVirtual(addr);
+ // Memory allocated for HLE use that can be addressed from the emulated application
+ // The primary use of this is sharing a commandbuffer between the HLE OS (syscore) and the LLE
+ // core running the user application (appcore)
+ if (vaddr >= HLE::CMD_BUFFER_ADDR && vaddr < HLE::CMD_BUFFER_ADDR_END) {
+ HLE::Write<T>(vaddr, data);
+
// Hardware I/O register writes
// 0x10XXXXXX- is physical address space, 0x1EXXXXXX is virtual address space
- if ((addr & 0xFF000000) == 0x10000000 || (addr & 0xFF000000) == 0x1E000000) {
- HW::Write<const T>(addr, data);
-
- // ExeFS:/.code is loaded here:
- } else if ((addr & 0xFFF00000) == 0x00100000) {
- // TODO(ShizZy): This is dumb... handle correctly. From 3DBrew:
- // http://3dbrew.org/wiki/Memory_layout#ARM11_User-land_memory_regions
- // The ExeFS:/.code is loaded here, executables must be loaded to the 0x00100000 region when
- // the exheader "special memory" flag is clear. The 0x03F00000-byte size restriction only
- // applies when this flag is clear. Executables are usually loaded to 0x14000000 when the
- // exheader "special memory" flag is set, however this address can be arbitrary.
- *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
-
- // Scratchpad memory
- } else if (addr > MEM_SCRATCHPAD_VADDR && addr <= (MEM_SCRATCHPAD_VADDR + MEM_SCRATCHPAD_SIZE)) {
- *(T*)&g_scratchpad[addr & MEM_SCRATCHPAD_MASK] = data;
-
- // Heap mapped by ControlMemory:
- } else if ((addr & 0x3E000000) == 0x08000000) {
- // TODO(ShizZy): Writes to this virtual address should be put in physical memory at FCRAM + GSP
- // heap size... the following is writing to FCRAM + 0, which is actually supposed to be the
- // application's GSP heap
- *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
-
- } else if ((addr & 0xFF000000) == 0x14000000) {
+ } else if ((vaddr & 0xFF000000) == 0x10000000 || (vaddr & 0xFF000000) == 0x1E000000) {
+ HW::Write<T>(vaddr, data);
+
+ // FCRAM - GSP heap
+ } else if ((vaddr > HEAP_GSP_VADDR) && (vaddr < HEAP_GSP_VADDR_END)) {
+ *(T*)&g_heap_gsp[vaddr & HEAP_GSP_MASK] = data;
+
+ // FCRAM - application heap
+ } else if ((vaddr > HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) {
+ *(T*)&g_heap[vaddr & HEAP_MASK] = data;
+
+ } else if ((vaddr & 0xFF000000) == 0x14000000) {
_assert_msg_(MEMMAP, false, "umimplemented write to GSP heap");
- } else if ((addr & 0xFFF00000) == 0x1EC00000) {
+ } else if ((vaddr & 0xFFF00000) == 0x1EC00000) {
_assert_msg_(MEMMAP, false, "umimplemented write to IO registers");
- } else if ((addr & 0xFF000000) == 0x1F000000) {
+ } else if ((vaddr & 0xFF000000) == 0x1F000000) {
_assert_msg_(MEMMAP, false, "umimplemented write to VRAM");
- } else if ((addr & 0xFFF00000) == 0x1FF00000) {
+ } else if ((vaddr & 0xFFF00000) == 0x1FF00000) {
_assert_msg_(MEMMAP, false, "umimplemented write to DSP memory");
- } else if ((addr & 0xFFFF0000) == 0x1FF80000) {
+ } else if ((vaddr & 0xFFFF0000) == 0x1FF80000) {
_assert_msg_(MEMMAP, false, "umimplemented write to Configuration Memory");
- } else if ((addr & 0xFFFFF000) == 0x1FF81000) {
+ } else if ((vaddr & 0xFFFFF000) == 0x1FF81000) {
_assert_msg_(MEMMAP, false, "umimplemented write to shared page");
- // HACK(bunnei): There is no layer yet to translate virtual addresses to physical addresses.
- // Until we progress far enough along, we'll accept all physical address writes here. I think
- // that this is typically a corner-case from usermode software unless they are trying to do
- // bare-metal things (e.g. early 3DS homebrew writes directly to the FB @ 0x20184E60, etc.
- } else if (((addr & 0xF0000000) == MEM_FCRAM_PADDR) && (addr < (MEM_FCRAM_PADDR_END))) {
- *(T*)&g_fcram[addr & MEM_FCRAM_MASK] = data;
-
// Error out...
} else {
- _assert_msg_(MEMMAP, false, "unknown memory write");
+ _assert_msg_(MEMMAP, false, "unknown Write%d 0x%08X @ 0x%08X", sizeof(data) * 8,
+ data, vaddr);
}
}
-bool IsValidAddress(const u32 addr) {
- if ((addr & 0x3E000000) == 0x08000000) {
- return true;
- } else if ((addr & 0x3F800000) == 0x04000000) {
- return true;
- } else if ((addr & 0xBFFF0000) == 0x00010000) {
- return true;
- } else if ((addr & 0x3F000000) >= 0x08000000 && (addr & 0x3F000000) < 0x08000000 + MEM_FCRAM_MASK) {
- return true;
+u8 *GetPointer(const u32 addr) {
+ const u32 vaddr = _AddressPhysicalToVirtual(addr);
+
+ // FCRAM - GSP heap
+ if ((vaddr >= HEAP_GSP_VADDR) && (vaddr < HEAP_GSP_VADDR_END)) {
+ return g_heap_gsp + (vaddr & HEAP_GSP_MASK);
+
+ // FCRAM - application heap
+ } else if ((vaddr >= HEAP_VADDR) && (vaddr < HEAP_VADDR_END)) {
+ return g_heap + (vaddr & HEAP_MASK);
+
} else {
- return false;
+ ERROR_LOG(MEMMAP, "Unknown GetPointer @ 0x%08x", vaddr);
+ return 0;
}
}
-u8 *GetPointer(const u32 addr) {
- // TODO(bunnei): Just a stub for now... ImplementMe!
- if ((addr & 0x3E000000) == 0x08000000) {
- return g_fcram + (addr & MEM_FCRAM_MASK);
-
- // HACK(bunnei): There is no layer yet to translate virtual addresses to physical addresses.
- // Until we progress far enough along, we'll accept all physical address reads here. I think
- // that this is typically a corner-case from usermode software unless they are trying to do
- // bare-metal things (e.g. early 3DS homebrew writes directly to the FB @ 0x20184E60, etc.
- } else if (((addr & 0xF0000000) == MEM_FCRAM_PADDR) && (addr < (MEM_FCRAM_PADDR_END))) {
- return g_fcram + (addr & MEM_FCRAM_MASK);
-
- //else if ((addr & 0x3F800000) == 0x04000000) {
- // return g_vram + (addr & MEM_VRAM_MASK);
- //}
- //else if ((addr & 0x3F000000) >= 0x08000000 && (addr & 0x3F000000) < 0x08000000 + g_MemorySize) {
- // return m_pRAM + (addr & g_MemoryMask);
- //}
- } else {
- //ERROR_LOG(MEMMAP, "Unknown GetPointer %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
- ERROR_LOG(MEMMAP, "Unknown GetPointer %08x", addr);
- static bool reported = false;
- //if (!reported) {
- // Reporting::ReportMessage("Unknown GetPointer %08x PC %08x LR %08x", addr, currentMIPS->pc, currentMIPS->r[MIPS_REG_RA]);
- // reported = true;
- //}
- //if (!g_Config.bIgnoreBadMemAccess) {
- // Core_EnableStepping(true);
- // host->SetDebugMode(true);
- //}
- return 0;
+/**
+ * Maps a block of memory on the GSP heap
+ * @param size Size of block in bytes
+ * @param flags Memory allocation flags
+ */
+u32 MapBlock_HeapGSP(u32 size, u32 operation, u32 permissions) {
+ HeapBlock block;
+
+ block.base_address = HEAP_GSP_VADDR;
+ block.size = size;
+ block.operation = operation;
+ block.permissions = permissions;
+
+ if (g_heap_gsp_map.size() > 0) {
+ const HeapBlock last_block = g_heap_gsp_map.rbegin()->second;
+ block.address = last_block.address + last_block.size;
}
+ g_heap_gsp_map[block.GetVirtualAddress()] = block;
+
+ return block.GetVirtualAddress();
}
u8 Read8(const u32 addr) {
diff --git a/src/core/system.cpp b/src/core/system.cpp
index edb07fef5..c77092327 100644
--- a/src/core/system.cpp
+++ b/src/core/system.cpp
@@ -7,6 +7,7 @@
#include "core/mem_map.h"
#include "core/system.h"
#include "core/hw/hw.h"
+#include "core/hle/hle.h"
#include "video_core/video_core.h"
@@ -19,15 +20,16 @@ void UpdateState(State state) {
}
void Init(EmuWindow* emu_window) {
- Core::Init();
- Memory::Init();
+ Core::Init();
+ Memory::Init();
HW::Init();
- CoreTiming::Init();
+ HLE::Init();
+ CoreTiming::Init();
VideoCore::Init(emu_window);
}
void RunLoopFor(int cycles) {
- RunLoopUntil(CoreTiming::GetTicks() + cycles);
+ RunLoopUntil(CoreTiming::GetTicks() + cycles);
}
void RunLoopUntil(u64 global_cycles) {
@@ -35,9 +37,12 @@ void RunLoopUntil(u64 global_cycles) {
void Shutdown() {
Core::Shutdown();
+ Memory::Shutdown();
HW::Shutdown();
+ HLE::Shutdown();
+ CoreTiming::Shutdown();
VideoCore::Shutdown();
- g_ctr_file_system.Shutdown();
+ g_ctr_file_system.Shutdown();
}
} // namespace