xboxkrnl.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstring>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/kernel/types/status.h>
#include <rex/kernel/types/thread.h>
#include <rex/ppc/context.h>
#include <rex/kernel/object/kernel_thread.h>
#include <rex/kernel/types/list.h>
#include <rex/memory.h>
#include <rex/title.h>
 
namespace rex::kernel::xboxkrnl {
 
struct X_RTL_CRITICAL_SECTION;
 
REX_KERNEL_API void RtlInitializeCriticalSection(X_RTL_CRITICAL_SECTION* cs);
REX_KERNEL_API X_STATUS RtlInitializeCriticalSectionAndSpinCount(X_RTL_CRITICAL_SECTION* cs,
                                                                 u32 spin_count);
}  // namespace rex::kernel::xboxkrnl
 
namespace rex::kernel::xboxkrnl {

REX_KERNEL_API u32 NtSetEvent(u32 handle, be_u32* previous_state_ptr);
REX_KERNEL_API u32 NtClearEvent(u32 handle);

REX_KERNEL_API u32 NtWaitForMultipleObjectsEx(u32 count, be_u32* handles, u32 wait_type,
                                              u32 wait_mode, u32 alertable, u64* timeout_ptr);

REX_KERNEL_API u32 KeWaitForSingleObject(u32 object_address, u32 wait_reason, u32 processor_mode,
                                         u32 alertable, u64* timeout_ptr);
REX_KERNEL_API u32 KeSetEvent(u32 event_address, u32 increment, u32 wait);

REX_KERNEL_API u32 KeKfAcquireSpinLock(rex::kernel::GuestAddressSpace& memory, PPCContext* ctx,
                                       rex::kernel::X_KSPINLOCK* lock, bool change_irql = true);
REX_KERNEL_API void KeKfReleaseSpinLock(rex::kernel::GuestAddressSpace& memory, PPCContext* ctx,
                                        rex::kernel::X_KSPINLOCK* lock, u32 old_irql,
                                        bool change_irql = true);

REX_KERNEL_API void KeInitializeApc(rex::kernel::XAPC* apc, u32 thread_ptr, u32 kernel_routine,
                                    u32 rundown_routine, u32 normal_routine, u32 apc_mode,
                                    u32 normal_context);
REX_KERNEL_API u32 KeInsertQueueApc(rex::kernel::GuestAddressSpace& memory, rex::kernel::XAPC* apc,
                                    u32 arg1, u32 arg2, u32 priority_increment, PPCContext* ctx);
 
}  // namespace rex::kernel::xboxkrnl
 
namespace rex::kernel {
 
#pragma pack(push, 4)
 
struct X_VIDEO_MODE {
  be_u32 display_width;
  be_u32 display_height;
  be_u32 is_interlaced;  
  be_u32 is_widescreen;  
  be_u32 is_hi_def;      
  be_f32 refresh_rate;   
  be_u32 video_standard; 
  be_u32 reserved_0;     
  be_u32 unknown_0x01;   
  be_u32 reserved[3];
};
REX_STATIC_ASSERT_SIZE(X_VIDEO_MODE, 48);

inline void FillXVideoMode(const VideoMode& mode, X_VIDEO_MODE& out) {
  std::memset(&out, 0, sizeof(X_VIDEO_MODE));
  out.display_width = mode.width;
  out.display_height = mode.height;
  out.is_interlaced = 0;
  out.is_widescreen = mode.width * 3 >= mode.height * 4;
  out.is_hi_def = mode.width >= 1280 || mode.height >= 720;
  out.refresh_rate = mode.refresh_rate;
  out.video_standard = 1;
  out.reserved_0 = 0x4A;
  out.unknown_0x01 = 0x01;
}
 
#pragma pack(pop)
 
}  // namespace rex::kernel
 
namespace rex::kernel::xboxkrnl {

REX_KERNEL_API void VdQueryVideoMode(kernel::X_VIDEO_MODE* video_mode);
 
}  // namespace rex::kernel::xboxkrnl