ShuriZma
/
xenia
mirror of https://github.com/xenia-project/xenia.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Converting some exports to the new way.

This commit is contained in:
Ben Vanik 2015-06-01 20:56:57 -07:00
parent f634edb9eb
commit a91a754b24
17 changed files with 857 additions and 1325 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
libxenia.vcxproj
View File

@ -388,7 +388,6 @@
<ClInclude Include="src\xenia\kernel\xboxkrnl_ordinals.h" /> <ClInclude Include="src\xenia\kernel\xboxkrnl_ordinals.h" />
<ClInclude Include="src\xenia\kernel\xboxkrnl_private.h" /> <ClInclude Include="src\xenia\kernel\xboxkrnl_private.h" />
<ClInclude Include="src\xenia\kernel\xboxkrnl_rtl.h" /> <ClInclude Include="src\xenia\kernel\xboxkrnl_rtl.h" />
<ClInclude Include="src\xenia\kernel\xboxkrnl_error.h" />
<ClInclude Include="src\xenia\kernel\xobject.h" /> <ClInclude Include="src\xenia\kernel\xobject.h" />
<ClInclude Include="src\xenia\memory.h" /> <ClInclude Include="src\xenia\memory.h" />
<ClInclude Include="src\xenia\profiling.h" /> <ClInclude Include="src\xenia\profiling.h" />

3
libxenia.vcxproj.filters
View File

@ -1341,9 +1341,6 @@
<ClInclude Include="third_party\xbyak\xbyak\xbyak.h"> <ClInclude Include="third_party\xbyak\xbyak\xbyak.h">
<Filter>third_party\xbyak\xbyak</Filter> <Filter>third_party\xbyak\xbyak</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\xenia\kernel\xboxkrnl_error.h">
<Filter>src\xenia\kernel</Filter>
</ClInclude>
<ClInclude Include="src\xenia\apu\audio_decoder.h"> <ClInclude Include="src\xenia\apu\audio_decoder.h">
<Filter>src\xenia\apu</Filter> <Filter>src\xenia\apu</Filter>
</ClInclude> </ClInclude>

30
src/xenia/kernel/util/shim_utils.h
View File

