From f68de21ad1cd267029b60ee3767d219c46f5fba0 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 10 Apr 2014 19:58:28 -0400
Subject: added initial modules for setting up SysCall HLE

---
 src/core/hle/function_wrappers.h | 726 +++++++++++++++++++++++++++++++++++++++
 src/core/hle/hle.h               |  35 ++
 src/core/hle/hle_syscall.cpp     |  22 ++
 src/core/hle/hle_syscall.h       |  42 +++
 4 files changed, 825 insertions(+)
 create mode 100644 src/core/hle/function_wrappers.h
 create mode 100644 src/core/hle/hle.h
 create mode 100644 src/core/hle/hle_syscall.cpp
 create mode 100644 src/core/hle/hle_syscall.h

(limited to 'src/core/hle')

diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
new file mode 100644
index 000000000..22588d95d
--- /dev/null
+++ b/src/core/hle/function_wrappers.h
@@ -0,0 +1,726 @@
+// 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);
+}
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
new file mode 100644
index 000000000..6780b52c4
--- /dev/null
+++ b/src/core/hle/hle.h
@@ -0,0 +1,35 @@
+// 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"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+typedef void (*HLEFunc)();
+typedef void (*SysCallFunc)();
+
+struct HLEFunction {
+	u32                 id;
+	HLEFunc             func;
+	const char*         name;
+	u32                 flags;
+};
+
+struct HLEModule {
+	const char*         name;
+	int                 num_funcs;
+	const HLEFunction*  func_table;
+};
+
+struct SysCall {
+    u8                  id;
+	SysCallFunc         func;
+    const char*         name;
+};
+
+#define PARAM(n)        Core::g_app_core->GetReg(n)
+#define RETURN(n)       Core::g_app_core->SetReg(0, n)
diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp
new file mode 100644
index 000000000..c8a516848
--- /dev/null
+++ b/src/core/hle/hle_syscall.cpp
@@ -0,0 +1,22 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.  
+
+#include "core/hle/function_wrappers.h"
+#include "core/hle/hle_syscall.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+Result SVC_ConnectToPort(void* out, const char* port_name) {
+    NOTICE_LOG(OSHLE, "SVC_ConnectToPort called, port_name: %s", port_name);
+    return 0;
+}
+
+const SysCall SysCallTable[] = {
+    {0x2D, WrapI_VC<SVC_ConnectToPort>, "svcConnectToPort"},
+};
+
+void Register_SysCalls() {
+}
diff --git a/src/core/hle/hle_syscall.h b/src/core/hle/hle_syscall.h
new file mode 100644
index 000000000..506dcfc78
--- /dev/null
+++ b/src/core/hle/hle_syscall.h
@@ -0,0 +1,42 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.  
+
+#pragma once
+
+#include "common/common_types.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//template <class T>
+//class KernelObject {
+//public:
+//	virtual ~KernelObject() {}
+//
+//	T GetNative() const {
+//        return m_native;
+//    }
+//
+//    void SetNative(const T& native) {
+//        m_native = native;
+//    }
+//
+//	virtual const char *GetTypeName() {return "[BAD KERNEL OBJECT TYPE]";}
+//	virtual const char *GetName() {return "[UNKNOWN KERNEL OBJECT]";}
+//
+//private:
+//    T m_native;
+//};
+
+//class Handle : public KernelObject<u32> {
+//    const char* GetTypeName() { 
+//        return "Handle";
+//    }
+//};
+
+
+typedef u32 Handle;
+typedef s32 Result;
+
+
+Result ConnectToPort(Handle* out, const char* port_name);
-- 
cgit v1.2.3


From 2a7d7ce55d51a1cf893d14e893b87941df4a2f03 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 10 Apr 2014 21:30:00 -0400
Subject: - removed syscall classes (will just use HLEFunction)

- added hle.cpp and module registration
- removed unused code
---
 src/core/hle/hle.h           | 18 ++++++++++--------
 src/core/hle/hle_syscall.cpp | 10 ++++++----
 src/core/hle/hle_syscall.h   |  4 +---
 3 files changed, 17 insertions(+), 15 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 6780b52c4..6648c787f 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -10,13 +10,11 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 typedef void (*HLEFunc)();
