Some functions added

rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp

@@ -2,73 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAppUtil;
+#include "sceAppUtil.h"
-
-struct SceAppUtilInitParam
-{
-	u32 workBufSize;
-	char reserved[60];
-};
-
-struct SceAppUtilBootParam
-{
-	u32 attr;
-	u32 appVersion;
-	char reserved[32];
-};
-
-struct SceAppUtilSaveDataMountPoint
-{
-	char data[16];
-};
-
-struct SceAppUtilSaveDataSlotParam
-{
-	u32 status;
-	char title[64];
-	char subTitle[128];
-	char detail[512];
-	char iconPath[64];
-	s32 userParam;
-	u32 sizeKB;
-	SceDateTime modifiedTime;
-	char reserved[48];
-};
-
-struct SceAppUtilSaveDataSlotEmptyParam
-{
-	vm::psv::ptr<char> title;
-	vm::psv::ptr<char> iconPath;
-	vm::psv::ptr<void> iconBuf;
-	u32 iconBufSize;
-	char reserved[32];
-};
-
-struct SceAppUtilSaveDataSlot
-{
-	u32 id;
-	u32 status;
-	s32 userParam;
-	vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
-};
-
-struct SceAppUtilSaveDataFile
-{
-	vm::psv::ptr<const char> filePath;
-	vm::psv::ptr<void> buf;
-	u32 bufSize;
-	s64 offset;
-	u32 mode;
-	u32 progDelta;
-	char reserved[32];
-};
-
-struct SceAppUtilSaveDataFileSlot
-{
-	u32 id;
-	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
-	char reserved[32];
-};
 
 s32 sceAppUtilInit(vm::psv::ptr<const SceAppUtilInitParam> initParam, vm::psv::ptr<SceAppUtilBootParam> bootParam)
 {

rpcs3/Emu/ARMv7/Modules/sceAppUtil.h

@@ -0,0 +1,69 @@
+#pragma once
+
+struct SceAppUtilInitParam
+{
+	u32 workBufSize;
+	char reserved[60];
+};
+
+struct SceAppUtilBootParam
+{
+	u32 attr;
+	u32 appVersion;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataMountPoint
+{
+	char data[16];
+};
+
+struct SceAppUtilSaveDataSlotParam
+{
+	u32 status;
+	char title[64];
+	char subTitle[128];
+	char detail[512];
+	char iconPath[64];
+	s32 userParam;
+	u32 sizeKB;
+	SceDateTime modifiedTime;
+	char reserved[48];
+};
+
+struct SceAppUtilSaveDataSlotEmptyParam
+{
+	vm::psv::ptr<char> title;
+	vm::psv::ptr<char> iconPath;
+	vm::psv::ptr<void> iconBuf;
+	u32 iconBufSize;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataSlot
+{
+	u32 id;
+	u32 status;
+	s32 userParam;
+	vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
+};
+
+struct SceAppUtilSaveDataFile
+{
+	vm::psv::ptr<const char> filePath;
+	vm::psv::ptr<void> buf;
+	u32 bufSize;
+	s64 offset;
+	u32 mode;
+	u32 progDelta;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataFileSlot
+{
+	u32 id;
+	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
+	char reserved[32];
+};
+
+extern psv_log_base sceAppUtil;

rpcs3/Emu/ARMv7/Modules/sceCamera.cpp

@@ -4,6 +4,249 @@
 
 extern psv_log_base sceCamera;
 
+struct SceCameraInfo
+{
+	u32 sizeThis;
+	u32 wPriority;
+	u32 wFormat;
+	u32 wResolution;
+	u32 wFramerate;
+	u32 wWidth;
+	u32 wHeight;
+	u32 wRange;
+	u32 _padding_0;
+	u32 sizeIBase;
+	u32 sizeUBase;
+	u32 sizeVBase;
+	vm::psv::ptr<void> pvIBase;
+	vm::psv::ptr<void> pvUBase;
+	vm::psv::ptr<void> pvVBase;
+	u32 wPitch;
+	u32 wBuffer;
+};
+
+struct SceCameraRead
+{
+	u32 sizeThis;
+	s32 dwMode;
+	s32 _padding_0;
+	s32 dwStatus;
+	u32 qwFrame;
+	u32 qwTimestamp;
+	u32 sizeIBase;
+	u32 sizeUBase;
+	u32 sizeVBase;
+	vm::psv::ptr<void> pvIBase;
+	vm::psv::ptr<void> pvUBase;
+	vm::psv::ptr<void> pvVBase;
+};
+
+s32 sceCameraOpen(s32 devnum, vm::psv::ptr<SceCameraInfo> pInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraClose(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraStart(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraStop(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraRead(s32 devnum, vm::psv::ptr<SceCameraRead> pRead)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraIsActive(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSaturation(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSaturation(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetBrightness(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetBrightness(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetContrast(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetContrast(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSharpness(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSharpness(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetReverse(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetReverse(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetEffect(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetEffect(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetEV(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetEV(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetZoom(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetZoom(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetAntiFlicker(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetISO(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetISO(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetGain(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetGain(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetWhiteBalance(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetBacklight(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetBacklight(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetNightmode(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetNightmode(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraLedSwitch(s32 devnum, s32 iSwitch)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSharpnessOffForDebug(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+void sceCameraUseCacheMemoryForTrial(s32 isCache)
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceCamera, #name, name)
 
 psv_log_base sceCamera("SceCamera", []()
@@ -12,45 +255,45 @@ psv_log_base sceCamera("SceCamera", []()
 	sceCamera.on_unload = nullptr;
 	sceCamera.on_stop = nullptr;
 
-	//REG_FUNC(0xA462F801, sceCameraOpen);
+	REG_FUNC(0xA462F801, sceCameraOpen);
-	//REG_FUNC(0xCD6E1CFC, sceCameraClose);
+	REG_FUNC(0xCD6E1CFC, sceCameraClose);
-	//REG_FUNC(0xA8FEAE35, sceCameraStart);
+	REG_FUNC(0xA8FEAE35, sceCameraStart);
-	//REG_FUNC(0x1DD9C9CE, sceCameraStop);
+	REG_FUNC(0x1DD9C9CE, sceCameraStop);
-	//REG_FUNC(0x79B5C2DE, sceCameraRead);
+	REG_FUNC(0x79B5C2DE, sceCameraRead);
-	//REG_FUNC(0x103A75B8, sceCameraIsActive);
+	REG_FUNC(0x103A75B8, sceCameraIsActive);
-	//REG_FUNC(0x624F7653, sceCameraGetSaturation);
+	REG_FUNC(0x624F7653, sceCameraGetSaturation);
-	//REG_FUNC(0xF9F7CA3D, sceCameraSetSaturation);
+	REG_FUNC(0xF9F7CA3D, sceCameraSetSaturation);
-	//REG_FUNC(0x85D5951D, sceCameraGetBrightness);
+	REG_FUNC(0x85D5951D, sceCameraGetBrightness);
-	//REG_FUNC(0x98D71588, sceCameraSetBrightness);
+	REG_FUNC(0x98D71588, sceCameraSetBrightness);
-	//REG_FUNC(0x8FBE84BE, sceCameraGetContrast);
+	REG_FUNC(0x8FBE84BE, sceCameraGetContrast);
-	//REG_FUNC(0x06FB2900, sceCameraSetContrast);
+	REG_FUNC(0x06FB2900, sceCameraSetContrast);
-	//REG_FUNC(0xAA72C3DC, sceCameraGetSharpness);
+	REG_FUNC(0xAA72C3DC, sceCameraGetSharpness);
-	//REG_FUNC(0xD1A5BB0B, sceCameraSetSharpness);
+	REG_FUNC(0xD1A5BB0B, sceCameraSetSharpness);
-	//REG_FUNC(0x44F6043F, sceCameraGetReverse);
+	REG_FUNC(0x44F6043F, sceCameraGetReverse);
-	//REG_FUNC(0x1175F477, sceCameraSetReverse);
+	REG_FUNC(0x1175F477, sceCameraSetReverse);
-	//REG_FUNC(0x7E8EF3B2, sceCameraGetEffect);
+	REG_FUNC(0x7E8EF3B2, sceCameraGetEffect);
-	//REG_FUNC(0xE9D2CFB1, sceCameraSetEffect);
+	REG_FUNC(0xE9D2CFB1, sceCameraSetEffect);
-	//REG_FUNC(0x8B5E6147, sceCameraGetEV);
+	REG_FUNC(0x8B5E6147, sceCameraGetEV);
-	//REG_FUNC(0x62AFF0B8, sceCameraSetEV);
+	REG_FUNC(0x62AFF0B8, sceCameraSetEV);
-	//REG_FUNC(0x06D3816C, sceCameraGetZoom);
+	REG_FUNC(0x06D3816C, sceCameraGetZoom);
-	//REG_FUNC(0xF7464216, sceCameraSetZoom);
+	REG_FUNC(0xF7464216, sceCameraSetZoom);
-	//REG_FUNC(0x9FDACB99, sceCameraGetAntiFlicker);
+	REG_FUNC(0x9FDACB99, sceCameraGetAntiFlicker);
-	//REG_FUNC(0xE312958A, sceCameraSetAntiFlicker);
+	REG_FUNC(0xE312958A, sceCameraSetAntiFlicker);
-	//REG_FUNC(0x4EBD5C68, sceCameraGetISO);
+	REG_FUNC(0x4EBD5C68, sceCameraGetISO);
-	//REG_FUNC(0x3CF630A1, sceCameraSetISO);
+	REG_FUNC(0x3CF630A1, sceCameraSetISO);
-	//REG_FUNC(0x2C36D6F3, sceCameraGetGain);
+	REG_FUNC(0x2C36D6F3, sceCameraGetGain);
-	//REG_FUNC(0xE65CFE86, sceCameraSetGain);
+	REG_FUNC(0xE65CFE86, sceCameraSetGain);
-	//REG_FUNC(0xDBFFA1DA, sceCameraGetWhiteBalance);
+	REG_FUNC(0xDBFFA1DA, sceCameraGetWhiteBalance);
-	//REG_FUNC(0x4D4514AC, sceCameraSetWhiteBalance);
+	REG_FUNC(0x4D4514AC, sceCameraSetWhiteBalance);
-	//REG_FUNC(0x8DD1292B, sceCameraGetBacklight);
+	REG_FUNC(0x8DD1292B, sceCameraGetBacklight);
-	//REG_FUNC(0xAE071044, sceCameraSetBacklight);
+	REG_FUNC(0xAE071044, sceCameraSetBacklight);
-	//REG_FUNC(0x12B6FF26, sceCameraGetNightmode);
+	REG_FUNC(0x12B6FF26, sceCameraGetNightmode);
-	//REG_FUNC(0x3F26233E, sceCameraSetNightmode);
+	REG_FUNC(0x3F26233E, sceCameraSetNightmode);
-	//REG_FUNC(0xD02CFA5C, sceCameraLedSwitch);
+	REG_FUNC(0xD02CFA5C, sceCameraLedSwitch);
-	//REG_FUNC(0x89B16030, sceCameraLedBlink);
+	REG_FUNC(0x89B16030, sceCameraLedBlink);
-	//REG_FUNC(0x7670474C, sceCameraUseCacheMemoryForTrial);
+	REG_FUNC(0x7670474C, sceCameraUseCacheMemoryForTrial);
-	//REG_FUNC(0x27BB0528, sceCameraGetNoiseReductionForDebug);
+	REG_FUNC(0x27BB0528, sceCameraGetNoiseReductionForDebug);
-	//REG_FUNC(0x233C9E27, sceCameraSetNoiseReductionForDebug);
+	REG_FUNC(0x233C9E27, sceCameraSetNoiseReductionForDebug);
-	//REG_FUNC(0xC387F4DC, sceCameraGetSharpnessOffForDebug);
+	REG_FUNC(0xC387F4DC, sceCameraGetSharpnessOffForDebug);
-	//REG_FUNC(0xE22C2375, sceCameraSetSharpnessOffForDebug);
+	REG_FUNC(0xE22C2375, sceCameraSetSharpnessOffForDebug);
 });

rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp

@@ -4,6 +4,33 @@
 
 extern psv_log_base sceCodecEngine;
 
+struct SceCodecEnginePmonProcessorLoad
+{
+	u32 size;
+	u32 average;
+};
+
+s32 sceCodecEnginePmonStart()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonStop()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonGetProcessorLoad(vm::psv::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonReset()
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceCodecEngine, #name, name)
 
 psv_log_base sceCodecEngine("SceCodecEngine", []()
@@ -12,8 +39,8 @@ psv_log_base sceCodecEngine("SceCodecEngine", []()
 	sceCodecEngine.on_unload = nullptr;
 	sceCodecEngine.on_stop = nullptr;
 
-	//REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
+	REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
-	//REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);
+	REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);
-	//REG_FUNC(0x859E4A68, sceCodecEnginePmonGetProcessorLoad);
+	REG_FUNC(0x859E4A68, sceCodecEnginePmonGetProcessorLoad);
-	//REG_FUNC(0xA097E4C8, sceCodecEnginePmonReset);
+	REG_FUNC(0xA097E4C8, sceCodecEnginePmonReset);
 });

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp

@@ -2,8 +2,509 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "sceGxm.h"
+#include "sceAppUtil.h"
+#include "sceIme.h"
+
 extern psv_log_base sceCommonDialog;
 
+enum SceCommonDialogStatus : s32
+{
+	SCE_COMMON_DIALOG_STATUS_NONE = 0,
+	SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
+	SCE_COMMON_DIALOG_STATUS_FINISHED = 2
+};
+
+enum SceCommonDialogResult : s32
+{
+	SCE_COMMON_DIALOG_RESULT_OK,
+	SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
+	SCE_COMMON_DIALOG_RESULT_ABORTED
+};
+
+struct SceCommonDialogRenderTargetInfo
+{
+	vm::psv::ptr<void> depthSurfaceData;
+	vm::psv::ptr<void> colorSurfaceData;
+	SceGxmColorSurfaceType surfaceType;
+	SceGxmColorFormat colorFormat;
+	u32 width;
+	u32 height;
+	u32 strideInPixels;
+	u8 reserved[32];
+};
+
+struct SceCommonDialogUpdateParam
+{
+	SceCommonDialogRenderTargetInfo renderTarget;
+	vm::psv::ptr<SceGxmSyncObject> displaySyncObject;
+	u8 reserved[32];
+};
+
+struct SceMsgDialogUserMessageParam
+{
+	s32 buttonType;
+	vm::psv::ptr<const char> msg;
+	char reserved[32];
+};
+
+struct SceMsgDialogSystemMessageParam
+{
+	s32 sysMsgType;
+	s32 value;
+	char reserved[32];
+};
+
+struct SceMsgDialogErrorCodeParam
+{
+	s32 errorCode;
+	char reserved[32];
+};
+
+struct SceMsgDialogProgressBarParam
+{
+	s32 barType;
+	SceMsgDialogSystemMessageParam sysMsgParam;
+	vm::psv::ptr<const char> msg;
+	char reserved[32];
+};
+
+struct SceMsgDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	vm::psv::ptr<SceMsgDialogUserMessageParam> userMsgParam;
+	vm::psv::ptr<SceMsgDialogSystemMessageParam> sysMsgParam;
+	vm::psv::ptr<SceMsgDialogErrorCodeParam> errorCodeParam;
+	vm::psv::ptr<SceMsgDialogProgressBarParam> progBarParam;
+	u32 flag;
+	char reserved[32];
+};
+
+struct SceMsgDialogResult
+{
+	s32 mode;
+	s32 result;
+	s32 buttonId;
+	u8 reserved[32];
+};
+
+
+struct SceNetCheckDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	u8 reserved[128];
+};
+
+struct SceNetCheckDialogResult
+{
+	s32 result;
+	u8 reserved[128];
+};
+
+struct SceSaveDataDialogFixedParam
+{
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogListParam
+{
+	vm::psv::ptr<const u32> slotList;
+	u32 slotListSize;
+	s32 focusPos;
+	u32 focusId;
+	vm::psv::ptr<const char> listTitle;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogUserMessageParam
+{
+	s32 buttonType;
+	vm::psv::ptr<const char> msg;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSystemMessageParam
+{
+	s32 sysMsgType;
+	s32 value;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogErrorCodeParam
+{
+	s32 errorCode;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogProgressBarParam
+{
+	s32 barType;
+	SceSaveDataDialogSystemMessageParam sysMsgParam;
+	vm::psv::ptr<const char> msg;
+	u32 targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSlotConfigParam
+{
+	vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint;
+	vm::psv::ptr<const char> appSubDir;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	s32 dispType;
+	vm::psv::ptr<SceSaveDataDialogFixedParam> fixedParam;
+	vm::psv::ptr<SceSaveDataDialogListParam> listParam;
+	vm::psv::ptr<SceSaveDataDialogUserMessageParam> userMsgParam;
+	vm::psv::ptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
+	vm::psv::ptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
+	vm::psv::ptr<SceSaveDataDialogProgressBarParam> progBarParam;
+	vm::psv::ptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
+	u32 flag;
+	vm::psv::ptr<void> userdata;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogFinishParam
+{
+	u32 flag;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSlotInfo
+{
+	u32 isExist;
+	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
+	u8 reserved[32];
+};
+
+struct SceSaveDataDialogResult
+{
+	s32 mode;
+	s32 result;
+	s32 buttonId;
+	u32 slotId;
+	vm::psv::ptr<SceSaveDataDialogSlotInfo> slotInfo;
+	vm::psv::ptr<void> userdata;
+	char reserved[32];
+};
+
+
+struct SceImeDialogParam
+{
+	u32 sdkVersion;
+	u32 inputMethod;
+	u64 supportedLanguages;
+	s32 languagesForced;
+	u32 type;
+	u32 option;
+	vm::psv::ptr<SceImeCharFilter> filter;
+	u32 dialogMode;
+	u32 textBoxMode;
+	vm::psv::ptr<const u16> title;
+	u32 maxTextLength;
+	vm::psv::ptr<u16> initialText;
+	vm::psv::ptr<u16> inputTextBuffer;
+	char reserved[32];
+};
+
+struct SceImeDialogResult
+{
+	s32 result;
+	char reserved[32];
+};
+
+enum ScePhotoImportDialogFormatType : s32
+{
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
+};
+
+enum ScePhotoImportDialogOrientation : s32
+{
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM
+};
+
+struct ScePhotoImportDialogFileDataSub
+{
+	u32 width;
+	u32 height;
+	ScePhotoImportDialogFormatType format;
+	ScePhotoImportDialogOrientation orientation;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogFileData
+{
+	char fileName[1024];
+	char photoTitle[256];
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogItemData
+{
+	ScePhotoImportDialogFileData fileData;
+	ScePhotoImportDialogFileDataSub dataSub;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogResult
+{
+	s32 result;
+	u32 importedItemNum;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	u32 visibleCategory;
+	u32 itemCount;
+	vm::psv::ptr<ScePhotoImportDialogItemData> itemData;
+	char reserved[32];
+};
+
+struct ScePhotoReviewDialogParam
+{
+	u32 sdkVersion;
+	s32 mode;
+	char fileName[1024];
+	vm::psv::ptr<void> workMemory;
+	u32 workMemorySize;
+	char reserved[32];
+};
+
+struct ScePhotoReviewDialogResult
+{
+	s32 result;
+	char reserved[32];
+};
+
+
+s32 sceCommonDialogUpdate(vm::psv::ptr<const SceCommonDialogUpdateParam> updateParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogInit(vm::psv::ptr<const SceMsgDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceMsgDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogGetResult(vm::psv::ptr<SceMsgDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogClose()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogProgressBarInc(s32 target, u32 delta)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogInit(vm::psv::ptr<SceNetCheckDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceNetCheckDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogGetResult(vm::psv::ptr<SceNetCheckDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogInit(vm::psv::ptr<const SceSaveDataDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceSaveDataDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogGetResult(vm::psv::ptr<SceSaveDataDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceSaveDataDialogGetSubStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogSubClose()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogContinue(vm::psv::ptr<const SceSaveDataDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogFinish(vm::psv::ptr<const SceSaveDataDialogFinishParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogProgressBarInc(s32 target, u32 delta)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogInit(vm::psv::ptr<const SceImeDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceImeDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogGetResult(vm::psv::ptr<SceImeDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogInit(vm::psv::ptr<const ScePhotoImportDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus scePhotoImportDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogGetResult(vm::psv::ptr<ScePhotoImportDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogInit(vm::psv::ptr<const ScePhotoReviewDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus scePhotoReviewDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogGetResult(vm::psv::ptr<ScePhotoReviewDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceCommonDialog, #name, name)
 
 psv_log_base sceCommonDialog("SceCommonDialog", []()
@@ -12,44 +513,44 @@ psv_log_base sceCommonDialog("SceCommonDialog", []()
 	sceCommonDialog.on_unload = nullptr;
 	sceCommonDialog.on_stop = nullptr;
 
-	//REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
+	REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
-	//REG_FUNC(0x755FF270, sceMsgDialogInit);
+	REG_FUNC(0x755FF270, sceMsgDialogInit);
-	//REG_FUNC(0x4107019E, sceMsgDialogGetStatus);
+	REG_FUNC(0x4107019E, sceMsgDialogGetStatus);
-	//REG_FUNC(0xC296D396, sceMsgDialogClose);
+	REG_FUNC(0xC296D396, sceMsgDialogClose);
-	//REG_FUNC(0x0CC66115, sceMsgDialogAbort);
+	REG_FUNC(0x0CC66115, sceMsgDialogAbort);
-	//REG_FUNC(0xBB3BFC89, sceMsgDialogGetResult);
+	REG_FUNC(0xBB3BFC89, sceMsgDialogGetResult);
-	//REG_FUNC(0x81ACF695, sceMsgDialogTerm);
+	REG_FUNC(0x81ACF695, sceMsgDialogTerm);
-	//REG_FUNC(0x7BE0E08B, sceMsgDialogProgressBarInc);
+	REG_FUNC(0x7BE0E08B, sceMsgDialogProgressBarInc);
-	//REG_FUNC(0x9CDA5E0D, sceMsgDialogProgressBarSetValue);
+	REG_FUNC(0x9CDA5E0D, sceMsgDialogProgressBarSetValue);
-	//REG_FUNC(0xA38A4A0D, sceNetCheckDialogInit);
+	REG_FUNC(0xA38A4A0D, sceNetCheckDialogInit);
-	//REG_FUNC(0x8027292A, sceNetCheckDialogGetStatus);
+	REG_FUNC(0x8027292A, sceNetCheckDialogGetStatus);
-	//REG_FUNC(0x2D8EDF09, sceNetCheckDialogAbort);
+	REG_FUNC(0x2D8EDF09, sceNetCheckDialogAbort);
-	//REG_FUNC(0xB05FCE9E, sceNetCheckDialogGetResult);
+	REG_FUNC(0xB05FCE9E, sceNetCheckDialogGetResult);
-	//REG_FUNC(0x8BE51C15, sceNetCheckDialogTerm);
+	REG_FUNC(0x8BE51C15, sceNetCheckDialogTerm);
-	//REG_FUNC(0xBF5248FA, sceSaveDataDialogInit);
+	REG_FUNC(0xBF5248FA, sceSaveDataDialogInit);
-	//REG_FUNC(0x6E258046, sceSaveDataDialogGetStatus);
+	REG_FUNC(0x6E258046, sceSaveDataDialogGetStatus);
-	//REG_FUNC(0x013E7F74, sceSaveDataDialogAbort);
+	REG_FUNC(0x013E7F74, sceSaveDataDialogAbort);
-	//REG_FUNC(0xB2FF576E, sceSaveDataDialogGetResult);
+	REG_FUNC(0xB2FF576E, sceSaveDataDialogGetResult);
-	//REG_FUNC(0x2192A10A, sceSaveDataDialogTerm);
+	REG_FUNC(0x2192A10A, sceSaveDataDialogTerm);
-	//REG_FUNC(0x19192C8B, sceSaveDataDialogContinue);
+	REG_FUNC(0x19192C8B, sceSaveDataDialogContinue);
-	//REG_FUNC(0xBA0542CA, sceSaveDataDialogGetSubStatus);
+	REG_FUNC(0xBA0542CA, sceSaveDataDialogGetSubStatus);
-	//REG_FUNC(0x415D6068, sceSaveDataDialogSubClose);
+	REG_FUNC(0x415D6068, sceSaveDataDialogSubClose);
-	//REG_FUNC(0x6C49924B, sceSaveDataDialogFinish);
+	REG_FUNC(0x6C49924B, sceSaveDataDialogFinish);
-	//REG_FUNC(0xBDE00A83, sceSaveDataDialogProgressBarInc);
+	REG_FUNC(0xBDE00A83, sceSaveDataDialogProgressBarInc);
-	//REG_FUNC(0x5C322D1E, sceSaveDataDialogProgressBarSetValue);
+	REG_FUNC(0x5C322D1E, sceSaveDataDialogProgressBarSetValue);
-	//REG_FUNC(0x1E7043BF, sceImeDialogInit);
+	REG_FUNC(0x1E7043BF, sceImeDialogInit);
-	//REG_FUNC(0xCF0431FD, sceImeDialogGetStatus);
+	REG_FUNC(0xCF0431FD, sceImeDialogGetStatus);
-	//REG_FUNC(0x594A220E, sceImeDialogAbort);
+	REG_FUNC(0x594A220E, sceImeDialogAbort);
-	//REG_FUNC(0x2EB3D046, sceImeDialogGetResult);
+	REG_FUNC(0x2EB3D046, sceImeDialogGetResult);
-	//REG_FUNC(0x838A3AF4, sceImeDialogTerm);
+	REG_FUNC(0x838A3AF4, sceImeDialogTerm);
-	//REG_FUNC(0x73EE7C9C, scePhotoImportDialogInit);
+	REG_FUNC(0x73EE7C9C, scePhotoImportDialogInit);
-	//REG_FUNC(0x032206D8, scePhotoImportDialogGetStatus);
+	REG_FUNC(0x032206D8, scePhotoImportDialogGetStatus);
-	//REG_FUNC(0xD855414C, scePhotoImportDialogGetResult);
+	REG_FUNC(0xD855414C, scePhotoImportDialogGetResult);
-	//REG_FUNC(0x7FE5BD77, scePhotoImportDialogTerm);
+	REG_FUNC(0x7FE5BD77, scePhotoImportDialogTerm);
-	//REG_FUNC(0x4B125581, scePhotoImportDialogAbort);
+	REG_FUNC(0x4B125581, scePhotoImportDialogAbort);
-	//REG_FUNC(0xCD990375, scePhotoReviewDialogInit);
+	REG_FUNC(0xCD990375, scePhotoReviewDialogInit);
-	//REG_FUNC(0xF4F600CA, scePhotoReviewDialogGetStatus);
+	REG_FUNC(0xF4F600CA, scePhotoReviewDialogGetStatus);
-	//REG_FUNC(0xFFA35858, scePhotoReviewDialogGetResult);
+	REG_FUNC(0xFFA35858, scePhotoReviewDialogGetResult);
-	//REG_FUNC(0xC700B2DF, scePhotoReviewDialogTerm);
+	REG_FUNC(0xC700B2DF, scePhotoReviewDialogTerm);
-	//REG_FUNC(0x74FF2A8B, scePhotoReviewDialogAbort);
+	REG_FUNC(0x74FF2A8B, scePhotoReviewDialogAbort);
 });

rpcs3/Emu/ARMv7/Modules/sceDbg.cpp

@@ -4,6 +4,33 @@
 
 extern psv_log_base sceDbg;
 
+enum SceDbgBreakOnErrorState : s32
+{
+	SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
+	SCE_DBG_ENABLE_BREAK_ON_ERROR
+};
+
+s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDbgAssertionHandler(vm::psv::ptr<const char> pFile, s32 line, bool stop, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDbgLoggingHandler(vm::psv::ptr<const char> pFile, s32 line, s32 severity, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceDbg, #name, name)
 
 psv_log_base sceDbg("SceDbg", []()
@@ -12,8 +39,8 @@ psv_log_base sceDbg("SceDbg", []()
 	sceDbg.on_unload = nullptr;
 	sceDbg.on_stop = nullptr;
 
-	//REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
+	REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
-	//REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);
+	REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);
-	//REG_FUNC(0x6605AB19, sceDbgLoggingHandler);
+	REG_FUNC(0x6605AB19, sceDbgLoggingHandler);
-	//REG_FUNC(0xED4A00BA, sceDbgSetBreakOnErrorState);
+	REG_FUNC(0xED4A00BA, sceDbgSetBreakOnErrorState);
 });

rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp

@@ -4,7 +4,7 @@
 
 extern psv_log_base sceDeci4p;
 
-typedef s32(*SceKernelDeci4pCallback)(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon);
+typedef vm::psv::ptr<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon)> SceKernelDeci4pCallback;
 
 s32 sceKernelDeci4pOpen(vm::psv::ptr<const char> protoname, u32 protonum, u32 bufsize)
 {

rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp

@@ -4,6 +4,72 @@
 
 extern psv_log_base sceDeflt;
 
+s32 sceGzipIsValid(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceGzipGetInfo(vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<vm::psv::ptr<const char>> ppszName, vm::psv::ptr<vm::psv::ptr<const char>> ppszComment, vm::psv::ptr<u16> pusCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceGzipGetName(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceGzipGetComment(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const void> sceGzipGetCompressedData(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceGzipDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<u32> puiCrc32)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibIsValid(vm::psv::ptr<const void> pSrcZlib)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibGetInfo(vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u8> pbCmf, vm::psv::ptr<u8> pbFlg, vm::psv::ptr<u32> puiDictId, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const void> sceZlibGetCompressedData(vm::psv::ptr<const void> pSrcZlib)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u32> puiAdler32)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceZlibAdler32(u32 uiAdler, vm::psv::ptr<const u8> pSrc, u32 uiSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceDeflateDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcDeflate, vm::psv::ptr<vm::psv::ptr<const void>> ppNext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZipGetInfo(vm::psv::ptr<const void> pSrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<u32> puiCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceDeflt, #name, name)
 
 psv_log_base sceDeflt("SceDeflt", []()
@@ -12,16 +78,16 @@ psv_log_base sceDeflt("SceDeflt", []()
 	sceDeflt.on_unload = nullptr;
 	sceDeflt.on_stop = nullptr;
 
-	//REG_FUNC(0xCD83A464, sceZlibAdler32);
+	REG_FUNC(0xCD83A464, sceZlibAdler32);
-	//REG_FUNC(0x110D5050, sceDeflateDecompress);
+	REG_FUNC(0x110D5050, sceDeflateDecompress);
-	//REG_FUNC(0xE3CB51A3, sceGzipDecompress);
+	REG_FUNC(0xE3CB51A3, sceGzipDecompress);
-	//REG_FUNC(0xBABCF5CF, sceGzipGetComment);
+	REG_FUNC(0xBABCF5CF, sceGzipGetComment);
-	//REG_FUNC(0xE1844802, sceGzipGetCompressedData);
+	REG_FUNC(0xE1844802, sceGzipGetCompressedData);
-	//REG_FUNC(0x1B8E5862, sceGzipGetInfo);
+	REG_FUNC(0x1B8E5862, sceGzipGetInfo);
-	//REG_FUNC(0xAEBAABE6, sceGzipGetName);
+	REG_FUNC(0xAEBAABE6, sceGzipGetName);
-	//REG_FUNC(0xDEDADC31, sceGzipIsValid);
+	REG_FUNC(0xDEDADC31, sceGzipIsValid);
-	//REG_FUNC(0xE38F754D, sceZlibDecompress);
+	REG_FUNC(0xE38F754D, sceZlibDecompress);
-	//REG_FUNC(0xE680A65A, sceZlibGetCompressedData);
+	REG_FUNC(0xE680A65A, sceZlibGetCompressedData);
-	//REG_FUNC(0x4C0A685D, sceZlibGetInfo);
+	REG_FUNC(0x4C0A685D, sceZlibGetInfo);
-	//REG_FUNC(0x14A0698D, sceZlibIsValid);
+	REG_FUNC(0x14A0698D, sceZlibIsValid);
 });

rpcs3/Emu/ARMv7/Modules/sceFiber.cpp

@@ -4,6 +4,79 @@
 
 extern psv_log_base sceFiber;
 
+typedef vm::psv::ptr<void(u32 argOnInitialize, u32 argOnRun)> SceFiberEntry;
+
+union SceFiber
+{
+	static const uint size = 128;
+	static const uint align = 8;
+	u64 padding[size / sizeof(u64)];
+};
+
+union SceFiberOptParam 
+{
+	static const uint size = 128;
+	static const uint align = 8;
+	u64 padding[size / sizeof(u64)];
+};
+
+union SceFiberInfo
+{
+	static const uint size = 128;
+	static const uint align = 8;
+	u64 padding[size / sizeof(u64)];
+
+	struct
+	{
+		SceFiberEntry entry;
+		u32 argOnInitialize;
+		vm::psv::ptr<void> addrContext;
+		s32 sizeContext;
+		char name[32];
+	};
+};
+
+s32 _sceFiberInitializeImpl(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<const char> name, SceFiberEntry entry, u32 argOnInitialize, vm::psv::ptr<void> addrContext, u32 sizeContext, vm::psv::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberOptParamInitialize(vm::psv::ptr<SceFiberOptParam> optParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberFinalize(vm::psv::ptr<SceFiber> fiber)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberRun(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnReturn)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberSwitch(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnRun)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberGetSelf(vm::psv::ptr<vm::psv::ptr<SceFiber>> fiber)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberReturnToThread(u32 argOnReturn, vm::psv::ptr<u32> argOnRun)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberGetInfo(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<SceFiberInfo> fiberInfo)
+{
+	throw __FUNCTION__;
+}
+
+
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceFiber, #name, name)
 
 psv_log_base sceFiber("SceFiber", []()
@@ -12,15 +85,15 @@ psv_log_base sceFiber("SceFiber", []()
 	sceFiber.on_unload = nullptr;
 	sceFiber.on_stop = nullptr;
 
-	//REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
+	REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
 	//REG_FUNC(0xC6A3F9BB, _sceFiberInitializeWithInternalOptionImpl);
 	//REG_FUNC(0x7D0C7DDB, _sceFiberAttachContextAndRun);
 	//REG_FUNC(0xE00B9AFE, _sceFiberAttachContextAndSwitch);
-	//REG_FUNC(0x801AB334, sceFiberOptParamInitialize);
+	REG_FUNC(0x801AB334, sceFiberOptParamInitialize);
-	//REG_FUNC(0xE160F844, sceFiberFinalize);
+	REG_FUNC(0xE160F844, sceFiberFinalize);
-	//REG_FUNC(0x7DF23243, sceFiberRun);
+	REG_FUNC(0x7DF23243, sceFiberRun);
-	//REG_FUNC(0xE4283144, sceFiberSwitch);
+	REG_FUNC(0xE4283144, sceFiberSwitch);
-	//REG_FUNC(0x414D8CA5, sceFiberGetSelf);
+	REG_FUNC(0x414D8CA5, sceFiberGetSelf);
-	//REG_FUNC(0x3B42921F, sceFiberReturnToThread);
+	REG_FUNC(0x3B42921F, sceFiberReturnToThread);
-	//REG_FUNC(0x189599B4, sceFiberGetInfo);
+	REG_FUNC(0x189599B4, sceFiberGetInfo);
 });

rpcs3/Emu/ARMv7/Modules/sceIme.cpp

@@ -2,7 +2,33 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceIme;
+#include "sceIme.h"
+
+s32 sceImeOpen(vm::psv::ptr<SceImeParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeUpdate()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeSetCaret(vm::psv::ptr<const SceImeCaret> caret)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeSetPreeditGeometry(vm::psv::ptr<const SceImePreeditGeometry> preedit)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeClose()
+{
+	throw __FUNCTION__;
+}
+
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceIme, #name, name)
 
@@ -12,9 +38,9 @@ psv_log_base sceIme("SceIme", []()
 	sceIme.on_unload = nullptr;
 	sceIme.on_stop = nullptr;
 
-	//REG_FUNC(0x0E050613, sceImeOpen);
+	REG_FUNC(0x0E050613, sceImeOpen);
-	//REG_FUNC(0x71D6898A, sceImeUpdate);
+	REG_FUNC(0x71D6898A, sceImeUpdate);
-	//REG_FUNC(0x889A8421, sceImeClose);
+	REG_FUNC(0x889A8421, sceImeClose);
-	//REG_FUNC(0xD8342D2A, sceImeSetCaret);
+	REG_FUNC(0xD8342D2A, sceImeSetCaret);
-	//REG_FUNC(0x7B1EFAA5, sceImeSetPreeditGeometry);
+	REG_FUNC(0x7B1EFAA5, sceImeSetPreeditGeometry);
 });

rpcs3/Emu/ARMv7/Modules/sceIme.h

@@ -0,0 +1,70 @@
+#pragma once
+
+typedef s32(SceImeCharFilter)(u16 ch);
+
+struct SceImeRect
+{
+	u32 x;
+	u32 y;
+	u32 width;
+	u32 height;
+};
+
+struct SceImeEditText
+{
+	u32 preeditIndex;
+	u32 preeditLength;
+	u32 caretIndex;
+	vm::psv::ptr<u16> str;
+};
+
+union SceImeEventParam
+{
+	SceImeRect rect;
+	SceImeEditText text;
+	u32 caretIndex;
+};
+
+struct SceImeEvent
+{
+	u32 id;
+	SceImeEventParam param;
+};
+
+struct SceImeCaret
+{
+	u32 x;
+	u32 y;
+	u32 height;
+	u32 index;
+};
+
+struct SceImePreeditGeometry
+{
+	u32 x;
+	u32 y;
+	u32 height;
+};
+
+typedef void(SceImeEventHandler)(vm::psv::ptr<void> arg, vm::psv::ptr<const SceImeEvent> e);
+
+struct SceImeParam
+{
+	u32 size;
+	u32 inputMethod;
+	u64 supportedLanguages;
+	s32 languagesForced;
+	u32 type;
+	u32 option;
+	vm::psv::ptr<void> work;
+	vm::psv::ptr<void> arg;
+	vm::psv::ptr<SceImeEventHandler> handler;
+	vm::psv::ptr<SceImeCharFilter> filter;
+	vm::psv::ptr<u32> initialText;
+	u32 maxTextLength;
+	vm::psv::ptr<u32> inputTextBuffer;
+	u32 reserved0;
+	u32 reserved1;
+};
+
+extern psv_log_base sceIme;

rpcs3/Loader/ELF32.cpp

@@ -256,9 +256,7 @@ namespace loader
 							}
 							case 0x0000002f: // movw r*,# instruction is replaced
 							{
-								const u32 addr = *++code;
+								if (!data) // probably, imported object
-
-								if (!data)
 								{
 									auto found = vnid_list.find(code.addr());
 									if (found != vnid_list.end())
@@ -269,36 +267,32 @@ namespace loader
 
 								if (!data)
 								{
-									LOG_ERROR(LOADER, ".sceRefs: movw writing failed (code=0x%x, addr=0x%x)", code, addr);
+									LOG_ERROR(LOADER, ".sceRefs: movw writing failed (ref_addr=0x%x, addr=0x%x)", code, code[1]);
-									break;
+								}
+								else //if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: movw written at 0x%x (ref_addr=0x%x, data=0x%x)", code[1], code, data);
 								}
 
+								const u32 addr = *++code;
 								vm::psv::write16(addr + 0, vm::psv::read16(addr + 0) | (data & 0x800) >> 1 | (data & 0xf000) >> 12);
 								vm::psv::write16(addr + 2, vm::psv::read16(addr + 2) | (data & 0x700) << 4 | (data & 0xff));
-
-								//if (Ini.HLELogging.GetValue())
-								{
-									LOG_NOTICE(LOADER, ".sceRefs: movw written at 0x%x (data=0x%x)", addr, data);
-								}
 								break;
 							}
 							case 0x00000030: // movt r*,# instruction is replaced
 							{
-								const u32 addr = *++code;
-
 								if (!data)
 								{
-									LOG_ERROR(LOADER, ".sceRefs: movt writing failed (code=0x%x, addr=0x%x)", code, addr);
+									LOG_ERROR(LOADER, ".sceRefs: movt writing failed (ref_addr=0x%x, addr=0x%x)", code, code[1]);
-									break;
+								}
+								else //if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: movt written at 0x%x (ref_addr=0x%x, data=0x%x)", code[1], code, data);
 								}
 
+								const u32 addr = *++code;
 								vm::psv::write16(addr + 0, vm::psv::read16(addr + 0) | (data & 0x8000000) >> 17 | (data & 0xf0000000) >> 28);
 								vm::psv::write16(addr + 2, vm::psv::read16(addr + 2) | (data & 0x7000000) >> 12 | (data & 0xff0000) >> 16);
-
-								//if (Ini.HLELogging.GetValue())
-								{
-									LOG_NOTICE(LOADER, ".sceRefs: movt written at 0x%x (data=0x%x)", addr, data);
-								}
 								break;
 							}
 							case 0x00000000:

rpcs3/emucore.vcxproj

@@ -335,7 +335,9 @@
     <ClInclude Include="Emu\ARMv7\ARMv7Thread.h" />
     <ClInclude Include="Emu\ARMv7\Modules\psv_event_flag.h" />
     <ClInclude Include="Emu\ARMv7\Modules\psv_sema.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceAppUtil.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceGxm.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceIme.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" />
     <ClInclude Include="Emu\ARMv7\PSVFuncList.h" />
     <ClInclude Include="Emu\ARMv7\PSVObjectList.h" />

rpcs3/emucore.vcxproj.filters

@@ -1486,5 +1486,11 @@
     <ClInclude Include="Emu\ARMv7\Modules\sceGxm.h">
       <Filter>Emu\CPU\ARMv7\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceAppUtil.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceIme.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>