@ -107,6 +107,7 @@ template <typename T>
class ParamBase : public Param { class ParamBase : public Param {
public: public:
ParamBase() : Param(), value_(0) {} ParamBase() : Param(), value_(0) {}
ParamBase(T value) : Param(), value_(value) {}
ParamBase(Init& init) : Param(init) { LoadValue<T>(init); } ParamBase(Init& init) : Param(init) { LoadValue<T>(init); }
ParamBase& operator=(const T& other) { ParamBase& operator=(const T& other) {
value_ = other; value_ = other;
@ -206,6 +207,31 @@ class PrimitivePointerParam : public ParamBase<uint32_t> {
xe::be<T>* host_ptr_; xe::be<T>* host_ptr_;
}; };
template <typename CHAR, typename STR>
class StringPointerParam : public ParamBase<uint32_t> {
public:
StringPointerParam(Init& init) : ParamBase(init) {
host_ptr_ = value_ ? reinterpret_cast<CHAR*>(
init.ppc_context->virtual_membase + value_)
: nullptr;
}
StringPointerParam(CHAR* host_ptr) : ParamBase(), host_ptr_(host_ptr) {}
StringPointerParam& operator=(const CHAR*& other) {
host_ptr_ = other;
return *this;
}
uint32_t guest_address() const { return value_; }
uintptr_t host_address() const {
return reinterpret_cast<uintptr_t>(host_ptr_);
}
STR value() const { return STR(host_ptr_); }
operator CHAR*() const { return host_ptr_; }
operator bool() const { return host_ptr_ != nullptr; }
protected:
CHAR* host_ptr_;
};
template <typename T> template <typename T>
class TypedPointerParam : public ParamBase<uint32_t> { class TypedPointerParam : public ParamBase<uint32_t> {
public: public:
@ -265,9 +291,11 @@ using lpdword_t = const shim::PrimitivePointerParam<uint32_t>&;
using lpqword_t = const shim::PrimitivePointerParam<uint64_t>&; using lpqword_t = const shim::PrimitivePointerParam<uint64_t>&;
using lpfloat_t = const shim::PrimitivePointerParam<float>&; using lpfloat_t = const shim::PrimitivePointerParam<float>&;
using lpdouble_t = const shim::PrimitivePointerParam<double>&; using lpdouble_t = const shim::PrimitivePointerParam<double>&;
using lpstring_t = const shim::StringPointerParam<char, std::string>&;
using lpwstring_t = const shim::StringPointerParam<wchar_t, std::wstring>&;
using function_t = const shim::ParamBase<uint32_t>&; using function_t = const shim::ParamBase<uint32_t>&;
using unknown_t = const shim::ParamBase<uint32_t>&; using unknown_t = const shim::ParamBase<uint32_t>&;
using unknown_pointer_t = const shim::PointerParam&; using lpunknown_t = const shim::PointerParam&;
template <typename T> template <typename T>
using pointer_t = const shim::TypedPointerParam<T>&; using pointer_t = const shim::TypedPointerParam<T>&;

8
src/xenia/kernel/xam_info.cc
View File

@ -65,13 +65,6 @@ SHIM_CALL XGetLanguage_shim(PPCContext* ppc_context,
SHIM_SET_RETURN_32(desired_language); SHIM_SET_RETURN_32(desired_language);
} }
SHIM_CALL XamVoiceIsActiveProcess_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
XELOGD("XamVoiceIsActiveProcess()");
// Returning 0 here will short-circuit a bunch of voice stuff.
SHIM_SET_RETURN_32(0);
}
SHIM_CALL XamGetExecutionId_shim(PPCContext* ppc_context, SHIM_CALL XamGetExecutionId_shim(PPCContext* ppc_context,
KernelState* kernel_state) { KernelState* kernel_state) {
uint32_t info_ptr = SHIM_GET_ARG_32(0); uint32_t info_ptr = SHIM_GET_ARG_32(0);
@ -217,7 +210,6 @@ void xe::kernel::xam::RegisterInfoExports(
SHIM_SET_MAPPING("xam.xex", XGetGameRegion, state); SHIM_SET_MAPPING("xam.xex", XGetGameRegion, state);
SHIM_SET_MAPPING("xam.xex", XGetLanguage, state); SHIM_SET_MAPPING("xam.xex", XGetLanguage, state);
SHIM_SET_MAPPING("xam.xex", XamVoiceIsActiveProcess, state);
SHIM_SET_MAPPING("xam.xex", XamGetExecutionId, state); SHIM_SET_MAPPING("xam.xex", XamGetExecutionId, state);
SHIM_SET_MAPPING("xam.xex", XamLoaderSetLaunchData, state); SHIM_SET_MAPPING("xam.xex", XamLoaderSetLaunchData, state);

2
src/xenia/kernel/xam_module.cc
View File

@ -29,8 +29,6 @@ XamModule::XamModule(Emulator* emulator, KernelState* kernel_state)
xam::RegisterNotifyExports(export_resolver_, kernel_state_); xam::RegisterNotifyExports(export_resolver_, kernel_state_);
xam::RegisterUIExports(export_resolver_, kernel_state_); xam::RegisterUIExports(export_resolver_, kernel_state_);
xam::RegisterUserExports(export_resolver_, kernel_state_); xam::RegisterUserExports(export_resolver_, kernel_state_);
xam::RegisterVideoExports(export_resolver_, kernel_state_);
xam::RegisterVoiceExports(export_resolver_, kernel_state_);
} }
std::vector<xe::cpu::Export*> xam_exports; std::vector<xe::cpu::Export*> xam_exports;

4
src/xenia/kernel/xam_private.h
View File

@ -38,10 +38,6 @@ void RegisterUIExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterUserExports(xe::cpu::ExportResolver* export_resolver, void RegisterUserExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterVoiceExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
} // namespace xam } // namespace xam
} // namespace kernel } // namespace kernel

23
src/xenia/kernel/xam_video.cc
View File

@ -18,27 +18,14 @@ namespace kernel {
// TODO(benvanik): actually check to see if these are the same. // TODO(benvanik): actually check to see if these are the same.
void VdQueryVideoMode(pointer_t<X_VIDEO_MODE> video_mode); void VdQueryVideoMode(pointer_t<X_VIDEO_MODE> video_mode);
SHIM_CALL XGetVideoMode_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t video_mode_ptr = SHIM_GET_ARG_32(0);
X_VIDEO_MODE* video_mode = (X_VIDEO_MODE*)SHIM_MEM_ADDR(video_mode_ptr);
XELOGD("XGetVideoMode(%.8X)", video_mode_ptr); void XGetVideoMode(pointer_t<X_VIDEO_MODE> video_mode) {
VdQueryVideoMode(std::move(video_mode));
VdQueryVideoMode(video_mode);
} }
DECLARE_XAM_EXPORT(XGetVideoMode, ExportTag::kVideo | ExportTag::kStub);
SHIM_CALL XGetVideoCapabilities_shim(PPCContext* ppc_context, dword_result_t XGetVideoCapabilities() { return 0; }
KernelState* kernel_state) { DECLARE_XAM_EXPORT(XGetVideoCapabilities, ExportTag::kVideo | ExportTag::kStub);
XELOGD("XGetVideoCapabilities()");
SHIM_SET_RETURN_32(0);
}
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
void xe::kernel::xam::RegisterVideoExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {
SHIM_SET_MAPPING("xam.xex", XGetVideoCapabilities, state);
SHIM_SET_MAPPING("xam.xex", XGetVideoMode, state);
}

48
src/xenia/kernel/xam_voice.cc
View File

@ -17,44 +17,26 @@
namespace xe { namespace xe {
namespace kernel { namespace kernel {
SHIM_CALL XamVoiceCreate_shim(PPCContext* ppc_context, dword_result_t XamVoiceIsActiveProcess() {
KernelState* kernel_state) { // Returning 0 here will short-circuit a bunch of voice stuff.
uint32_t unk1 = SHIM_GET_ARG_32(0); // 0 return 0;
uint32_t unk2 = SHIM_GET_ARG_32(1); // 0xF }
uint32_t out_voice_ptr = SHIM_GET_ARG_32(2); DECLARE_XAM_EXPORT(XamVoiceIsActiveProcess, ExportTag::kStub);
XELOGD("XamVoiceCreate(%.8X, %.8X, %.8X)", unk1, unk2, out_voice_ptr);
dword_result_t XamVoiceCreate(unknown_t unk1, // 0
unknown_t unk2, // 0xF
lpdword_t out_voice_ptr) {
// Null out the ptr. // Null out the ptr.
SHIM_SET_MEM_32(out_voice_ptr, 0); out_voice_ptr.Zero();
return X_ERROR_ACCESS_DENIED;
SHIM_SET_RETURN_32(X_ERROR_ACCESS_DENIED);
} }
DECLARE_XAM_EXPORT(XamVoiceCreate, ExportTag::kStub);
SHIM_CALL XamVoiceClose_shim(PPCContext* ppc_context, dword_result_t XamVoiceClose(lpunknown_t voice_ptr) { return 0; }
KernelState* kernel_state) { DECLARE_XAM_EXPORT(XamVoiceClose, ExportTag::kStub);
uint32_t voice_ptr = SHIM_GET_ARG_32(0);
XELOGD("XamVoiceClose(%.8X)", voice_ptr); dword_result_t XamVoiceHeadsetPresent(lpunknown_t voice_ptr) { return 0; }
DECLARE_XAM_EXPORT(XamVoiceHeadsetPresent, ExportTag::kStub);
SHIM_SET_RETURN_32(0);
}
SHIM_CALL XamVoiceHeadsetPresent_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t voice_ptr = SHIM_GET_ARG_32(0);
XELOGD("XamVoiceHeadsetPresent(%.8X)", voice_ptr);
SHIM_SET_RETURN_32(0);
}
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
void xe::kernel::xam::RegisterVoiceExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {
SHIM_SET_MAPPING("xam.xex", XamVoiceCreate, state);
SHIM_SET_MAPPING("xam.xex", XamVoiceClose, state);
SHIM_SET_MAPPING("xam.xex", XamVoiceHeadsetPresent, state);
}

252
src/xenia/kernel/xboxkrnl_debug.cc
View File

@ -17,203 +17,8 @@
namespace xe { namespace xe {
namespace kernel { namespace kernel {
#define SHIM_GPR_32(n) (uint32_t)(ppc_context->r[n]) void DbgBreakPoint() { DebugBreak(); }
DECLARE_XBOXKRNL_EXPORT(DbgBreakPoint, ExportTag::kImportant);
// TODO: clean me up!
SHIM_CALL DbgPrint_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(0);
if (format_ptr == 0) {
SHIM_SET_RETURN_32(-1);
return;
}
const char* format = (const char*)SHIM_MEM_ADDR(format_ptr);
int arg_index = 0;
char buffer[512]; // TODO: ensure it never writes past the end of the
// buffer...
char* b = buffer;
for (; *format != '\0'; ++format) {
const char* start = format;
if (*format != '%') {
*b++ = *format;
continue;
}
++format;
if (*format == '\0') {
break;
}
if (*format == '%') {
*b++ = *format;
continue;
}
const char* end;
end = format;
// skip flags
while (*end == '-' || *end == '+' || *end == ' ' || *end == '#' ||
*end == '0') {
++end;
}
if (*end == '\0') {
break;
}
int arg_extras = 0;
// skip width
if (*end == '*') {
++end;
arg_extras++;
} else {
while (*end >= '0' && *end <= '9') {
++end;
}
}
if (*end == '\0') {
break;
}
// skip precision
if (*end == '.') {
++end;
if (*end == '*') {
++end;
++arg_extras;
} else {
while (*end >= '0' && *end <= '9') {
++end;
}
}
}
if (*end == '\0') {
break;
}
// get length
int arg_size = 4;
if (*end == 'h') {
++end;
arg_size = 4;
if (*end == 'h') {
++end;
}
} else if (*end == 'l') {
++end;
arg_size = 4;
if (*end == 'l') {
++end;
arg_size = 8;
}
} else if (*end == 'j') {
arg_size = 8;
++end;
} else if (*end == 'z') {
arg_size = 4;
++end;
} else if (*end == 't') {
arg_size = 8;
++end;
} else if (*end == 'L') {
arg_size = 8;
++end;
}
if (*end == '\0') {
break;
}
if (*end == 'd' || *end == 'i' || *end == 'u' || *end == 'o' ||
*end == 'x' || *end == 'X' || *end == 'f' || *end == 'F' ||
*end == 'e' || *end == 'E' || *end == 'g' || *end == 'G' ||
*end == 'a' || *end == 'A' || *end == 'c') {
char local[512];
local[0] = '\0';
strncat(local, start, end + 1 - start);
assert_true(arg_size == 8 || arg_size == 4);
if (arg_size == 8) {
if (arg_extras == 0) {
uint64_t value =
arg_index < 7
? SHIM_GET_ARG_64(1 + arg_index)
: SHIM_MEM_32(SHIM_GPR_32(1) + 16 + ((1 + arg_index) * 8));
int result = sprintf(b, local, value);
b += result;
arg_index++;
} else {
assert_true(false);
}
} else if (arg_size == 4) {
if (arg_extras == 0) {
uint64_t value =
arg_index < 7
? SHIM_GET_ARG_64(1 + arg_index)
: SHIM_MEM_32(SHIM_GPR_32(1) + 16 + ((1 + arg_index) * 8));
int result = sprintf(b, local, (uint32_t)value);
b += result;
arg_index++;
} else {
assert_true(false);
}
}
} else if (*end == 'n') {
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = arg_index < 7
? SHIM_GET_ARG_32(1 + arg_index)
: (uint32_t)SHIM_MEM_64(SHIM_GPR_32(1) + 16 +
((1 + arg_index) * 8));
SHIM_SET_MEM_32(value, (uint32_t)((b - buffer) / sizeof(char)));
arg_index++;
} else {
assert_true(false);
}
} else if (*end == 's' || *end == 'p') {
char local[512];
local[0] = '\0';
strncat(local, start, end + 1 - start);
assert_true(arg_size == 4);
if (arg_extras == 0) {
uint32_t value = arg_index < 7
? SHIM_GET_ARG_32(1 + arg_index)
: (uint32_t)SHIM_MEM_64(SHIM_GPR_32(1) + 16 +
((1 + arg_index) * 8));
const void* pointer = (const void*)SHIM_MEM_ADDR(value);
int result = sprintf(b, local, pointer);
b += result;
arg_index++;
} else {
assert_true(false);
}
} else {
assert_true(false);
break;
}
format = end;
}
*b++ = '\0';
XELOGD("(DbgPrint) %s", buffer);
}
SHIM_CALL DbgBreakPoint_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
XELOGD("DbgBreakPoint()");
DebugBreak();
}
// https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx // https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
typedef struct { typedef struct {
@ -234,24 +39,24 @@ typedef struct {
xe::be<uint32_t> exception_information[15]; xe::be<uint32_t> exception_information[15];
} X_EXCEPTION_RECORD; } X_EXCEPTION_RECORD;
static_assert_size(X_EXCEPTION_RECORD, 0x50); static_assert_size(X_EXCEPTION_RECORD, 0x50);
void AppendParam(StringBuffer& string_buffer,
pointer_t<X_EXCEPTION_RECORD> record) {
string_buffer.AppendFormat("%.8X(%.8X)", record.guest_address(),
record->exception_code);
}
SHIM_CALL RtlRaiseException_shim(PPCContext* ppc_context, void RtlRaiseException(pointer_t<X_EXCEPTION_RECORD> record) {
KernelState* kernel_state) {
uint32_t record_ptr = SHIM_GET_ARG_32(0);
auto record = reinterpret_cast<X_EXCEPTION_RECORD*>(SHIM_MEM_ADDR(record_ptr));
XELOGD("RtlRaiseException(%.8X(%.8X))", record_ptr, record->exception_code);
if (record->exception_code == 0x406D1388) { if (record->exception_code == 0x406D1388) {
// SetThreadName. FFS. // SetThreadName. FFS.
// https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx // https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
// TODO: check record->number_parameters to make sure it's a correct size // TODO: check record->number_parameters to make sure it's a correct size
auto thread_info = reinterpret_cast<X_THREADNAME_INFO*>(&record->exception_information[0]); auto thread_info =
reinterpret_cast<X_THREADNAME_INFO*>(&record->exception_information[0]);
assert_true(thread_info->type == 0x1000); assert_true(thread_info->type == 0x1000);
const char* name = (const char*)SHIM_MEM_ADDR(thread_info->name_ptr); auto name =
kernel_memory()->TranslateVirtual<const char*>(thread_info->name_ptr);
object_ref<XThread> thread; object_ref<XThread> thread;
if (thread_info->thread_id == -1) { if (thread_info->thread_id == -1) {
@ -259,7 +64,7 @@ SHIM_CALL RtlRaiseException_shim(PPCContext* ppc_context,
thread = retain_object(XThread::GetCurrentThread()); thread = retain_object(XThread::GetCurrentThread());
} else { } else {
// Lookup thread by ID. // Lookup thread by ID.
thread = kernel_state->GetThreadByID(thread_info->thread_id); thread = kernel_state()->GetThreadByID(thread_info->thread_id);
} }
if (thread) { if (thread) {
@ -282,39 +87,20 @@ SHIM_CALL RtlRaiseException_shim(PPCContext* ppc_context,
// This is going to suck. // This is going to suck.
DebugBreak(); DebugBreak();
} }
DECLARE_XBOXKRNL_EXPORT(RtlRaiseException, ExportTag::kImportant);
void xeKeBugCheckEx(uint32_t code, uint32_t param1, uint32_t param2, void KeBugCheckEx(dword_t code, dword_t param1, dword_t param2, dword_t param3,
uint32_t param3, uint32_t param4) { dword_t param4) {
XELOGD("*** STOP: 0x%.8X (0x%.8X, 0x%.8X, 0x%.8X, 0x%.8X)", code, param1, XELOGD("*** STOP: 0x%.8X (0x%.8X, 0x%.8X, 0x%.8X, 0x%.8X)", code, param1,
param2, param3, param4); param2, param3, param4);
fflush(stdout); fflush(stdout);
DebugBreak(); DebugBreak();
assert_always(); assert_always();
} }
DECLARE_XBOXKRNL_EXPORT(KeBugCheckEx, ExportTag::kImportant);
SHIM_CALL KeBugCheck_shim(PPCContext* ppc_context, KernelState* kernel_state) { void KeBugCheck(dword_t code) { KeBugCheckEx(code, 0, 0, 0, 0); }
uint32_t code = SHIM_GET_ARG_32(0); DECLARE_XBOXKRNL_EXPORT(KeBugCheck, ExportTag::kImportant);
xeKeBugCheckEx(code, 0, 0, 0, 0);
}
SHIM_CALL KeBugCheckEx_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t code = SHIM_GET_ARG_32(0);
uint32_t param1 = SHIM_GET_ARG_32(1);
uint32_t param2 = SHIM_GET_ARG_32(2);
uint32_t param3 = SHIM_GET_ARG_32(3);
uint32_t param4 = SHIM_GET_ARG_32(4);
xeKeBugCheckEx(code, param1, param2, param3, param4);
}
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
void xe::kernel::xboxkrnl::RegisterDebugExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {
SHIM_SET_MAPPING("xboxkrnl.exe", DbgPrint, state);
SHIM_SET_MAPPING("xboxkrnl.exe", DbgBreakPoint, state);
SHIM_SET_MAPPING("xboxkrnl.exe", RtlRaiseException, state);
SHIM_SET_MAPPING("xboxkrnl.exe", KeBugCheck, state);
SHIM_SET_MAPPING("xboxkrnl.exe", KeBugCheckEx, state);
}

325
src/xenia/kernel/xboxkrnl_error.cc
View File

@ -7,8 +7,6 @@
****************************************************************************** ******************************************************************************
*/ */
#include "xenia/kernel/xboxkrnl_error.h"
#include <algorithm> #include <algorithm>
#include "xenia/base/atomic.h" #include "xenia/base/atomic.h"
@ -24,8 +22,7 @@
namespace xe { namespace xe {
namespace kernel { namespace kernel {
struct error_lookup_table struct error_lookup_table {
{
uint32_t base_code; uint32_t base_code;
size_t count; size_t count;
const uint32_t* entries; const uint32_t* entries;
@ -39,25 +36,19 @@ const uint32_t error_table_0x00000103[] = {
0x000000EA, // 0x00000105 0x000000EA, // 0x00000105
0x00000514, // 0x00000106 0x00000514, // 0x00000106
0x00000515, // 0x00000107 0x00000515, // 0x00000107
0, 0, 0, 0, 0,
0,
0,
0,
0x000003FE, // 0x0000010C 0x000003FE, // 0x0000010C
0x00000516, // 0x0000010D 0x00000516, // 0x0000010D
}; };
const uint32_t error_table_0x40000002[] = { const uint32_t error_table_0x40000002[] = {
0x00000057, // 0x40000002 0x00000057, // 0x40000002
0, 0, 0, 0,
0,
0,
0x00000517, // 0x40000006 0x00000517, // 0x40000006
0, 0,
0x00000460, // 0x40000008 0x00000460, // 0x40000008
0x000003F6, // 0x40000009 0x000003F6, // 0x40000009
0, 0, 0,
0,
0x00000461, // 0x4000000C 0x00000461, // 0x4000000C
0x00000518, // 0x4000000D 0x00000518, // 0x4000000D
}; };
@ -77,10 +68,7 @@ const uint32_t error_table_0x80000001[] = {
0x80000004, // 0x80000004 0x80000004, // 0x80000004
0x000000EA, // 0x80000005 0x000000EA, // 0x80000005
0x00000012, // 0x80000006 0x00000012, // 0x80000006
0, 0, 0, 0, 0,
0,
0,
0,
0x0000056F, // 0x8000000B 0x0000056F, // 0x8000000B
0, 0,
0x0000012B, // 0x8000000D 0x0000012B, // 0x8000000D
@ -93,9 +81,7 @@ const uint32_t error_table_0x80000001[] = {
0x000000FF, // 0x80000014 0x000000FF, // 0x80000014
0x000000FF, // 0x80000015 0x000000FF, // 0x80000015
0x00000456, // 0x80000016 0x00000456, // 0x80000016
0, 0, 0, 0,
0,
0,
0x00000103, // 0x8000001A 0x00000103, // 0x8000001A
0x0000044D, // 0x8000001B 0x0000044D, // 0x8000001B
0x00000456, // 0x8000001C 0x00000456, // 0x8000001C
@ -105,8 +91,7 @@ const uint32_t error_table_0x80000001[] = {
0, 0,
0x0000044F, // 0x80000021 0x0000044F, // 0x80000021
0x00000450, // 0x80000022 0x00000450, // 0x80000022
0, 0, 0,
0,
0x00000962, // 0x80000025 0x00000962, // 0x80000025
}; };
@ -134,36 +119,21 @@ const uint32_t error_table_0x80090300[] = {
0x00000005, // 0x8009030F 0x00000005, // 0x8009030F
0x00000005, // 0x80090310 0x00000005, // 0x80090310
0x0000051F, // 0x80090311 0x0000051F, // 0x80090311
0, 0, 0, 0, 0,
0,
0,
0,
0x00000554, // 0x80090316 0x00000554, // 0x80090316
0, 0,
0x000006F8, // 0x80090318 0x000006F8, // 0x80090318
0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0x00000057, // 0x80090320 0x00000057, // 0x80090320
0x0000007A, // 0x80090321 0x0000007A, // 0x80090321
0x00000574, // 0x80090322 0x00000574, // 0x80090322
0, 0, 0,
0,
0x000006FE, // 0x80090325 0x000006FE, // 0x80090325
0x00000057, // 0x80090326 0x00000057, // 0x80090326
0x00000057, // 0x80090327 0x00000057, // 0x80090327
0x00000532, // 0x80090328 0x00000532, // 0x80090328
0x00001770, // 0x80090329 0x00001770, // 0x80090329
0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0x00001771, // 0x80090330 0x00001771, // 0x80090330
0x00000001, // 0x80090331 0x00000001, // 0x80090331
}; };
@ -207,15 +177,12 @@ const uint32_t error_table_0xC0000001[] = {
0x00000006, // 0xC0000024 0x00000006, // 0xC0000024
0xC0000025, // 0xC0000025 0xC0000025, // 0xC0000025
0xC0000026, // 0xC0000026 0xC0000026, // 0xC0000026
0, 0, 0, 0,
0,
0,
0x0000009E, // 0xC000002A 0x0000009E, // 0xC000002A
0xC000002B, // 0xC000002B 0xC000002B, // 0xC000002B
0x000001E7, // 0xC000002C 0x000001E7, // 0xC000002C
0x000001E7, // 0xC000002D 0x000001E7, // 0xC000002D
0, 0, 0,
0,
0x00000057, // 0xC0000030 0x00000057, // 0xC0000030
0, 0,
0x00000571, // 0xC0000032 0x00000571, // 0xC0000032
@ -351,9 +318,7 @@ const uint32_t error_table_0xC0000001[] = {
0x000000E6, // 0xC00000B4 0x000000E6, // 0xC00000B4
0x00000079, // 0xC00000B5 0x00000079, // 0xC00000B5
0x00000026, // 0xC00000B6 0x00000026, // 0xC00000B6
0, 0, 0, 0,
0,
0,
0x00000005, // 0xC00000BA 0x00000005, // 0xC00000BA
0x00000032, // 0xC00000BB 0x00000032, // 0xC00000BB
0x00000033, // 0xC00000BC 0x00000033, // 0xC00000BC
@ -401,10 +366,7 @@ const uint32_t error_table_0xC0000001[] = {
0x00000550, // 0xC00000E6 0x00000550, // 0xC00000E6
0x00000551, // 0xC00000E7 0x00000551, // 0xC00000E7
0x000006F8, // 0xC00000E8 0x000006F8, // 0xC00000E8
0, 0, 0, 0, 0,
0,
0,
0,
0x00000552, // 0xC00000ED 0x00000552, // 0xC00000ED
0x00000553, // 0xC00000EE 0x00000553, // 0xC00000EE
0x00000057, // 0xC00000EF 0x00000057, // 0xC00000EF
@ -439,21 +401,9 @@ const uint32_t error_table_0xC0000001[] = {
0, 0,
0x00000558, // 0xC000010D 0x00000558, // 0xC000010D
0x00000420, // 0xC000010E 0x00000420, // 0xC000010E
0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0x000005A4, // 0xC0000117 0x000005A4, // 0xC0000117
0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0x000003EE, // 0xC000011E 0x000003EE, // 0xC000011E
0x00000004, // 0xC000011F 0x00000004, // 0xC000011F
0x000003E3, // 0xC0000120 0x000003E3, // 0xC0000120
@ -465,21 +415,17 @@ const uint32_t error_table_0xC0000001[] = {
0x0000055D, // 0xC0000126 0x0000055D, // 0xC0000126
0x0000055E, // 0xC0000127 0x0000055E, // 0xC0000127
0x00000006, // 0xC0000128 0x00000006, // 0xC0000128
0, 0, 0,
0,
0x0000055F, // 0xC000012B 0x0000055F, // 0xC000012B
0, 0,
0x000005AF, // 0xC000012D 0x000005AF, // 0xC000012D
0, 0, 0,
0,
0x000000C1, // 0xC0000130 0x000000C1, // 0xC0000130
0, 0, 0,
0,
0x00000576, // 0xC0000133 0x00000576, // 0xC0000133
0, 0,
0x0000007E, // 0xC0000135 0x0000007E, // 0xC0000135
0, 0, 0,
0,
0x000000B6, // 0xC0000138 0x000000B6, // 0xC0000138
0x0000007F, // 0xC0000139 0x0000007F, // 0xC0000139
0, 0,
@ -491,11 +437,7 @@ const uint32_t error_table_0xC0000001[] = {
0x0000003B, // 0xC0000140 0x0000003B, // 0xC0000140
0x0000003B, // 0xC0000141 0x0000003B, // 0xC0000141
0x0000045A, // 0xC0000142 0x0000045A, // 0xC0000142
0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0x0000007C, // 0xC0000148 0x0000007C, // 0xC0000148
0x00000056, // 0xC0000149 0x00000056, // 0xC0000149
0, 0,
@ -518,26 +460,14 @@ const uint32_t error_table_0xC0000001[] = {
0x00000569, // 0xC000015B 0x00000569, // 0xC000015B
0x000003F9, // 0xC000015C 0x000003F9, // 0xC000015C
0x0000056A, // 0xC000015D 0x0000056A, // 0xC000015D
0, 0, 0, 0, 0,
0,
0,
0,
0x00000459, // 0xC0000162 0x00000459, // 0xC0000162
0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0x00000466, // 0xC0000169 0x00000466, // 0xC0000169
0x00000467, // 0xC000016A 0x00000467, // 0xC000016A
0x00000468, // 0xC000016B 0x00000468, // 0xC000016B
0x0000045F, // 0xC000016C 0x0000045F, // 0xC000016C
0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0x00000451, // 0xC0000172 0x00000451, // 0xC0000172
0x00000452, // 0xC0000173 0x00000452, // 0xC0000173
0x00000453, // 0xC0000174 0x00000453, // 0xC0000174
@ -605,33 +535,22 @@ const uint32_t error_table_0xC0000202[] = {
0x0000003B, // 0xC0000215 0x0000003B, // 0xC0000215
0x00000032, // 0xC0000216 0x00000032, // 0xC0000216
0x00000032, // 0xC0000217 0x00000032, // 0xC0000217
0, 0, 0, 0, 0,
0,
0,
0,
0x000017E6, // 0xC000021C 0x000017E6, // 0xC000021C
0, 0, 0, 0,
0,
0,
0x0000046C, // 0xC0000220 0x0000046C, // 0xC0000220
0x000000C1, // 0xC0000221 0x000000C1, // 0xC0000221
0, 0, 0,
0,
0x00000773, // 0xC0000224 0x00000773, // 0xC0000224
0x00000490, // 0xC0000225 0x00000490, // 0xC0000225
0, 0, 0, 0, 0,
0,
0,
0,
0xC000022A, // 0xC000022A 0xC000022A, // 0xC000022A
0xC000022B, // 0xC000022B 0xC000022B, // 0xC000022B
0, 0,
0x000004D5, // 0xC000022D 0x000004D5, // 0xC000022D
0, 0, 0,
0,
0x00000492, // 0xC0000230 0x00000492, // 0xC0000230
0, 0, 0,
0,
0x00000774, // 0xC0000233 0x00000774, // 0xC0000233
0x00000775, // 0xC0000234 0x00000775, // 0xC0000234
0x00000006, // 0xC0000235 0x00000006, // 0xC0000235
@ -649,66 +568,39 @@ const uint32_t error_table_0xC0000202[] = {
0x000004D4, // 0xC0000241 0x000004D4, // 0xC0000241
0, 0,
0x000004C8, // 0xC0000243 0x000004C8, // 0xC0000243
0, 0, 0,
0,
0x000004D6, // 0xC0000246 0x000004D6, // 0xC0000246
0x000004D7, // 0xC0000247 0x000004D7, // 0xC0000247
0x000004D8, // 0xC0000248 0x000004D8, // 0xC0000248
0x000000C1, // 0xC0000249 0x000000C1, // 0xC0000249
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0x0000054F, // 0xC0000253 0x0000054F, // 0xC0000253
0, 0, 0, 0,
0,
0,
0x000004D0, // 0xC0000257 0x000004D0, // 0xC0000257
0, 0,
0x00000573, // 0xC0000259 0x00000573, // 0xC0000259
0, 0, 0, 0, 0,
0,
0,
0,
0x00000422, // 0xC000025E 0x00000422, // 0xC000025E
0, 0, 0, 0,
0,
0,
0x000000B6, // 0xC0000262 0x000000B6, // 0xC0000262
0x0000007F, // 0xC0000263 0x0000007F, // 0xC0000263
0x00000120, // 0xC0000264 0x00000120, // 0xC0000264
0x00000476, // 0xC0000265 0x00000476, // 0xC0000265
0, 0,
0x000010FE, // 0xC0000267 0x000010FE, // 0xC0000267
0, 0, 0, 0, 0,
0,
0,
0,
0x000007D1, // 0xC000026C 0x000007D1, // 0xC000026C
0x000004B1, // 0xC000026D 0x000004B1, // 0xC000026D
0x00000015, // 0xC000026E 0x00000015, // 0xC000026E
0, 0, 0, 0,
0,
0,
0x00000491, // 0xC0000272 0x00000491, // 0xC0000272
0, 0, 0,
0,
0x00001126, // 0xC0000275 0x00001126, // 0xC0000275
0x00001129, // 0xC0000276 0x00001129, // 0xC0000276
0x0000112A, // 0xC0000277 0x0000112A, // 0xC0000277
0x00001128, // 0xC0000278 0x00001128, // 0xC0000278
0x00000780, // 0xC0000279 0x00000780, // 0xC0000279
0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0x00000781, // 0xC0000280 0x00000781, // 0xC0000280
0x000000A1, // 0xC0000281 0x000000A1, // 0xC0000281
0, 0,
@ -717,8 +609,7 @@ const uint32_t error_table_0xC0000202[] = {
0x0000048A, // 0xC0000285 0x0000048A, // 0xC0000285
0x0000048B, // 0xC0000286 0x0000048B, // 0xC0000286
0x0000048C, // 0xC0000287 0x0000048C, // 0xC0000287
0, 0, 0,
0,
0x00000005, // 0xC000028A 0x00000005, // 0xC000028A
0x00000005, // 0xC000028B 0x00000005, // 0xC000028B
0, 0,
@ -729,92 +620,22 @@ const uint32_t error_table_0xC0000202[] = {
0x00001777, // 0xC0000291 0x00001777, // 0xC0000291
0x00001778, // 0xC0000292 0x00001778, // 0xC0000292
0x00001772, // 0xC0000293 0x00001772, // 0xC0000293
0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0x00000001, // 0xC000029C 0x00000001, // 0xC000029C
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0x00001127, // 0xC00002B2 0x00001127, // 0xC00002B2
0, 0, 0, 0,
0,
0,
0x00000651, // 0xC00002B6 0x00000651, // 0xC00002B6
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0x00000575, // 0xC00002C3 0x00000575, // 0xC00002C3
0, 0,
0x000003E6, // 0xC00002C5 0x000003E6, // 0xC00002C5
0, 0, 0, 0, 0,
0,
0,
0,
0x000010E8, // 0xC00002CA 0x000010E8, // 0xC00002CA
0, 0,
0x000004E3, // 0xC00002CC 0x000004E3, // 0xC00002CC
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0x00000052, // 0xC00002EA 0x00000052, // 0xC00002EA
}; };
@ -907,15 +728,7 @@ const uint32_t error_table_0xC0020001[] = {
0, 0,
0x00000721, // 0xC0020057 0x00000721, // 0xC0020057
0x00000722, // 0xC0020058 0x00000722, // 0xC0020058
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0,
0,
0,
0,
0x0000077A, // 0xC0020062 0x0000077A, // 0xC0020062
0x0000077B, // 0xC0020063 0x0000077B, // 0xC0020063
}; };
@ -955,15 +768,12 @@ const uint32_t error_table_0xC0050003[] = {
const uint32_t error_table_0xC0980001[] = { const uint32_t error_table_0xC0980001[] = {
0x00000037, // 0xC0980001 0x00000037, // 0xC0980001
0x00000037, // 0xC0980002 0x00000037, // 0xC0980002
0, 0, 0, 0, 0, 0,
0,
0,
0,
0,
0x00000037, // 0xC0980008 0x00000037, // 0xC0980008
}; };
#define MAKE_ENTRY(x) { ##x, xe::countof(error_table_##x), error_table_##x } #define MAKE_ENTRY(x) \
{ ##x, xe::countof(error_table_##x), error_table_##x }
const error_lookup_table error_tables[] = { const error_lookup_table error_tables[] = {
MAKE_ENTRY(0x00000103), MAKE_ENTRY(0x00000103),
MAKE_ENTRY(0x40000002), MAKE_ENTRY(0x40000002),
@ -979,24 +789,18 @@ const error_lookup_table error_tables[] = {
MAKE_ENTRY(0xC0030059), MAKE_ENTRY(0xC0030059),
MAKE_ENTRY(0xC0050003), MAKE_ENTRY(0xC0050003),
MAKE_ENTRY(0xC0980001), MAKE_ENTRY(0xC0980001),
{ 0, 0, nullptr }, {0, 0, nullptr},
}; };
#undef MAKE_ENTRY #undef MAKE_ENTRY
SHIM_CALL RtlNtStatusToDosError_shim(PPCContext* ppc_context, dword_result_t RtlNtStatusToDosError(dword_t source_status) {
KernelState* kernel_state) { uint32_t status = source_status;
uint32_t status = SHIM_GET_ARG_32(0);
XELOGD("RtlNtStatusToDosError(%.4X)", status);
if (!status || (status & 0x20000000)) { if (!status || (status & 0x20000000)) {
SHIM_SET_RETURN_32(status); return status & 0xFFFF;
return;
} }
if ((status >> 16) == 0x8007) { if ((status >> 16) == 0x8007) {
SHIM_SET_RETURN_32(status & 0xFFFF); return status & 0xFFFF;
return;
} }
if ((status & 0xF0000000) == 0xD0000000) { if ((status & 0xF0000000) == 0xD0000000) {
@ -1016,25 +820,20 @@ SHIM_CALL RtlNtStatusToDosError_shim(PPCContext* ppc_context,
break; break;
} }
XELOGE("RtlNtStatusToDosError => %X", result); XELOGE("RtlNtStatusToDosError => %X", result);
SHIM_SET_RETURN_32(result); return result;
return;
} }
++error_table; ++error_table;
} }
if ((status >> 16) == 0xC001) { if ((status >> 16) == 0xC001) {
SHIM_SET_RETURN_32(status & 0xFFFF); return status & 0xFFFF;
return;
} }
XELOGE("RtlNtStatusToDosError lookup NOT IMPLEMENTED"); XELOGE("RtlNtStatusToDosError lookup NOT IMPLEMENTED");
SHIM_SET_RETURN_32(317); // ERROR_MR_MID_NOT_FOUND return 317; // ERROR_MR_MID_NOT_FOUND
} }
DECLARE_XBOXKRNL_EXPORT(RtlNtStatusToDosError,
ExportTag::kImportant | ExportTag::kLogResult);
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
void xe::kernel::xboxkrnl::RegisterErrorExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {
SHIM_SET_MAPPING("xboxkrnl.exe", RtlNtStatusToDosError, state);
}

21
src/xenia/kernel/xboxkrnl_error.h
View File

@ -1,21 +0,0 @@
/**
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#ifndef XENIA_KERNEL_XBOXKRNL_ERROR_H_
#define XENIA_KERNEL_XBOXKRNL_ERROR_H_
#include "xenia/xbox.h"
namespace xe {
namespace kernel {
} // namespace kernel
} // namespace xe
#endif // XENIA_KERNEL_XBOXKRNL_ERROR_H_

13
src/xenia/kernel/xboxkrnl_hal.cc
View File

@ -16,12 +16,7 @@
namespace xe { namespace xe {
namespace kernel { namespace kernel {
SHIM_CALL HalReturnToFirmware_shim(PPCContext* ppc_context, void HalReturnToFirmware(dword_t routine) {
KernelState* kernel_state) {
uint32_t routine = SHIM_GET_ARG_32(0);
XELOGD("HalReturnToFirmware(%d)", routine);
// void // void
// IN FIRMWARE_REENTRY Routine // IN FIRMWARE_REENTRY Routine
@ -33,11 +28,7 @@ SHIM_CALL HalReturnToFirmware_shim(PPCContext* ppc_context,
XELOGE("Game requested shutdown via HalReturnToFirmware"); XELOGE("Game requested shutdown via HalReturnToFirmware");
exit(0); exit(0);
} }
DECLARE_XBOXKRNL_EXPORT(HalReturnToFirmware, ExportTag::kImportant);
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
void xe::kernel::xboxkrnl::RegisterHalExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {
SHIM_SET_MAPPING("xboxkrnl.exe", HalReturnToFirmware, state);
}

4
src/xenia/kernel/xboxkrnl_module.cc
View File

@ -30,9 +30,6 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
// Register all exported functions. // Register all exported functions.
xboxkrnl::RegisterAudioExports(export_resolver_, kernel_state_); xboxkrnl::RegisterAudioExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterAudioXmaExports(export_resolver_, kernel_state_); xboxkrnl::RegisterAudioXmaExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterDebugExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterErrorExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterHalExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterIoExports(export_resolver_, kernel_state_); xboxkrnl::RegisterIoExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterMemoryExports(export_resolver_, kernel_state_); xboxkrnl::RegisterMemoryExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterMiscExports(export_resolver_, kernel_state_); xboxkrnl::RegisterMiscExports(export_resolver_, kernel_state_);
@ -41,7 +38,6 @@ XboxkrnlModule::XboxkrnlModule(Emulator* emulator, KernelState* kernel_state)
xboxkrnl::RegisterRtlExports(export_resolver_, kernel_state_); xboxkrnl::RegisterRtlExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterStringExports(export_resolver_, kernel_state_); xboxkrnl::RegisterStringExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterThreadingExports(export_resolver_, kernel_state_); xboxkrnl::RegisterThreadingExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterUsbcamExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterVideoExports(export_resolver_, kernel_state_); xboxkrnl::RegisterVideoExports(export_resolver_, kernel_state_);
// KeDebugMonitorData (?*) // KeDebugMonitorData (?*)

8
src/xenia/kernel/xboxkrnl_private.h
View File

@ -25,12 +25,6 @@ void RegisterAudioExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterAudioXmaExports(xe::cpu::ExportResolver* export_resolver, void RegisterAudioXmaExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterDebugExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterErrorExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterHalExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterIoExports(xe::cpu::ExportResolver* export_resolver, void RegisterIoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver, void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver,
@ -47,8 +41,6 @@ void RegisterStringExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterThreadingExports(xe::cpu::ExportResolver* export_resolver, void RegisterThreadingExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
void RegisterUsbcamExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver, void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state); KernelState* kernel_state);
} // namespace xboxkrnl } // namespace xboxkrnl

23
src/xenia/kernel/xboxkrnl_strings.cc
View File

@ -961,6 +961,28 @@ SHIM_CALL _vscwprintf_shim(PPCContext* ppc_context, KernelState* kernel_state) {
SHIM_SET_RETURN_32(count); SHIM_SET_RETURN_32(count);
} }
SHIM_CALL DbgPrint_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t format_ptr = SHIM_GET_ARG_32(0);
if (!format_ptr) {
SHIM_SET_RETURN_32(X_STATUS_INVALID_PARAMETER);
return;
}
auto format = (const uint8_t*)SHIM_MEM_ADDR(format_ptr);
StackArgList args(ppc_context);
StringFormatData data(format);
int32_t count = format_core(ppc_context, data, args, false);
if (count <= 0) {
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
return;
}
XELOGD("(DbgPrint) %s", data.str().c_str());
SHIM_SET_RETURN_32(X_STATUS_SUCCESS);
}
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
@ -971,4 +993,5 @@ void xe::kernel::xboxkrnl::RegisterStringExports(
SHIM_SET_MAPPING("xboxkrnl.exe", _vsnprintf, state); SHIM_SET_MAPPING("xboxkrnl.exe", _vsnprintf, state);
SHIM_SET_MAPPING("xboxkrnl.exe", vswprintf, state); SHIM_SET_MAPPING("xboxkrnl.exe", vswprintf, state);
SHIM_SET_MAPPING("xboxkrnl.exe", _vscwprintf, state); SHIM_SET_MAPPING("xboxkrnl.exe", _vscwprintf, state);
SHIM_SET_MAPPING("xboxkrnl.exe", DbgPrint, state);
} }

27
src/xenia/kernel/xboxkrnl_usbcam.cc
View File

@ -16,30 +16,19 @@
namespace xe { namespace xe {
namespace kernel { namespace kernel {
SHIM_CALL XUsbcamCreate_shim(PPCContext* ppc_context, dword_result_t XUsbcamCreate(unknown_t unk1, // E
KernelState* kernel_state) { unknown_t unk2, // 0x4B000
uint32_t unk1 = SHIM_GET_ARG_32(0); // E lpunknown_t unk3_ptr) {
uint32_t unk2 = SHIM_GET_ARG_32(1); // 0x4B000
uint32_t unk3_ptr = SHIM_GET_ARG_32(3);
XELOGD("XUsbcamCreate(%.8X, %.8X, %.8X)", unk1, unk2, unk3_ptr);
// 0 = success. // 0 = success.
SHIM_SET_RETURN_32(X_ERROR_DEVICE_NOT_CONNECTED); return X_ERROR_DEVICE_NOT_CONNECTED;
} }
DECLARE_XBOXKRNL_EXPORT(XUsbcamCreate, ExportTag::kStub);
SHIM_CALL XUsbcamGetState_shim(PPCContext* ppc_context, dword_result_t XUsbcamGetState() {
KernelState* kernel_state) {
XELOGD("XUsbcamGetState()");
// 0 = not connected. // 0 = not connected.
SHIM_SET_RETURN_32(0); return 0;
} }
DECLARE_XBOXKRNL_EXPORT(XUsbcamGetState, ExportTag::kStub);
} // namespace kernel } // namespace kernel
} // namespace xe } // namespace xe
void xe::kernel::xboxkrnl::RegisterUsbcamExports(
xe::cpu::ExportResolver* export_resolver, KernelState* kernel_state) {
SHIM_SET_MAPPING("xboxkrnl.exe", XUsbcamCreate, state);
SHIM_SET_MAPPING("xboxkrnl.exe", XUsbcamGetState, state);
}

18
src/xenia/kernel/xboxkrnl_video.cc
View File

@ -115,8 +115,8 @@ DECLARE_XBOXKRNL_EXPORT(VdSetDisplayModeOverride,
ExportTag::kVideo | ExportTag::kStub); ExportTag::kVideo | ExportTag::kStub);
dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback, dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback,
unknown_t unk1, unknown_pointer_t unk2_ptr, unknown_t unk1, lpunknown_t unk2_ptr,
unknown_pointer_t unk3_ptr) { lpunknown_t unk3_ptr) {
// r3 = 0x4F810000 // r3 = 0x4F810000
// r4 = function ptr (cleanup callback?) // r4 = function ptr (cleanup callback?)
// r5 = 0 // r5 = 0
@ -175,8 +175,7 @@ void VdEnableRingBufferRPtrWriteBack(lpvoid_t ptr, int_t block_size) {
} }
DECLARE_XBOXKRNL_EXPORT(VdEnableRingBufferRPtrWriteBack, ExportTag::kVideo); DECLARE_XBOXKRNL_EXPORT(VdEnableRingBufferRPtrWriteBack, ExportTag::kVideo);
void VdGetSystemCommandBuffer(unknown_pointer_t p0_ptr, void VdGetSystemCommandBuffer(lpunknown_t p0_ptr, lpunknown_t p1_ptr) {
unknown_pointer_t p1_ptr) {
p0_ptr.Zero(0x94); p0_ptr.Zero(0x94);
xe::store_and_swap<uint32_t>(p0_ptr, 0xBEEF0000); xe::store_and_swap<uint32_t>(p0_ptr, 0xBEEF0000);
xe::store_and_swap<uint32_t>(p1_ptr, 0xBEEF0001); xe::store_and_swap<uint32_t>(p1_ptr, 0xBEEF0001);
@ -184,7 +183,7 @@ void VdGetSystemCommandBuffer(unknown_pointer_t p0_ptr,
DECLARE_XBOXKRNL_EXPORT(VdGetSystemCommandBuffer, DECLARE_XBOXKRNL_EXPORT(VdGetSystemCommandBuffer,
ExportTag::kVideo | ExportTag::kStub); ExportTag::kVideo | ExportTag::kStub);
void VdSetSystemCommandBufferGpuIdentifierAddress(unknown_pointer_t unk) { void VdSetSystemCommandBufferGpuIdentifierAddress(lpunknown_t unk) {
// r3 = 0x2B10(d3d?) + 8 // r3 = 0x2B10(d3d?) + 8
} }
DECLARE_XBOXKRNL_EXPORT(VdSetSystemCommandBufferGpuIdentifierAddress, DECLARE_XBOXKRNL_EXPORT(VdSetSystemCommandBufferGpuIdentifierAddress,
@ -202,7 +201,7 @@ dword_result_t VdInitializeScalerCommandBuffer(
unknown_t unk3, // 0x050002d0 size of ? unknown_t unk3, // 0x050002d0 size of ?
unknown_t unk4, // 0x050002d0 size of ? unknown_t unk4, // 0x050002d0 size of ?
unknown_t unk5, // 7? unknown_t unk5, // 7?
unknown_pointer_t unk6, // 0x2004909c <-- points to zeros? lpunknown_t unk6, // 0x2004909c <-- points to zeros?
unknown_t unk7, // 7? unknown_t unk7, // 7?
lpvoid_t dest_ptr // Points to the first 80000000h where the memcpy lpvoid_t dest_ptr // Points to the first 80000000h where the memcpy
// sources from. // sources from.
@ -290,12 +289,11 @@ dword_result_t VdRetrainEDRAM(unknown_t unk0, unknown_t unk1, unknown_t unk2,
} }
DECLARE_XBOXKRNL_EXPORT(VdRetrainEDRAM, ExportTag::kVideo | ExportTag::kStub); DECLARE_XBOXKRNL_EXPORT(VdRetrainEDRAM, ExportTag::kVideo | ExportTag::kStub);
void VdSwap( void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer
lpvoid_t buffer_ptr, // ptr into primary ringbuffer
lpvoid_t fetch_ptr, // frontbuffer texture fetch lpvoid_t fetch_ptr, // frontbuffer texture fetch
unknown_t unk2, // unknown_t unk2, //
unknown_pointer_t unk3, // buffer from VdGetSystemCommandBuffer lpunknown_t unk3, // buffer from VdGetSystemCommandBuffer
unknown_pointer_t unk4, // from VdGetSystemCommandBuffer (0xBEEF0001) lpunknown_t unk4, // from VdGetSystemCommandBuffer (0xBEEF0001)
lpdword_t frontbuffer_ptr, // ptr to frontbuffer address lpdword_t frontbuffer_ptr, // ptr to frontbuffer address
lpdword_t color_format_ptr, lpdword_t color_space_ptr) { lpdword_t color_format_ptr, lpdword_t color_space_ptr) {
gpu::xenos::xe_gpu_texture_fetch_t fetch; gpu::xenos::xe_gpu_texture_fetch_t fetch;