mirrors/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-20 19:45:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Modules cleanup

Browse source
This commit is contained in:
Nekotekina 2015-08-01 00:47:29 +03:00
parent a2646f9871
commit b391e93466
22 changed files with 613 additions and 1384 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

173
rpcs3/Emu/SysCalls/Modules/cellGem.cpp
View file

@ -6,193 +6,108 @@
extern Module cellGem;
struct cellGemInternal
{
bool m_bInitialized;
CellGemAttribute attribute;
cellGemInternal()
: m_bInitialized(false)
{
}
};
cellGemInternal cellGemInstance;
s32 cellGemCalibrate()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemClearStatusFlags()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemConvertVideoFinish()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemConvertVideoStart()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemEnableCameraPitchAngleCorrection()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemEnableMagnetometer()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemEnd()
{
cellGem.Warning("cellGemEnd()");
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
cellGemInstance.m_bInitialized = false;
return CELL_OK;
}
s32 cellGemFilterState()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemForceRGB()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetAccelerometerPositionInDevice()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetAllTrackableHues()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetCameraState()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetEnvironmentLightingColor()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetHuePixels()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetImageState()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetInertialState()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetInfo(vm::ptr<CellGemInfo> info)
{
cellGem.Warning("cellGemGetInfo(info=0x%x)", info.addr());
cellGem.Todo("cellGemGetInfo(info=*0x%x)", info);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
info->max_connect = cellGemInstance.attribute.max_connect;
// TODO: Support many controllers to be connected
info->now_connect = 1;
info->status[0] = CELL_GEM_STATUS_READY;
info->port[0] = 7;
*info = {};
return CELL_OK;
}
@ -201,59 +116,41 @@ s32 cellGemGetMemorySize(s32 max_connect)
{
cellGem.Warning("cellGemGetMemorySize(max_connect=%d)", max_connect);
if (max_connect > CELL_GEM_MAX_NUM)
if (max_connect > CELL_GEM_MAX_NUM || max_connect <= 0)
{
return CELL_GEM_ERROR_INVALID_PARAMETER;
}
return 1024 * 1024 * max_connect; // 1 MB * max_connect
return max_connect <= 2 ? 0x120000 : 0x140000;
}
s32 cellGemGetRGB()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetRumble()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetState()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetStatusFlags()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemGetTrackerHue()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
@ -267,22 +164,12 @@ s32 cellGemInit(vm::ptr<CellGemAttribute> attribute)
{
cellGem.Warning("cellGemInit(attribute=*0x%x)", attribute);
if (cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_ALREADY_INITIALIZED;
cellGemInstance.m_bInitialized = true;
cellGemInstance.attribute = *attribute;
return CELL_OK;
}
s32 cellGemInvalidateCalibration()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
@ -295,98 +182,65 @@ s32 cellGemIsTrackableHue()
s32 cellGemPrepareCamera()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemPrepareVideoConvert()
{
UNIMPLEMENTED_FUNC(cellGem);
return CELL_OK;
}
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
s32 cellGemReadExternalPortDeviceInfo()
{
UNIMPLEMENTED_FUNC(cellGem);
return CELL_OK;
}
s32 cellGemReset()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemSetRumble()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemSetYaw()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemTrackHues()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemUpdateFinish()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemUpdateStart()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
s32 cellGemWriteExternalPort()
{
UNIMPLEMENTED_FUNC(cellGem);
if (!cellGemInstance.m_bInitialized)
return CELL_GEM_ERROR_UNINITIALIZED;
return CELL_OK;
}
Module cellGem("cellGem", []()
{
cellGemInstance.m_bInitialized = false;
//REG_FUNC(cellGem, cellGemAttributeInit);
REG_FUNC(cellGem, cellGemCalibrate);
REG_FUNC(cellGem, cellGemClearStatusFlags);
REG_FUNC(cellGem, cellGemConvertVideoFinish);
@ -410,21 +264,18 @@ Module cellGem("cellGem", []()
REG_FUNC(cellGem, cellGemGetState);
REG_FUNC(cellGem, cellGemGetStatusFlags);
REG_FUNC(cellGem, cellGemGetTrackerHue);
//REG_FUNC(cellGem, cellGemGetVideoConvertSize);
REG_FUNC(cellGem, cellGemHSVtoRGB);
REG_FUNC(cellGem, cellGemInit);
REG_FUNC(cellGem, cellGemInvalidateCalibration);
REG_FUNC(cellGem, cellGemIsTrackableHue);
REG_FUNC(cellGem, cellGemPrepareCamera);
REG_FUNC(cellGem, cellGemPrepareVideoConvert);
//REG_FUNC(cellGem, cellGemReadExternalPortDeviceInfo);
REG_FUNC(cellGem, cellGemReadExternalPortDeviceInfo);
REG_FUNC(cellGem, cellGemReset);
REG_FUNC(cellGem, cellGemSetRumble);
REG_FUNC(cellGem, cellGemSetYaw);
REG_FUNC(cellGem, cellGemTrackHues);
REG_FUNC(cellGem, cellGemUpdateFinish);
REG_FUNC(cellGem, cellGemUpdateStart);
//REG_FUNC(cellGem, cellGemVideoConvertAttributeInit);
//REG_FUNC(cellGem, cellGemVideoConvertAttributeInitRgba);
REG_FUNC(cellGem, cellGemWriteExternalPort);
});

2
rpcs3/Emu/SysCalls/Modules/cellGem.h
View file

@ -186,4 +186,4 @@ struct CellGemVideoConvertAttribute
be_t<u32> buffer_memory;
be_t<u32> video_data_out;
u8 alpha;
};
};

24
rpcs3/Emu/SysCalls/Modules/cellMic.cpp
View file