-typedef void (*SysCallFunc)();
 
 struct HLEFunction {
 	u32                 id;
 	HLEFunc             func;
 	const char*         name;
-	u32                 flags;
 };
 
 struct HLEModule {
@@ -25,11 +23,15 @@ struct HLEModule {
 	const HLEFunction*  func_table;
 };
 
-struct SysCall {
-    u8                  id;
-	SysCallFunc         func;
-    const char*         name;
-};
-
 #define PARAM(n)        Core::g_app_core->GetReg(n)
 #define RETURN(n)       Core::g_app_core->SetReg(0, n)
+
+namespace HLE {
+
+void Init();
+
+void Shutdown();
+
+void RegisterModule(const char *name, int num_functions, const HLEFunction *func_table);
+
+} // namespace
diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp
index c8a516848..b17a2e220 100644
--- a/src/core/hle/hle_syscall.cpp
+++ b/src/core/hle/hle_syscall.cpp
@@ -7,16 +7,18 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-
+typedef u32 Handle;
+typedef s32 Result;
 
 Result SVC_ConnectToPort(void* out, const char* port_name) {
-    NOTICE_LOG(OSHLE, "SVC_ConnectToPort called, port_name: %s", port_name);
+    NOTICE_LOG(OSHLE, "svcConnectToPort called, port_name: %s", port_name);
     return 0;
 }
 
-const SysCall SysCallTable[] = {
+const HLEFunction SysCallTable[] = {
     {0x2D, WrapI_VC<SVC_ConnectToPort>, "svcConnectToPort"},
 };
 
-void Register_SysCalls() {
+void Register_SysCall() {
+    HLE::RegisterModule("SysCallTable", ARRAY_SIZE(SysCallTable), SysCallTable);
 }
diff --git a/src/core/hle/hle_syscall.h b/src/core/hle/hle_syscall.h
index 506dcfc78..643af0bf4 100644
--- a/src/core/hle/hle_syscall.h
+++ b/src/core/hle/hle_syscall.h
@@ -35,8 +35,6 @@
 //};
 
 
-typedef u32 Handle;
-typedef s32 Result;
 
 
-Result ConnectToPort(Handle* out, const char* port_name);
+void Register_SysCall();
-- 
cgit v1.2.3


From 3bd041f5b0cd481ded892594d569462492679e39 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 10 Apr 2014 22:15:07 -0400
Subject: changed some naming/misc cleanups

---
 src/core/hle/hle.h           | 28 +++++++++++++++-------------
 src/core/hle/hle_syscall.cpp |  4 ++--
 src/core/hle/hle_syscall.h   |  3 ---
 3 files changed, 17 insertions(+), 18 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 6648c787f..35c8a4621 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -9,29 +9,31 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-typedef void (*HLEFunc)();
+#define PARAM(n)        Core::g_app_core->GetReg(n)
+#define RETURN(n)       Core::g_app_core->SetReg(0, n)
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace HLE {
 
-struct HLEFunction {
+typedef void (*Func)();
+
+struct FunctionDef {
 	u32                 id;
-	HLEFunc             func;
-	const char*         name;
+	Func                func;
+	std::string         name;
 };
 
-struct HLEModule {
-	const char*         name;
+struct ModuleDef {
+	std::string         name;
 	int                 num_funcs;
-	const HLEFunction*  func_table;
+	const FunctionDef*  func_table;
 };
 
-#define PARAM(n)        Core::g_app_core->GetReg(n)
-#define RETURN(n)       Core::g_app_core->SetReg(0, n)
-
-namespace HLE {
-
 void Init();
 
 void Shutdown();
 
-void RegisterModule(const char *name, int num_functions, const HLEFunction *func_table);
+void RegisterModule(std::string name, int num_functions, const FunctionDef *func_table);
 
 } // namespace
diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp
index b17a2e220..fdcaa914f 100644
--- a/src/core/hle/hle_syscall.cpp
+++ b/src/core/hle/hle_syscall.cpp
@@ -15,10 +15,10 @@ Result SVC_ConnectToPort(void* out, const char* port_name) {
     return 0;
 }
 
-const HLEFunction SysCallTable[] = {
+const HLE::FunctionDef SysCall_Table[] = {
     {0x2D, WrapI_VC<SVC_ConnectToPort>, "svcConnectToPort"},
 };
 
 void Register_SysCall() {
-    HLE::RegisterModule("SysCallTable", ARRAY_SIZE(SysCallTable), SysCallTable);
+    HLE::RegisterModule("SysCallTable", ARRAY_SIZE(SysCall_Table), SysCall_Table);
 }
diff --git a/src/core/hle/hle_syscall.h b/src/core/hle/hle_syscall.h
index 643af0bf4..4faa14535 100644
--- a/src/core/hle/hle_syscall.h
+++ b/src/core/hle/hle_syscall.h
@@ -34,7 +34,4 @@
 //    }
 //};
 
-
-
-
 void Register_SysCall();
-- 
cgit v1.2.3


From 2bde8f28561ea9436d13d990f6b129a0e80a325e Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 10 Apr 2014 23:26:12 -0400
Subject: base code to call a syscall from ARM11 appcore

---
 src/core/hle/hle.h           |  6 +++--
 src/core/hle/hle_syscall.cpp | 55 ++++++++++++++++++++++++++++++++++++++++----
 src/core/hle/hle_syscall.h   |  2 +-
 3 files changed, 56 insertions(+), 7 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 35c8a4621..e3b8d483a 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -30,10 +30,12 @@ struct ModuleDef {
 	const FunctionDef*  func_table;
 };
 
+void RegisterModule(std::string name, int num_functions, const FunctionDef *func_table);
+
+void CallSyscall(u32 opcode);
+
 void Init();
 
 void Shutdown();
 
-void RegisterModule(std::string name, int num_functions, const FunctionDef *func_table);
-
 } // namespace
diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp
index fdcaa914f..53d721275 100644
--- a/src/core/hle/hle_syscall.cpp
+++ b/src/core/hle/hle_syscall.cpp
@@ -10,15 +10,62 @@
 typedef u32 Handle;
 typedef s32 Result;
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 Result SVC_ConnectToPort(void* out, const char* port_name) {
     NOTICE_LOG(OSHLE, "svcConnectToPort called, port_name: %s", port_name);
     return 0;
 }
 
-const HLE::FunctionDef SysCall_Table[] = {
-    {0x2D, WrapI_VC<SVC_ConnectToPort>, "svcConnectToPort"},
+const HLE::FunctionDef Syscall_Table[] = {
+    {0x00,  NULL,                           "Unknown"},
+    {0x01,  NULL,                           "svcControlMemory"},
+    {0x02,  NULL,                           "svcQueryMemory"},
+    {0x03,  NULL,                           "svcExitProcess"},
+    {0x04,  NULL,                           "svcGetProcessAffinityMask"},
+    {0x05,  NULL,                           "svcSetProcessAffinityMask"},
+    {0x06,  NULL,                           "svcGetProcessIdealProcessor"},
+    {0x07,  NULL,                           "svcSetProcessIdealProcessor"},
+    {0x08,  NULL,                           "svcCreateThread"},
+    {0x09,  NULL,                           "svcExitThread"},
+    {0x0A,  NULL,                           "svcSleepThread"},
+    {0x0B,  NULL,                           "svcGetThreadPriority"},
+    {0x0C,  NULL,                           "svcSetThreadPriority"},
+    {0x0D,  NULL,                           "svcGetThreadAffinityMask"},
+    {0x0E,  NULL,                           "svcSetThreadAffinityMask"},
+    {0x0F,  NULL,                           "svcGetThreadIdealProcessor"},
+    {0x10,  NULL,                           "svcSetThreadIdealProcessor"},
+    {0x11,  NULL,                           "svcGetCurrentProcessorNumber"},
+    {0x12,  NULL,                           "svcRun"},
+    {0x13,  NULL,                           "svcCreateMutex"},
+    {0x14,  NULL,                           "svcReleaseMutex"},
+    {0x15,  NULL,                           "svcCreateSemaphore"},
+    {0x16,  NULL,                           "svcReleaseSemaphore"},
+    {0x17,  NULL,                           "svcCreateEvent"},
+    {0x18,  NULL,                           "svcSignalEvent"},
+    {0x19,  NULL,                           "svcClearEvent"},
+    {0x1A,  NULL,                           "svcCreateTimer"},
+    {0x1B,  NULL,                           "svcSetTimer"},
+    {0x1C,  NULL,                           "svcCancelTimer"},
+    {0x1D,  NULL,                           "svcClearTimer"},
+    {0x1E,  NULL,                           "svcCreateMemoryBlock"},
+    {0x1F,  NULL,                           "svcMapMemoryBlock"},
+    {0x20,  NULL,                           "svcUnmapMemoryBlock"},
+    {0x21,  NULL,                           "svcCreateAddressArbiter"},
+    {0x22,  NULL,                           "svcArbitrateAddress"},
+    {0x23,  NULL,                           "svcCloseHandle"},
+    {0x24,  NULL,                           "svcWaitSynchronization1"},
+    {0x25,  NULL,                           "svcWaitSynchronizationN"},
+    {0x26,  NULL,                           "svcSignalAndWait"},
+    {0x27,  NULL,                           "svcDuplicateHandle"},
+    {0x28,  NULL,                           "svcGetSystemTick"},
+    {0x29,  NULL,                           "svcGetHandleInfo"},
+    {0x2A,  NULL,                           "svcGetSystemInfo"},
+    {0x2B,  NULL,                           "svcGetProcessInfo"},
+    {0x2C,  NULL,                           "svcGetThreadInfo"},
+    {0x2D,  WrapI_VC<SVC_ConnectToPort>,    "svcConnectToPort"},
 };
 
-void Register_SysCall() {
-    HLE::RegisterModule("SysCallTable", ARRAY_SIZE(SysCall_Table), SysCall_Table);
+void Register_Syscall() {
+    HLE::RegisterModule("SyscallTable", ARRAY_SIZE(Syscall_Table), Syscall_Table);
 }
diff --git a/src/core/hle/hle_syscall.h b/src/core/hle/hle_syscall.h
index 4faa14535..80b20c358 100644
--- a/src/core/hle/hle_syscall.h
+++ b/src/core/hle/hle_syscall.h
@@ -34,4 +34,4 @@
 //    }
 //};
 
-void Register_SysCall();
+void Register_Syscall();
-- 
cgit v1.2.3


From e9f0e4967d410fb25081a232b5c3d899dd7a80ed Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Fri, 11 Apr 2014 14:19:40 -0400
Subject: added remaining known syscall functions to Syscall_Table

---
 src/core/hle/hle_syscall.cpp | 80 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp
index 53d721275..92d9b0c85 100644
--- a/src/core/hle/hle_syscall.cpp
+++ b/src/core/hle/hle_syscall.cpp
@@ -64,6 +64,86 @@ const HLE::FunctionDef Syscall_Table[] = {
     {0x2B,  NULL,                           "svcGetProcessInfo"},
     {0x2C,  NULL,                           "svcGetThreadInfo"},
     {0x2D,  WrapI_VC<SVC_ConnectToPort>,    "svcConnectToPort"},
+    {0x2E   NULL,                           "svcSendSyncRequest1"},
+    {0x2F   NULL,                           "svcSendSyncRequest2"},
+    {0x30   NULL,                           "svcSendSyncRequest3"},
+    {0x31   NULL,                           "svcSendSyncRequest4"},
+    {0x32   NULL,                           "svcSendSyncRequest"},
+    {0x33   NULL,                           "svcOpenProcess"},
+    {0x34   NULL,                           "svcOpenThread"},
+    {0x35   NULL,                           "svcGetProcessId"},
+    {0x36   NULL,                           "svcGetProcessIdOfThread"},
+    {0x37   NULL,                           "svcGetThreadId"},
+    {0x38   NULL,                           "svcGetResourceLimit"},
+    {0x39   NULL,                           "svcGetResourceLimitLimitValues"},
+    {0x3A   NULL,                           "svcGetResourceLimitCurrentValues"},
+    {0x3B   NULL,                           "svcGetThreadContext"},
+    {0x3C   NULL,                           "svcBreak"},
+    {0x3D   NULL,                           "svcOutputDebugString"},
+    {0x3E   NULL,                           "svcControlPerformanceCounter"},
+    {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,                           "svcCreatePort"},
+    {0x48   NULL,                           "svcCreateSessionToPort"},
+    {0x49   NULL,                           "svcCreateSession"},
+    {0x4A   NULL,                           "svcAcceptSession"},
+    {0x4B   NULL,                           "svcReplyAndReceive1"},
+    {0x4C   NULL,                           "svcReplyAndReceive2"},
+    {0x4D   NULL,                           "svcReplyAndReceive3"},
+    {0x4E   NULL,                           "svcReplyAndReceive4"},
+    {0x4F   NULL,                           "svcReplyAndReceive"},
+    {0x50   NULL,                           "svcBindInterrupt"},
+    {0x51   NULL,                           "svcUnbindInterrupt"},
+    {0x52   NULL,                           "svcInvalidateProcessDataCache"},
+    {0x53   NULL,                           "svcStoreProcessDataCache"},
+    {0x54   NULL,                           "svcFlushProcessDataCache"},
+    {0x55   NULL,                           "svcStartInterProcessDma"},
+    {0x56   NULL,                           "svcStopDma"},
+    {0x57   NULL,                           "svcGetDmaState"},
+    {0x58   NULL,                           "svcRestartDma"},
+    {0x59,  NULL,                           "Unknown"},
+    {0x5A,  NULL,                           "Unknown"},
+    {0x5B,  NULL,                           "Unknown"},
+    {0x5C,  NULL,                           "Unknown"},
+    {0x5D,  NULL,                           "Unknown"},
+    {0x5E,  NULL,                           "Unknown"},
+    {0x5F,  NULL,                           "Unknown"},
+    {0x60   NULL,                           "svcDebugActiveProcess"},
+    {0x61   NULL,                           "svcBreakDebugProcess"},
+    {0x62   NULL,                           "svcTerminateDebugProcess"},
+    {0x63   NULL,                           "svcGetProcessDebugEvent"},
+    {0x64   NULL,                           "svcContinueDebugEvent"},
+    {0x65   NULL,                           "svcGetProcessList"},
+    {0x66   NULL,                           "svcGetThreadList"},
+    {0x67   NULL,                           "svcGetDebugThreadContext"},
+    {0x68   NULL,                           "svcSetDebugThreadContext"},
+    {0x69   NULL,                           "svcQueryDebugProcessMemory"},
+    {0x6A   NULL,                           "svcReadProcessMemory"},
+    {0x6B   NULL,                           "svcWriteProcessMemory"},
+    {0x6C   NULL,                           "svcSetHardwareBreakPoint"},
+    {0x6D   NULL,                           "svcGetDebugThreadParam"},
+    {0x6E,  NULL,                           "Unknown"},
+    {0x6F,  NULL,                           "Unknown"},
+    {0x70   NULL,                           "svcControlProcessMemory"},
+    {0x71   NULL,                           "svcMapProcessMemory"},
+    {0x72   NULL,                           "svcUnmapProcessMemory"},
+    {0x73,  NULL,                           "Unknown"},
+    {0x74,  NULL,                           "Unknown"},
+    {0x75,  NULL,                           "Unknown"},
+    {0x76   NULL,                           "svcTerminateProcess"},
+    {0x77,  NULL,                           "Unknown"},
+    {0x78   NULL,                           "svcCreateResourceLimit"},
+    {0x79,  NULL,                           "Unknown"},
+    {0x7A,  NULL,                           "Unknown"},
+    {0x7B,  NULL,                           "Unknown"},
+    {0x7C   NULL,                           "svcKernelSetState"},
+    {0x7D   NULL,                           "svcQueryProcessMemory"},
 };
 
 void Register_Syscall() {
-- 
cgit v1.2.3


From f6c328cf37fe6e0250c20fcbf128f301b3d71d36 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Fri, 11 Apr 2014 18:07:49 -0400
Subject: moved hle.cpp into hle folder (due to mistake earlier)

---
 src/core/hle/hle.cpp | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 src/core/hle/hle.cpp

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
new file mode 100644
index 000000000..d62d2d0ce
--- /dev/null
+++ b/src/core/hle/hle.cpp
@@ -0,0 +1,57 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.  
+
+#include <vector>
+
+#include "core/hle/hle.h"
+#include "core/hle/hle_syscall.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace HLE {
+
+static std::vector<ModuleDef> g_module_db;
+
+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 HLE function %s", info->name);
+    }
+}
+
+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() {
+    Register_Syscall();
+}
+
+void Init() {
+    RegisterAllModules();
+    NOTICE_LOG(HLE, "initialized OK");
+}
+
+void Shutdown() {
+    g_module_db.clear();
+    NOTICE_LOG(HLE, "shutdown OK");
+}
+
+} // namespace
-- 
cgit v1.2.3


From 7ea75858984e23ed22ad1dfa8ad0315aaeded538 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Fri, 11 Apr 2014 18:09:23 -0400
Subject: replace tabs with spaces

---
 src/core/hle/hle.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index e3b8d483a..9466be540 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -19,15 +19,15 @@ namespace HLE {
 typedef void (*Func)();
 
 struct FunctionDef {
-	u32                 id;
-	Func                func;
-	std::string         name;
+    u32                 id;
+    Func                func;
+    std::string         name;
 };
 
 struct ModuleDef {
-	std::string         name;
-	int                 num_funcs;
-	const FunctionDef*  func_table;
+    std::string         name;
+    int                 num_funcs;
+    const FunctionDef*  func_table;
 };
 
 void RegisterModule(std::string name, int num_functions, const FunctionDef *func_table);
-- 
cgit v1.2.3


From 02fbd42e7f006236199698c61ca917092afa1f7d Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Fri, 11 Apr 2014 18:44:21 -0400
Subject: - renamed hle_syscall to just syscall

- added service.h as an initial service interface
---
 src/core/hle/hle.cpp           |   4 +-
 src/core/hle/hle_syscall.cpp   | 151 ----------------------------------------
 src/core/hle/hle_syscall.h     |  37 ----------
 src/core/hle/service/service.h |  60 ++++++++++++++++
 src/core/hle/syscall.cpp       | 153 +++++++++++++++++++++++++++++++++++++++++
 src/core/hle/syscall.h         |  19 +++++
 6 files changed, 234 insertions(+), 190 deletions(-)
 delete mode 100644 src/core/hle/hle_syscall.cpp
 delete mode 100644 src/core/hle/hle_syscall.h
 create mode 100644 src/core/hle/service/service.h
 create mode 100644 src/core/hle/syscall.cpp
 create mode 100644 src/core/hle/syscall.h

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
index d62d2d0ce..32aff0eb5 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -5,7 +5,7 @@
 #include <vector>
 
 #include "core/hle/hle.h"
-#include "core/hle/hle_syscall.h"
+#include "core/hle/syscall.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -41,7 +41,7 @@ void RegisterModule(std::string name, int num_functions, const FunctionDef* func
 }
 
 void RegisterAllModules() {
-    Register_Syscall();
+    Syscall::Register();
 }
 
 void Init() {
diff --git a/src/core/hle/hle_syscall.cpp b/src/core/hle/hle_syscall.cpp
deleted file mode 100644
index 92d9b0c85..000000000
--- a/src/core/hle/hle_syscall.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.  
-
-#include "core/hle/function_wrappers.h"
-#include "core/hle/hle_syscall.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-typedef u32 Handle;
-typedef s32 Result;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-Result SVC_ConnectToPort(void* out, const char* port_name) {
-    NOTICE_LOG(OSHLE, "svcConnectToPort called, port_name: %s", port_name);
-    return 0;
-}
-
-const HLE::FunctionDef Syscall_Table[] = {
-    {0x00,  NULL,                           "Unknown"},
-    {0x01,  NULL,                           "svcControlMemory"},
-    {0x02,  NULL,                           "svcQueryMemory"},
-    {0x03,  NULL,                           "svcExitProcess"},
-    {0x04,  NULL,                           "svcGetProcessAffinityMask"},
-    {0x05,  NULL,                           "svcSetProcessAffinityMask"},
-    {0x06,  NULL,                           "svcGetProcessIdealProcessor"},
-    {0x07,  NULL,                           "svcSetProcessIdealProcessor"},
-    {0x08,  NULL,                           "svcCreateThread"},
-    {0x09,  NULL,                           "svcExitThread"},
-    {0x0A,  NULL,                           "svcSleepThread"},
-    {0x0B,  NULL,                           "svcGetThreadPriority"},
-    {0x0C,  NULL,                           "svcSetThreadPriority"},
-    {0x0D,  NULL,                           "svcGetThreadAffinityMask"},
-    {0x0E,  NULL,                           "svcSetThreadAffinityMask"},
-    {0x0F,  NULL,                           "svcGetThreadIdealProcessor"},
-    {0x10,  NULL,                           "svcSetThreadIdealProcessor"},
-    {0x11,  NULL,                           "svcGetCurrentProcessorNumber"},
-    {0x12,  NULL,                           "svcRun"},
-    {0x13,  NULL,                           "svcCreateMutex"},
-    {0x14,  NULL,                           "svcReleaseMutex"},
-    {0x15,  NULL,                           "svcCreateSemaphore"},
-    {0x16,  NULL,                           "svcReleaseSemaphore"},
-    {0x17,  NULL,                           "svcCreateEvent"},
-    {0x18,  NULL,                           "svcSignalEvent"},
-    {0x19,  NULL,                           "svcClearEvent"},
-    {0x1A,  NULL,                           "svcCreateTimer"},
-    {0x1B,  NULL,                           "svcSetTimer"},
-    {0x1C,  NULL,                           "svcCancelTimer"},
-    {0x1D,  NULL,                           "svcClearTimer"},
-    {0x1E,  NULL,                           "svcCreateMemoryBlock"},
-    {0x1F,  NULL,                           "svcMapMemoryBlock"},
-    {0x20,  NULL,                           "svcUnmapMemoryBlock"},
-    {0x21,  NULL,                           "svcCreateAddressArbiter"},
-    {0x22,  NULL,                           "svcArbitrateAddress"},
-    {0x23,  NULL,                           "svcCloseHandle"},
-    {0x24,  NULL,                           "svcWaitSynchronization1"},
-    {0x25,  NULL,                           "svcWaitSynchronizationN"},
-    {0x26,  NULL,                           "svcSignalAndWait"},
-    {0x27,  NULL,                           "svcDuplicateHandle"},
-    {0x28,  NULL,                           "svcGetSystemTick"},
-    {0x29,  NULL,                           "svcGetHandleInfo"},
-    {0x2A,  NULL,                           "svcGetSystemInfo"},
-    {0x2B,  NULL,                           "svcGetProcessInfo"},
-    {0x2C,  NULL,                           "svcGetThreadInfo"},
-    {0x2D,  WrapI_VC<SVC_ConnectToPort>,    "svcConnectToPort"},
-    {0x2E   NULL,                           "svcSendSyncRequest1"},
-    {0x2F   NULL,                           "svcSendSyncRequest2"},
-    {0x30   NULL,                           "svcSendSyncRequest3"},
-    {0x31   NULL,                           "svcSendSyncRequest4"},
-    {0x32   NULL,                           "svcSendSyncRequest"},
-    {0x33   NULL,                           "svcOpenProcess"},
-    {0x34   NULL,                           "svcOpenThread"},
-    {0x35   NULL,                           "svcGetProcessId"},
-    {0x36   NULL,                           "svcGetProcessIdOfThread"},
-    {0x37   NULL,                           "svcGetThreadId"},
-    {0x38   NULL,                           "svcGetResourceLimit"},
-    {0x39   NULL,                           "svcGetResourceLimitLimitValues"},
-    {0x3A   NULL,                           "svcGetResourceLimitCurrentValues"},
-    {0x3B   NULL,                           "svcGetThreadContext"},
-    {0x3C   NULL,                           "svcBreak"},
-    {0x3D   NULL,                           "svcOutputDebugString"},
-    {0x3E   NULL,                           "svcControlPerformanceCounter"},
-    {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,                           "svcCreatePort"},
-    {0x48   NULL,                           "svcCreateSessionToPort"},
-    {0x49   NULL,                           "svcCreateSession"},
-    {0x4A   NULL,                           "svcAcceptSession"},
-    {0x4B   NULL,                           "svcReplyAndReceive1"},
-    {0x4C   NULL,                           "svcReplyAndReceive2"},
-    {0x4D   NULL,                           "svcReplyAndReceive3"},
-    {0x4E   NULL,                           "svcReplyAndReceive4"},
-    {0x4F   NULL,                           "svcReplyAndReceive"},
-    {0x50   NULL,                           "svcBindInterrupt"},
-    {0x51   NULL,                           "svcUnbindInterrupt"},
-    {0x52   NULL,                           "svcInvalidateProcessDataCache"},
-    {0x53   NULL,                           "svcStoreProcessDataCache"},
-    {0x54   NULL,                           "svcFlushProcessDataCache"},
-    {0x55   NULL,                           "svcStartInterProcessDma"},
-    {0x56   NULL,                           "svcStopDma"},
-    {0x57   NULL,                           "svcGetDmaState"},
-    {0x58   NULL,                           "svcRestartDma"},
-    {0x59,  NULL,                           "Unknown"},
-    {0x5A,  NULL,                           "Unknown"},
-    {0x5B,  NULL,                           "Unknown"},
-    {0x5C,  NULL,                           "Unknown"},
-    {0x5D,  NULL,                           "Unknown"},
-    {0x5E,  NULL,                           "Unknown"},
-    {0x5F,  NULL,                           "Unknown"},
-    {0x60   NULL,                           "svcDebugActiveProcess"},
-    {0x61   NULL,                           "svcBreakDebugProcess"},
-    {0x62   NULL,                           "svcTerminateDebugProcess"},
-    {0x63   NULL,                           "svcGetProcessDebugEvent"},
-    {0x64   NULL,                           "svcContinueDebugEvent"},
-    {0x65   NULL,                           "svcGetProcessList"},
-    {0x66   NULL,                           "svcGetThreadList"},
-    {0x67   NULL,                           "svcGetDebugThreadContext"},
-    {0x68   NULL,                           "svcSetDebugThreadContext"},
-    {0x69   NULL,                           "svcQueryDebugProcessMemory"},
-    {0x6A   NULL,                           "svcReadProcessMemory"},
-    {0x6B   NULL,                           "svcWriteProcessMemory"},
-    {0x6C   NULL,                           "svcSetHardwareBreakPoint"},
-    {0x6D   NULL,                           "svcGetDebugThreadParam"},
-    {0x6E,  NULL,                           "Unknown"},
-    {0x6F,  NULL,                           "Unknown"},
-    {0x70   NULL,                           "svcControlProcessMemory"},
-    {0x71   NULL,                           "svcMapProcessMemory"},
-    {0x72   NULL,                           "svcUnmapProcessMemory"},
-    {0x73,  NULL,                           "Unknown"},
-    {0x74,  NULL,                           "Unknown"},
-    {0x75,  NULL,                           "Unknown"},
-    {0x76   NULL,                           "svcTerminateProcess"},
-    {0x77,  NULL,                           "Unknown"},
-    {0x78   NULL,                           "svcCreateResourceLimit"},
-    {0x79,  NULL,                           "Unknown"},
-    {0x7A,  NULL,                           "Unknown"},
-    {0x7B,  NULL,                           "Unknown"},
-    {0x7C   NULL,                           "svcKernelSetState"},
-    {0x7D   NULL,                           "svcQueryProcessMemory"},
-};
-
-void Register_Syscall() {
-    HLE::RegisterModule("SyscallTable", ARRAY_SIZE(Syscall_Table), Syscall_Table);
-}
diff --git a/src/core/hle/hle_syscall.h b/src/core/hle/hle_syscall.h
deleted file mode 100644
index 80b20c358..000000000
--- a/src/core/hle/hle_syscall.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2
-// Refer to the license.txt file included.  
-
-#pragma once
-
-#include "common/common_types.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-//template <class T>
-//class KernelObject {
-//public:
-//	virtual ~KernelObject() {}
-//
-//	T GetNative() const {
-//        return m_native;
-//    }
-//
-//    void SetNative(const T& native) {
-//        m_native = native;
-//    }
-//
-//	virtual const char *GetTypeName() {return "[BAD KERNEL OBJECT TYPE]";}
-//	virtual const char *GetName() {return "[UNKNOWN KERNEL OBJECT]";}
-//
-//private:
-//    T m_native;
-//};
-
-//class Handle : public KernelObject<u32> {
-//    const char* GetTypeName() { 
-//        return "Handle";
-//    }
-//};
-
-void Register_Syscall();
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
new file mode 100644
index 000000000..f15099982
--- /dev/null
+++ b/src/core/hle/service/service.h
@@ -0,0 +1,60 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+
+#include "common/common_types.h"
+#include "core/hle/syscall.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Service
+
+namespace Service {
+
+typedef s32 NativeUID;
+
+/// Interface to a CTROS service
+class Interface {
+public:
+
+    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 String name of service
+     */
+    virtual std::string GetName() {
+        return "[UNKNOWN SERVICE NAME]";
+    }
+
+    /**
+     * Gets the string name used by CTROS for a service
+     * @return Port name of service
+     */
+    virtual std::string GetPort() {
+        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
+     */
+    virtual Syscall::Result Sync() = 0;
+
+private:
+    u32 m_uid;
+};
+
+} // namespace
diff --git a/src/core/hle/syscall.cpp b/src/core/hle/syscall.cpp
new file mode 100644
index 000000000..98155dc8e
--- /dev/null
+++ b/src/core/hle/syscall.cpp
@@ -0,0 +1,153 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.  
+
+#include <map>
+
+#include "core/hle/function_wrappers.h"
+#include "core/hle/syscall.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Syscall
+
+namespace Syscall {
+
+Result SVC_ConnectToPort(void* out, const char* port_name) {
+    NOTICE_LOG(OSHLE, "svcConnectToPort called, port_name: %s", port_name);
+    return 0;
+}
+
+const HLE::FunctionDef Syscall_Table[] = {
+    {0x00,  NULL,                           "Unknown"},
+    {0x01,  NULL,                           "svcControlMemory"},
+    {0x02,  NULL,                           "svcQueryMemory"},
+    {0x03,  NULL,                           "svcExitProcess"},
+    {0x04,  NULL,                           "svcGetProcessAffinityMask"},
+    {0x05,  NULL,                           "svcSetProcessAffinityMask"},
+    {0x06,  NULL,                           "svcGetProcessIdealProcessor"},
+    {0x07,  NULL,                           "svcSetProcessIdealProcessor"},
+    {0x08,  NULL,                           "svcCreateThread"},
+    {0x09,  NULL,                           "svcExitThread"},
+    {0x0A,  NULL,                           "svcSleepThread"},
+    {0x0B,  NULL,                           "svcGetThreadPriority"},
+    {0x0C,  NULL,                           "svcSetThreadPriority"},
+    {0x0D,  NULL,                           "svcGetThreadAffinityMask"},
+    {0x0E,  NULL,                           "svcSetThreadAffinityMask"},
+    {0x0F,  NULL,                           "svcGetThreadIdealProcessor"},
+    {0x10,  NULL,                           "svcSetThreadIdealProcessor"},
+    {0x11,  NULL,                           "svcGetCurrentProcessorNumber"},
+    {0x12,  NULL,                           "svcRun"},
+    {0x13,  NULL,                           "svcCreateMutex"},
+    {0x14,  NULL,                           "svcReleaseMutex"},
+    {0x15,  NULL,                           "svcCreateSemaphore"},
+    {0x16,  NULL,                           "svcReleaseSemaphore"},
+    {0x17,  NULL,                           "svcCreateEvent"},
+    {0x18,  NULL,                           "svcSignalEvent"},
+    {0x19,  NULL,                           "svcClearEvent"},
+    {0x1A,  NULL,                           "svcCreateTimer"},
+    {0x1B,  NULL,                           "svcSetTimer"},
+    {0x1C,  NULL,                           "svcCancelTimer"},
+    {0x1D,  NULL,                           "svcClearTimer"},
+    {0x1E,  NULL,                           "svcCreateMemoryBlock"},
+    {0x1F,  NULL,                           "svcMapMemoryBlock"},
+    {0x20,  NULL,                           "svcUnmapMemoryBlock"},
+    {0x21,  NULL,                           "svcCreateAddressArbiter"},
+    {0x22,  NULL,                           "svcArbitrateAddress"},
+    {0x23,  NULL,                           "svcCloseHandle"},
+    {0x24,  NULL,                           "svcWaitSynchronization1"},
+    {0x25,  NULL,                           "svcWaitSynchronizationN"},
+    {0x26,  NULL,                           "svcSignalAndWait"},
+    {0x27,  NULL,                           "svcDuplicateHandle"},
+    {0x28,  NULL,                           "svcGetSystemTick"},
+    {0x29,  NULL,                           "svcGetHandleInfo"},
+    {0x2A,  NULL,                           "svcGetSystemInfo"},
+    {0x2B,  NULL,                           "svcGetProcessInfo"},
+    {0x2C,  NULL,                           "svcGetThreadInfo"},
+    {0x2D,  WrapI_VC<SVC_ConnectToPort>,    "svcConnectToPort"},
+    {0x2E,  NULL,                           "svcSendSyncRequest1"},
+    {0x2F,  NULL,                           "svcSendSyncRequest2"},
+    {0x30,  NULL,                           "svcSendSyncRequest3"},
+    {0x31,  NULL,                           "svcSendSyncRequest4"},
+    {0x32,  NULL,                           "svcSendSyncRequest"},
+    {0x33,  NULL,                           "svcOpenProcess"},
+    {0x34,  NULL,                           "svcOpenThread"},
+    {0x35,  NULL,                           "svcGetProcessId"},
+    {0x36,  NULL,                           "svcGetProcessIdOfThread"},
+    {0x37,  NULL,                           "svcGetThreadId"},
+    {0x38,  NULL,                           "svcGetResourceLimit"},
+    {0x39,  NULL,                           "svcGetResourceLimitLimitValues"},
+    {0x3A,  NULL,                           "svcGetResourceLimitCurrentValues"},
+    {0x3B,  NULL,                           "svcGetThreadContext"},
+    {0x3C,  NULL,                           "svcBreak"},
+    {0x3D,  NULL,                           "svcOutputDebugString"},
+    {0x3E,  NULL,                           "svcControlPerformanceCounter"},
+    {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,                           "svcCreatePort"},
+    {0x48,  NULL,                           "svcCreateSessionToPort"},
+    {0x49,  NULL,                           "svcCreateSession"},
+    {0x4A,  NULL,                           "svcAcceptSession"},
+    {0x4B,  NULL,                           "svcReplyAndReceive1"},
+    {0x4C,  NULL,                           "svcReplyAndReceive2"},
+    {0x4D,  NULL,                           "svcReplyAndReceive3"},
+    {0x4E,  NULL,                           "svcReplyAndReceive4"},
+    {0x4F,  NULL,                           "svcReplyAndReceive"},
+    {0x50,  NULL,                           "svcBindInterrupt"},
+    {0x51,  NULL,                           "svcUnbindInterrupt"},
+    {0x52,  NULL,                           "svcInvalidateProcessDataCache"},
+    {0x53,  NULL,                           "svcStoreProcessDataCache"},
+    {0x54,  NULL,                           "svcFlushProcessDataCache"},
+    {0x55,  NULL,                           "svcStartInterProcessDma"},
+    {0x56,  NULL,                           "svcStopDma"},
+    {0x57,  NULL,                           "svcGetDmaState"},
+    {0x58,  NULL,                           "svcRestartDma"},
+    {0x59,  NULL,                           "Unknown"},
+    {0x5A,  NULL,                           "Unknown"},
+    {0x5B,  NULL,                           "Unknown"},
+    {0x5C,  NULL,                           "Unknown"},
+    {0x5D,  NULL,                           "Unknown"},
+    {0x5E,  NULL,                           "Unknown"},
+    {0x5F,  NULL,                           "Unknown"},
+    {0x60,  NULL,                           "svcDebugActiveProcess"},
+    {0x61,  NULL,                           "svcBreakDebugProcess"},
+    {0x62,  NULL,                           "svcTerminateDebugProcess"},
+    {0x63,  NULL,                           "svcGetProcessDebugEvent"},
+    {0x64,  NULL,                           "svcContinueDebugEvent"},
+    {0x65,  NULL,                           "svcGetProcessList"},
+    {0x66,  NULL,                           "svcGetThreadList"},
+    {0x67,  NULL,                           "svcGetDebugThreadContext"},
+    {0x68,  NULL,                           "svcSetDebugThreadContext"},
+    {0x69,  NULL,                           "svcQueryDebugProcessMemory"},
+    {0x6A,  NULL,                           "svcReadProcessMemory"},
+    {0x6B,  NULL,                           "svcWriteProcessMemory"},
+    {0x6C,  NULL,                           "svcSetHardwareBreakPoint"},
+    {0x6D,  NULL,                           "svcGetDebugThreadParam"},
+    {0x6E,  NULL,                           "Unknown"},
+    {0x6F,  NULL,                           "Unknown"},
+    {0x70,  NULL,                           "svcControlProcessMemory"},
+    {0x71,  NULL,                           "svcMapProcessMemory"},
+    {0x72,  NULL,                           "svcUnmapProcessMemory"},
+    {0x73,  NULL,                           "Unknown"},
+    {0x74,  NULL,                           "Unknown"},
+    {0x75,  NULL,                           "Unknown"},
+    {0x76,  NULL,                           "svcTerminateProcess"},
+    {0x77,  NULL,                           "Unknown"},
+    {0x78,  NULL,                           "svcCreateResourceLimit"},
+    {0x79,  NULL,                           "Unknown"},
+    {0x7A,  NULL,                           "Unknown"},
+    {0x7B,  NULL,                           "Unknown"},
+    {0x7C,  NULL,                           "svcKernelSetState"},
+    {0x7D,  NULL,                           "svcQueryProcessMemory"},
+};
+
+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
-- 
cgit v1.2.3


From 68e198476f17a026fed88f3c9a271aa768694354 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sat, 12 Apr 2014 21:55:36 -0400
Subject: - added HLE to connect to "srv:" service

- added a manager for keeping track of services/ports
- added a memory mapped region for memory accessed by HLE
- added HLE for GetThreadCommandBuffer function
---
 src/core/hle/hle.cpp             |  13 ++
 src/core/hle/hle.h               |   7 ++
 src/core/hle/service/service.cpp | 115 +++++++++++++++++
 src/core/hle/service/service.h   |  57 ++++++++-
 src/core/hle/syscall.cpp         | 266 ++++++++++++++++++++-------------------
 5 files changed, 328 insertions(+), 130 deletions(-)
 create mode 100644 src/core/hle/service/service.cpp

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
index 32aff0eb5..3d2c53954 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -4,8 +4,10 @@
 
 #include <vector>
 
+#include "core/mem_map.h"
 #include "core/hle/hle.h"
 #include "core/hle/syscall.h"
+#include "core/hle/service/service.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -35,6 +37,14 @@ void CallSyscall(u32 opcode) {
     }
 }
 
+/// 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(OS_THREAD_COMMAND_BUFFER_ADDR);
+    return OS_THREAD_COMMAND_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);
@@ -45,7 +55,10 @@ void RegisterAllModules() {
 }
 
 void Init() {
+    Service::Init();
+    
     RegisterAllModules();
+
     NOTICE_LOG(HLE, "initialized OK");
 }
 
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 9466be540..2bd1f99a2 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -16,6 +16,11 @@
 
 namespace HLE {
 
+enum {
+    OS_THREAD_COMMAND_BUFFER_ADDR = 0xA0004000,
+};
+
+typedef u32 Addr;
 typedef void (*Func)();
 
 struct FunctionDef {
@@ -34,6 +39,8 @@ void RegisterModule(std::string name, int num_functions, const FunctionDef *func
 
 void CallSyscall(u32 opcode);
 
+Addr CallGetThreadCommandBuffer();
+
 void Init();
 
 void Shutdown();
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
new file mode 100644
index 000000000..4bc96cc18
--- /dev/null
+++ b/src/core/hle/service/service.cpp
@@ -0,0 +1,115 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "common/common.h"
+#include "common/log.h"
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Service
+
+namespace Service {
+
+Manager* g_manager = NULL;  ///< Service manager
+
+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);
+}
+
+class Interface_SRV : public Interface {
+public:
+
+    Interface_SRV() {
+    }
+
+    ~Interface_SRV() {
+    }
+
+    /**
+     * Gets the string name used by CTROS for a service
+     * @return String name of service
+     */
+    std::string GetName() {
+        return "ServiceManager";
+    }
+
+    /**
+     * Gets the string name used by CTROS for a service
+     * @return Port name of service
+     */
+    std::string GetPortName() {
+        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() {
+        ERROR_LOG(HLE, "Unimplemented function ServiceManager::Sync");
+        return -1;
+    }
+
+};
+
+/// Initialize ServiceManager
+void Init() {
+    g_manager = new Manager;
+    g_manager->AddService(new Interface_SRV);
+    NOTICE_LOG(HLE, "ServiceManager initialized OK");
+}
+
+/// Shutdown ServiceManager
+void Shutdown() {
+    delete g_manager;
+    NOTICE_LOG(HLE, "ServiceManager shutdown OK");
+}
+
+
+}
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index f15099982..3fd855dee 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <vector>
+#include <map>
 #include <string>
 
 #include "common/common_types.h"
@@ -14,10 +16,13 @@
 
 namespace Service {
 
-typedef s32 NativeUID;
+typedef s32 NativeUID;          ///< Native handle for a service
+
+class Manager;
 
 /// Interface to a CTROS service
 class Interface {
+    friend class Manager;
 public:
 
     virtual ~Interface() {
@@ -43,7 +48,7 @@ public:
      * Gets the string name used by CTROS for a service
      * @return Port name of service
      */
-    virtual std::string GetPort() {
+    virtual std::string GetPortName() {
         return "[UNKNOWN SERVICE PORT]";
     }
 
@@ -57,4 +62,52 @@ private:
     u32 m_uid;
 };
 
+/// 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/syscall.cpp b/src/core/hle/syscall.cpp
index 98155dc8e..8225f168b 100644
--- a/src/core/hle/syscall.cpp
+++ b/src/core/hle/syscall.cpp
@@ -6,144 +6,154 @@
 
 #include "core/hle/function_wrappers.h"
 #include "core/hle/syscall.h"
+#include "core/hle/service/service.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Namespace Syscall
 
 namespace Syscall {
 
-Result SVC_ConnectToPort(void* out, const char* port_name) {
-    NOTICE_LOG(OSHLE, "svcConnectToPort called, port_name: %s", port_name);
+/// 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;
 }
 
 const HLE::FunctionDef Syscall_Table[] = {
-    {0x00,  NULL,                           "Unknown"},
-    {0x01,  NULL,                           "svcControlMemory"},
-    {0x02,  NULL,                           "svcQueryMemory"},
-    {0x03,  NULL,                           "svcExitProcess"},
-    {0x04,  NULL,                           "svcGetProcessAffinityMask"},
-    {0x05,  NULL,                           "svcSetProcessAffinityMask"},
-    {0x06,  NULL,                           "svcGetProcessIdealProcessor"},
-    {0x07,  NULL,                           "svcSetProcessIdealProcessor"},
-    {0x08,  NULL,                           "svcCreateThread"},
-    {0x09,  NULL,                           "svcExitThread"},
-    {0x0A,  NULL,                           "svcSleepThread"},
-    {0x0B,  NULL,                           "svcGetThreadPriority"},
-    {0x0C,  NULL,                           "svcSetThreadPriority"},
-    {0x0D,  NULL,                           "svcGetThreadAffinityMask"},
-    {0x0E,  NULL,                           "svcSetThreadAffinityMask"},
-    {0x0F,  NULL,                           "svcGetThreadIdealProcessor"},
-    {0x10,  NULL,                           "svcSetThreadIdealProcessor"},
-    {0x11,  NULL,                           "svcGetCurrentProcessorNumber"},
-    {0x12,  NULL,                           "svcRun"},
-    {0x13,  NULL,                           "svcCreateMutex"},
-    {0x14,  NULL,                           "svcReleaseMutex"},
-    {0x15,  NULL,                           "svcCreateSemaphore"},
-    {0x16,  NULL,                           "svcReleaseSemaphore"},
-    {0x17,  NULL,                           "svcCreateEvent"},
-    {0x18,  NULL,                           "svcSignalEvent"},
-    {0x19,  NULL,                           "svcClearEvent"},
-    {0x1A,  NULL,                           "svcCreateTimer"},
-    {0x1B,  NULL,                           "svcSetTimer"},
-    {0x1C,  NULL,                           "svcCancelTimer"},
-    {0x1D,  NULL,                           "svcClearTimer"},
-    {0x1E,  NULL,                           "svcCreateMemoryBlock"},
-    {0x1F,  NULL,                           "svcMapMemoryBlock"},
-    {0x20,  NULL,                           "svcUnmapMemoryBlock"},
-    {0x21,  NULL,                           "svcCreateAddressArbiter"},
-    {0x22,  NULL,                           "svcArbitrateAddress"},
-    {0x23,  NULL,                           "svcCloseHandle"},
-    {0x24,  NULL,                           "svcWaitSynchronization1"},
-    {0x25,  NULL,                           "svcWaitSynchronizationN"},
-    {0x26,  NULL,                           "svcSignalAndWait"},
-    {0x27,  NULL,                           "svcDuplicateHandle"},
-    {0x28,  NULL,                           "svcGetSystemTick"},
-    {0x29,  NULL,                           "svcGetHandleInfo"},
-    {0x2A,  NULL,                           "svcGetSystemInfo"},
-    {0x2B,  NULL,                           "svcGetProcessInfo"},
-    {0x2C,  NULL,                           "svcGetThreadInfo"},
-    {0x2D,  WrapI_VC<SVC_ConnectToPort>,    "svcConnectToPort"},
-    {0x2E,  NULL,                           "svcSendSyncRequest1"},
-    {0x2F,  NULL,                           "svcSendSyncRequest2"},
-    {0x30,  NULL,                           "svcSendSyncRequest3"},
-    {0x31,  NULL,                           "svcSendSyncRequest4"},
-    {0x32,  NULL,                           "svcSendSyncRequest"},
-    {0x33,  NULL,                           "svcOpenProcess"},
-    {0x34,  NULL,                           "svcOpenThread"},
-    {0x35,  NULL,                           "svcGetProcessId"},
-    {0x36,  NULL,                           "svcGetProcessIdOfThread"},
-    {0x37,  NULL,                           "svcGetThreadId"},
-    {0x38,  NULL,                           "svcGetResourceLimit"},
-    {0x39,  NULL,                           "svcGetResourceLimitLimitValues"},
-    {0x3A,  NULL,                           "svcGetResourceLimitCurrentValues"},
-    {0x3B,  NULL,                           "svcGetThreadContext"},
-    {0x3C,  NULL,                           "svcBreak"},
-    {0x3D,  NULL,                           "svcOutputDebugString"},
-    {0x3E,  NULL,                           "svcControlPerformanceCounter"},
-    {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,                           "svcCreatePort"},
-    {0x48,  NULL,                           "svcCreateSessionToPort"},
-    {0x49,  NULL,                           "svcCreateSession"},
-    {0x4A,  NULL,                           "svcAcceptSession"},
-    {0x4B,  NULL,                           "svcReplyAndReceive1"},
-    {0x4C,  NULL,                           "svcReplyAndReceive2"},
-    {0x4D,  NULL,                           "svcReplyAndReceive3"},
-    {0x4E,  NULL,                           "svcReplyAndReceive4"},
-    {0x4F,  NULL,                           "svcReplyAndReceive"},
-    {0x50,  NULL,                           "svcBindInterrupt"},
-    {0x51,  NULL,                           "svcUnbindInterrupt"},
-    {0x52,  NULL,                           "svcInvalidateProcessDataCache"},
-    {0x53,  NULL,                           "svcStoreProcessDataCache"},
-    {0x54,  NULL,                           "svcFlushProcessDataCache"},
-    {0x55,  NULL,                           "svcStartInterProcessDma"},
-    {0x56,  NULL,                           "svcStopDma"},
-    {0x57,  NULL,                           "svcGetDmaState"},
-    {0x58,  NULL,                           "svcRestartDma"},
-    {0x59,  NULL,                           "Unknown"},
-    {0x5A,  NULL,                           "Unknown"},
-    {0x5B,  NULL,                           "Unknown"},
-    {0x5C,  NULL,                           "Unknown"},
-    {0x5D,  NULL,                           "Unknown"},
-    {0x5E,  NULL,                           "Unknown"},
-    {0x5F,  NULL,                           "Unknown"},
-    {0x60,  NULL,                           "svcDebugActiveProcess"},
-    {0x61,  NULL,                           "svcBreakDebugProcess"},
-    {0x62,  NULL,                           "svcTerminateDebugProcess"},
-    {0x63,  NULL,                           "svcGetProcessDebugEvent"},
-    {0x64,  NULL,                           "svcContinueDebugEvent"},
-    {0x65,  NULL,                           "svcGetProcessList"},
-    {0x66,  NULL,                           "svcGetThreadList"},
-    {0x67,  NULL,                           "svcGetDebugThreadContext"},
-    {0x68,  NULL,                           "svcSetDebugThreadContext"},
-    {0x69,  NULL,                           "svcQueryDebugProcessMemory"},
-    {0x6A,  NULL,                           "svcReadProcessMemory"},
-    {0x6B,  NULL,                           "svcWriteProcessMemory"},
-    {0x6C,  NULL,                           "svcSetHardwareBreakPoint"},
-    {0x6D,  NULL,                           "svcGetDebugThreadParam"},
-    {0x6E,  NULL,                           "Unknown"},
-    {0x6F,  NULL,                           "Unknown"},
-    {0x70,  NULL,                           "svcControlProcessMemory"},
-    {0x71,  NULL,                           "svcMapProcessMemory"},
-    {0x72,  NULL,                           "svcUnmapProcessMemory"},
-    {0x73,  NULL,                           "Unknown"},
-    {0x74,  NULL,                           "Unknown"},
-    {0x75,  NULL,                           "Unknown"},
-    {0x76,  NULL,                           "svcTerminateProcess"},
-    {0x77,  NULL,                           "Unknown"},
-    {0x78,  NULL,                           "svcCreateResourceLimit"},
-    {0x79,  NULL,                           "Unknown"},
-    {0x7A,  NULL,                           "Unknown"},
-    {0x7B,  NULL,                           "Unknown"},
-    {0x7C,  NULL,                           "svcKernelSetState"},
-    {0x7D,  NULL,                           "svcQueryProcessMemory"},
+    {0x00,  NULL,                       "Unknown"},
+    {0x01,  NULL,                       "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,  NULL,                       "CloseHandle"},
+    {0x24,  NULL,                       "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() {
-- 
cgit v1.2.3


From b24e6f2b609e1a75f05124a6246801dd0e56183a Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sat, 12 Apr 2014 22:08:48 -0400
Subject: cleanups to service HLE

---
 src/core/hle/service/service.cpp | 12 ++++++------
 src/core/hle/service/service.h   |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 4bc96cc18..3434b6dbf 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -75,7 +75,7 @@ public:
      * Gets the string name used by CTROS for a service
      * @return String name of service
      */
-    std::string GetName() {
+    std::string GetName() const {
         return "ServiceManager";
     }
 
@@ -83,7 +83,7 @@ public:
      * Gets the string name used by CTROS for a service
      * @return Port name of service
      */
-    std::string GetPortName() {
+    std::string GetPortName() const {
         return "srv:";
     }
 
@@ -92,8 +92,8 @@ public:
      * @return Return result of svcSendSyncRequest passed back to user app
      */
     Syscall::Result Sync() {
-        ERROR_LOG(HLE, "Unimplemented function ServiceManager::Sync");
-        return -1;
+        ERROR_LOG(HLE, "Unimplemented function Interface_SRV::Sync");
+        return 0;
     }
 
 };
@@ -102,13 +102,13 @@ public:
 void Init() {
     g_manager = new Manager;
     g_manager->AddService(new Interface_SRV);
-    NOTICE_LOG(HLE, "ServiceManager initialized OK");
+    NOTICE_LOG(HLE, "Services initialized OK");
 }
 
 /// Shutdown ServiceManager
 void Shutdown() {
     delete g_manager;
-    NOTICE_LOG(HLE, "ServiceManager shutdown OK");
+    NOTICE_LOG(HLE, "Services shutdown OK");
 }
 
 
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 3fd855dee..3cad6c642 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -40,7 +40,7 @@ public:
      * Gets the string name used by CTROS for a service
      * @return String name of service
      */
-    virtual std::string GetName() {
+    virtual std::string GetName() const {
         return "[UNKNOWN SERVICE NAME]";
     }
 
@@ -48,7 +48,7 @@ public:
      * Gets the string name used by CTROS for a service
      * @return Port name of service
      */
-    virtual std::string GetPortName() {
+    virtual std::string GetPortName() const {
         return "[UNKNOWN SERVICE PORT]";
     }
 
-- 
cgit v1.2.3


From 6f6d5158de18a7ca134406d55446c27f6db48a1a Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sat, 12 Apr 2014 23:31:39 -0400
Subject: added OS memory read/write for thread command buffer

---
 src/core/hle/hle.cpp | 45 +++++++++++++++++++++++++++++++++++++++++++--
 src/core/hle/hle.h   | 13 ++++++++++++-
 2 files changed, 55 insertions(+), 3 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
index 3d2c53954..51432dc87 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -15,6 +15,40 @@ 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);
+    }
+}
+
+// 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) {
@@ -41,8 +75,8 @@ void CallSyscall(u32 opcode) {
 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(OS_THREAD_COMMAND_BUFFER_ADDR);
-    return OS_THREAD_COMMAND_BUFFER_ADDR;
+    RETURN(CMD_BUFFER_ADDR);
+    return CMD_BUFFER_ADDR;
 }
 
 void RegisterModule(std::string name, int num_functions, const FunctionDef* func_table) {
@@ -56,6 +90,8 @@ void RegisterAllModules() {
 
 void Init() {
     Service::Init();
+
+    g_command_buffer = new u8[CMD_BUFFER_SIZE];
     
     RegisterAllModules();
 
@@ -63,7 +99,12 @@ void Init() {
 }
 
 void Shutdown() {
+    Service::Shutdown();
+
+    delete g_command_buffer;
+
     g_module_db.clear();
+
     NOTICE_LOG(HLE, "shutdown OK");
 }
 
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 2bd1f99a2..5ee90bcdc 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -17,7 +17,10 @@
 namespace HLE {
 
 enum {
-    OS_THREAD_COMMAND_BUFFER_ADDR = 0xA0004000,
+    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;
@@ -35,6 +38,14 @@ struct ModuleDef {
     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);
+
 void RegisterModule(std::string name, int num_functions, const FunctionDef *func_table);
 
 void CallSyscall(u32 opcode);
-- 
cgit v1.2.3


From 67f6e414702cbb83a53392e1cca229875a186cea Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sun, 13 Apr 2014 00:37:10 -0400
Subject: added a GetPointer function for reading from HLE command buffer

---
 src/core/hle/hle.cpp | 8 ++++++++
 src/core/hle/hle.h   | 6 ++++++
 2 files changed, 14 insertions(+)

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
index 51432dc87..a4ab61c0c 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -37,6 +37,14 @@ inline void Write(u32 addr, const T data) {
     }
 }
 
+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);
+    }
+}
+
 // Explicitly instantiate template functions because we aren't defining this in the header:
 
 template void Read<u64>(u64 &var, const u32 addr);
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index 5ee90bcdc..d02948be3 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -46,6 +46,12 @@ inline void Read(T &var, const u32 addr);
 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);
-- 
cgit v1.2.3


From 5ea4679630d6776837114252476dd445f377322d Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sun, 13 Apr 2014 00:38:48 -0400
Subject: added some very initial command parsing for SRV Sync

---
 src/core/hle/service/service.cpp | 36 +++++++++++++++++++++++++++++++-----
 1 file changed, 31 insertions(+), 5 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 3434b6dbf..556dfc8a2 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -5,15 +5,16 @@
 #include "common/common.h"
 #include "common/log.h"
 
+#include "core/hle/hle.h"
 #include "core/hle/service/service.h"
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Namespace Service
-
 namespace Service {
 
 Manager* g_manager = NULL;  ///< Service manager
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Service Manager class
+
 Manager::Manager() {
 }
 
@@ -62,7 +63,11 @@ Interface* Manager::FetchFromPortName(std::string port_name) {
     return FetchFromUID(itr->second);
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface to "SRV" service
+
 class Interface_SRV : public Interface {
+
 public:
 
     Interface_SRV() {
@@ -71,6 +76,12 @@ public:
     ~Interface_SRV() {
     }
 
+    enum {
+        CMD_OFFSET              = 0x80,
+        CMD_HEADER_INIT         = 0x10002,  ///< Command header to initialize SRV service
+        CMD_HEADER_GET_HANDLE   = 0x50100,  ///< Command header to get handle of other services
+    };
+
     /**
      * Gets the string name used by CTROS for a service
      * @return String name of service
@@ -92,12 +103,27 @@ public:
      * @return Return result of svcSendSyncRequest passed back to user app
      */
     Syscall::Result Sync() {
-        ERROR_LOG(HLE, "Unimplemented function Interface_SRV::Sync");
+        u32 header = 0;
+        HLE::Read<u32>(header, (HLE::CMD_BUFFER_ADDR + CMD_OFFSET));
+
+        switch (header) {
+        case CMD_HEADER_INIT:
+            NOTICE_LOG(HLE, "Interface_SRV::Sync - Initialize");
+            break;
+
+        case CMD_HEADER_GET_HANDLE:
+            NOTICE_LOG(HLE, "Interface_SRV::Sync - GetHandle, port: %s", HLE::GetCharPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET + 4));
+            break;
+        }
+
         return 0;
     }
-
+     
 };
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Module interface
+
 /// Initialize ServiceManager
 void Init() {
     g_manager = new Manager;
-- 
cgit v1.2.3


From 524e78ece8139ad1adf4c6cf08ff1f705e7af823 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sun, 13 Apr 2014 01:22:05 -0400
Subject: renamed class Interface_SRV to SRV

---
 src/core/hle/service/service.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 556dfc8a2..b0b2b7b35 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -66,14 +66,14 @@ Interface* Manager::FetchFromPortName(std::string port_name) {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Interface to "SRV" service
 
-class Interface_SRV : public Interface {
+class SRV : public Interface {
 
 public:
 
-    Interface_SRV() {
+    SRV() {
     }
 
-    ~Interface_SRV() {
+    ~SRV() {
     }
 
     enum {
@@ -108,11 +108,11 @@ public:
 
         switch (header) {
         case CMD_HEADER_INIT:
-            NOTICE_LOG(HLE, "Interface_SRV::Sync - Initialize");
+            NOTICE_LOG(HLE, "SRV::Sync - Initialize");
             break;
 
         case CMD_HEADER_GET_HANDLE:
-            NOTICE_LOG(HLE, "Interface_SRV::Sync - GetHandle, port: %s", HLE::GetCharPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET + 4));
+            NOTICE_LOG(HLE, "SRV::Sync - GetHandle, port: %s", HLE::GetCharPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET + 4));
             break;
         }
 
@@ -127,7 +127,7 @@ public:
 /// Initialize ServiceManager
 void Init() {
     g_manager = new Manager;
-    g_manager->AddService(new Interface_SRV);
+    g_manager->AddService(new SRV);
     NOTICE_LOG(HLE, "Services initialized OK");
 }
 
-- 
cgit v1.2.3


From 9f4d677cdf1fcc937d2e68cae3f52f53c24582f8 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sun, 13 Apr 2014 16:33:45 -0400
Subject: added framework for APT service (application and title launching
 service)

---
 src/core/hle/hle.cpp             |  1 +
 src/core/hle/service/apt.cpp     | 21 ++++++++++++
 src/core/hle/service/apt.h       | 71 ++++++++++++++++++++++++++++++++++++++++
 src/core/hle/service/service.cpp | 29 +++++++++++++---
 src/core/hle/service/service.h   |  1 +
 5 files changed, 118 insertions(+), 5 deletions(-)
 create mode 100644 src/core/hle/service/apt.cpp
 create mode 100644 src/core/hle/service/apt.h

(limited to 'src/core/hle')

diff --git a/src/core/hle/hle.cpp b/src/core/hle/hle.cpp
index a4ab61c0c..c173b82de 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -42,6 +42,7 @@ u8 *GetPointer(const u32 addr) {
         return g_command_buffer + (addr & CMD_BUFFER_MASK);
     } else {
         ERROR_LOG(HLE, "unknown pointer from address %08X", addr);
+        return 0;
     }
 }
 
diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
new file mode 100644
index 000000000..9ab5a361c
--- /dev/null
+++ b/src/core/hle/service/apt.cpp
@@ -0,0 +1,21 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+
+#include "common/log.h"
+#include "core/hle/service/apt.h"
+
+
+
+
+namespace Service {
+
+
+Syscall::Result APT::Sync() {
+    NOTICE_LOG(HLE, "APT::Sync - Initialize");
+    return 0;
+}
+
+
+}
diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
new file mode 100644
index 000000000..05c544378
--- /dev/null
+++ b/src/core/hle/service/apt.h
@@ -0,0 +1,71 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Service
+
+namespace Service {
+
+// 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.
+
+class APT : public Interface {
+public:
+
+    APT() {
+    }
+
+    ~APT() {
+    }
+
+    enum {
+        CMD_OFFSET                              = 0x00000080,
+
+        CMD_HEADER_INIT                         = 0x00020080,   ///< Initialize service
+        CMD_HEADER_GET_LOCK_HANDLE              = 0x00010040,   ///< Get service Mutex
+        CMD_HEADER_ENABLE                       = 0x00030040,   ///< Enable service
+        CMD_HEADER_INQUIRE_NOTIFICATION         = 0x000B0040,   ///< Inquire notification
+        CMD_HEADER_PREPARE_TO_JUMP_TO_HOME_MENU = 0x002B0000,   ///< Prepare to jump to home menu
+        CMD_HEADER_JUMP_TO_HOME_MENU            = 0x002C0044,   ///< Jump to home menu
+        CMD_HEADER_NOTIFY_TO_WAIT               = 0x00430040,   ///< Notify to wait
+        CMD_HEADER_APPLET_UTILITY               = 0x004B00C2,   ///< Applet utility
+        CMD_HEADER_GLANCE_PARAMETER             = 0x000E0080,   ///< Glance parameter
+        CMD_HEADER_RECEIVE_PARAMETER            = 0x000D0080,   ///< Receive parameter
+        CMD_HEADER_REPLY_SLEEP_QUERY            = 0x003E0080,   ///< Reply sleep query
+        CMD_HEADER_PREPARE_TO_CLOSE_APP         = 0x00220040,   ///< Prepare to close application
+        CMD_HEADER_CLOSE_APP                    = 0x00270044,   ///< Close application
+    };
+
+    /**
+     * Gets the string name used by CTROS for the APT service
+     * @return String name of service
+     */
+    std::string GetName() const {
+        return "APT";
+    }
+
+    /**
+     * Gets the string port name used by CTROS for the APT service
+     * @return Port name of service
+     */
+    std::string GetPortName() const {
+        return "APT:U";
+    }
+
+    /**
+     * Called when svcSendSyncRequest is called, loads command buffer and executes comand
+     * @return Return result of svcSendSyncRequest passed back to user app
+     */
+    virtual Syscall::Result Sync();
+
+};
+
+} // namespace
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index b0b2b7b35..b2470d814 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -7,6 +7,7 @@
 
 #include "core/hle/hle.h"
 #include "core/hle/service/service.h"
+#include "core/hle/service/apt.h"
 
 namespace Service {
 
@@ -104,19 +105,36 @@ public:
      */
     Syscall::Result Sync() {
         u32 header = 0;
-        HLE::Read<u32>(header, (HLE::CMD_BUFFER_ADDR + CMD_OFFSET));
+        Syscall::Result res = 0;
+        
+        u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
+
+        switch (cmd_buff[0]) {
 
-        switch (header) {
         case CMD_HEADER_INIT:
-            NOTICE_LOG(HLE, "SRV::Sync - Initialize");
+            NOTICE_LOG(OSHLE, "SRV::Sync - Initialize");
             break;
 
         case CMD_HEADER_GET_HANDLE:
-            NOTICE_LOG(HLE, "SRV::Sync - GetHandle, port: %s", HLE::GetCharPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET + 4));
+            const char* port_name = (const char*)&cmd_buff[1];
+            Interface* service = g_manager->FetchFromPortName(port_name);
+
+            NOTICE_LOG(OSHLE, "SRV::Sync - GetHandle - port: %s, handle: 0x%08X", port_name, 
+                service->GetUID());
+
+            if (NULL != service) {
+                cmd_buff[3] = service->GetUID();
+            } else {
+                ERROR_LOG(OSHLE, "Service %s does not exist", port_name);
+                res = -1;
+            }
+            
             break;
         }
 
-        return 0;
+        cmd_buff[1] = res;
+
+        return res;
     }
      
 };
@@ -128,6 +146,7 @@ public:
 void Init() {
     g_manager = new Manager;
     g_manager->AddService(new SRV);
+    g_manager->AddService(new APT);
     NOTICE_LOG(HLE, "Services initialized OK");
 }
 
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 3cad6c642..365583ed2 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -8,6 +8,7 @@
 #include <map>
 #include <string>
 
+#include "common/common.h"
 #include "common/common_types.h"
 #include "core/hle/syscall.h"
 
-- 
cgit v1.2.3


From 18766b9e69bf822764eba98237325d07b3c4ef0f Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Sun, 13 Apr 2014 22:59:16 -0400
Subject: added a stub for GetLockHandle

---
 src/core/hle/service/apt.cpp     | 35 ++++++++++++++++++++++++++++++-----
 src/core/hle/service/apt.h       |  8 +++++++-
 src/core/hle/service/service.cpp | 10 +++++++---
 3 files changed, 44 insertions(+), 9 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
index 9ab5a361c..5e37b838a 100644
--- a/src/core/hle/service/apt.cpp
+++ b/src/core/hle/service/apt.cpp
@@ -4,17 +4,42 @@
 
 
 #include "common/log.h"
-#include "core/hle/service/apt.h"
-
-
 
+#include "core/hle/hle.h"
+#include "core/hle/service/apt.h"
 
 namespace Service {
 
+// Returns handle to APT Mutex. Not imlemented.
+Syscall::Result APT::GetLockHandle() {
+    return 0x00000000;
+}
 
+/**
+ * Called when svcSendSyncRequest is called, loads command buffer and executes comand
+ * @return Return result of svcSendSyncRequest passed back to user app
+ */
 Syscall::Result APT::Sync() {
-    NOTICE_LOG(HLE, "APT::Sync - Initialize");
-    return 0;
+    Syscall::Result res = 0;
+    u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
+
+    switch(cmd_buff[0]) {
+    case CMD_HEADER_INIT:
+        NOTICE_LOG(OSHLE, "APT::Sync - Initialize");
+        break;
+
+    case CMD_HEADER_GET_LOCK_HANDLE:
+        NOTICE_LOG(OSHLE, "APT::Sync - GetLockHandle");
+        cmd_buff[5] = GetLockHandle();
+        break;
+
+    default:
+        ERROR_LOG(OSHLE, "APT::Sync - Unknown command 0x%08X", cmd_buff[0]);
+        res = -1;
+        break;
+    }
+
+    return res;
 }
 
 
diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
index 05c544378..3730bc30e 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -64,7 +64,13 @@ public:
      * Called when svcSendSyncRequest is called, loads command buffer and executes comand
      * @return Return result of svcSendSyncRequest passed back to user app
      */
-    virtual Syscall::Result Sync();
+    Syscall::Result Sync();
+
+private:
+
+
+    Syscall::Result GetLockHandle();
+
 
 };
 
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index b2470d814..44c7c8627 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -104,9 +104,7 @@ public:
      * @return Return result of svcSendSyncRequest passed back to user app
      */
     Syscall::Result Sync() {
-        u32 header = 0;
         Syscall::Result res = 0;
-        
         u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
 
         switch (cmd_buff[0]) {
@@ -116,6 +114,7 @@ public:
             break;
 
         case CMD_HEADER_GET_HANDLE:
+        {
             const char* port_name = (const char*)&cmd_buff[1];
             Interface* service = g_manager->FetchFromPortName(port_name);
 
@@ -128,7 +127,12 @@ public:
                 ERROR_LOG(OSHLE, "Service %s does not exist", port_name);
                 res = -1;
             }
-            
+            break;
+        }
+
+        default:
+            ERROR_LOG(OSHLE, "SRV::Sync - Unknown command 0x%08X", cmd_buff[0]);
+            res = -1;
             break;
         }
 
-- 
cgit v1.2.3


From 7ec5950bc4c8e4a786df1f4c3392d7b5332d1613 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Tue, 15 Apr 2014 22:40:19 -0400
Subject: - extracted srv: calls from service.cpp and put in its own module

- added function tables for service calls
- lots of refactoring
---
 src/core/hle/service/apt.cpp     | 91 +++++++++++++++++++++++++++++++++++++---
 src/core/hle/service/apt.h       | 17 ++------
 src/core/hle/service/service.cpp | 84 ++-----------------------------------
 src/core/hle/service/service.h   | 19 +++++----
 4 files changed, 105 insertions(+), 106 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
index 5e37b838a..b1e49db97 100644
--- a/src/core/hle/service/apt.cpp
+++ b/src/core/hle/service/apt.cpp
@@ -10,8 +10,89 @@
 
 namespace Service {
 
+const HLE::FunctionDef APT_U_Table[] = {
+    {0x00010040, NULL,      "GetLockHandle"},
+    {0x00020080, NULL,      "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"},
+};
+
 // Returns handle to APT Mutex. Not imlemented.
-Syscall::Result APT::GetLockHandle() {
+Syscall::Result APT_U::GetLockHandle() {
     return 0x00000000;
 }
 
@@ -19,22 +100,22 @@ Syscall::Result APT::GetLockHandle() {
  * Called when svcSendSyncRequest is called, loads command buffer and executes comand
  * @return Return result of svcSendSyncRequest passed back to user app
  */
-Syscall::Result APT::Sync() {
+Syscall::Result APT_U::Sync() {
     Syscall::Result res = 0;
     u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
 
     switch(cmd_buff[0]) {
     case CMD_HEADER_INIT:
-        NOTICE_LOG(OSHLE, "APT::Sync - Initialize");
+        NOTICE_LOG(OSHLE, "APT_U::Sync - Initialize");
         break;
 
     case CMD_HEADER_GET_LOCK_HANDLE:
-        NOTICE_LOG(OSHLE, "APT::Sync - GetLockHandle");
+        NOTICE_LOG(OSHLE, "APT_U::Sync - GetLockHandle");
         cmd_buff[5] = GetLockHandle();
         break;
 
     default:
-        ERROR_LOG(OSHLE, "APT::Sync - Unknown command 0x%08X", cmd_buff[0]);
+        ERROR_LOG(OSHLE, "APT_U::Sync - Unknown command 0x%08X", cmd_buff[0]);
         res = -1;
         break;
     }
diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
index 3730bc30e..0e1f205c7 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -17,13 +17,13 @@ namespace Service {
 // 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.
 
-class APT : public Interface {
+class APT_U : public Interface {
 public:
 
-    APT() {
+    APT_U() {
     }
 
-    ~APT() {
+    ~APT_U() {
     }
 
     enum {
@@ -44,14 +44,6 @@ public:
         CMD_HEADER_CLOSE_APP                    = 0x00270044,   ///< Close application
     };
 
-    /**
-     * Gets the string name used by CTROS for the APT service
-     * @return String name of service
-     */
-    std::string GetName() const {
-        return "APT";
-    }
-
     /**
      * Gets the string port name used by CTROS for the APT service
      * @return Port name of service
@@ -68,10 +60,9 @@ public:
 
 private:
 
-
     Syscall::Result GetLockHandle();
 
-
+    DISALLOW_COPY_AND_ASSIGN(APT_U);
 };
 
 } // namespace
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 44c7c8627..799dbe90e 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -4,10 +4,12 @@
 
 #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/srv.h"
 
 namespace Service {
 
@@ -64,84 +66,6 @@ Interface* Manager::FetchFromPortName(std::string port_name) {
     return FetchFromUID(itr->second);
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Interface to "SRV" service
-
-class SRV : public Interface {
-
-public:
-
-    SRV() {
-    }
-
-    ~SRV() {
-    }
-
-    enum {
-        CMD_OFFSET              = 0x80,
-        CMD_HEADER_INIT         = 0x10002,  ///< Command header to initialize SRV service
-        CMD_HEADER_GET_HANDLE   = 0x50100,  ///< Command header to get handle of other services
-    };
-
-    /**
-     * Gets the string name used by CTROS for a service
-     * @return String name of service
-     */
-    std::string GetName() const {
-        return "ServiceManager";
-    }
-
-    /**
-     * Gets the string name used by CTROS for a 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() {
-        Syscall::Result res = 0;
-        u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
-
-        switch (cmd_buff[0]) {
-
-        case CMD_HEADER_INIT:
-            NOTICE_LOG(OSHLE, "SRV::Sync - Initialize");
-            break;
-
-        case CMD_HEADER_GET_HANDLE:
-        {
-            const char* port_name = (const char*)&cmd_buff[1];
-            Interface* service = g_manager->FetchFromPortName(port_name);
-
-            NOTICE_LOG(OSHLE, "SRV::Sync - GetHandle - port: %s, handle: 0x%08X", port_name, 
-                service->GetUID());
-
-            if (NULL != service) {
-                cmd_buff[3] = service->GetUID();
-            } else {
-                ERROR_LOG(OSHLE, "Service %s does not exist", port_name);
-                res = -1;
-            }
-            break;
-        }
-
-        default:
-            ERROR_LOG(OSHLE, "SRV::Sync - Unknown command 0x%08X", cmd_buff[0]);
-            res = -1;
-            break;
-        }
-
-        cmd_buff[1] = res;
-
-        return res;
-    }
-     
-};
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Module interface
@@ -149,8 +73,8 @@ public:
 /// Initialize ServiceManager
 void Init() {
     g_manager = new Manager;
-    g_manager->AddService(new SRV);
-    g_manager->AddService(new APT);
+    g_manager->AddService(new SRV::Interface);
+    g_manager->AddService(new APT_U);
     NOTICE_LOG(HLE, "Services initialized OK");
 }
 
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 365583ed2..9368a9f0f 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -37,14 +37,6 @@ public:
         return (NativeUID)m_uid;
     }
 
-    /**
-     * Gets the string name used by CTROS for a service
-     * @return String name of service
-     */
-    virtual std::string GetName() const {
-        return "[UNKNOWN SERVICE NAME]";
-    }
-
     /**
      * Gets the string name used by CTROS for a service
      * @return Port name of service
@@ -59,8 +51,19 @@ public:
      */
     virtual Syscall::Result Sync() = 0;
 
+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;
 };
 
 /// Simple class to manage accessing services from ports and UID handles
-- 
cgit v1.2.3


From 386dd722e7a2463eadefd3b1fd82681e8edcb5b7 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Tue, 15 Apr 2014 22:42:35 -0400
Subject: fixed naming for APT_U

---
 src/core/hle/service/apt.cpp     |  6 +++---
 src/core/hle/service/apt.h       | 10 +++++-----
 src/core/hle/service/service.cpp |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
index b1e49db97..288a68a86 100644
--- a/src/core/hle/service/apt.cpp
+++ b/src/core/hle/service/apt.cpp
@@ -8,7 +8,7 @@
 #include "core/hle/hle.h"
 #include "core/hle/service/apt.h"
 
-namespace Service {
+namespace APT_U {
 
 const HLE::FunctionDef APT_U_Table[] = {
     {0x00010040, NULL,      "GetLockHandle"},
@@ -92,7 +92,7 @@ const HLE::FunctionDef APT_U_Table[] = {
 };
 
 // Returns handle to APT Mutex. Not imlemented.
-Syscall::Result APT_U::GetLockHandle() {
+Syscall::Result Interface::GetLockHandle() {
     return 0x00000000;
 }
 
@@ -100,7 +100,7 @@ Syscall::Result APT_U::GetLockHandle() {
  * Called when svcSendSyncRequest is called, loads command buffer and executes comand
  * @return Return result of svcSendSyncRequest passed back to user app
  */
-Syscall::Result APT_U::Sync() {
+Syscall::Result Interface::Sync() {
     Syscall::Result res = 0;
     u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
 
diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
index 0e1f205c7..2be5a7e15 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -9,7 +9,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Namespace Service
 
-namespace Service {
+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
@@ -17,13 +17,13 @@ namespace Service {
 // 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.
 
-class APT_U : public Interface {
+class Interface : public Service::Interface {
 public:
 
-    APT_U() {
+    Interface() {
     }
 
-    ~APT_U() {
+    ~Interface() {
     }
 
     enum {
@@ -62,7 +62,7 @@ private:
 
     Syscall::Result GetLockHandle();
 
-    DISALLOW_COPY_AND_ASSIGN(APT_U);
+    DISALLOW_COPY_AND_ASSIGN(Interface);
 };
 
 } // namespace
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 799dbe90e..81a34ed06 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -74,7 +74,7 @@ Interface* Manager::FetchFromPortName(std::string port_name) {
 void Init() {
     g_manager = new Manager;
     g_manager->AddService(new SRV::Interface);
-    g_manager->AddService(new APT_U);
+    g_manager->AddService(new APT_U::Interface);
     NOTICE_LOG(HLE, "Services initialized OK");
 }
 
-- 
cgit v1.2.3


From ffabed8c25490be0e61409cebd1615eedb223c3d Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Tue, 15 Apr 2014 23:28:03 -0400
Subject: restructured hle:services completely to use function lookup tables

---
 src/core/hle/service/apt.cpp   | 200 +++++++++++++++++++----------------------
 src/core/hle/service/apt.h     |  30 +------
 src/core/hle/service/service.h |  28 +++++-
 src/core/hle/service/srv.cpp   |  55 ++++++++++++
 src/core/hle/service/srv.h     |  39 ++++++++
 5 files changed, 215 insertions(+), 137 deletions(-)
 create mode 100644 src/core/hle/service/srv.cpp
 create mode 100644 src/core/hle/service/srv.h

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
index 288a68a86..e5c9dd873 100644
--- a/src/core/hle/service/apt.cpp
+++ b/src/core/hle/service/apt.cpp
@@ -10,118 +10,104 @@
 
 namespace APT_U {
 
-const HLE::FunctionDef APT_U_Table[] = {
-    {0x00010040, NULL,      "GetLockHandle"},
-    {0x00020080, NULL,      "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"},
-};
-
-// Returns handle to APT Mutex. Not imlemented.
-Syscall::Result Interface::GetLockHandle() {
-    return 0x00000000;
+void Initialize() {
+    NOTICE_LOG(OSHLE, "APT_U::Sync - Initialize");
 }
 
-/**
- * Called when svcSendSyncRequest is called, loads command buffer and executes comand
- * @return Return result of svcSendSyncRequest passed back to user app
- */
-Syscall::Result Interface::Sync() {
-    Syscall::Result res = 0;
-    u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + CMD_OFFSET);
-
-    switch(cmd_buff[0]) {
-    case CMD_HEADER_INIT:
-        NOTICE_LOG(OSHLE, "APT_U::Sync - Initialize");
-        break;
+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
+}
 
-    case CMD_HEADER_GET_LOCK_HANDLE:
-        NOTICE_LOG(OSHLE, "APT_U::Sync - GetLockHandle");
-        cmd_buff[5] = GetLockHandle();
-        break;
+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"},
+};
 
-    default:
-        ERROR_LOG(OSHLE, "APT_U::Sync - Unknown command 0x%08X", cmd_buff[0]);
-        res = -1;
-        break;
-    }
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface class
 
-    return res;
+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
index 2be5a7e15..9f0245cc8 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -20,29 +20,9 @@ namespace APT_U {
 class Interface : public Service::Interface {
 public:
 
-    Interface() {
-    }
-
-    ~Interface() {
-    }
-
-    enum {
-        CMD_OFFSET                              = 0x00000080,
+    Interface();
 
-        CMD_HEADER_INIT                         = 0x00020080,   ///< Initialize service
-        CMD_HEADER_GET_LOCK_HANDLE              = 0x00010040,   ///< Get service Mutex
-        CMD_HEADER_ENABLE                       = 0x00030040,   ///< Enable service
-        CMD_HEADER_INQUIRE_NOTIFICATION         = 0x000B0040,   ///< Inquire notification
-        CMD_HEADER_PREPARE_TO_JUMP_TO_HOME_MENU = 0x002B0000,   ///< Prepare to jump to home menu
-        CMD_HEADER_JUMP_TO_HOME_MENU            = 0x002C0044,   ///< Jump to home menu
-        CMD_HEADER_NOTIFY_TO_WAIT               = 0x00430040,   ///< Notify to wait
-        CMD_HEADER_APPLET_UTILITY               = 0x004B00C2,   ///< Applet utility
-        CMD_HEADER_GLANCE_PARAMETER             = 0x000E0080,   ///< Glance parameter
-        CMD_HEADER_RECEIVE_PARAMETER            = 0x000D0080,   ///< Receive parameter
-        CMD_HEADER_REPLY_SLEEP_QUERY            = 0x003E0080,   ///< Reply sleep query
-        CMD_HEADER_PREPARE_TO_CLOSE_APP         = 0x00220040,   ///< Prepare to close application
-        CMD_HEADER_CLOSE_APP                    = 0x00270044,   ///< Close application
-    };
+    ~Interface();
 
     /**
      * Gets the string port name used by CTROS for the APT service
@@ -52,12 +32,6 @@ public:
         return "APT:U";
     }
 
-    /**
-     * 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:
 
     Syscall::Result GetLockHandle();
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 9368a9f0f..3b256aa3e 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -17,7 +17,9 @@
 
 namespace Service {
 
-typedef s32 NativeUID;          ///< Native handle for a service
+typedef s32 NativeUID;                          ///< Native handle for a service
+
+static const int kCommandHeaderOffset = 0x80;   ///< Offset into command buffer of header
 
 class Manager;
 
@@ -26,6 +28,9 @@ class Interface {
     friend class Manager;
 public:
 
+    Interface() {
+    }
+
     virtual ~Interface() {
     }
 
@@ -49,7 +54,24 @@ public:
      * Called when svcSendSyncRequest is called, loads command buffer and executes comand
      * @return Return result of svcSendSyncRequest passed back to user app
      */
-    virtual Syscall::Result Sync() = 0;
+    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());
+        }
+
+        itr->second.func();
+
+        return 0; // TODO: Implement return from actual function
+    }
 
 protected:
     /**
@@ -64,6 +86,8 @@ protected:
 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
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
new file mode 100644
index 000000000..bb6c08b78
--- /dev/null
+++ b/src/core/hle/service/srv.cpp
@@ -0,0 +1,55 @@
+// 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 {
+
+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);
+
+    const char* port_name = (const char*)&cmd_buff[1];
+    Service::Interface* service = Service::g_manager->FetchFromPortName(port_name);
+
+    NOTICE_LOG(OSHLE, "SRV::Sync - GetHandle - port: %s, handle: 0x%08X", port_name, 
+        service->GetUID());
+
+    if (NULL != service) {
+        cmd_buff[3] = service->GetUID();
+    } else {
+        ERROR_LOG(OSHLE, "Service %s does not exist", port_name);
+        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..b4c5a0c17
--- /dev/null
+++ b/src/core/hle/service/srv.h
@@ -0,0 +1,39 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include "core/hle/service/service.h"
+
+namespace SRV {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Interface to "SRV" service
+
+class Interface : public Service::Interface {
+
+public:
+
+    Interface();
+
+    ~Interface();
+
+    /**
+     * Gets the string name used by CTROS for a 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
-- 
cgit v1.2.3


From acef5e0b17e85bd25a5994d83b22d0ba02f589ba Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Tue, 15 Apr 2014 23:41:52 -0400
Subject: removed no longer used function header

---
 src/core/hle/service/apt.h | 2 --
 1 file changed, 2 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
index 9f0245cc8..889b12711 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -34,8 +34,6 @@ public:
 
 private:
 
-    Syscall::Result GetLockHandle();
-
     DISALLOW_COPY_AND_ASSIGN(Interface);
 };
 
-- 
cgit v1.2.3


From 32c3462047d814eada8f3b80ee5ea2cd03936ae0 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Wed, 16 Apr 2014 00:03:41 -0400
Subject: - added stubbed out GSP::Gpu service interface

- various cleanups/refactors to HLE services
---
 src/core/hle/service/apt.h       |  2 +-
 src/core/hle/service/gsp.cpp     | 56 ++++++++++++++++++++++++++++++++++++++++
 src/core/hle/service/gsp.h       | 34 ++++++++++++++++++++++++
 src/core/hle/service/service.cpp |  4 +++
 src/core/hle/service/service.h   | 10 ++++---
 src/core/hle/service/srv.cpp     |  2 +-
 src/core/hle/service/srv.h       |  2 +-
 7 files changed, 103 insertions(+), 7 deletions(-)
 create mode 100644 src/core/hle/service/gsp.cpp
 create mode 100644 src/core/hle/service/gsp.h

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
index 889b12711..9345eabc3 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -25,7 +25,7 @@ public:
     ~Interface();
 
     /**
-     * Gets the string port name used by CTROS for the APT service
+     * Gets the string port name used by CTROS for the service
      * @return Port name of service
      */
     std::string GetPortName() const {
diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp
new file mode 100644
index 000000000..6dfd76de3
--- /dev/null
+++ b/src/core/hle/service/gsp.cpp
@@ -0,0 +1,56 @@
+// 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 {
+
+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..0a9d452f6
--- /dev/null
+++ b/src/core/hle/service/gsp.h
@@ -0,0 +1,34 @@
+// Copyright 2014 Citra Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace Service
+
+namespace GSP_GPU {
+
+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/service.cpp b/src/core/hle/service/service.cpp
index 81a34ed06..f612ff830 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -9,6 +9,7 @@
 #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/srv.h"
 
 namespace Service {
@@ -73,8 +74,11 @@ Interface* Manager::FetchFromPortName(std::string port_name) {
 /// 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);
+
     NOTICE_LOG(HLE, "Services initialized OK");
 }
 
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 3b256aa3e..9cbf8b6fa 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -19,7 +19,8 @@ namespace Service {
 
 typedef s32 NativeUID;                          ///< Native handle for a service
 
-static const int kCommandHeaderOffset = 0x80;   ///< Offset into command buffer of header
+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;
 
@@ -59,14 +60,15 @@ public:
         auto itr = m_functions.find(cmd_buff[0]);
 
         if (itr == m_functions.end()) {
-            ERROR_LOG(OSHLE, "Unknown/unimplemented function: port=%s, command=0x%08X!", 
+            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!", 
+            ERROR_LOG(OSHLE, "Unimplemented function: port = %s, name = %s!", 
                 GetPortName().c_str(), itr->second.name.c_str());
-        }
+            return -1;
+        } 
 
         itr->second.func();
 
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index bb6c08b78..ad7448461 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -17,7 +17,7 @@ void GetServiceHandle() {
     Syscall::Result res = 0;
     u32* cmd_buff = (u32*)HLE::GetPointer(HLE::CMD_BUFFER_ADDR + Service::kCommandHeaderOffset);
 
-    const char* port_name = (const char*)&cmd_buff[1];
+    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, 
diff --git a/src/core/hle/service/srv.h b/src/core/hle/service/srv.h
index b4c5a0c17..a1d26a34d 100644
--- a/src/core/hle/service/srv.h
+++ b/src/core/hle/service/srv.h
@@ -18,7 +18,7 @@ public:
     ~Interface();
 
     /**
-     * Gets the string name used by CTROS for a service
+     * Gets the string name used by CTROS for the service
      * @return Port name of service
      */
     std::string GetPortName() const {
-- 
cgit v1.2.3


From de3dcd38f6572da88a67e625e6aa98c2a2f786d7 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Wed, 16 Apr 2014 20:41:33 -0400
Subject: - fixed tabs in function_wrappers.h

- fixed log message wording in hle.cpp
- added syscall stubs for CloseHandle and WaitSynchronization1
---
 src/core/hle/function_wrappers.h | 541 ++++++++++++++++++++-------------------
 src/core/hle/hle.cpp             |   2 +-
 src/core/hle/hle.h               |   1 +
 src/core/hle/syscall.cpp         | 264 ++++++++++---------
 4 files changed, 413 insertions(+), 395 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
index 22588d95d..7d9389769 100644
--- a/src/core/hle/function_wrappers.h
+++ b/src/core/hle/function_wrappers.h
@@ -25,659 +25,659 @@
 
 //32bit wrappers
 template<void func()> void WrapV_V() {
-	func();
+    func();
 }
 
 template<u32 func()> void WrapU_V() {
-	RETURN(func());
+    RETURN(func());
 }
 
 template<int func(void *, const char *)> void WrapI_VC() {
-	u32 retval = func(Memory::GetPointer(PARAM(0)), Memory::GetCharPointer(PARAM(1)));
-	RETURN(retval);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    u32 retval = func(PARAM(0), Memory::GetPointer(PARAM(1)));
+    RETURN(retval);
 }
 
 template<float func()> void WrapF_V() {
-	RETURNF(func());
+    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)));
+    RETURNF(func(PARAM(0), PARAMF(0), PARAM(1)));
 }
 
 template<u32 func(u32)> void WrapU_U() {
-	u32 retval = func(PARAM(0));
-	RETURN(retval);
+    u32 retval = func(PARAM(0));
+    RETURN(retval);
 }
 
 template<u32 func(u32, int)> void WrapU_UI() {
-	u32 retval = func(PARAM(0), PARAM(1));
-	RETURN(retval);
+    u32 retval = func(PARAM(0), PARAM(1));
+    RETURN(retval);
 }
 
 template<int func(u32)> void WrapI_U() {
-	int retval = func(PARAM(0));
-	RETURN(retval);
+    int retval = func(PARAM(0));
+    RETURN(retval);
 }
 
 template<int func(u32, int)> void WrapI_UI() {
-	int retval = func(PARAM(0), PARAM(1));
-	RETURN(retval);
+    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);
+    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);
+    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);
+    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);
+    // 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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    int retval = func();
+    RETURN(retval);
 }
 
 template<u32 func(int)> void WrapU_I() {
-	u32 retval = func(PARAM(0));
-	RETURN(retval);
+    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);
+    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);
+    int retval = func(PARAM(0));
+    RETURN(retval);
 }
 
 template<void func(u32)> void WrapV_U() {
-	func(PARAM(0));
+    func(PARAM(0));
 }
 
 template<void func(int)> void WrapV_I() {
-	func(PARAM(0));
+    func(PARAM(0));
 }
 
 template<void func(u32, u32)> void WrapV_UU() {
-	func(PARAM(0), PARAM(1));
+    func(PARAM(0), PARAM(1));
 }
 
 template<void func(int, int)> void WrapV_II() {
-	func(PARAM(0), PARAM(1));
+    func(PARAM(0), PARAM(1));
 }
 
 template<void func(u32, const char *)> void WrapV_UC() {
-	func(PARAM(0), Memory::GetCharPointer(PARAM(1)));
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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));
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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));
+    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));
+    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));
+    func(PARAM(0), PARAM(1), PARAM(2));
 }
 
 template<u32 func(int, u32)> void WrapU_IU() {
-	int retval = func(PARAM(0), PARAM(1));
-	RETURN(retval);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    int retval = func(PARAM(0), PARAM(1), PARAM(2));
+    RETURN(retval);
 }
 
 template<void func(int, u32)> void WrapV_IU() {
-	func(PARAM(0), PARAM(1));
+    func(PARAM(0), PARAM(1));
 }
 
 template<void func(u32, int)> void WrapV_UI() {
-	func(PARAM(0), PARAM(1));
+    func(PARAM(0), PARAM(1));
 }
 
 template<u32 func(const char *)> void WrapU_C() {
-	u32 retval = func(Memory::GetCharPointer(PARAM(0)));
-	RETURN(retval);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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));
+    func(PARAM(0), PARAM(1), PARAM(2));
 }
 
 template<void func(int, int, u32)> void WrapV_IIU() {
-	func(PARAM(0), PARAM(1), PARAM(2));
+    func(PARAM(0), PARAM(1), PARAM(2));
 }
 
 template<void func(u32, int, u32)> void WrapV_UIU() {
-	func(PARAM(0), PARAM(1), PARAM(2));
+    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);
+    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));
+    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));
+    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));
+    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));
+    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);
+    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));
+    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);
+    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));
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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));
+    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);
+    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));
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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);
+    int retval = func(PARAM(0), PARAM(1), PARAM(2));
+    RETURN(retval);
 }
 
 template<u32 func(u32, u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUUU() {
@@ -686,33 +686,33 @@ template<u32 func(u32, u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUUU() {
 }
 
 template<int func(u32, int, u32, u32)> void WrapI_UIUU() {
-	u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3));
-	RETURN(retval);
+    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);
+    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);
+    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);
+    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);
+    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);
+    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(){
@@ -724,3 +724,8 @@ template<int func(int, const char *, u32, void *, int, int, int)> void WrapI_ICU
   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(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
index c173b82de..5672a659f 100644
--- a/src/core/hle/hle.cpp
+++ b/src/core/hle/hle.cpp
@@ -76,7 +76,7 @@ void CallSyscall(u32 opcode) {
     if (info->func) {
         info->func();
     } else {
-        ERROR_LOG(HLE, "Unimplemented HLE function %s", info->name);
+        ERROR_LOG(HLE, "Unimplemented SysCall function %s(..)", info->name.c_str());
     }
 }
 
diff --git a/src/core/hle/hle.h b/src/core/hle/hle.h
index d02948be3..628a1da89 100644
--- a/src/core/hle/hle.h
+++ b/src/core/hle/hle.h
@@ -10,6 +10,7 @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #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)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/hle/syscall.cpp b/src/core/hle/syscall.cpp
index 8225f168b..c5b887795 100644
--- a/src/core/hle/syscall.cpp
+++ b/src/core/hle/syscall.cpp
@@ -27,133 +27,145 @@ Result SendSyncRequest(Handle session) {
     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,  NULL,                       "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,  NULL,                       "CloseHandle"},
-    {0x24,  NULL,                       "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"},
+    {0x00,  NULL,                               "Unknown"},
+    {0x01,  NULL,                               "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() {
-- 
cgit v1.2.3


From b8851305bd9840c55a50ca386630f59166ae9578 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Wed, 16 Apr 2014 20:46:05 -0400
Subject: updated service comments

---
 src/core/hle/service/apt.cpp | 3 +++
 src/core/hle/service/apt.h   | 3 ++-
 src/core/hle/service/gsp.cpp | 3 +++
 src/core/hle/service/gsp.h   | 3 ++-
 src/core/hle/service/srv.cpp | 3 +++
 src/core/hle/service/srv.h   | 7 ++++---
 6 files changed, 17 insertions(+), 5 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/apt.cpp b/src/core/hle/service/apt.cpp
index e5c9dd873..4f8d7248d 100644
--- a/src/core/hle/service/apt.cpp
+++ b/src/core/hle/service/apt.cpp
@@ -8,6 +8,9 @@
 #include "core/hle/hle.h"
 #include "core/hle/service/apt.h"
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace APT_U
+
 namespace APT_U {
 
 void Initialize() {
diff --git a/src/core/hle/service/apt.h b/src/core/hle/service/apt.h
index 9345eabc3..e74baac0c 100644
--- a/src/core/hle/service/apt.h
+++ b/src/core/hle/service/apt.h
@@ -7,7 +7,7 @@
 #include "core/hle/service/service.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Namespace Service
+// Namespace APT_U
 
 namespace APT_U {
 
@@ -17,6 +17,7 @@ namespace APT_U {
 // 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:
 
diff --git a/src/core/hle/service/gsp.cpp b/src/core/hle/service/gsp.cpp
index 6dfd76de3..7c80ab8b5 100644
--- a/src/core/hle/service/gsp.cpp
+++ b/src/core/hle/service/gsp.cpp
@@ -8,6 +8,9 @@
 #include "core/hle/hle.h"
 #include "core/hle/service/gsp.h"
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace GSP_GPU
+
 namespace GSP_GPU {
 
 const HLE::FunctionDef FunctionTable[] = {
diff --git a/src/core/hle/service/gsp.h b/src/core/hle/service/gsp.h
index 0a9d452f6..3b1846082 100644
--- a/src/core/hle/service/gsp.h
+++ b/src/core/hle/service/gsp.h
@@ -7,10 +7,11 @@
 #include "core/hle/service/service.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Namespace Service
+// Namespace GSP_GPU
 
 namespace GSP_GPU {
 
+/// Interface to "srv:" service
 class Interface : public Service::Interface {
 public:
 
diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index ad7448461..1ec78dd15 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -7,6 +7,9 @@
 #include "core/hle/service/service.h"
 
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+// Namespace SRV
+
 namespace SRV {
 
 void Initialize() {
diff --git a/src/core/hle/service/srv.h b/src/core/hle/service/srv.h
index a1d26a34d..d9ac8fc88 100644
--- a/src/core/hle/service/srv.h
+++ b/src/core/hle/service/srv.h
@@ -4,11 +4,12 @@
 
 #include "core/hle/service/service.h"
 
-namespace SRV {
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Interface to "SRV" service
+// Namespace SRV
+
+namespace SRV {
 
+/// Interface to "srv:" service
 class Interface : public Service::Interface {
 
 public:
-- 
cgit v1.2.3


From bb5bc2df257330561c886ed768ce2191e2641a6c Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Wed, 16 Apr 2014 20:58:36 -0400
Subject: added class stub for HID:User service

---
 src/core/hle/service/hid.cpp     | 33 +++++++++++++++++++++++++++++++++
 src/core/hle/service/hid.h       | 37 +++++++++++++++++++++++++++++++++++++
 src/core/hle/service/service.cpp |  2 ++
 3 files changed, 72 insertions(+)
 create mode 100644 src/core/hle/service/hid.cpp
 create mode 100644 src/core/hle/service/hid.h

(limited to 'src/core/hle')

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
index f612ff830..e6605a398 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -10,6 +10,7 @@
 #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 {
@@ -78,6 +79,7 @@ void Init() {
     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");
 }
-- 
cgit v1.2.3


From 9d1a17ca88ee05cacb6e0f87d9a80b50d3acf69b Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Wed, 16 Apr 2014 21:22:15 -0400
Subject: fixed bug with printing std::string in log messages

---
 src/core/hle/service/srv.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/service/srv.cpp b/src/core/hle/service/srv.cpp
index 1ec78dd15..579ea4a34 100644
--- a/src/core/hle/service/srv.cpp
+++ b/src/core/hle/service/srv.cpp
@@ -23,13 +23,13 @@ void GetServiceHandle() {
     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, 
+    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);
+        ERROR_LOG(OSHLE, "Service %s does not exist", port_name.c_str());
         res = -1;
     }
     cmd_buff[1] = res;
-- 
cgit v1.2.3


From f0797dcf1ff954c357ebf4aa7eb234ebadae333d Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Wed, 16 Apr 2014 22:19:23 -0400
Subject: added a new function wrapper

---
 src/core/hle/function_wrappers.h | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'src/core/hle')

diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
index 7d9389769..4897d3f28 100644
--- a/src/core/hle/function_wrappers.h
+++ b/src/core/hle/function_wrappers.h
@@ -725,6 +725,11 @@ template<int func(int, const char *, u32, void *, int, int, int)> void WrapI_ICU
   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);
-- 
cgit v1.2.3


From b2baafaf8ba760ce2b975391fd04db52ad386e29 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 17 Apr 2014 23:05:31 -0400
Subject: added GSP heap memory allocation

---
 src/core/hle/syscall.cpp | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/syscall.cpp b/src/core/hle/syscall.cpp
index c5b887795..0cb563955 100644
--- a/src/core/hle/syscall.cpp
+++ b/src/core/hle/syscall.cpp
@@ -4,6 +4,10 @@
 
 #include <map>
 
+#include "core/mem_map.h"
+
+#include "core/hw/hw_lcd.h"
+
 #include "core/hle/function_wrappers.h"
 #include "core/hle/syscall.h"
 #include "core/hle/service/service.h"
@@ -13,6 +17,26 @@
 
 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);
@@ -41,7 +65,7 @@ Result WaitSynchronization1(Handle handle, s64 nanoseconds) {
 
 const HLE::FunctionDef Syscall_Table[] = {
     {0x00,  NULL,                               "Unknown"},
-    {0x01,  NULL,                               "ControlMemory"},
+    {0x01,  WrapI_VUUUUU<ControlMemory>,        "ControlMemory"},
     {0x02,  NULL,                               "QueryMemory"},
     {0x03,  NULL,                               "ExitProcess"},
     {0x04,  NULL,                               "GetProcessAffinityMask"},
-- 
cgit v1.2.3


From 70c2cce963264678b5ba5b6aa17c2653bf459e61 Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Thu, 17 Apr 2014 23:48:23 -0400
Subject: renamed hw_lcd module to just lcd

---
 src/core/hle/syscall.cpp | 2 --
 1 file changed, 2 deletions(-)

(limited to 'src/core/hle')

diff --git a/src/core/hle/syscall.cpp b/src/core/hle/syscall.cpp
index 0cb563955..e5533a741 100644
--- a/src/core/hle/syscall.cpp
+++ b/src/core/hle/syscall.cpp
@@ -6,8 +6,6 @@
 
 #include "core/mem_map.h"
 
-#include "core/hw/hw_lcd.h"
-
 #include "core/hle/function_wrappers.h"
 #include "core/hle/syscall.h"
 #include "core/hle/service/service.h"
-- 
cgit v1.2.3