ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.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_private.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\memory.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">
<Filter>third_party\xbyak\xbyak</Filter>
</ClInclude>
<ClInclude Include="src\xenia\kernel\xboxkrnl_error.h">
<Filter>src\xenia\kernel</Filter>
</ClInclude>
<ClInclude Include="src\xenia\apu\audio_decoder.h">
<Filter>src\xenia\apu</Filter>
</ClInclude>

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

@ -107,6 +107,7 @@ template <typename T>
class ParamBase : public Param {
public:
ParamBase() : Param(), value_(0) {}
ParamBase(T value) : Param(), value_(value) {}
ParamBase(Init& init) : Param(init) { LoadValue<T>(init); }
ParamBase& operator=(const T& other) {
value_ = other;
@ -206,6 +207,31 @@ class PrimitivePointerParam : public ParamBase<uint32_t> {
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>
class TypedPointerParam : public ParamBase<uint32_t> {
public:
@ -265,9 +291,11 @@ using lpdword_t = const shim::PrimitivePointerParam<uint32_t>&;
using lpqword_t = const shim::PrimitivePointerParam<uint64_t>&;
using lpfloat_t = const shim::PrimitivePointerParam<float>&;
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 unknown_t = const shim::ParamBase<uint32_t>&;
using unknown_pointer_t = const shim::PointerParam&;
using lpunknown_t = const shim::PointerParam&;
template <typename 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_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,
KernelState* kernel_state) {
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", XGetLanguage, state);
SHIM_SET_MAPPING("xam.xex", XamVoiceIsActiveProcess, state);
SHIM_SET_MAPPING("xam.xex", XamGetExecutionId, 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::RegisterUIExports(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;

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

@ -38,10 +38,6 @@ void RegisterUIExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterUserExports(xe::cpu::ExportResolver* export_resolver,
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 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.
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);
VdQueryVideoMode(video_mode);
void XGetVideoMode(pointer_t<X_VIDEO_MODE> video_mode) {
VdQueryVideoMode(std::move(video_mode));
}
DECLARE_XAM_EXPORT(XGetVideoMode, ExportTag::kVideo | ExportTag::kStub);
SHIM_CALL XGetVideoCapabilities_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
XELOGD("XGetVideoCapabilities()");
SHIM_SET_RETURN_32(0);
}
dword_result_t XGetVideoCapabilities() { return 0; }
DECLARE_XAM_EXPORT(XGetVideoCapabilities, ExportTag::kVideo | ExportTag::kStub);
} // namespace kernel
} // 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 kernel {
SHIM_CALL XamVoiceCreate_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t unk1 = SHIM_GET_ARG_32(0); // 0
uint32_t unk2 = SHIM_GET_ARG_32(1); // 0xF
uint32_t out_voice_ptr = SHIM_GET_ARG_32(2);
XELOGD("XamVoiceCreate(%.8X, %.8X, %.8X)", unk1, unk2, out_voice_ptr);
dword_result_t XamVoiceIsActiveProcess() {
// Returning 0 here will short-circuit a bunch of voice stuff.
return 0;
}
DECLARE_XAM_EXPORT(XamVoiceIsActiveProcess, ExportTag::kStub);
dword_result_t XamVoiceCreate(unknown_t unk1, // 0
unknown_t unk2, // 0xF
lpdword_t out_voice_ptr) {
// Null out the ptr.
SHIM_SET_MEM_32(out_voice_ptr, 0);
SHIM_SET_RETURN_32(X_ERROR_ACCESS_DENIED);
out_voice_ptr.Zero();
return X_ERROR_ACCESS_DENIED;
}
DECLARE_XAM_EXPORT(XamVoiceCreate, ExportTag::kStub);
SHIM_CALL XamVoiceClose_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t voice_ptr = SHIM_GET_ARG_32(0);
dword_result_t XamVoiceClose(lpunknown_t voice_ptr) { return 0; }
DECLARE_XAM_EXPORT(XamVoiceClose, ExportTag::kStub);
XELOGD("XamVoiceClose(%.8X)", voice_ptr);
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);
}
dword_result_t XamVoiceHeadsetPresent(lpunknown_t voice_ptr) { return 0; }
DECLARE_XAM_EXPORT(XamVoiceHeadsetPresent, ExportTag::kStub);
} // namespace kernel
} // 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 kernel {
#define SHIM_GPR_32(n) (uint32_t)(ppc_context->r[n])
// 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();
}
void DbgBreakPoint() { DebugBreak(); }
DECLARE_XBOXKRNL_EXPORT(DbgBreakPoint, ExportTag::kImportant);
// https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
typedef struct {
@ -234,24 +39,24 @@ typedef struct {
xe::be<uint32_t> exception_information[15];
} X_EXCEPTION_RECORD;
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,
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);
void RtlRaiseException(pointer_t<X_EXCEPTION_RECORD> record) {
if (record->exception_code == 0x406D1388) {
// SetThreadName. FFS.
// https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
// 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);
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;
if (thread_info->thread_id == -1) {
@ -259,7 +64,7 @@ SHIM_CALL RtlRaiseException_shim(PPCContext* ppc_context,
thread = retain_object(XThread::GetCurrentThread());
} else {
// Lookup thread by ID.
thread = kernel_state->GetThreadByID(thread_info->thread_id);
thread = kernel_state()->GetThreadByID(thread_info->thread_id);
}
if (thread) {
@ -282,39 +87,20 @@ SHIM_CALL RtlRaiseException_shim(PPCContext* ppc_context,
// This is going to suck.
DebugBreak();
}
DECLARE_XBOXKRNL_EXPORT(RtlRaiseException, ExportTag::kImportant);
void xeKeBugCheckEx(uint32_t code, uint32_t param1, uint32_t param2,
uint32_t param3, uint32_t param4) {
void KeBugCheckEx(dword_t code, dword_t param1, dword_t param2, dword_t param3,
dword_t param4) {
XELOGD("*** STOP: 0x%.8X (0x%.8X, 0x%.8X, 0x%.8X, 0x%.8X)", code, param1,
param2, param3, param4);
fflush(stdout);
DebugBreak();
assert_always();
}
DECLARE_XBOXKRNL_EXPORT(KeBugCheckEx, ExportTag::kImportant);
SHIM_CALL KeBugCheck_shim(PPCContext* ppc_context, KernelState* kernel_state) {
uint32_t code = SHIM_GET_ARG_32(0);
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);
}
void KeBugCheck(dword_t code) { KeBugCheckEx(code, 0, 0, 0, 0); }
DECLARE_XBOXKRNL_EXPORT(KeBugCheck, ExportTag::kImportant);
} // namespace kernel
} // 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 "xenia/base/atomic.h"
@ -24,8 +22,7 @@
namespace xe {
namespace kernel {
struct error_lookup_table
{
struct error_lookup_table {
uint32_t base_code;
size_t count;
const uint32_t* entries;
@ -39,25 +36,19 @@ const uint32_t error_table_0x00000103[] = {
0x000000EA, // 0x00000105
0x00000514, // 0x00000106
0x00000515, // 0x00000107
0,
0,
0,
0,
0, 0, 0, 0,
0x000003FE, // 0x0000010C
0x00000516, // 0x0000010D
};
const uint32_t error_table_0x40000002[] = {
0x00000057, // 0x40000002
0,
0,
0,
0, 0, 0,
0x00000517, // 0x40000006
0,
0x00000460, // 0x40000008
0x000003F6, // 0x40000009
0,
0,
0, 0,
0x00000461, // 0x4000000C
0x00000518, // 0x4000000D
};
@ -77,10 +68,7 @@ const uint32_t error_table_0x80000001[] = {
0x80000004, // 0x80000004
0x000000EA, // 0x80000005
0x00000012, // 0x80000006
0,
0,
0,
0,
0, 0, 0, 0,
0x0000056F, // 0x8000000B
0,
0x0000012B, // 0x8000000D
@ -93,9 +81,7 @@ const uint32_t error_table_0x80000001[] = {
0x000000FF, // 0x80000014
0x000000FF, // 0x80000015
0x00000456, // 0x80000016
0,
0,
0,
0, 0, 0,
0x00000103, // 0x8000001A
0x0000044D, // 0x8000001B
0x00000456, // 0x8000001C
@ -105,8 +91,7 @@ const uint32_t error_table_0x80000001[] = {
0,
0x0000044F, // 0x80000021
0x00000450, // 0x80000022
0,
0,
0, 0,
0x00000962, // 0x80000025
};
@ -134,36 +119,21 @@ const uint32_t error_table_0x80090300[] = {
0x00000005, // 0x8009030F
0x00000005, // 0x80090310
0x0000051F, // 0x80090311
0,
0,
0,
0,
0, 0, 0, 0,
0x00000554, // 0x80090316
0,
0x000006F8, // 0x80090318
0,
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0, 0,
0x00000057, // 0x80090320
0x0000007A, // 0x80090321
0x00000574, // 0x80090322
0,
0,
0, 0,
0x000006FE, // 0x80090325
0x00000057, // 0x80090326
0x00000057, // 0x80090327
0x00000532, // 0x80090328
0x00001770, // 0x80090329
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0,
0x00001771, // 0x80090330
0x00000001, // 0x80090331
};
@ -207,15 +177,12 @@ const uint32_t error_table_0xC0000001[] = {
0x00000006, // 0xC0000024
0xC0000025, // 0xC0000025
0xC0000026, // 0xC0000026
0,
0,
0,
0, 0, 0,
0x0000009E, // 0xC000002A
0xC000002B, // 0xC000002B
0x000001E7, // 0xC000002C
0x000001E7, // 0xC000002D
0,
0,
0, 0,
0x00000057, // 0xC0000030
0,
0x00000571, // 0xC0000032
@ -351,9 +318,7 @@ const uint32_t error_table_0xC0000001[] = {
0x000000E6, // 0xC00000B4
0x00000079, // 0xC00000B5
0x00000026, // 0xC00000B6
0,
0,
0,
0, 0, 0,
0x00000005, // 0xC00000BA
0x00000032, // 0xC00000BB
0x00000033, // 0xC00000BC
@ -401,10 +366,7 @@ const uint32_t error_table_0xC0000001[] = {
0x00000550, // 0xC00000E6
0x00000551, // 0xC00000E7
0x000006F8, // 0xC00000E8
0,
0,
0,
0,
0, 0, 0, 0,
0x00000552, // 0xC00000ED
0x00000553, // 0xC00000EE
0x00000057, // 0xC00000EF
@ -439,21 +401,9 @@ const uint32_t error_table_0xC0000001[] = {
0,
0x00000558, // 0xC000010D
0x00000420, // 0xC000010E
0,
0,
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0, 0, 0,
0x000005A4, // 0xC0000117
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0,
0x000003EE, // 0xC000011E
0x00000004, // 0xC000011F
0x000003E3, // 0xC0000120
@ -465,21 +415,17 @@ const uint32_t error_table_0xC0000001[] = {
0x0000055D, // 0xC0000126
0x0000055E, // 0xC0000127
0x00000006, // 0xC0000128
0,
0,
0, 0,
0x0000055F, // 0xC000012B
0,
0x000005AF, // 0xC000012D
0,
0,
0, 0,
0x000000C1, // 0xC0000130
0,
0,
0, 0,
0x00000576, // 0xC0000133
0,
0x0000007E, // 0xC0000135
0,
0,
0, 0,
0x000000B6, // 0xC0000138
0x0000007F, // 0xC0000139
0,
@ -491,11 +437,7 @@ const uint32_t error_table_0xC0000001[] = {
0x0000003B, // 0xC0000140
0x0000003B, // 0xC0000141
0x0000045A, // 0xC0000142
0,
0,
0,
0,
0,
0, 0, 0, 0, 0,
0x0000007C, // 0xC0000148
0x00000056, // 0xC0000149
0,
@ -518,26 +460,14 @@ const uint32_t error_table_0xC0000001[] = {
0x00000569, // 0xC000015B
0x000003F9, // 0xC000015C
0x0000056A, // 0xC000015D
0,
0,
0,
0,
0, 0, 0, 0,
0x00000459, // 0xC0000162
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0,
0x00000466, // 0xC0000169
0x00000467, // 0xC000016A
0x00000468, // 0xC000016B
0x0000045F, // 0xC000016C
0,
0,
0,
0,
0,
0, 0, 0, 0, 0,
0x00000451, // 0xC0000172
0x00000452, // 0xC0000173
0x00000453, // 0xC0000174
@ -605,33 +535,22 @@ const uint32_t error_table_0xC0000202[] = {
0x0000003B, // 0xC0000215
0x00000032, // 0xC0000216
0x00000032, // 0xC0000217
0,
0,
0,
0,
0, 0, 0, 0,
0x000017E6, // 0xC000021C
0,
0,
0,
0, 0, 0,
0x0000046C, // 0xC0000220
0x000000C1, // 0xC0000221
0,
0,
0, 0,
0x00000773, // 0xC0000224
0x00000490, // 0xC0000225
0,
0,
0,
0,
0, 0, 0, 0,
0xC000022A, // 0xC000022A
0xC000022B, // 0xC000022B
0,
0x000004D5, // 0xC000022D
0,
0,
0, 0,
0x00000492, // 0xC0000230
0,
0,
0, 0,
0x00000774, // 0xC0000233
0x00000775, // 0xC0000234
0x00000006, // 0xC0000235
@ -649,66 +568,39 @@ const uint32_t error_table_0xC0000202[] = {
0x000004D4, // 0xC0000241
0,
0x000004C8, // 0xC0000243
0,
0,
0, 0,
0x000004D6, // 0xC0000246
0x000004D7, // 0xC0000247
0x000004D8, // 0xC0000248
0x000000C1, // 0xC0000249
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x0000054F, // 0xC0000253
0,
0,
0,
0, 0, 0,
0x000004D0, // 0xC0000257
0,
0x00000573, // 0xC0000259
0,
0,
0,
0,
0, 0, 0, 0,
0x00000422, // 0xC000025E
0,
0,
0,
0, 0, 0,
0x000000B6, // 0xC0000262
0x0000007F, // 0xC0000263
0x00000120, // 0xC0000264
0x00000476, // 0xC0000265
0,
0x000010FE, // 0xC0000267
0,
0,
0,
0,
0, 0, 0, 0,
0x000007D1, // 0xC000026C
0x000004B1, // 0xC000026D
0x00000015, // 0xC000026E
0,
0,
0,
0, 0, 0,
0x00000491, // 0xC0000272
0,
0,
0, 0,
0x00001126, // 0xC0000275
0x00001129, // 0xC0000276
0x0000112A, // 0xC0000277
0x00001128, // 0xC0000278
0x00000780, // 0xC0000279
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0,
0x00000781, // 0xC0000280
0x000000A1, // 0xC0000281
0,
@ -717,8 +609,7 @@ const uint32_t error_table_0xC0000202[] = {
0x0000048A, // 0xC0000285
0x0000048B, // 0xC0000286
0x0000048C, // 0xC0000287
0,
0,
0, 0,
0x00000005, // 0xC000028A
0x00000005, // 0xC000028B
0,
@ -729,92 +620,22 @@ const uint32_t error_table_0xC0000202[] = {
0x00001777, // 0xC0000291
0x00001778, // 0xC0000292
0x00001772, // 0xC0000293
0,
0,
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0, 0, 0,
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
0,
0,
0,
0, 0, 0,
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
0,
0x000003E6, // 0xC00002C5
0,
0,
0,
0,
0, 0, 0, 0,
0x000010E8, // 0xC00002CA
0,
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
};
@ -907,15 +728,7 @@ const uint32_t error_table_0xC0020001[] = {
0,
0x00000721, // 0xC0020057
0x00000722, // 0xC0020058
0,
0,
0,
0,
0,
0,
0,
0,
0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0x0000077A, // 0xC0020062
0x0000077B, // 0xC0020063
};
@ -955,15 +768,12 @@ const uint32_t error_table_0xC0050003[] = {
const uint32_t error_table_0xC0980001[] = {
0x00000037, // 0xC0980001
0x00000037, // 0xC0980002
0,
0,
0,
0,
0,
0, 0, 0, 0, 0,
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[] = {
MAKE_ENTRY(0x00000103),
MAKE_ENTRY(0x40000002),
@ -979,24 +789,18 @@ const error_lookup_table error_tables[] = {
MAKE_ENTRY(0xC0030059),
MAKE_ENTRY(0xC0050003),
MAKE_ENTRY(0xC0980001),
{ 0, 0, nullptr },
{0, 0, nullptr},
};
#undef MAKE_ENTRY
SHIM_CALL RtlNtStatusToDosError_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t status = SHIM_GET_ARG_32(0);
XELOGD("RtlNtStatusToDosError(%.4X)", status);
dword_result_t RtlNtStatusToDosError(dword_t source_status) {
uint32_t status = source_status;
if (!status || (status & 0x20000000)) {
SHIM_SET_RETURN_32(status);
return;
return status & 0xFFFF;
}
if ((status >> 16) == 0x8007) {
SHIM_SET_RETURN_32(status & 0xFFFF);
return;
return status & 0xFFFF;
}
if ((status & 0xF0000000) == 0xD0000000) {
@ -1016,25 +820,20 @@ SHIM_CALL RtlNtStatusToDosError_shim(PPCContext* ppc_context,
break;
}
XELOGE("RtlNtStatusToDosError => %X", result);
SHIM_SET_RETURN_32(result);
return;
return result;
}
++error_table;
}
if ((status >> 16) == 0xC001) {
SHIM_SET_RETURN_32(status & 0xFFFF);
return;
return status & 0xFFFF;
}
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 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 kernel {
SHIM_CALL HalReturnToFirmware_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t routine = SHIM_GET_ARG_32(0);
XELOGD("HalReturnToFirmware(%d)", routine);
void HalReturnToFirmware(dword_t routine) {
// void
// IN FIRMWARE_REENTRY Routine
@ -33,11 +28,7 @@ SHIM_CALL HalReturnToFirmware_shim(PPCContext* ppc_context,
XELOGE("Game requested shutdown via HalReturnToFirmware");
exit(0);
}
DECLARE_XBOXKRNL_EXPORT(HalReturnToFirmware, ExportTag::kImportant);
} // namespace kernel
} // 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.
xboxkrnl::RegisterAudioExports(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::RegisterMemoryExports(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::RegisterStringExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterThreadingExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterUsbcamExports(export_resolver_, kernel_state_);
xboxkrnl::RegisterVideoExports(export_resolver_, kernel_state_);
// KeDebugMonitorData (?*)

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

@ -25,12 +25,6 @@ void RegisterAudioExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterAudioXmaExports(xe::cpu::ExportResolver* export_resolver,
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,
KernelState* kernel_state);
void RegisterMemoryExports(xe::cpu::ExportResolver* export_resolver,
@ -47,8 +41,6 @@ void RegisterStringExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterThreadingExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterUsbcamExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
void RegisterVideoExports(xe::cpu::ExportResolver* export_resolver,
KernelState* kernel_state);
} // 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_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 xe
@ -971,4 +993,5 @@ void xe::kernel::xboxkrnl::RegisterStringExports(
SHIM_SET_MAPPING("xboxkrnl.exe", _vsnprintf, state);
SHIM_SET_MAPPING("xboxkrnl.exe", vswprintf, 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 kernel {
SHIM_CALL XUsbcamCreate_shim(PPCContext* ppc_context,
KernelState* kernel_state) {
uint32_t unk1 = SHIM_GET_ARG_32(0); // E
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);
dword_result_t XUsbcamCreate(unknown_t unk1, // E
unknown_t unk2, // 0x4B000
lpunknown_t unk3_ptr) {
// 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,
KernelState* kernel_state) {
XELOGD("XUsbcamGetState()");
dword_result_t XUsbcamGetState() {
// 0 = not connected.
SHIM_SET_RETURN_32(0);
return 0;
}
DECLARE_XBOXKRNL_EXPORT(XUsbcamGetState, ExportTag::kStub);
} // namespace kernel
} // 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);
dword_result_t VdInitializeEngines(unknown_t unk0, function_t callback,
unknown_t unk1, unknown_pointer_t unk2_ptr,
unknown_pointer_t unk3_ptr) {
unknown_t unk1, lpunknown_t unk2_ptr,
lpunknown_t unk3_ptr) {
// r3 = 0x4F810000
// r4 = function ptr (cleanup callback?)
// r5 = 0
@ -175,8 +175,7 @@ void VdEnableRingBufferRPtrWriteBack(lpvoid_t ptr, int_t block_size) {
}
DECLARE_XBOXKRNL_EXPORT(VdEnableRingBufferRPtrWriteBack, ExportTag::kVideo);
void VdGetSystemCommandBuffer(unknown_pointer_t p0_ptr,
unknown_pointer_t p1_ptr) {
void VdGetSystemCommandBuffer(lpunknown_t p0_ptr, lpunknown_t p1_ptr) {
p0_ptr.Zero(0x94);
xe::store_and_swap<uint32_t>(p0_ptr, 0xBEEF0000);
xe::store_and_swap<uint32_t>(p1_ptr, 0xBEEF0001);
@ -184,7 +183,7 @@ void VdGetSystemCommandBuffer(unknown_pointer_t p0_ptr,
DECLARE_XBOXKRNL_EXPORT(VdGetSystemCommandBuffer,
ExportTag::kVideo | ExportTag::kStub);
void VdSetSystemCommandBufferGpuIdentifierAddress(unknown_pointer_t unk) {
void VdSetSystemCommandBufferGpuIdentifierAddress(lpunknown_t unk) {
// r3 = 0x2B10(d3d?) + 8
}
DECLARE_XBOXKRNL_EXPORT(VdSetSystemCommandBufferGpuIdentifierAddress,
@ -202,7 +201,7 @@ dword_result_t VdInitializeScalerCommandBuffer(
unknown_t unk3, // 0x050002d0 size of ?
unknown_t unk4, // 0x050002d0 size of ?
unknown_t unk5, // 7?
unknown_pointer_t unk6, // 0x2004909c <-- points to zeros?
lpunknown_t unk6, // 0x2004909c <-- points to zeros?
unknown_t unk7, // 7?
lpvoid_t dest_ptr // Points to the first 80000000h where the memcpy
// 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);
void VdSwap(
lpvoid_t buffer_ptr, // ptr into primary ringbuffer
void VdSwap(lpvoid_t buffer_ptr, // ptr into primary ringbuffer
lpvoid_t fetch_ptr, // frontbuffer texture fetch
unknown_t unk2, //
unknown_pointer_t unk3, // buffer from VdGetSystemCommandBuffer
unknown_pointer_t unk4, // from VdGetSystemCommandBuffer (0xBEEF0001)
lpunknown_t unk3, // buffer from VdGetSystemCommandBuffer
lpunknown_t unk4, // from VdGetSystemCommandBuffer (0xBEEF0001)
lpdword_t frontbuffer_ptr, // ptr to frontbuffer address
lpdword_t color_format_ptr, lpdword_t color_space_ptr) {
gpu::xenos::xe_gpu_texture_fetch_t fetch;