@ -7,27 +7,10 @@
extern Module cellMic;
struct cellMicInternal
{
bool m_bCellMicInitialized;;
cellMicInternal()
: m_bCellMicInitialized(false)
{
}
};
cellMicInternal cellMicInstance;
s32 cellMicInit()
{
cellMic.Warning("cellMicInit()");
if (cellMicInstance.m_bCellMicInitialized)
return CELL_MICIN_ERROR_ALREADY_INIT;
cellMicInstance.m_bCellMicInitialized = true;
return CELL_OK;
}
@ -35,11 +18,6 @@ s32 cellMicEnd()
{
cellMic.Warning("cellMicEnd()");
if (!cellMicInstance.m_bCellMicInitialized)
return CELL_MICIN_ERROR_NOT_INIT;
cellMicInstance.m_bCellMicInitialized = false;
return CELL_OK;
}
@ -285,8 +263,6 @@ s32 cellMicGetDeviceIdentifier()
Module cellMic("cellMic", []()
{
cellMicInstance.m_bCellMicInitialized = false;
REG_FUNC(cellMic, cellMicInit);
REG_FUNC(cellMic, cellMicEnd);
REG_FUNC(cellMic, cellMicOpen);

80
rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
View file

@ -28,32 +28,16 @@
extern Module cellNetCtl;
std::unique_ptr<CellNetCtlInternal> g_netCtl;
s32 cellNetCtlInit()
{
cellNetCtl.Log("cellNetCtlInit()");
if (g_netCtl->m_bInitialized)
{
return CELL_NET_CTL_ERROR_NOT_TERMINATED;
}
g_netCtl->m_bInitialized = true;
cellNetCtl.Warning("cellNetCtlInit()");
return CELL_OK;
}
s32 cellNetCtlTerm()
{
cellNetCtl.Log("cellNetCtlTerm()");
if (!g_netCtl->m_bInitialized)
{
return CELL_NET_CTL_ERROR_NOT_INITIALIZED;
}
g_netCtl->m_bInitialized = false;
cellNetCtl.Warning("cellNetCtlTerm()");
return CELL_OK;
}
@ -268,10 +252,55 @@ s32 cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
return CELL_OK;
}
s32 cellGameUpdateInit()
{
throw EXCEPTION("");
}
s32 cellGameUpdateTerm()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckStartAsync()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckFinishAsync()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckStartWithoutDialogAsync()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckAbort()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckStartAsyncEx()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckFinishAsyncEx()
{
throw EXCEPTION("");
}
s32 cellGameUpdateCheckStartWithoutDialogAsyncEx()
{
throw EXCEPTION("");
}
Module cellNetCtl("cellNetCtl", []()
{
g_netCtl = std::make_unique<CellNetCtlInternal>();
REG_FUNC(cellNetCtl, cellNetCtlInit);
REG_FUNC(cellNetCtl, cellNetCtlTerm);
@ -286,4 +315,15 @@ Module cellNetCtl("cellNetCtl", []()
REG_FUNC(cellNetCtl, cellNetCtlNetStartDialogUnloadAsync);
REG_FUNC(cellNetCtl, cellNetCtlGetNatInfo);
REG_FUNC(cellNetCtl, cellGameUpdateInit);
REG_FUNC(cellNetCtl, cellGameUpdateTerm);
REG_FUNC(cellNetCtl, cellGameUpdateCheckStartAsync);
REG_FUNC(cellNetCtl, cellGameUpdateCheckFinishAsync);
REG_FUNC(cellNetCtl, cellGameUpdateCheckStartWithoutDialogAsync);
REG_FUNC(cellNetCtl, cellGameUpdateCheckAbort);
REG_FUNC(cellNetCtl, cellGameUpdateCheckStartAsyncEx);
REG_FUNC(cellNetCtl, cellGameUpdateCheckFinishAsyncEx);
REG_FUNC(cellNetCtl, cellGameUpdateCheckStartWithoutDialogAsyncEx);
});

12
rpcs3/Emu/SysCalls/Modules/cellNetCtl.h
View file

@ -196,18 +196,6 @@ enum
CELL_NET_CTL_NATINFO_NAT_TYPE_3 = 3,
};
struct CellNetCtlInternal
{
bool m_bInitialized;
CellNetCtlInternal()
: m_bInitialized(false)
{
}
};
extern std::unique_ptr<CellNetCtlInternal> g_netCtl;
struct CellNetCtlEtherAddr
{
u8 data[6];

32
rpcs3/Emu/SysCalls/Modules/cellSearch.cpp
View file

@ -6,30 +6,9 @@
extern Module cellSearch;
struct cellSearchInternal
{
bool m_bInitialized;
cellSearchInternal()
: m_bInitialized(false)
{
}
};
cellSearchInternal cellSearchInstance;
s32 cellSearchInitialize(CellSearchMode mode, u32 container, vm::ptr<CellSearchSystemCallback> func, vm::ptr<u32> userData)
{
cellSearch.Todo("cellSearchInitialize()");
if (cellSearchInstance.m_bInitialized)
return CELL_SEARCH_ERROR_ALREADY_INITIALIZED;
if (mode != 0)
return CELL_SEARCH_ERROR_UNKNOWN_MODE;
if (!func)
return CELL_SEARCH_ERROR_PARAM;
cellSearchInstance.m_bInitialized = true;
cellSearch.Warning("cellSearchInitialize()");
// TODO: Store the arguments somewhere so we can use them later.
@ -38,12 +17,7 @@ s32 cellSearchInitialize(CellSearchMode mode, u32 container, vm::ptr<CellSearchS
s32 cellSearchFinalize()
{
cellSearch.Log("cellSearchFinalize()");
if (!cellSearchInstance.m_bInitialized)
return CELL_SEARCH_ERROR_NOT_INITIALIZED;
cellSearchInstance.m_bInitialized = false;
cellSearch.Warning("cellSearchFinalize()");
return CELL_OK;
}
@ -158,8 +132,6 @@ s32 cellSearchEnd()
Module cellSearch("cellSearch", []()
{
cellSearchInstance.m_bInitialized = false;
REG_FUNC(cellSearch, cellSearchInitialize);
REG_FUNC(cellSearch, cellSearchFinalize);
REG_FUNC(cellSearch, cellSearchStartListSearch);

28
rpcs3/Emu/SysCalls/Modules/cellUsbd.cpp
View file

@ -6,38 +6,16 @@
extern Module cellUsbd;
struct cellUsbdInternal
{
bool m_bInitialized;
cellUsbdInternal()
: m_bInitialized(false)
{
}
};
cellUsbdInternal cellUsbdInstance;
s32 cellUsbdInit()
{
cellUsbd.Log("cellUsbdInit()");
if (cellUsbdInstance.m_bInitialized)
return CELL_USBD_ERROR_ALREADY_INITIALIZED;
cellUsbdInstance.m_bInitialized = true;
cellUsbd.Warning("cellUsbdInit()");
return CELL_OK;
}
s32 cellUsbdEnd()
{
cellUsbd.Log("cellUsbdEnd()");
if (!cellUsbdInstance.m_bInitialized)
return CELL_USBD_ERROR_NOT_INITIALIZED;
cellUsbdInstance.m_bInitialized = false;
cellUsbd.Warning("cellUsbdEnd()");
return CELL_OK;
}
@ -176,8 +154,6 @@ s32 cellUsbdFreeMemory()
Module cellUsbd("cellUsbd", []()
{
cellUsbdInstance.m_bInitialized = false;
REG_FUNC(cellUsbd, cellUsbdInit);
REG_FUNC(cellUsbd, cellUsbdEnd);

196
rpcs3/Emu/SysCalls/Modules/sceNp.cpp
View file

@ -12,37 +12,24 @@
extern Module sceNp;
std::unique_ptr<SceNpInternal> g_sceNp;
s32 sceNpInit(u32 poolsize, vm::ptr<u32> poolptr)
s32 sceNpInit(u32 poolsize, vm::ptr<void> poolptr)
{
sceNp.Warning("sceNpInit(poolsize=%d, poolptr=0x%x)", poolsize, poolptr);
if (g_sceNp->m_bSceNpInitialized)
{
sceNp.Error("sceNpInit(): sceNp has been already initialized.");
return SCE_NP_ERROR_ALREADY_INITIALIZED;
}
sceNp.Warning("sceNpInit(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr);
if (poolsize == 0)
{
sceNp.Error("sceNpInit(): poolsize given is 0.");
return SCE_NP_ERROR_INVALID_ARGUMENT;
}
else if (poolsize < 128 * 1024)
{
sceNp.Error("sceNp2Init(): poolsize given is under 131072 bytes.");
return SCE_NP_ERROR_INSUFFICIENT_BUFFER;
}
if (!poolptr)
{
sceNp.Error("sceNpInit(): poolptr is invalid.");
return SCE_NP_ERROR_INVALID_ARGUMENT;
}
g_sceNp->m_bSceNpInitialized = true;
return CELL_OK;
}
@ -50,14 +37,6 @@ s32 sceNpTerm()
{
sceNp.Warning("sceNpTerm()");
if (!g_sceNp->m_bSceNpInitialized)
{
sceNp.Error("sceNpTerm(): sceNp has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
g_sceNp->m_bSceNpInitialized = false;
return CELL_OK;
}
@ -282,11 +261,6 @@ s32 sceNpBasicGetFriendListEntryCount(vm::ptr<u32> count)
{
sceNp.Warning("sceNpBasicGetFriendListEntryCount(count=*0x%x)", count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
// TODO: Check if there are any friends
*count = 0;
@ -339,11 +313,6 @@ s32 sceNpBasicGetPlayersHistoryEntryCount(u32 options, vm::ptr<u32> count)
{
sceNp.Todo("sceNpBasicGetPlayersHistoryEntryCount(options=%d, count=*0x%x)", options, count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -363,11 +332,6 @@ s32 sceNpBasicGetBlockListEntryCount(u32 count)
{
sceNp.Todo("sceNpBasicGetBlockListEntryCount(count=%d)", count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -381,11 +345,6 @@ s32 sceNpBasicGetMessageAttachmentEntryCount(vm::ptr<u32> count)
{
sceNp.Todo("sceNpBasicGetMessageAttachmentEntryCount(count=*0x%x)", count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -393,11 +352,6 @@ s32 sceNpBasicGetMessageAttachmentEntry(u32 index, vm::ptr<SceNpUserInfo> from)
{
sceNp.Todo("sceNpBasicGetMessageAttachmentEntry(index=%d, from=*0x%x)", index, from);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -417,11 +371,6 @@ s32 sceNpBasicGetMatchingInvitationEntryCount(vm::ptr<u32> count)
{
sceNp.Todo("sceNpBasicGetMatchingInvitationEntryCount(count=*0x%x)", count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -429,11 +378,6 @@ s32 sceNpBasicGetMatchingInvitationEntry(u32 index, vm::ptr<SceNpUserInfo> from)
{
sceNp.Todo("sceNpBasicGetMatchingInvitationEntry(index=%d, from=*0x%x)", index, from);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -441,11 +385,6 @@ s32 sceNpBasicGetClanMessageEntryCount(vm::ptr<u32> count)
{
sceNp.Todo("sceNpBasicGetClanMessageEntryCount(count=*0x%x)", count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -453,11 +392,6 @@ s32 sceNpBasicGetClanMessageEntry(u32 index, vm::ptr<SceNpUserInfo> from)
{
sceNp.Todo("sceNpBasicGetClanMessageEntry(index=%d, from=*0x%x)", index, from);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -465,11 +399,6 @@ s32 sceNpBasicGetMessageEntryCount(u32 type, vm::ptr<u32> count)
{
sceNp.Warning("sceNpBasicGetMessageEntryCount(type=%d, count=*0x%x)", type, count);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
// TODO: Check if there are messages
*count = 0;
@ -480,11 +409,6 @@ s32 sceNpBasicGetMessageEntry(u32 type, u32 index, vm::ptr<SceNpUserInfo> from)
{
sceNp.Todo("sceNpBasicGetMessageEntry(type=%d, index=%d, from=*0x%x)", type, index, from);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -492,11 +416,6 @@ s32 sceNpBasicGetEvent(vm::ptr<s32> event, vm::ptr<SceNpUserInfo> from, vm::ptr<
{
sceNp.Warning("sceNpBasicGetEvent(event=*0x%x, from=*0x%x, data=*0x%x, size=*0x%x)", event, from, data, size);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_BASIC_ERROR_NOT_INITIALIZED;
}
// TODO: Check for other error and pass other events
*event = SCE_NP_BASIC_EVENT_OFFLINE;
@ -759,15 +678,6 @@ s32 sceNpLookupInit()
{
sceNp.Warning("sceNpLookupInit()");
// TODO: Make sure the error code returned is right,
// since there are no error codes for Lookup utility.
if (g_sceNp->m_bLookupInitialized)
{
return SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED;
}
g_sceNp->m_bLookupInitialized = true;
return CELL_OK;
}
@ -775,13 +685,6 @@ s32 sceNpLookupTerm()
{
sceNp.Warning("sceNpLookupTerm()");
if (!g_sceNp->m_bLookupInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
g_sceNp->m_bLookupInitialized = false;
return CELL_OK;
}
@ -922,11 +825,6 @@ s32 sceNpManagerGetStatus(vm::ptr<u32> status)
{
sceNp.Warning("sceNpManagerGetStatus(status=*0x%x)", status);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_ERROR_NOT_INITIALIZED;
}
// TODO: Support different statuses
*status = SCE_NP_MANAGER_STATUS_OFFLINE;
@ -985,11 +883,6 @@ s32 sceNpManagerGetContentRatingFlag(vm::ptr<u32> isRestricted, vm::ptr<u32> age
{
sceNp.Warning("sceNpManagerGetContentRatingFlag(isRestricted=*0x%x, age=*0x%x)", isRestricted, age);
if (!g_sceNp->m_bSceNpInitialized)
{
return SCE_NP_ERROR_NOT_INITIALIZED;
}
// TODO: read user's parental control information
*isRestricted = 0;
*age = 18;
@ -1217,13 +1110,6 @@ s32 sceNpScoreInit()
{
sceNp.Warning("sceNpScoreInit()");
if (g_sceNp->m_bScoreInitialized)
{
return SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED;
}
g_sceNp->m_bScoreInitialized = true;
return CELL_OK;
}
@ -1231,13 +1117,6 @@ s32 sceNpScoreTerm()
{
sceNp.Warning("sceNpScoreTerm()");
if (!g_sceNp->m_bScoreInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
g_sceNp->m_bScoreInitialized = false;
return CELL_OK;
}
@ -1571,6 +1450,18 @@ s32 sceNpSignalingGetPeerNetInfoResult()
return CELL_OK;
}
s32 sceNpUtilCmpNpId()
{
UNIMPLEMENTED_FUNC(sceNp);
return CELL_OK;
}
s32 sceNpUtilCmpNpIdInOrder()
{
UNIMPLEMENTED_FUNC(sceNp);
return CELL_OK;
}
s32 _sceNpSysutilClientMalloc()
{
UNIMPLEMENTED_FUNC(sceNp);
@ -1583,10 +1474,54 @@ s32 _sceNpSysutilClientFree()
return CELL_OK;
}
s32 _Z33_sce_np_sysutil_send_empty_packetiPN16sysutil_cxmlutil11FixedMemoryEPKcS3_()
{
throw EXCEPTION("");
}
s32 _Z27_sce_np_sysutil_send_packetiRN4cxml8DocumentE()
{
throw EXCEPTION("");
}
s32 _Z36_sce_np_sysutil_recv_packet_fixedmemiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE()
{
throw EXCEPTION("");
}
s32 _Z40_sce_np_sysutil_recv_packet_fixedmem_subiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE()
{
throw EXCEPTION("");
}
s32 _Z27_sce_np_sysutil_recv_packetiRN4cxml8DocumentERNS_7ElementE()
{
throw EXCEPTION("");
}
s32 _Z29_sce_np_sysutil_cxml_set_npidRN4cxml8DocumentERNS_7ElementEPKcPK7SceNpId()
{
throw EXCEPTION("");
}
s32 _Z31_sce_np_sysutil_send_packet_subiRN4cxml8DocumentE()
{
throw EXCEPTION("");
}
s32 _Z37sce_np_matching_set_matching2_runningb()
{
throw EXCEPTION("");
}
s32 _Z32_sce_np_sysutil_cxml_prepare_docPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentEPKcRNS2_7ElementES6_i()
{
throw EXCEPTION("");
}
Module sceNp("sceNp", []()
{
g_sceNp = std::make_unique<SceNpInternal>();
REG_FUNC(sceNp, sceNpInit);
REG_FUNC(sceNp, sceNpTerm);
REG_FUNC(sceNp, sceNpDrmIsAvailable);
@ -1805,6 +1740,17 @@ Module sceNp("sceNp", []()
REG_FUNC(sceNp, sceNpSignalingGetPeerNetInfo);
REG_FUNC(sceNp, sceNpSignalingCancelPeerNetInfo);
REG_FUNC(sceNp, sceNpSignalingGetPeerNetInfoResult);
REG_FUNC(sceNp, sceNpUtilCmpNpId);
REG_FUNC(sceNp, sceNpUtilCmpNpIdInOrder);
REG_FUNC(sceNp, _sceNpSysutilClientMalloc);
REG_FUNC(sceNp, _sceNpSysutilClientFree);
REG_FUNC(sceNp, _Z33_sce_np_sysutil_send_empty_packetiPN16sysutil_cxmlutil11FixedMemoryEPKcS3_);
REG_FUNC(sceNp, _Z27_sce_np_sysutil_send_packetiRN4cxml8DocumentE);
REG_FUNC(sceNp, _Z36_sce_np_sysutil_recv_packet_fixedmemiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE);
REG_FUNC(sceNp, _Z40_sce_np_sysutil_recv_packet_fixedmem_subiPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentERNS2_7ElementE);
REG_FUNC(sceNp, _Z27_sce_np_sysutil_recv_packetiRN4cxml8DocumentERNS_7ElementE);
REG_FUNC(sceNp, _Z29_sce_np_sysutil_cxml_set_npidRN4cxml8DocumentERNS_7ElementEPKcPK7SceNpId);
REG_FUNC(sceNp, _Z31_sce_np_sysutil_send_packet_subiRN4cxml8DocumentE);
REG_FUNC(sceNp, _Z37sce_np_matching_set_matching2_runningb);
REG_FUNC(sceNp, _Z32_sce_np_sysutil_cxml_prepare_docPN16sysutil_cxmlutil11FixedMemoryERN4cxml8DocumentEPKcRNS2_7ElementES6_i);
});

55
rpcs3/Emu/SysCalls/Modules/sceNp.h
View file

@ -807,37 +807,6 @@ enum
SCE_NP_SIGNALING_CTX_MAX = 8,
};
struct SceNpInternal
{
bool m_bSceNpInitialized;
bool m_bScoreInitialized;
bool m_bLookupInitialized;
SceNpInternal()
: m_bSceNpInitialized(false),
m_bScoreInitialized(false),
m_bLookupInitialized(false)
{
}
};
struct SceNp2Internal
{
bool m_bSceNp2Initialized;
bool m_bSceNp2Matching2Initialized;
bool m_bSceNp2Matching2Initialized2;
SceNp2Internal()
: m_bSceNp2Initialized(false),
m_bSceNp2Matching2Initialized(false),
m_bSceNp2Matching2Initialized2(false)
{
}
};
extern std::unique_ptr<SceNpInternal> g_sceNp;
extern std::unique_ptr<SceNp2Internal> g_sceNp2;
// NP communication ID structure
struct SceNpCommunicationId
{
@ -1998,8 +1967,8 @@ struct SceNpMatching2UtilityInitParam
{
be_t<u32> containerId;
be_t<u32> requestCbQueueLen;
be_t<u32> sessionEventCbQueueLen;;
be_t<u32> sessionMsgCbQueueLen;;
be_t<u32> sessionEventCbQueueLen;
be_t<u32> sessionMsgCbQueueLen;
u8 reserved[16];
};
@ -2007,8 +1976,8 @@ struct SceNpMatching2UtilityInitParam
struct SceNpMatching2MemoryInfo
{
be_t<u32> totalMemSize;
be_t<u32> curMemUsage;;
be_t<u32> maxMemUsage;;
be_t<u32> curMemUsage;
be_t<u32> maxMemUsage;
u8 reserved[12];
};
@ -2016,14 +1985,14 @@ struct SceNpMatching2MemoryInfo
struct SceNpMatching2CbQueueInfo
{
be_t<u32> requestCbQueueLen;
be_t<u32> curRequestCbQueueLen;;
be_t<u32> maxRequestCbQueueLen;;
be_t<u32> sessionEventCbQueueLen;;
be_t<u32> curSessionEventCbQueueLen;;
be_t<u32> maxSessionEventCbQueueLen;;
be_t<u32> sessionMsgCbQueueLen;;
be_t<u32> curSessionMsgCbQueueLen;;
be_t<u32> maxSessionMsgCbQueueLen;;
be_t<u32> curRequestCbQueueLen;
be_t<u32> maxRequestCbQueueLen;
be_t<u32> sessionEventCbQueueLen;
be_t<u32> curSessionEventCbQueueLen;
be_t<u32> maxSessionEventCbQueueLen;
be_t<u32> sessionMsgCbQueueLen;
be_t<u32> curSessionMsgCbQueueLen;
be_t<u32> maxSessionMsgCbQueueLen;
u8 reserved[12];
};

479
rpcs3/Emu/SysCalls/Modules/sceNp2.cpp
View file

@ -6,79 +6,37 @@
extern Module sceNp2;
std::unique_ptr<SceNp2Internal> g_sceNp2;
s32 sceNp2Init(u32 poolsize, vm::ptr<u32> poolptr)
s32 sceNp2Init(u32 poolsize, vm::ptr<void> poolptr)
{
sceNp2.Warning("sceNp2Init(poolsize=%d, poolptr=0x%x)", poolsize, poolptr);
if (g_sceNp2->m_bSceNp2Initialized)
{
sceNp2.Error("sceNp2Init(): sceNp2 has been already initialized.");
return SCE_NP_ERROR_ALREADY_INITIALIZED;
}
sceNp2.Warning("sceNp2Init(poolsize=0x%x, poolptr=*0x%x)", poolsize, poolptr);
if (poolsize == 0)
{
sceNp2.Error("sceNp2Init(): poolsize given is 0.");
return SCE_NP_ERROR_INVALID_ARGUMENT;
}
else if (poolsize < 128 * 1024)
{
sceNp2.Error("sceNp2Init(): poolsize given is under 131072 bytes.");
return SCE_NP_ERROR_INSUFFICIENT_BUFFER;
}
if (!poolptr)
{
sceNp2.Error("sceNp2Init(): poolptr is invalid.");
return SCE_NP_ERROR_INVALID_ARGUMENT;
}
g_sceNp->m_bSceNpInitialized = true;
g_sceNp2->m_bSceNp2Initialized = true;
return CELL_OK;
}
s32 sceNpMatching2Init(u32 poolsize, s32 priority)
{
sceNp2.Todo("sceNpMatching2Init(poolsize=%d, priority=%d)", poolsize, priority);
if (!g_sceNp2->m_bSceNp2Initialized)
{
sceNp2.Error("sceNpMatching2Init(): sceNp2 has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
if (g_sceNp2->m_bSceNp2Matching2Initialized)
{
sceNp2.Error("sceNpMatching2Init(): sceNpMatching2 has already been intialized.");
return SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED;
}
g_sceNp2->m_bSceNp2Matching2Initialized = true;
sceNp2.Todo("sceNpMatching2Init(poolsize=0x%x, priority=%d)", poolsize, priority);
return CELL_OK;
}
s32 sceNpMatching2Init2(u32 poolsize, s32 priority, vm::ptr<SceNpMatching2UtilityInitParam> param)
{
sceNp2.Todo("sceNpMatching2Init2(poolsize=%d, priority=%d, param=*0x%x)", poolsize, priority, param);
if (!g_sceNp2->m_bSceNp2Initialized)
{
sceNp2.Error("sceNpMatching2Init2(): sceNp2 has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
if (g_sceNp2->m_bSceNp2Matching2Initialized2)
{
sceNp2.Error("sceNpMatching2Init2(): new sceNpMatching2 has already been intialized.");
return SCE_NP_MATCHING2_ERROR_ALREADY_INITIALIZED;
}
g_sceNp2->m_bSceNp2Matching2Initialized2 = true;
sceNp2.Todo("sceNpMatching2Init2(poolsize=0x%x, priority=%d, param=*0x%x)", poolsize, priority, param);
// TODO:
// 1. Create an internal thread
@ -92,14 +50,6 @@ s32 sceNp2Term()
{
sceNp2.Warning("sceNp2Term()");
if (!g_sceNp2->m_bSceNp2Initialized)
{
sceNp2.Error("sceNp2Term(): sceNp2 has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
g_sceNp2->m_bSceNp2Initialized = false;
return CELL_OK;
}
@ -107,20 +57,6 @@ s32 sceNpMatching2Term(PPUThread& ppu)
{
sceNp2.Warning("sceNpMatching2Term()");
if (!g_sceNp2->m_bSceNp2Initialized)
{
sceNp2.Error("sceNpMatching2Term(): sceNp2 has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
if (!g_sceNp2->m_bSceNp2Matching2Initialized)
{
sceNp2.Error("sceNpMatching2Term(): sceNpMatching2 has not been intialized.");
return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED;
}
g_sceNp2->m_bSceNp2Matching2Initialized = false;
return CELL_OK;
}
@ -128,31 +64,394 @@ s32 sceNpMatching2Term2()
{
sceNp2.Warning("sceNpMatching2Term2()");
if (!g_sceNp2->m_bSceNp2Initialized)
{
sceNp2.Error("sceNpMatching2Term2(): sceNp2 has not been intialized.");
return SCE_NP_ERROR_NOT_INITIALIZED;
}
if (!g_sceNp2->m_bSceNp2Matching2Initialized2)
{
sceNp2.Error("sceNpMatching2Term(): new sceNpMatching2 has not been intialized.");
return SCE_NP_MATCHING2_ERROR_NOT_INITIALIZED;
}
g_sceNp2->m_bSceNp2Matching2Initialized2 = false;
return CELL_OK;
}
s32 sceNpMatching2DestroyContext()
{
throw EXCEPTION("");
}
s32 sceNpMatching2LeaveLobby()
{
throw EXCEPTION("");
}
s32 sceNpMatching2RegisterLobbyMessageCallback()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetWorldInfoList()
{
throw EXCEPTION("");
}
s32 sceNpMatching2RegisterLobbyEventCallback()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetLobbyMemberDataInternalList()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SearchRoom()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SignalingGetConnectionStatus()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetUserInfo()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetClanLobbyId()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetLobbyMemberDataInternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2ContextStart()
{
throw EXCEPTION("");
}
s32 sceNpMatching2CreateServerContext()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetMemoryInfo()
{
throw EXCEPTION("");
}
s32 sceNpMatching2LeaveRoom()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetRoomDataExternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SignalingGetConnectionInfo()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SendRoomMessage()
{
throw EXCEPTION("");
}
s32 sceNpMatching2JoinLobby()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomMemberDataExternalList()
{
throw EXCEPTION("");
}
s32 sceNpMatching2AbortRequest()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetServerInfo()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetEventData()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomSlotInfoLocal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SendLobbyChatMessage()
{
throw EXCEPTION("");
}
s32 sceNpMatching2AbortContextStart()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomMemberIdListLocal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2JoinRoom()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomMemberDataInternalLocal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetCbQueueInfo()
{
throw EXCEPTION("");
}
s32 sceNpMatching2KickoutRoomMember()
{
throw EXCEPTION("");
}
s32 sceNpMatching2ContextStartAsync()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetSignalingOptParam()
{
throw EXCEPTION("");
}
s32 sceNpMatching2RegisterContextCallback()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SendRoomChatMessage()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetRoomDataInternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomDataInternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SignalingGetPingInfo()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetServerIdListLocal()
{
throw EXCEPTION("");
}
s32 sceNpUtilBuildCdnUrl()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GrantRoomOwner()
{
throw EXCEPTION("");
}
s32 sceNpMatching2CreateContext()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetSignalingOptParamLocal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2RegisterSignalingCallback()
{
throw EXCEPTION("");
}
s32 sceNpMatching2ClearEventData()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetUserInfoList()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomMemberDataInternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetRoomMemberDataInternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2JoinProhibitiveRoom()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SignalingSetCtxOpt()
{
throw EXCEPTION("");
}
s32 sceNpMatching2DeleteServerContext()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetDefaultRequestOptParam()
{
throw EXCEPTION("");
}
s32 sceNpMatching2RegisterRoomEventCallback()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomPasswordLocal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetRoomDataExternalList()
{
throw EXCEPTION("");
}
s32 sceNpMatching2CreateJoinRoom()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SignalingGetCtxOpt()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetLobbyInfoList()
{
throw EXCEPTION("");
}
s32 sceNpMatching2GetLobbyMemberIdListLocal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SendLobbyInvitation()
{
throw EXCEPTION("");
}
s32 sceNpMatching2ContextStop()
{
throw EXCEPTION("");
}
s32 sceNpMatching2SetLobbyMemberDataInternal()
{
throw EXCEPTION("");
}
s32 sceNpMatching2RegisterRoomMessageCallback()
{
throw EXCEPTION("");
}
Module sceNp2("sceNp2", []()
{
g_sceNp2 = std::make_unique<SceNp2Internal>();
REG_FUNC(sceNp2, sceNp2Init);
REG_FUNC(sceNp2, sceNpMatching2Init);
REG_FUNC(sceNp2, sceNpMatching2Init2);
REG_FUNC(sceNp2, sceNp2Term);
REG_FUNC(sceNp2, sceNpMatching2Term);
REG_FUNC(sceNp2, sceNpMatching2DestroyContext);
REG_FUNC(sceNp2, sceNpMatching2LeaveLobby);
REG_FUNC(sceNp2, sceNpMatching2RegisterLobbyMessageCallback);
REG_FUNC(sceNp2, sceNpMatching2GetWorldInfoList);
REG_FUNC(sceNp2, sceNpMatching2RegisterLobbyEventCallback);
REG_FUNC(sceNp2, sceNpMatching2GetLobbyMemberDataInternalList);
REG_FUNC(sceNp2, sceNpMatching2SearchRoom);
REG_FUNC(sceNp2, sceNpMatching2SignalingGetConnectionStatus);
REG_FUNC(sceNp2, sceNpMatching2SetUserInfo);
REG_FUNC(sceNp2, sceNpMatching2GetClanLobbyId);
REG_FUNC(sceNp2, sceNpMatching2GetLobbyMemberDataInternal);
REG_FUNC(sceNp2, sceNpMatching2ContextStart);
REG_FUNC(sceNp2, sceNpMatching2CreateServerContext);
REG_FUNC(sceNp2, sceNpMatching2GetMemoryInfo);
REG_FUNC(sceNp2, sceNpMatching2LeaveRoom);
REG_FUNC(sceNp2, sceNpMatching2SetRoomDataExternal);
REG_FUNC(sceNp2, sceNpMatching2Term2);
});
REG_FUNC(sceNp2, sceNpMatching2SignalingGetConnectionInfo);
REG_FUNC(sceNp2, sceNpMatching2SendRoomMessage);
REG_FUNC(sceNp2, sceNpMatching2JoinLobby);
REG_FUNC(sceNp2, sceNpMatching2GetRoomMemberDataExternalList);
REG_FUNC(sceNp2, sceNpMatching2AbortRequest);
REG_FUNC(sceNp2, sceNpMatching2Term);
REG_FUNC(sceNp2, sceNpMatching2GetServerInfo);
REG_FUNC(sceNp2, sceNpMatching2GetEventData);
REG_FUNC(sceNp2, sceNpMatching2GetRoomSlotInfoLocal);
REG_FUNC(sceNp2, sceNpMatching2SendLobbyChatMessage);
REG_FUNC(sceNp2, sceNpMatching2Init);
REG_FUNC(sceNp2, sceNp2Init);
REG_FUNC(sceNp2, sceNpMatching2AbortContextStart);
REG_FUNC(sceNp2, sceNpMatching2GetRoomMemberIdListLocal);
REG_FUNC(sceNp2, sceNpMatching2JoinRoom);
REG_FUNC(sceNp2, sceNpMatching2GetRoomMemberDataInternalLocal);
REG_FUNC(sceNp2, sceNpMatching2GetCbQueueInfo);
REG_FUNC(sceNp2, sceNpMatching2KickoutRoomMember);
REG_FUNC(sceNp2, sceNpMatching2ContextStartAsync);
REG_FUNC(sceNp2, sceNpMatching2SetSignalingOptParam);
REG_FUNC(sceNp2, sceNpMatching2RegisterContextCallback);
REG_FUNC(sceNp2, sceNpMatching2SendRoomChatMessage);
REG_FUNC(sceNp2, sceNpMatching2SetRoomDataInternal);
REG_FUNC(sceNp2, sceNpMatching2GetRoomDataInternal);
REG_FUNC(sceNp2, sceNpMatching2SignalingGetPingInfo);
REG_FUNC(sceNp2, sceNpMatching2GetServerIdListLocal);
REG_FUNC(sceNp2, sceNpUtilBuildCdnUrl);
REG_FUNC(sceNp2, sceNpMatching2GrantRoomOwner);
REG_FUNC(sceNp2, sceNpMatching2CreateContext);
REG_FUNC(sceNp2, sceNpMatching2GetSignalingOptParamLocal);
REG_FUNC(sceNp2, sceNpMatching2RegisterSignalingCallback);
REG_FUNC(sceNp2, sceNpMatching2ClearEventData);
REG_FUNC(sceNp2, sceNp2Term);
REG_FUNC(sceNp2, sceNpMatching2GetUserInfoList);
REG_FUNC(sceNp2, sceNpMatching2GetRoomMemberDataInternal);
REG_FUNC(sceNp2, sceNpMatching2SetRoomMemberDataInternal);
REG_FUNC(sceNp2, sceNpMatching2JoinProhibitiveRoom);
REG_FUNC(sceNp2, sceNpMatching2SignalingSetCtxOpt);
REG_FUNC(sceNp2, sceNpMatching2DeleteServerContext);
REG_FUNC(sceNp2, sceNpMatching2SetDefaultRequestOptParam);
REG_FUNC(sceNp2, sceNpMatching2RegisterRoomEventCallback);
REG_FUNC(sceNp2, sceNpMatching2GetRoomPasswordLocal);
REG_FUNC(sceNp2, sceNpMatching2GetRoomDataExternalList);
REG_FUNC(sceNp2, sceNpMatching2CreateJoinRoom);
REG_FUNC(sceNp2, sceNpMatching2SignalingGetCtxOpt);
REG_FUNC(sceNp2, sceNpMatching2GetLobbyInfoList);
REG_FUNC(sceNp2, sceNpMatching2GetLobbyMemberIdListLocal);
REG_FUNC(sceNp2, sceNpMatching2SendLobbyInvitation);
REG_FUNC(sceNp2, sceNpMatching2ContextStop);
REG_FUNC(sceNp2, sceNpMatching2Init2);
REG_FUNC(sceNp2, sceNpMatching2SetLobbyMemberDataInternal);
REG_FUNC(sceNp2, sceNpMatching2RegisterRoomMessageCallback);
});

244
rpcs3/Emu/SysCalls/Modules/sceNpClans.cpp
View file

@ -8,24 +8,15 @@
extern Module sceNpClans;
std::unique_ptr<SceNpClansInternal> g_sceNpClans;
s32 sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicationPassphrase> passphrase, vm::ptr<void> pool, vm::ptr<u32> poolSize, u32 flags)
{
sceNpClans.Warning("sceNpClansInit(commId=*0x%x, passphrase=*0x%x, pool=*0x%x, poolSize=*0x%x, flags=0x%x)", commId, passphrase, pool, poolSize, flags);
if (g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_ALREADY_INITIALIZED;
}
if (flags != 0)
{
return SCE_NP_CLANS_ERROR_NOT_SUPPORTED;
}
g_sceNpClans->m_bSceNpClansInitialized = true;
return CELL_OK;
}
@ -33,13 +24,6 @@ s32 sceNpClansTerm()
{
sceNpClans.Warning("sceNpClansTerm()");
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
g_sceNpClans->m_bSceNpClansInitialized = false;
return CELL_OK;
}
@ -47,11 +31,6 @@ s32 sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle, u64 flags)
{
sceNpClans.Todo("sceNpClansCreateRequest(handle=*0x%x, flags=0x%llx)", handle, flags);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
if (flags != 0)
{
return SCE_NP_CLANS_ERROR_NOT_SUPPORTED;
@ -63,444 +42,221 @@ s32 sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle, u64 flags)
s32 sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<char> name, vm::cptr<char> tag, vm::ptr<u32> clanId)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<SceNpClansPagingRequest> paging, vm::ptr<SceNpClansEntry> clanList, vm::ptr<SceNpClansPagingResult> pageResult)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetClanListByNpId()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansSearchByProfile()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansSearchByName()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetClanInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansUpdateClanInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetMemberList()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetMemberInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansUpdateMemberInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansChangeMemberRole()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetAutoAcceptStatus()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansUpdateAutoAcceptStatus()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansJoinClan()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansLeaveClan()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansKickMember(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<u32> npid, vm::ptr<SceNpClansMessage> message)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansSendInvitation(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<u32> npid, vm::ptr<SceNpClansMessage> message)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansCancelInvitation()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansSendInvitationResponse(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<SceNpClansMessage> message, b8 accept)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansSendMembershipRequest(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<SceNpClansMessage> message)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansCancelMembershipRequest()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansSendMembershipResponse()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansGetBlacklist()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansAddBlacklistEntry()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansRemoveBlacklistEntry()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansRetrieveAnnouncements()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansPostAnnouncement()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansRemoveAnnouncement()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansPostChallenge(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, u32 targetClan, vm::ptr<SceNpClansMessage> message, vm::ptr<SceNpClansMessageData> data, u32 duration, vm::ptr<u32> mId)
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
if (data)
{
return SCE_NP_CLANS_ERROR_NOT_SUPPORTED;
}
return CELL_OK;
}
s32 sceNpClansRetrievePostedChallenges()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansRemovePostedChallenge()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansRetrieveChallenges()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpClansRemoveChallenge()
{
UNIMPLEMENTED_FUNC(sceNpClans);
if (!g_sceNpClans->m_bSceNpClansInitialized)
{
return SCE_NP_CLANS_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
Module sceNpClans("sceNpClans", []()
{
g_sceNpClans = std::make_unique<SceNpClansInternal>();
REG_FUNC(sceNpClans, sceNpClansInit);
REG_FUNC(sceNpClans, sceNpClansTerm);
REG_FUNC(sceNpClans, sceNpClansCreateRequest);

14
rpcs3/Emu/SysCalls/Modules/sceNpClans.h
View file

@ -60,18 +60,6 @@ enum
SCE_NP_CLANS_SERVER_ERROR_FAILED_TO_SEND_NP_MESSAGE = 0x8002284c,
};
struct SceNpClansInternal
{
bool m_bSceNpClansInitialized;
SceNpClansInternal()
: m_bSceNpClansInitialized(false)
{
}
};
extern SceNpClansInternal* sceNpClansInstance;
// Clan roles
enum
{
@ -263,4 +251,4 @@ struct SceNpClansBlacklistEntry
{
SceNpId entry;
SceNpId registeredBy;
};
};

49
rpcs3/Emu/SysCalls/Modules/sceNpCommerce2.cpp
View file

@ -6,8 +6,6 @@
extern Module sceNpCommerce2;
std::unique_ptr<SceNpCommerce2Internal> g_sceNpCommerce2;
s32 sceNpCommerce2ExecuteStoreBrowse()
{
UNIMPLEMENTED_FUNC(sceNpCommerce2);
@ -24,13 +22,6 @@ s32 sceNpCommerce2Init()
{
sceNpCommerce2.Warning("sceNpCommerce2Init()");
if (g_sceNpCommerce2->m_bSceNpCommerce2Initialized)
{
return SCE_NP_COMMERCE2_ERROR_ALREADY_INITIALIZED;
}
g_sceNpCommerce2->m_bSceNpCommerce2Initialized = true;
return CELL_OK;
}
@ -38,13 +29,6 @@ s32 sceNpCommerce2Term()
{
sceNpCommerce2.Warning("sceNpCommerce2Term()");
if (!g_sceNpCommerce2->m_bSceNpCommerce2Initialized)
{
return SCE_NP_COMMERCE2_ERROR_NOT_INITIALIZED;
}
g_sceNpCommerce2->m_bSceNpCommerce2Initialized = false;
return CELL_OK;
}
@ -60,6 +44,21 @@ s32 sceNpCommerce2DestroyCtx()
return CELL_OK;
}
s32 sceNpCommerce2EmptyStoreCheckStart()
{
throw EXCEPTION("");
}
s32 sceNpCommerce2EmptyStoreCheckAbort()
{
throw EXCEPTION("");
}
s32 sceNpCommerce2EmptyStoreCheckFinish()
{
throw EXCEPTION("");
}
s32 sceNpCommerce2CreateSessionStart()
{
UNIMPLEMENTED_FUNC(sceNpCommerce2);
@ -306,16 +305,27 @@ s32 sceNpCommerce2DestroyReq()
return CELL_OK;
}
s32 sceNpCommerce2DoServiceListStartAsync()
{
throw EXCEPTION("");
}
s32 sceNpCommerce2DoServiceListFinishAsync()
{
throw EXCEPTION("");
}
Module sceNpCommerce2("sceNpCommerce2", []()
{
g_sceNpCommerce2 = std::make_unique<SceNpCommerce2Internal>();
REG_FUNC(sceNpCommerce2, sceNpCommerce2ExecuteStoreBrowse);
REG_FUNC(sceNpCommerce2, sceNpCommerce2GetStoreBrowseUserdata);
REG_FUNC(sceNpCommerce2, sceNpCommerce2Init);
REG_FUNC(sceNpCommerce2, sceNpCommerce2Term);
REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateCtx);
REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyCtx);
REG_FUNC(sceNpCommerce2, sceNpCommerce2EmptyStoreCheckStart);
REG_FUNC(sceNpCommerce2, sceNpCommerce2EmptyStoreCheckAbort);
REG_FUNC(sceNpCommerce2, sceNpCommerce2EmptyStoreCheckFinish);
REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateSessionStart);
REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateSessionAbort);
REG_FUNC(sceNpCommerce2, sceNpCommerce2CreateSessionFinish);
@ -357,4 +367,7 @@ Module sceNpCommerce2("sceNpCommerce2", []()
REG_FUNC(sceNpCommerce2, sceNpCommerce2SetBGDLAvailability);
REG_FUNC(sceNpCommerce2, sceNpCommerce2AbortReq);
REG_FUNC(sceNpCommerce2, sceNpCommerce2DestroyReq);
REG_FUNC(sceNpCommerce2, sceNpCommerce2DoServiceListStartAsync);
REG_FUNC(sceNpCommerce2, sceNpCommerce2DoServiceListFinishAsync);
});

14
rpcs3/Emu/SysCalls/Modules/sceNpCommerce2.h
View file

@ -132,18 +132,6 @@ enum
SCE_NP_COMMERCE2_DO_PRODUCT_CODE_MEMORY_CONTAINER_SIZE = 16777216,
};
struct SceNpCommerce2Internal
{
bool m_bSceNpCommerce2Initialized;
SceNpCommerce2Internal()
: m_bSceNpCommerce2Initialized(false)
{
}
};
extern std::unique_ptr<SceNpCommerce2Internal> g_sceNpCommerce2;
// Common structure used when receiving data
struct SceNpCommerce2CommonData
{
@ -288,4 +276,4 @@ struct SceNpCommerce2ProductCodeParam
s8 padding3[3];
};
typedef void(*SceNpCommerce2Handler)(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, u32 arg);
using SceNpCommerce2Handler = void(u32 ctx_id, u32 subject_id, s32 event, s32 error_code, vm::ptr<void> arg);

72
rpcs3/Emu/SysCalls/Modules/sceNpSns.cpp
View file

@ -5,18 +5,9 @@
extern Module sceNpSns;
std::unique_ptr<SceNpSnsInternal> g_sceNpSns;
s32 sceNpSnsFbInit(/*const SceNpSnsFbInitParams params*/)
s32 sceNpSnsFbInit(vm::ptr<const SceNpSnsFbInitParams> params)
{
sceNpSns.Todo("sceNpSnsFbInit(params=?)"/*, params*/);
if (g_sceNpSns->m_bSceNpSnsInitialized)
{
return SCE_NP_SNS_FB_ERROR_ALREADY_INITIALIZED;
}
g_sceNpSns->m_bSceNpSnsInitialized = true;
sceNpSns.Todo("sceNpSnsFbInit(params=*0x%x)", params);
// TODO: Use the initialization parameters somewhere
@ -27,72 +18,65 @@ s32 sceNpSnsFbTerm()
{
sceNpSns.Warning("sceNpSnsFbTerm()");
if (!g_sceNpSns->m_bSceNpSnsInitialized)
{
return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED;
}
g_sceNpSns->m_bSceNpSnsInitialized = false;
return CELL_OK;
}
s32 sceNpSnsFbCreateHandle()
{
UNIMPLEMENTED_FUNC(sceNpSns);
if (!g_sceNpSns->m_bSceNpSnsInitialized)
{
return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpSnsFbDestroyHandle()
{
UNIMPLEMENTED_FUNC(sceNpSns);
if (!g_sceNpSns->m_bSceNpSnsInitialized)
{
return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpSnsFbAbortHandle()
{
UNIMPLEMENTED_FUNC(sceNpSns);
if (!g_sceNpSns->m_bSceNpSnsInitialized)
{
return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpSnsFbGetAccessToken()
{
UNIMPLEMENTED_FUNC(sceNpSns);
if (!g_sceNpSns->m_bSceNpSnsInitialized)
{
return SCE_NP_SNS_FB_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpSnsFbStreamPublish()
{
throw EXCEPTION("");
}
s32 sceNpSnsFbCheckThrottle()
{
throw EXCEPTION("");
}
s32 sceNpSnsFbCheckConfig()
{
throw EXCEPTION("");
}
s32 sceNpSnsFbLoadThrottle()
{
throw EXCEPTION("");
}
Module sceNpSns("sceNpSns", []()
{
g_sceNpSns = std::make_unique<SceNpSnsInternal>();
REG_FUNC(sceNpSns, sceNpSnsFbInit);
REG_FUNC(sceNpSns, sceNpSnsFbTerm);
REG_FUNC(sceNpSns, sceNpSnsFbCreateHandle);
REG_FUNC(sceNpSns, sceNpSnsFbDestroyHandle);
REG_FUNC(sceNpSns, sceNpSnsFbAbortHandle);
REG_FUNC(sceNpSns, sceNpSnsFbGetAccessToken);
REG_FUNC(sceNpSns, sceNpSnsFbStreamPublish);
REG_FUNC(sceNpSns, sceNpSnsFbCheckThrottle);
REG_FUNC(sceNpSns, sceNpSnsFbCheckConfig);
REG_FUNC(sceNpSns, sceNpSnsFbLoadThrottle);
});

16
rpcs3/Emu/SysCalls/Modules/sceNpSns.h
View file

@ -25,18 +25,6 @@ enum
SCE_NP_SNS_FB_ERROR_ACCESS_NOT_ALLOWED = 0x8002451c,
};
struct SceNpSnsInternal
{
bool m_bSceNpSnsInitialized;
SceNpSnsInternal()
: m_bSceNpSnsInitialized(false)
{
}
};
extern std::unique_ptr<SceNpSnsInternal> g_sceNpSns;
// Constants for SNS functions
enum
{
@ -47,6 +35,6 @@ enum
// Intilization parameters for functionalities coordinated with Facebook
struct SceNpSnsFbInitParams
{
be_t<u32> pool;
vm::bptr<void> pool;
be_t<u32> poolSize;
};
};

93
rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
View file

@ -40,20 +40,11 @@ struct trophy_handle_t
}
};
std::unique_ptr<SceNpTrophyInternal> g_sceNpTrophy;
// Functions
s32 sceNpTrophyInit(vm::ptr<void> pool, u32 poolSize, u32 containerId, u64 options)
{
sceNpTrophy.Warning("sceNpTrophyInit(pool=*0x%x, poolSize=0x%x, containerId=0x%x, options=0x%llx)", pool, poolSize, containerId, options);
if (g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_ALREADY_INITIALIZED;
}
g_sceNpTrophy->m_bInitialized = true;
return CELL_OK;
}
@ -61,13 +52,6 @@ s32 sceNpTrophyTerm()
{
sceNpTrophy.Warning("sceNpTrophyTerm()");
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
g_sceNpTrophy->m_bInitialized = false;
return CELL_OK;
}
@ -75,11 +59,6 @@ s32 sceNpTrophyCreateHandle(vm::ptr<u32> handle)
{
sceNpTrophy.Warning("sceNpTrophyCreateHandle(handle=*0x%x)", handle);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
if (!handle)
{
return SCE_NP_TROPHY_ERROR_INVALID_ARGUMENT;
@ -94,11 +73,6 @@ s32 sceNpTrophyDestroyHandle(u32 handle)
{
sceNpTrophy.Warning("sceNpTrophyDestroyHandle(handle=0x%x)", handle);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto hndl = Emu.GetIdManager().get<trophy_handle_t>(handle);
if (!hndl)
@ -115,11 +89,6 @@ s32 sceNpTrophyAbortHandle(u32 handle)
{
sceNpTrophy.Todo("sceNpTrophyAbortHandle(handle=0x%x)", handle);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto hndl = Emu.GetIdManager().get<trophy_handle_t>(handle);
if (!hndl)
@ -134,11 +103,6 @@ s32 sceNpTrophyCreateContext(vm::ptr<u32> context, vm::cptr<SceNpCommunicationId
{
sceNpTrophy.Warning("sceNpTrophyCreateContext(context=*0x%x, commId=*0x%x, commSign=*0x%x, options=0x%llx)", context, commId, commSign, options);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
// rough checks for further fmt::format call
if (commId->term || commId->num > 99)
{
@ -172,11 +136,6 @@ s32 sceNpTrophyDestroyContext(u32 context)
{
sceNpTrophy.Warning("sceNpTrophyDestroyContext(context=0x%x)", context);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -193,11 +152,6 @@ s32 sceNpTrophyRegisterContext(PPUThread& CPU, u32 context, u32 handle, vm::ptr<
{
sceNpTrophy.Error("sceNpTrophyRegisterContext(context=0x%x, handle=0x%x, statusCb=*0x%x, arg=*0x%x, options=0x%llx)", context, handle, statusCb, arg, options);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -278,11 +232,6 @@ s32 sceNpTrophyGetRequiredDiskSpace(u32 context, u32 handle, vm::ptr<u64> reqspa
{
sceNpTrophy.Todo("sceNpTrophyGetRequiredDiskSpace(context=0x%x, handle=0x%x, reqspace*=0x%x, options=0x%llx)", context, handle, reqspace, options);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -307,11 +256,6 @@ s32 sceNpTrophySetSoundLevel(u32 context, u32 handle, u32 level, u64 options)
{
sceNpTrophy.Todo("sceNpTrophySetSoundLevel(context=0x%x, handle=0x%x, level=%d, options=0x%llx)", context, handle, level, options);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -319,11 +263,6 @@ s32 sceNpTrophyGetGameInfo(u32 context, u32 handle, vm::ptr<SceNpTrophyGameDetai
{
sceNpTrophy.Error("sceNpTrophyGetGameInfo(context=0x%x, handle=0x%x, details=*0x%x, data=*0x%x)", context, handle, details, data);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -385,11 +324,6 @@ s32 sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, vm::ptr<u32>
{
sceNpTrophy.Error("sceNpTrophyUnlockTrophy(context=0x%x, handle=0x%x, trophyId=%d, platinumId=*0x%x)", context, handle, trophyId, platinumId);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -421,11 +355,6 @@ s32 sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, vm::ptr<SceNpTrophy
{
sceNpTrophy.Error("sceNpTrophyGetTrophyUnlockState(context=0x%x, handle=0x%x, flags=*0x%x, count=*0x%x)", context, handle, flags, count);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -461,11 +390,6 @@ s32 sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceN
{
sceNpTrophy.Warning("sceNpTrophyGetTrophyInfo(context=0x%x, handle=0x%x, trophyId=%d, details=*0x%x, data=*0x%x)", context, handle, trophyId, details, data);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
const auto ctxt = Emu.GetIdManager().get<trophy_context_t>(context);
if (!ctxt)
@ -523,11 +447,6 @@ s32 sceNpTrophyGetGameProgress(u32 context, u32 handle, vm::ptr<s32> percentage)
{
sceNpTrophy.Todo("sceNpTrophyGetGameProgress(context=0x%x, handle=0x%x, percentage=*0x%x)", context, handle, percentage);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -535,11 +454,6 @@ s32 sceNpTrophyGetGameIcon(u32 context, u32 handle, vm::ptr<void> buffer, vm::pt
{
sceNpTrophy.Todo("sceNpTrophyGetGameIcon(context=0x%x, handle=0x%x, buffer=*0x%x, size=*0x%x)", context, handle, buffer, size);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
@ -547,19 +461,12 @@ s32 sceNpTrophyGetTrophyIcon(u32 context, u32 handle, s32 trophyId, vm::ptr<void
{
sceNpTrophy.Todo("sceNpTrophyGetTrophyIcon(context=0x%x, handle=0x%x, trophyId=%d, buffer=*0x%x, size=*0x%x)", context, handle, trophyId, buffer, size);
if (!g_sceNpTrophy->m_bInitialized)
{
return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
Module sceNpTrophy("sceNpTrophy", []()
{
g_sceNpTrophy = std::make_unique<SceNpTrophyInternal>();
REG_FUNC(sceNpTrophy, sceNpTrophyGetGameProgress);
REG_FUNC(sceNpTrophy, sceNpTrophyRegisterContext);
REG_FUNC(sceNpTrophy, sceNpTrophyCreateHandle);

12
rpcs3/Emu/SysCalls/Modules/sceNpTrophy.h
View file

@ -75,18 +75,6 @@ enum SceNpTrophyGrade
SCE_NP_TROPHY_GRADE_BRONZE = 4,
};
struct SceNpTrophyInternal
{
bool m_bInitialized;
SceNpTrophyInternal()
: m_bInitialized(false)
{
}
};
extern std::unique_ptr<SceNpTrophyInternal> g_sceNpTrophy;
struct SceNpTrophyGameDetails
{
be_t<u32> numTrophies;

330
rpcs3/Emu/SysCalls/Modules/sceNpTus.cpp
View file

@ -7,32 +7,16 @@
extern Module sceNpTus;
std::unique_ptr<SceNpTusInternal> g_sceNpTus;
s32 sceNpTusInit()
{
sceNpTus.Warning("sceNpTusInit()");
if (g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_ALREADY_INITIALIZED;
}
g_sceNpTus->m_bSceNpTusInitialized = true;
return CELL_OK;
}
s32 sceNpTusTerm()
{
sceNpTus.Warning("sceNpTusTerm()");
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
g_sceNpTus->m_bSceNpTusInitialized = false;
return CELL_OK;
}
@ -40,631 +24,317 @@ s32 sceNpTusTerm()
s32 sceNpTusCreateTitleCtx()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDestroyTitleCtx()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusCreateTransactionCtx()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDestroyTransactionCtx()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetTimeout()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusAbortTransaction()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusWaitAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusPollAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetMultiSlotVariable()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetMultiSlotVariableVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetMultiSlotVariableAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetMultiSlotVariableVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotVariable()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotVariableVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotVariableAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotVariableVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserVariable()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserVariableVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserVariableAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserVariableVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusAddAndGetVariable()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusAddAndGetVariableVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusAddAndGetVariableAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusAddAndGetVariableVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusTryAndSetVariable()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusTryAndSetVariableVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusTryAndSetVariableAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusTryAndSetVariableVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotVariable()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotVariableVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotVariableAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotVariableVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetData()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetDataVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetDataAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusSetDataVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetData()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetDataVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetDataAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetDataVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotDataStatus()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotDataStatusVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotDataStatusAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiSlotDataStatusVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserDataStatus()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserDataStatusVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserDataStatusAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusGetMultiUserDataStatusVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotData()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotDataVUser()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotDataAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpTusDeleteMultiSlotDataVUserAsync()
{
UNIMPLEMENTED_FUNC(sceNpTus);
if (!g_sceNpTus->m_bSceNpTusInitialized)
{
return SCE_NP_COMMUNITY_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
Module sceNpTus("sceNpTus", []()
{
g_sceNpTus = std::make_unique<SceNpTusInternal>();
REG_FUNC(sceNpTus, sceNpTusInit);
REG_FUNC(sceNpTus, sceNpTusTerm);
REG_FUNC(sceNpTus, sceNpTusCreateTitleCtx);

12
rpcs3/Emu/SysCalls/Modules/sceNpTus.h
View file

@ -13,18 +13,6 @@ enum
SCE_NP_TUS_MAX_USER_NUM_PER_TRANS = 101,
};
struct SceNpTusInternal
{
bool m_bSceNpTusInitialized;
SceNpTusInternal()
: m_bSceNpTusInitialized(false)
{
}
};
extern std::unique_ptr<SceNpTusInternal> g_sceNpTus;
SceNpOnlineId SceNpTusVirtualUserId;
// Structure for representing a TUS variable

48
rpcs3/Emu/SysCalls/Modules/sceNpUtil.cpp
View file

@ -7,80 +7,34 @@
extern Module sceNpUtil;
std::unique_ptr<SceNpUtilInternal> g_sceNpUtil;
s32 sceNpUtilCmpNpId()
{
UNIMPLEMENTED_FUNC(sceNpUtil);
return CELL_OK;
}
s32 sceNpUtilCmpNpIdInOrder()
{
UNIMPLEMENTED_FUNC(sceNpUtil);
return CELL_OK;
}
s32 sceNpUtilBandwidthTestInitStart(u32 prio, size_t stack)
{
UNIMPLEMENTED_FUNC(sceNpUtil);
if (g_sceNpUtil->m_bSceNpUtilBandwidthTestInitialized)
{
return SCE_NP_ERROR_ALREADY_INITIALIZED;
}
g_sceNpUtil->m_bSceNpUtilBandwidthTestInitialized = true;
return CELL_OK;
}
s32 sceNpUtilBandwidthTestGetStatus()
{
UNIMPLEMENTED_FUNC(sceNpUtil);
if (!g_sceNpUtil->m_bSceNpUtilBandwidthTestInitialized)
{
return SCE_NP_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
s32 sceNpUtilBandwidthTestShutdown()
{
UNIMPLEMENTED_FUNC(sceNpUtil);
if (!g_sceNpUtil->m_bSceNpUtilBandwidthTestInitialized)
{
return SCE_NP_ERROR_NOT_INITIALIZED;
}
g_sceNpUtil->m_bSceNpUtilBandwidthTestInitialized = false;
return CELL_OK;
}
s32 sceNpUtilBandwidthTestAbort()
{
UNIMPLEMENTED_FUNC(sceNpUtil);
if (!g_sceNpUtil->m_bSceNpUtilBandwidthTestInitialized)
{
return SCE_NP_ERROR_NOT_INITIALIZED;
}
return CELL_OK;
}
Module sceNpUtil("sceNpUtil", []()
{
g_sceNpUtil = std::make_unique<SceNpUtilInternal>();
REG_FUNC(sceNpUtil, sceNpUtilBandwidthTestInitStart);
REG_FUNC(sceNpUtil, sceNpUtilBandwidthTestShutdown);
REG_FUNC(sceNpUtil, sceNpUtilCmpNpId);
REG_FUNC(sceNpUtil, sceNpUtilCmpNpIdInOrder);
REG_FUNC(sceNpUtil, sceNpUtilBandwidthTestGetStatus);
REG_FUNC(sceNpUtil, sceNpUtilBandwidthTestAbort);
});
});

12
rpcs3/Emu/SysCalls/Modules/sceNpUtil.h
View file

@ -1,13 +1 @@
#pragma once
struct SceNpUtilInternal
{
bool m_bSceNpUtilBandwidthTestInitialized;
SceNpUtilInternal()
: m_bSceNpUtilBandwidthTestInitialized(false)
{
}
};
extern std::unique_ptr<SceNpUtilInternal> g_sceNpUtil;