archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-04 05:51:27 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

sys_lv2dbg added, bugfix

Browse source
This commit is contained in:
Nekotekina 2015-07-09 18:30:37 +03:00
parent daa93a7226
commit 4bacfcf847
46 changed files with 1484 additions and 1205 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Utilities/Thread.cpp
View file

@ -1330,11 +1330,13 @@ void thread_t::detach()
// +clear m_thread // +clear m_thread
const auto ctrl = std::move(m_thread); const auto ctrl = std::move(m_thread);
// notify if detached by another thread
if (g_tls_this_thread != m_thread.get())
{ {
// lock for reliable notification // lock for reliable notification
std::lock_guard<std::mutex> lock(mutex); std::lock_guard<std::mutex> lock(mutex);
cv.notify_all(); cv.notify_one();
} }
ctrl->m_thread.detach(); ctrl->m_thread.detach();
@ -1359,7 +1361,7 @@ void thread_t::join()
// lock for reliable notification // lock for reliable notification
std::lock_guard<std::mutex> lock(mutex); std::lock_guard<std::mutex> lock(mutex);
cv.notify_all(); cv.notify_one();
} }
ctrl->m_thread.join(); ctrl->m_thread.join();

9
rpcs3/Emu/Cell/PPUThread.cpp
View file

@ -497,7 +497,14 @@ PPUThread::PPUThread(const std::string& name)
PPUThread::~PPUThread() PPUThread::~PPUThread()
{ {
join(); if (is_current())
{
detach();
}
else
{
join();
}
CloseStack(); CloseStack();
ppu_free_tls(m_id); ppu_free_tls(m_id);

12
rpcs3/Emu/Cell/PPUThread.h
View file

@ -19,18 +19,6 @@ enum
CR_SO = 0x1, CR_SO = 0x1,
}; };
enum
{
PPU_THREAD_STATUS_IDLE = (1 << 0),
PPU_THREAD_STATUS_RUNNABLE = (1 << 1),
PPU_THREAD_STATUS_ONPROC = (1 << 2),
PPU_THREAD_STATUS_SLEEP = (1 << 3),
PPU_THREAD_STATUS_STOP = (1 << 4),
PPU_THREAD_STATUS_ZOMBIE = (1 << 5),
PPU_THREAD_STATUS_DELETED = (1 << 6),
PPU_THREAD_STATUS_UNKNOWN = (1 << 7),
};
enum FPSCR_EXP enum FPSCR_EXP
{ {
FPSCR_FX = 0x80000000, FPSCR_FX = 0x80000000,

3
rpcs3/Emu/SysCalls/ModuleManager.cpp
View file

@ -55,6 +55,7 @@ extern Module sys_io;
extern Module sys_net; extern Module sys_net;
extern Module sysPrxForUser; extern Module sysPrxForUser;
extern Module sys_libc; extern Module sys_libc;
extern Module sys_lv2dbg;
struct ModuleInfo struct ModuleInfo
{ {
@ -107,7 +108,7 @@ static const g_module_list[] =
{ 0x0028, "cellAdecAtx", nullptr }, { 0x0028, "cellAdecAtx", nullptr },
{ 0x0029, "cellAdecAt3", nullptr }, { 0x0029, "cellAdecAt3", nullptr },
{ 0x002a, "cellDmuxPamf", nullptr }, { 0x002a, "cellDmuxPamf", nullptr },
{ 0x002e, "cellLv2dbg", nullptr }, { 0x002e, "sys_lv2dbg", &sys_lv2dbg },
{ 0x0030, "cellUsbpspcm", nullptr }, { 0x0030, "cellUsbpspcm", nullptr },
{ 0x0031, "cellAvconfExt", &cellAvconfExt }, { 0x0031, "cellAvconfExt", &cellAvconfExt },
{ 0x0032, "cellUserInfo", &cellUserInfo }, { 0x0032, "cellUserInfo", &cellUserInfo },

94
rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
View file

@ -7,44 +7,40 @@ extern Module cellAtrac;
#include "cellAtrac.h" #include "cellAtrac.h"
s32 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte) s32 cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<u32> puiWorkMemByte)
{ {
cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)", cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte=*0x%x)", pHandle, pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte);
pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
*puiWorkMemByte = 0x1000; // unproved *puiWorkMemByte = 0x1000;
return CELL_OK; return CELL_OK;
} }
s32 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) s32 cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
{ {
cellAtrac.Warning("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", cellAtrac.Warning("cellAtracCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority);
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
pHandle->data.pucWorkMem_addr = pucWorkMem_addr; pHandle->pucWorkMem = pucWorkMem;
return CELL_OK; return CELL_OK;
} }
s32 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes) s32 cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucWorkMem, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes)
{ {
cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)", cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes);
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr());
pHandle->data.pucWorkMem_addr = pucWorkMem_addr; pHandle->pucWorkMem = pucWorkMem;
return CELL_OK; return CELL_OK;
} }
s32 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle) s32 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
{ {
cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr()); cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=*0x%x)", pHandle);
return CELL_OK; return CELL_OK;
} }
s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<u32> piRemainFrame) s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, vm::ptr<float> pfOutAddr, vm::ptr<u32> puiSamples, vm::ptr<u32> puiFinishflag, vm::ptr<s32> piRemainFrame)
{ {
cellAtrac.Warning("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)", cellAtrac.Warning("cellAtracDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame);
pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
*puiSamples = 0; *puiSamples = 0;
*puiFinishflag = 1; *puiFinishflag = 1;
@ -52,12 +48,11 @@ s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition) s32 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::pptr<u8> ppucWritePointer, vm::ptr<u32> puiWritableByte, vm::ptr<u32> puiReadPosition)
{ {
cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)", cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition);
pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
*ppucWritePointer = pHandle->data.pucWorkMem_addr; *ppucWritePointer = pHandle->pucWorkMem;
*puiWritableByte = 0x1000; *puiWritableByte = 0x1000;
*puiReadPosition = 0; *puiReadPosition = 0;
return CELL_OK; return CELL_OK;
@ -65,14 +60,14 @@ s32 cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> pp
s32 cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte) s32 cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte)
{ {
cellAtrac.Warning("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte); cellAtrac.Warning("cellAtracAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte);
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piRemainFrame) s32 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piRemainFrame)
{ {
cellAtrac.Warning("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr()); cellAtrac.Warning("cellAtracGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame);
*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY; *piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
return CELL_OK; return CELL_OK;
@ -80,7 +75,7 @@ s32 cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piRem
s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize) s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVacantSize)
{ {
cellAtrac.Warning("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr()); cellAtrac.Warning("cellAtracGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize);
*puiVacantSize = 0x1000; *puiVacantSize = 0x1000;
return CELL_OK; return CELL_OK;
@ -88,32 +83,30 @@ s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVac
s32 cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle) s32 cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle)
{ {
cellAtrac.Warning("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr()); cellAtrac.Warning("cellAtracIsSecondBufferNeeded(pHandle=*0x%x)", pHandle);
return CELL_OK; return 0;
} }
s32 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte) s32 cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiReadPosition, vm::ptr<u32> puiDataByte)
{ {
cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)", cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte);
pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr());
*puiReadPosition = 0; *puiReadPosition = 0;
*puiDataByte = 0; // write to null block will occur *puiDataByte = 0; // write to null block will occur
return CELL_OK; return CELL_OK;
} }
s32 cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte) s32 cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u8> pucSecondBufferAddr, u32 uiSecondBufferByte)
{ {
cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)", cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte);
pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte);
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel) s32 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChannel)
{ {
cellAtrac.Warning("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr()); cellAtrac.Warning("cellAtracGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel);
*puiChannel = 2; *puiChannel = 2;
return CELL_OK; return CELL_OK;
@ -121,7 +114,7 @@ s32 cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiChanne
s32 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample) s32 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxSample)
{ {
cellAtrac.Warning("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr()); cellAtrac.Warning("cellAtracGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample);
*puiMaxSample = 512; *puiMaxSample = 512;
return CELL_OK; return CELL_OK;
@ -129,16 +122,15 @@ s32 cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiMaxS
s32 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample) s32 cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiNextSample)
{ {
cellAtrac.Warning("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr()); cellAtrac.Warning("cellAtracGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample);
*puiNextSample = 0; *puiNextSample = 0;
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSample, vm::ptr<u32> piLoopStartSample, vm::ptr<u32> piLoopEndSample) s32 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piEndSample, vm::ptr<s32> piLoopStartSample, vm::ptr<s32> piLoopEndSample)
{ {
cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)", cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample);
pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
*piEndSample = 0; *piEndSample = 0;
*piLoopStartSample = 0; *piLoopStartSample = 0;
@ -148,8 +140,7 @@ s32 cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piEndSa
s32 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition) s32 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiSamplePosition)
{ {
cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)", cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition);
pHandle.addr(), puiSamplePosition.addr());
*puiSamplePosition = 0; *puiSamplePosition = 0;
return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED; return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED;
@ -157,36 +148,33 @@ s32 cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32
s32 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate) s32 cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiBitrate)
{ {
cellAtrac.Warning("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)", cellAtrac.Warning("cellAtracGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate);
pHandle.addr(), puiBitrate.addr());
*puiBitrate = 128; *puiBitrate = 128;
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piLoopNum, vm::ptr<u32> puiLoopStatus) s32 cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piLoopNum, vm::ptr<u32> puiLoopStatus)
{ {
cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)", cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus);
pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr());
*piLoopNum = 0; *piLoopNum = 0;
*puiLoopStatus = 0; *puiLoopStatus = 0;
return CELL_OK; return CELL_OK;
} }
s32 cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, int iLoopNum) s32 cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, s32 iLoopNum)
{ {
cellAtrac.Warning("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum); cellAtrac.Warning("cellAtracSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum);
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo) s32 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo)
{ {
cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)", cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo);
pHandle.addr(), uiSample, pBufferInfo.addr());
pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr; pBufferInfo->pucWriteAddr = pHandle->pucWorkMem;
pBufferInfo->uiWritableByte = 0x1000; pBufferInfo->uiWritableByte = 0x1000;
pBufferInfo->uiMinWriteByte = 0; pBufferInfo->uiMinWriteByte = 0;
pBufferInfo->uiReadPosition = 0; pBufferInfo->uiReadPosition = 0;
@ -195,16 +183,14 @@ s32 cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiS
s32 cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte) s32 cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
{ {
cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)", cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x)", pHandle, uiSample, uiWriteByte);
pHandle.addr(), uiSample, uiWriteByte);
return CELL_OK; return CELL_OK;
} }
s32 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> piResult) s32 cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<s32> piResult)
{ {
cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)", cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult);
pHandle.addr(), piResult.addr());
*piResult = 0; *piResult = 0;
return CELL_OK; return CELL_OK;

20
rpcs3/Emu/SysCalls/Modules/cellAtrac.h
View file

@ -55,26 +55,24 @@ enum
}; };
// Remain Frame // Remain Frame
enum enum : s32
{ {
CELL_ATRAC_ALLDATA_IS_ON_MEMORY = -1, CELL_ATRAC_ALLDATA_IS_ON_MEMORY = -1,
CELL_ATRAC_NONLOOP_STREAM_DATA_IS_ON_MEMORY = -2, CELL_ATRAC_NONLOOP_STREAM_DATA_IS_ON_MEMORY = -2,
CELL_ATRAC_LOOP_STREAM_DATA_IS_ON_MEMORY = -3, CELL_ATRAC_LOOP_STREAM_DATA_IS_ON_MEMORY = -3,
}; };
union CellAtracHandle union CellAtracHandle
{ {
u8 uiWorkMem[512]; vm::ptr<u8> pucWorkMem;
// ...
struct AtracHandle
{
u32 pucWorkMem_addr;
} data;
}; };
CHECK_MAX_SIZE(CellAtracHandle, 512);
struct CellAtracBufferInfo struct CellAtracBufferInfo
{ {
be_t<u32> pucWriteAddr; vm::ptr<u8> pucWriteAddr;
be_t<u32> uiWritableByte; be_t<u32> uiWritableByte;
be_t<u32> uiMinWriteByte; be_t<u32> uiMinWriteByte;
be_t<u32> uiReadPosition; be_t<u32> uiReadPosition;
@ -82,6 +80,6 @@ struct CellAtracBufferInfo
struct CellAtracExtRes struct CellAtracExtRes
{ {
be_t<u32> pSpurs_addr; vm::ptr<struct CellSpurs> pSpurs;
u8 priority[8]; u8 priority[8];
}; };

92
rpcs3/Emu/SysCalls/Modules/cellFiber.cpp
View file

@ -7,73 +7,73 @@
extern Module cellFiber; extern Module cellFiber;
int _cellFiberPpuInitialize() s32 _cellFiberPpuInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int _cellFiberPpuSchedulerAttributeInitialize() s32 _cellFiberPpuSchedulerAttributeInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuInitializeScheduler() s32 cellFiberPpuInitializeScheduler()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuFinalizeScheduler() s32 cellFiberPpuFinalizeScheduler()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuRunFibers() s32 cellFiberPpuRunFibers()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuCheckFlags() s32 cellFiberPpuCheckFlags()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuHasRunnableFiber() s32 cellFiberPpuHasRunnableFiber()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int _cellFiberPpuAttributeInitialize() s32 _cellFiberPpuAttributeInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuCreateFiber() s32 cellFiberPpuCreateFiber()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuExit() s32 cellFiberPpuExit()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuYield() s32 cellFiberPpuYield()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuJoinFiber() s32 cellFiberPpuJoinFiber()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
@ -87,205 +87,205 @@ vm::ptr<void> cellFiberPpuSelf()
return vm::null; return vm::null;
} }
int cellFiberPpuSendSignal() s32 cellFiberPpuSendSignal()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuWaitSignal() s32 cellFiberPpuWaitSignal()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuWaitFlag() s32 cellFiberPpuWaitFlag()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuGetScheduler() s32 cellFiberPpuGetScheduler()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuSetPriority() s32 cellFiberPpuSetPriority()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuCheckStackLimit() s32 cellFiberPpuCheckStackLimit()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int _cellFiberPpuContextAttributeInitialize() s32 _cellFiberPpuContextAttributeInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextInitialize() s32 cellFiberPpuContextInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextFinalize() s32 cellFiberPpuContextFinalize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextRun() s32 cellFiberPpuContextRun()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextSwitch() s32 cellFiberPpuContextSwitch()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextSelf() s32 cellFiberPpuContextSelf()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextReturnToThread() s32 cellFiberPpuContextReturnToThread()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextCheckStackLimit() s32 cellFiberPpuContextCheckStackLimit()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextRunScheduler() s32 cellFiberPpuContextRunScheduler()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuContextEnterScheduler() s32 cellFiberPpuContextEnterScheduler()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuSchedulerTraceInitialize() s32 cellFiberPpuSchedulerTraceInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuSchedulerTraceFinalize() s32 cellFiberPpuSchedulerTraceFinalize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuSchedulerTraceStart() s32 cellFiberPpuSchedulerTraceStart()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuSchedulerTraceStop() s32 cellFiberPpuSchedulerTraceStop()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int _cellFiberPpuUtilWorkerControlAttributeInitialize() s32 _cellFiberPpuUtilWorkerControlAttributeInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlRunFibers() s32 cellFiberPpuUtilWorkerControlRunFibers()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlInitialize() s32 cellFiberPpuUtilWorkerControlInitialize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlSetPollingMode() s32 cellFiberPpuUtilWorkerControlSetPollingMode()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlJoinFiber() s32 cellFiberPpuUtilWorkerControlJoinFiber()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlDisconnectEventQueue() s32 cellFiberPpuUtilWorkerControlDisconnectEventQueue()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlSendSignal() s32 cellFiberPpuUtilWorkerControlSendSignal()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlConnectEventQueueToSpurs() s32 cellFiberPpuUtilWorkerControlConnectEventQueueToSpurs()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlFinalize() s32 cellFiberPpuUtilWorkerControlFinalize()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlWakeup() s32 cellFiberPpuUtilWorkerControlWakeup()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlCreateFiber() s32 cellFiberPpuUtilWorkerControlCreateFiber()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlShutdown() s32 cellFiberPpuUtilWorkerControlShutdown()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlCheckFlags() s32 cellFiberPpuUtilWorkerControlCheckFlags()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;
} }
int cellFiberPpuUtilWorkerControlInitializeWithAttribute() s32 cellFiberPpuUtilWorkerControlInitializeWithAttribute()
{ {
UNIMPLEMENTED_FUNC(cellFiber); UNIMPLEMENTED_FUNC(cellFiber);
return CELL_OK; return CELL_OK;

108
rpcs3/Emu/SysCalls/Modules/cellFont.cpp
View file

@ -11,7 +11,7 @@ extern Module cellFont;
CCellFontInternal* s_fontInternalInstance = nullptr; CCellFontInternal* s_fontInternalInstance = nullptr;
// Functions // Functions
int cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> config) s32 cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> config)
{ {
cellFont.Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.addr()); cellFont.Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.addr());
@ -30,13 +30,13 @@ int cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> co
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetRevisionFlags(vm::ptr<u64> revisionFlags) s32 cellFontGetRevisionFlags(vm::ptr<u64> revisionFlags)
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontInit(PPUThread& CPU, vm::ptr<CellFontConfig> config) s32 cellFontInit(PPUThread& CPU, vm::ptr<CellFontConfig> config)
{ {
cellFont.Log("cellFontInit(config=0x%x)", config.addr()); cellFont.Log("cellFontInit(config=0x%x)", config.addr());
@ -46,7 +46,7 @@ int cellFontInit(PPUThread& CPU, vm::ptr<CellFontConfig> config)
return cellFontInitializeWithRevision(revisionFlags.value(), config); return cellFontInitializeWithRevision(revisionFlags.value(), config);
} }
int cellFontEnd() s32 cellFontEnd()
{ {
cellFont.Log("cellFontEnd()"); cellFont.Log("cellFontEnd()");
@ -64,7 +64,7 @@ s32 cellFontSetFontsetOpenMode(u32 openMode)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, vm::ptr<CellFont> font) s32 cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, vm::ptr<CellFont> font)
{ {
cellFont.Warning("cellFontOpenFontMemory(library_addr=0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font_addr=0x%x)", cellFont.Warning("cellFontOpenFontMemory(library_addr=0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font_addr=0x%x)",
library.addr(), fontAddr, fontSize, subNum, uniqueId, font.addr()); library.addr(), fontAddr, fontSize, subNum, uniqueId, font.addr());
@ -83,7 +83,7 @@ int cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 f
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPath, u32 subNum, s32 uniqueId, vm::ptr<CellFont> font) s32 cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPath, u32 subNum, s32 uniqueId, vm::ptr<CellFont> font)
{ {
std::string fp(fontPath.get_ptr()); std::string fp(fontPath.get_ptr());
cellFont.Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)", cellFont.Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",
@ -96,12 +96,12 @@ int cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::cptr<char> fontPa
u32 fileSize = (u32)f.GetSize(); u32 fileSize = (u32)f.GetSize();
u32 bufferAddr = (u32)Memory.Alloc(fileSize, 1); // Freed in cellFontCloseFont u32 bufferAddr = (u32)Memory.Alloc(fileSize, 1); // Freed in cellFontCloseFont
f.Read(vm::get_ptr<void>(bufferAddr), fileSize); f.Read(vm::get_ptr<void>(bufferAddr), fileSize);
int ret = cellFontOpenFontMemory(library, bufferAddr, fileSize, subNum, uniqueId, font); s32 ret = cellFontOpenFontMemory(library, bufferAddr, fileSize, subNum, uniqueId, font);
font->origin = CELL_FONT_OPEN_FONT_FILE; font->origin = CELL_FONT_OPEN_FONT_FILE;
return ret; return ret;
} }
int cellFontOpenFontset(PPUThread& CPU, vm::ptr<CellFontLibrary> library, vm::ptr<CellFontType> fontType, vm::ptr<CellFont> font) s32 cellFontOpenFontset(PPUThread& CPU, vm::ptr<CellFontLibrary> library, vm::ptr<CellFontType> fontType, vm::ptr<CellFont> font)
{ {
cellFont.Log("cellFontOpenFontset(library_addr=0x%x, fontType_addr=0x%x, font_addr=0x%x)", cellFont.Log("cellFontOpenFontset(library_addr=0x%x, fontType_addr=0x%x, font_addr=0x%x)",
library.addr(), fontType.addr(), font.addr()); library.addr(), fontType.addr(), font.addr());
@ -179,12 +179,12 @@ int cellFontOpenFontset(PPUThread& CPU, vm::ptr<CellFontLibrary> library, vm::pt
vm::stackvar<char> f(CPU, (u32)file.length() + 1, 1); vm::stackvar<char> f(CPU, (u32)file.length() + 1, 1);
memcpy(f.get_ptr(), file.c_str(), file.size() + 1); memcpy(f.get_ptr(), file.c_str(), file.size() + 1);
int ret = cellFontOpenFontFile(library, f, 0, 0, font); //TODO: Find the correct values of subNum, uniqueId s32 ret = cellFontOpenFontFile(library, f, 0, 0, font); //TODO: Find the correct values of subNum, uniqueId
font->origin = CELL_FONT_OPEN_FONTSET; font->origin = CELL_FONT_OPEN_FONTSET;
return ret; return ret;
} }
int cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> font) s32 cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> font)
{ {
cellFont.Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.addr(), font.addr()); cellFont.Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.addr(), font.addr());
@ -205,7 +205,7 @@ s32 cellFontSetFontOpenMode(u32 openMode)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRendererConfig> config, vm::ptr<CellFontRenderer> Renderer) s32 cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRendererConfig> config, vm::ptr<CellFontRenderer> Renderer)
{ {
cellFont.Warning("cellFontCreateRenderer(library_addr=0x%x, config_addr=0x%x, Renderer_addr=0x%x)", cellFont.Warning("cellFontCreateRenderer(library_addr=0x%x, config_addr=0x%x, Renderer_addr=0x%x)",
library.addr(), config.addr(), Renderer.addr()); library.addr(), config.addr(), Renderer.addr());
@ -244,7 +244,7 @@ void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32
surface->Scissor.y1 = h; surface->Scissor.y1 = h;
} }
int cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h) s32 cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
{ {
cellFont.Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h); cellFont.Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h);
@ -253,12 +253,12 @@ int cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizontalLayout> layout) s32 cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizontalLayout> layout)
{ {
cellFont.Log("cellFontGetHorizontalLayout(font_addr=0x%x, layout_addr=0x%x)", cellFont.Log("cellFontGetHorizontalLayout(font_addr=0x%x, layout_addr=0x%x)",
font.addr(), layout.addr()); font.addr(), layout.addr());
int ascent, descent, lineGap; s32 ascent, descent, lineGap;
float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y); float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap); stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap);
@ -268,7 +268,7 @@ int cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizont
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> renderer) s32 cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> renderer)
{ {
cellFont.Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)", cellFont.Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)",
font.addr(), renderer.addr()); font.addr(), renderer.addr());
@ -280,7 +280,7 @@ int cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> rende
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontUnbindRenderer(vm::ptr<CellFont> font) s32 cellFontUnbindRenderer(vm::ptr<CellFont> font)
{ {
cellFont.Warning("cellFontBindRenderer(font_addr=0x%x)", font.addr()); cellFont.Warning("cellFontBindRenderer(font_addr=0x%x)", font.addr());
@ -291,13 +291,13 @@ int cellFontUnbindRenderer(vm::ptr<CellFont> font)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontDestroyRenderer() s32 cellFontDestroyRenderer()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h) s32 cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
{ {
cellFont.Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h); cellFont.Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h);
@ -308,7 +308,7 @@ int cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics) s32 cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
{ {
cellFont.Log("cellFontGetRenderCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)", cellFont.Log("cellFontGetRenderCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)",
font.addr(), code, metrics.addr()); font.addr(), code, metrics.addr());
@ -320,7 +320,7 @@ int cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontRenderSurface> surface, float x, float y, vm::ptr<CellFontGlyphMetrics> metrics, vm::ptr<CellFontImageTransInfo> transInfo) s32 cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontRenderSurface> surface, float x, float y, vm::ptr<CellFontGlyphMetrics> metrics, vm::ptr<CellFontImageTransInfo> transInfo)
{ {
cellFont.Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)", cellFont.Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)",
font.addr(), code, surface.addr(), x, y, metrics.addr(), transInfo.addr()); font.addr(), code, surface.addr(), x, y, metrics.addr(), transInfo.addr());
@ -329,14 +329,14 @@ int cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellF
return CELL_FONT_ERROR_RENDERER_UNBIND; return CELL_FONT_ERROR_RENDERER_UNBIND;
// Render the character // Render the character
int width, height, xoff, yoff; s32 width, height, xoff, yoff;
float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y); float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
unsigned char* box = stbtt_GetCodepointBitmap(font->stbfont, scale, scale, code, &width, &height, &xoff, &yoff); unsigned char* box = stbtt_GetCodepointBitmap(font->stbfont, scale, scale, code, &width, &height, &xoff, &yoff);
if (!box) return CELL_OK; if (!box) return CELL_OK;
// Get the baseLineY value // Get the baseLineY value
int baseLineY; s32 baseLineY;
int ascent, descent, lineGap; s32 ascent, descent, lineGap;
stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap); stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap);
baseLineY = (int)((float)ascent * scale); // ??? baseLineY = (int)((float)ascent * scale); // ???
@ -358,13 +358,13 @@ int cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellF
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontEndLibrary() s32 cellFontEndLibrary()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam) s32 cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
{ {
cellFont.Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.addr(), slantParam); cellFont.Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.addr(), slantParam);
@ -375,7 +375,7 @@ int cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam) s32 cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam)
{ {
cellFont.Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.addr(), slantParam.addr()); cellFont.Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.addr(), slantParam.addr());
@ -383,7 +383,7 @@ int cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId, vm::ptr<u32> fontCode) s32 cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId, vm::ptr<u32> fontCode)
{ {
cellFont.Todo("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x)", font.addr(), code, fontId.addr(), fontCode.addr()); cellFont.Todo("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x)", font.addr(), code, fontId.addr(), fontCode.addr());
@ -391,7 +391,7 @@ int cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId,
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontCloseFont(vm::ptr<CellFont> font) s32 cellFontCloseFont(vm::ptr<CellFont> font)
{ {
cellFont.Warning("cellFontCloseFont(font_addr=0x%x)", font.addr()); cellFont.Warning("cellFontCloseFont(font_addr=0x%x)", font.addr());
@ -403,12 +403,12 @@ int cellFontCloseFont(vm::ptr<CellFont> font)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics) s32 cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
{ {
cellFont.Log("cellFontGetCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)", font.addr(), code, metrics.addr()); cellFont.Log("cellFontGetCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)", font.addr(), code, metrics.addr());
int x0, y0, x1, y1; s32 x0, y0, x1, y1;
int advanceWidth, leftSideBearing; s32 advanceWidth, leftSideBearing;
float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y); float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
stbtt_GetCodepointBox(font->stbfont, code, &x0, &y0, &x1, &y1); stbtt_GetCodepointBox(font->stbfont, code, &x0, &y0, &x1, &y1);
stbtt_GetCodepointHMetrics(font->stbfont, code, &advanceWidth, &leftSideBearing); stbtt_GetCodepointHMetrics(font->stbfont, code, &advanceWidth, &leftSideBearing);
@ -425,121 +425,121 @@ int cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFo
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGraphicsSetFontRGBA() s32 cellFontGraphicsSetFontRGBA()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontOpenFontsetOnMemory() s32 cellFontOpenFontsetOnMemory()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGraphicsSetScalePixel() s32 cellFontGraphicsSetScalePixel()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGraphicsGetScalePixel() s32 cellFontGraphicsGetScalePixel()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetEffectWeight() s32 cellFontSetEffectWeight()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGlyphSetupVertexesGlyph() s32 cellFontGlyphSetupVertexesGlyph()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetVerticalLayout() s32 cellFontGetVerticalLayout()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetRenderCharGlyphMetricsVertical() s32 cellFontGetRenderCharGlyphMetricsVertical()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetScalePoint() s32 cellFontSetScalePoint()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetupRenderEffectSlant() s32 cellFontSetupRenderEffectSlant()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGraphicsSetLineRGBA() s32 cellFontGraphicsSetLineRGBA()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGraphicsSetDrawType() s32 cellFontGraphicsSetDrawType()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontEndGraphics() s32 cellFontEndGraphics()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGraphicsSetupDrawContext() s32 cellFontGraphicsSetupDrawContext()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetupRenderEffectWeight() s32 cellFontSetupRenderEffectWeight()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGlyphGetOutlineControlDistance() s32 cellFontGlyphGetOutlineControlDistance()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGlyphGetVertexesGlyphSize() s32 cellFontGlyphGetVertexesGlyphSize()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGenerateCharGlyph() s32 cellFontGenerateCharGlyph()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontDeleteGlyph() s32 cellFontDeleteGlyph()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontExtend(u32 a1, u32 a2, u32 a3) s32 cellFontExtend(u32 a1, u32 a2, u32 a3)
{ {
cellFont.Warning("cellFontExtend(a1=0x%x, a2=0x%x, a3=0x%x)", a1, a2, a3); cellFont.Warning("cellFontExtend(a1=0x%x, a2=0x%x, a3=0x%x)", a1, a2, a3);
//In a test I did: a1=0xcfe00000, a2=0x0, a3=(pointer to something) //In a test I did: a1=0xcfe00000, a2=0x0, a3=(pointer to something)
@ -559,19 +559,19 @@ int cellFontExtend(u32 a1, u32 a2, u32 a3)
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontRenderCharGlyphImageVertical() s32 cellFontRenderCharGlyphImageVertical()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontSetResolutionDpi() s32 cellFontSetResolutionDpi()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;
} }
int cellFontGetCharGlyphMetricsVertical() s32 cellFontGetCharGlyphMetricsVertical()
{ {
UNIMPLEMENTED_FUNC(cellFont); UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK; return CELL_FONT_OK;

6
rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
View file

@ -9,7 +9,7 @@ extern Module cellFontFT;
CCellFontFTInternal* s_fontFtInternalInstance = nullptr; CCellFontFTInternal* s_fontFtInternalInstance = nullptr;
int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontLibraryConfigFT> config, u32 lib_addr_addr) s32 cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontLibraryConfigFT> config, u32 lib_addr_addr)
{ {
cellFontFT.Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config_addr=0x%x, lib_addr_addr=0x%x", cellFontFT.Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config_addr=0x%x, lib_addr_addr=0x%x",
revisionFlags, config.addr(), lib_addr_addr); revisionFlags, config.addr(), lib_addr_addr);
@ -22,13 +22,13 @@ int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontL
return CELL_OK; return CELL_OK;
} }
int cellFontFTGetRevisionFlags() s32 cellFontFTGetRevisionFlags()
{ {
UNIMPLEMENTED_FUNC(cellFontFT); UNIMPLEMENTED_FUNC(cellFontFT);
return CELL_OK; return CELL_OK;
} }
int cellFontFTGetInitializedRevisionFlags() s32 cellFontFTGetInitializedRevisionFlags()
{ {
UNIMPLEMENTED_FUNC(cellFontFT); UNIMPLEMENTED_FUNC(cellFontFT);
return CELL_OK; return CELL_OK;

4
rpcs3/Emu/SysCalls/Modules/cellFs.cpp
View file

@ -750,7 +750,7 @@ bool sdata_check(u32 version, u32 flags, u64 filesizeInput, u64 filesizeTmp)
return true; return true;
} }
int sdata_unpack(const std::string& packed_file, const std::string& unpacked_file) s32 sdata_unpack(const std::string& packed_file, const std::string& unpacked_file)
{ {
std::shared_ptr<vfsFileBase> packed_stream(Emu.GetVFS().OpenFile(packed_file, vfsRead)); std::shared_ptr<vfsFileBase> packed_stream(Emu.GetVFS().OpenFile(packed_file, vfsRead));
std::shared_ptr<vfsFileBase> unpacked_stream(Emu.GetVFS().OpenFile(unpacked_file, vfsWriteNew)); std::shared_ptr<vfsFileBase> unpacked_stream(Emu.GetVFS().OpenFile(unpacked_file, vfsWriteNew));
@ -845,7 +845,7 @@ s32 cellFsSdataOpen(PPUThread& CPU, vm::cptr<char> path, s32 flags, vm::ptr<u32>
std::string::size_type last_slash = path.rfind('/'); //TODO: use a filesystem library to solve this more robustly std::string::size_type last_slash = path.rfind('/'); //TODO: use a filesystem library to solve this more robustly
last_slash = last_slash == std::string::npos ? 0 : last_slash+1; last_slash = last_slash == std::string::npos ? 0 : last_slash+1;
std::string unpacked_path = "/dev_hdd1/"+path.substr(last_slash,path.length()-last_slash)+".unpacked"; std::string unpacked_path = "/dev_hdd1/"+path.substr(last_slash,path.length()-last_slash)+".unpacked";
int ret = sdata_unpack(path, unpacked_path); s32 ret = sdata_unpack(path, unpacked_path);
if (ret) return ret; if (ret) return ret;
fd = Emu.GetIdManager().GetNewID(Emu.GetVFS().OpenFile(unpacked_path, vfsRead), TYPE_FS_FILE); fd = Emu.GetIdManager().GetNewID(Emu.GetVFS().OpenFile(unpacked_path, vfsRead), TYPE_FS_FILE);

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

@ -19,7 +19,7 @@ struct cellGemInternal
cellGemInternal cellGemInstance; cellGemInternal cellGemInstance;
int cellGemCalibrate() s32 cellGemCalibrate()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -29,7 +29,7 @@ int cellGemCalibrate()
return CELL_OK; return CELL_OK;
} }
int cellGemClearStatusFlags() s32 cellGemClearStatusFlags()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -39,7 +39,7 @@ int cellGemClearStatusFlags()
return CELL_OK; return CELL_OK;
} }
int cellGemConvertVideoFinish() s32 cellGemConvertVideoFinish()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -49,7 +49,7 @@ int cellGemConvertVideoFinish()
return CELL_OK; return CELL_OK;
} }
int cellGemConvertVideoStart() s32 cellGemConvertVideoStart()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -59,7 +59,7 @@ int cellGemConvertVideoStart()
return CELL_OK; return CELL_OK;
} }
int cellGemEnableCameraPitchAngleCorrection() s32 cellGemEnableCameraPitchAngleCorrection()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -69,7 +69,7 @@ int cellGemEnableCameraPitchAngleCorrection()
return CELL_OK; return CELL_OK;
} }
int cellGemEnableMagnetometer() s32 cellGemEnableMagnetometer()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -79,7 +79,7 @@ int cellGemEnableMagnetometer()
return CELL_OK; return CELL_OK;
} }
int cellGemEnd() s32 cellGemEnd()
{ {
cellGem.Warning("cellGemEnd()"); cellGem.Warning("cellGemEnd()");
@ -91,7 +91,7 @@ int cellGemEnd()
return CELL_OK; return CELL_OK;
} }
int cellGemFilterState() s32 cellGemFilterState()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -101,7 +101,7 @@ int cellGemFilterState()
return CELL_OK; return CELL_OK;
} }
int cellGemForceRGB() s32 cellGemForceRGB()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -111,7 +111,7 @@ int cellGemForceRGB()
return CELL_OK; return CELL_OK;
} }
int cellGemGetAccelerometerPositionInDevice() s32 cellGemGetAccelerometerPositionInDevice()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -121,7 +121,7 @@ int cellGemGetAccelerometerPositionInDevice()
return CELL_OK; return CELL_OK;
} }
int cellGemGetAllTrackableHues() s32 cellGemGetAllTrackableHues()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -131,7 +131,7 @@ int cellGemGetAllTrackableHues()
return CELL_OK; return CELL_OK;
} }
int cellGemGetCameraState() s32 cellGemGetCameraState()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -141,7 +141,7 @@ int cellGemGetCameraState()
return CELL_OK; return CELL_OK;
} }
int cellGemGetEnvironmentLightingColor() s32 cellGemGetEnvironmentLightingColor()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -151,7 +151,7 @@ int cellGemGetEnvironmentLightingColor()
return CELL_OK; return CELL_OK;
} }
int cellGemGetHuePixels() s32 cellGemGetHuePixels()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -161,7 +161,7 @@ int cellGemGetHuePixels()
return CELL_OK; return CELL_OK;
} }
int cellGemGetImageState() s32 cellGemGetImageState()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -171,7 +171,7 @@ int cellGemGetImageState()
return CELL_OK; return CELL_OK;
} }
int cellGemGetInertialState() s32 cellGemGetInertialState()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -181,7 +181,7 @@ int cellGemGetInertialState()
return CELL_OK; return CELL_OK;
} }
int cellGemGetInfo(vm::ptr<CellGemInfo> info) s32 cellGemGetInfo(vm::ptr<CellGemInfo> info)
{ {
cellGem.Warning("cellGemGetInfo(info=0x%x)", info.addr()); cellGem.Warning("cellGemGetInfo(info=0x%x)", info.addr());
@ -207,7 +207,7 @@ s32 cellGemGetMemorySize(s32 max_connect)
return 1024 * 1024 * max_connect; // 1 MB * max_connect return 1024 * 1024 * max_connect; // 1 MB * max_connect
} }
int cellGemGetRGB() s32 cellGemGetRGB()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -217,7 +217,7 @@ int cellGemGetRGB()
return CELL_OK; return CELL_OK;
} }
int cellGemGetRumble() s32 cellGemGetRumble()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -227,7 +227,7 @@ int cellGemGetRumble()
return CELL_OK; return CELL_OK;
} }
int cellGemGetState() s32 cellGemGetState()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -237,7 +237,7 @@ int cellGemGetState()
return CELL_OK; return CELL_OK;
} }
int cellGemGetStatusFlags() s32 cellGemGetStatusFlags()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -247,7 +247,7 @@ int cellGemGetStatusFlags()
return CELL_OK; return CELL_OK;
} }
int cellGemGetTrackerHue() s32 cellGemGetTrackerHue()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -257,13 +257,13 @@ int cellGemGetTrackerHue()
return CELL_OK; return CELL_OK;
} }
int cellGemHSVtoRGB() s32 cellGemHSVtoRGB()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
return CELL_OK; return CELL_OK;
} }
int cellGemInit(vm::ptr<CellGemAttribute> attribute) s32 cellGemInit(vm::ptr<CellGemAttribute> attribute)
{ {
cellGem.Warning("cellGemInit(attribute_addr=0x%x)", attribute.addr()); cellGem.Warning("cellGemInit(attribute_addr=0x%x)", attribute.addr());
@ -276,7 +276,7 @@ int cellGemInit(vm::ptr<CellGemAttribute> attribute)
return CELL_OK; return CELL_OK;
} }
int cellGemInvalidateCalibration() s32 cellGemInvalidateCalibration()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -286,13 +286,13 @@ int cellGemInvalidateCalibration()
return CELL_OK; return CELL_OK;
} }
int cellGemIsTrackableHue() s32 cellGemIsTrackableHue()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
return CELL_OK; return CELL_OK;
} }
int cellGemPrepareCamera() s32 cellGemPrepareCamera()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -302,7 +302,7 @@ int cellGemPrepareCamera()
return CELL_OK; return CELL_OK;
} }
int cellGemPrepareVideoConvert() s32 cellGemPrepareVideoConvert()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -312,7 +312,7 @@ int cellGemPrepareVideoConvert()
return CELL_OK; return CELL_OK;
} }
int cellGemReset() s32 cellGemReset()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -322,7 +322,7 @@ int cellGemReset()
return CELL_OK; return CELL_OK;
} }
int cellGemSetRumble() s32 cellGemSetRumble()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -332,7 +332,7 @@ int cellGemSetRumble()
return CELL_OK; return CELL_OK;
} }
int cellGemSetYaw() s32 cellGemSetYaw()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -342,7 +342,7 @@ int cellGemSetYaw()
return CELL_OK; return CELL_OK;
} }
int cellGemTrackHues() s32 cellGemTrackHues()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -352,7 +352,7 @@ int cellGemTrackHues()
return CELL_OK; return CELL_OK;
} }
int cellGemUpdateFinish() s32 cellGemUpdateFinish()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -362,7 +362,7 @@ int cellGemUpdateFinish()
return CELL_OK; return CELL_OK;
} }
int cellGemUpdateStart() s32 cellGemUpdateStart()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);
@ -372,7 +372,7 @@ int cellGemUpdateStart()
return CELL_OK; return CELL_OK;
} }
int cellGemWriteExternalPort() s32 cellGemWriteExternalPort()
{ {
UNIMPLEMENTED_FUNC(cellGem); UNIMPLEMENTED_FUNC(cellGem);

18
rpcs3/Emu/SysCalls/Modules/cellKb.cpp
View file

@ -8,7 +8,7 @@
extern Module sys_io; extern Module sys_io;
int cellKbInit(u32 max_connect) s32 cellKbInit(u32 max_connect)
{ {
sys_io.Warning("cellKbInit(max_connect=%d)", max_connect); sys_io.Warning("cellKbInit(max_connect=%d)", max_connect);
@ -22,7 +22,7 @@ int cellKbInit(u32 max_connect)
return CELL_OK; return CELL_OK;
} }
int cellKbEnd() s32 cellKbEnd()
{ {
sys_io.Log("cellKbEnd()"); sys_io.Log("cellKbEnd()");
@ -33,7 +33,7 @@ int cellKbEnd()
return CELL_OK; return CELL_OK;
} }
int cellKbClearBuf(u32 port_no) s32 cellKbClearBuf(u32 port_no)
{ {
sys_io.Log("cellKbClearBuf(port_no=%d)", port_no); sys_io.Log("cellKbClearBuf(port_no=%d)", port_no);
@ -94,7 +94,7 @@ u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode)
return 0x0000; return 0x0000;
} }
int cellKbGetInfo(vm::ptr<CellKbInfo> info) s32 cellKbGetInfo(vm::ptr<CellKbInfo> info)
{ {
sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info.addr()); sys_io.Log("cellKbGetInfo(info_addr=0x%x)", info.addr());
@ -114,7 +114,7 @@ int cellKbGetInfo(vm::ptr<CellKbInfo> info)
return CELL_OK; return CELL_OK;
} }
int cellKbRead(u32 port_no, vm::ptr<CellKbData> data) s32 cellKbRead(u32 port_no, vm::ptr<CellKbData> data)
{ {
sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.addr()); sys_io.Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.addr());
@ -140,7 +140,7 @@ int cellKbRead(u32 port_no, vm::ptr<CellKbData> data)
return CELL_OK; return CELL_OK;
} }
int cellKbSetCodeType(u32 port_no, u32 type) s32 cellKbSetCodeType(u32 port_no, u32 type)
{ {
sys_io.Log("cellKbSetCodeType(port_no=%d,type=%d)", port_no, type); sys_io.Log("cellKbSetCodeType(port_no=%d,type=%d)", port_no, type);
@ -152,13 +152,13 @@ int cellKbSetCodeType(u32 port_no, u32 type)
return CELL_OK; return CELL_OK;
} }
int cellKbSetLEDStatus(u32 port_no, u8 led) s32 cellKbSetLEDStatus(u32 port_no, u8 led)
{ {
UNIMPLEMENTED_FUNC(sys_io); UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK; return CELL_OK;
} }
int cellKbSetReadMode(u32 port_no, u32 rmode) s32 cellKbSetReadMode(u32 port_no, u32 rmode)
{ {
sys_io.Log("cellKbSetReadMode(port_no=%d,rmode=%d)", port_no, rmode); sys_io.Log("cellKbSetReadMode(port_no=%d,rmode=%d)", port_no, rmode);
@ -171,7 +171,7 @@ int cellKbSetReadMode(u32 port_no, u32 rmode)
return CELL_OK; return CELL_OK;
} }
int cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config) s32 cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config)
{ {
sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.addr()); sys_io.Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.addr());

269
rpcs3/Emu/SysCalls/Modules/cellLv2dbg.cpp
View file

@ -1,269 +0,0 @@
#include "stdafx.h"
#if 0
void cellLv2dbg_init();
Module cellLv2dbg(0x002e, cellLv2dbg_init);
// Return Codes
enum
{
CELL_LV2DBG_ERROR_DEINVALIDARGUMENTS = 0x80010409,
CELL_LV2DBG_ERROR_DEOPERATIONDENIED = 0x8001042c,
};
int sys_dbg_read_spu_thread_context()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_initialize_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_register_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_finalize_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_unregister_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_set_stacksize_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_signal_to_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_enable_floating_point_enabled_exception()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_disable_floating_point_enabled_exception()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_set_address_to_dabr()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_address_from_dabr()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_set_mask_to_ppu_exception_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_read_ppu_thread_context()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_read_spu_thread_context2()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_ppu_thread_name()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_spu_thread_name()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_spu_thread_group_name()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_ppu_thread_status()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_spu_thread_group_status()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_ppu_thread_ids()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_spu_thread_ids()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_spu_thread_group_ids()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_mutex_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_lwmutex_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_rwlock_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_semaphore_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_cond_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_lwcond_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_event_queue_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_event_flag_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_vm_get_page_information()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_mat_set_condition()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_mat_get_condition()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_signal_to_coredump_handler()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
int sys_dbg_get_coredump_params()
{
UNIMPLEMENTED_FUNC(cellLv2dbg);
return CELL_OK;
}
void cellLv2dbg_init()
{
REG_FUNC(cellLv2dbg, sys_dbg_read_spu_thread_context);
REG_FUNC(cellLv2dbg, sys_dbg_initialize_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_register_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_finalize_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_unregister_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_set_stacksize_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_signal_to_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_enable_floating_point_enabled_exception);
REG_FUNC(cellLv2dbg, sys_dbg_disable_floating_point_enabled_exception);
REG_FUNC(cellLv2dbg, sys_dbg_set_address_to_dabr);
REG_FUNC(cellLv2dbg, sys_dbg_get_address_from_dabr);
REG_FUNC(cellLv2dbg, sys_dbg_set_mask_to_ppu_exception_handler);
REG_FUNC(cellLv2dbg, sys_dbg_read_ppu_thread_context);
REG_FUNC(cellLv2dbg, sys_dbg_read_spu_thread_context2);
REG_FUNC(cellLv2dbg, sys_dbg_get_ppu_thread_name);
REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_name);
REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_group_name);
REG_FUNC(cellLv2dbg, sys_dbg_get_ppu_thread_status);
REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_group_status);
REG_FUNC(cellLv2dbg, sys_dbg_get_ppu_thread_ids);
REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_ids);
REG_FUNC(cellLv2dbg, sys_dbg_get_spu_thread_group_ids);
REG_FUNC(cellLv2dbg, sys_dbg_get_mutex_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_lwmutex_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_rwlock_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_semaphore_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_cond_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_lwcond_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_event_queue_information);
REG_FUNC(cellLv2dbg, sys_dbg_get_event_flag_information);
REG_FUNC(cellLv2dbg, sys_dbg_vm_get_page_information);
REG_FUNC(cellLv2dbg, sys_dbg_mat_set_condition);
REG_FUNC(cellLv2dbg, sys_dbg_mat_get_condition);
REG_FUNC(cellLv2dbg, sys_dbg_signal_to_coredump_handler);
REG_FUNC(cellLv2dbg, sys_dbg_get_coredump_params);
}
#endif

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

@ -19,7 +19,7 @@ struct cellMicInternal
cellMicInternal cellMicInstance; cellMicInternal cellMicInstance;
int cellMicInit() s32 cellMicInit()
{ {
cellMic.Warning("cellMicInit()"); cellMic.Warning("cellMicInit()");
@ -31,7 +31,7 @@ int cellMicInit()
return CELL_OK; return CELL_OK;
} }
int cellMicEnd() s32 cellMicEnd()
{ {
cellMic.Warning("cellMicEnd()"); cellMic.Warning("cellMicEnd()");
@ -43,241 +43,241 @@ int cellMicEnd()
return CELL_OK; return CELL_OK;
} }
int cellMicOpen() s32 cellMicOpen()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicClose() s32 cellMicClose()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetDeviceGUID() s32 cellMicGetDeviceGUID()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetType() s32 cellMicGetType()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicIsAttached() s32 cellMicIsAttached()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicIsOpen() s32 cellMicIsOpen()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetDeviceAttr() s32 cellMicGetDeviceAttr()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSetDeviceAttr() s32 cellMicSetDeviceAttr()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetSignalAttr() s32 cellMicGetSignalAttr()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSetSignalAttr() s32 cellMicSetSignalAttr()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetSignalState() s32 cellMicGetSignalState()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicStart() s32 cellMicStart()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicRead() s32 cellMicRead()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicStop() s32 cellMicStop()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicReset() s32 cellMicReset()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSetNotifyEventQueue() s32 cellMicSetNotifyEventQueue()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSetNotifyEventQueue2() s32 cellMicSetNotifyEventQueue2()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicRemoveNotifyEventQueue() s32 cellMicRemoveNotifyEventQueue()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicOpenEx() s32 cellMicOpenEx()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicStartEx() s32 cellMicStartEx()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetFormatRaw() s32 cellMicGetFormatRaw()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetFormatAux() s32 cellMicGetFormatAux()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetFormatDsp() s32 cellMicGetFormatDsp()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicOpenRaw() s32 cellMicOpenRaw()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicReadRaw() s32 cellMicReadRaw()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicReadAux() s32 cellMicReadAux()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicReadDsp() s32 cellMicReadDsp()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetStatus() s32 cellMicGetStatus()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicStopEx() s32 cellMicStopEx()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSysShareClose() s32 cellMicSysShareClose()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetFormat() s32 cellMicGetFormat()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSetMultiMicNotifyEventQueue() s32 cellMicSetMultiMicNotifyEventQueue()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetFormatEx() s32 cellMicGetFormatEx()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSysShareStop() s32 cellMicSysShareStop()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSysShareOpen() s32 cellMicSysShareOpen()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicCommand() s32 cellMicCommand()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSysShareStart() s32 cellMicSysShareStart()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSysShareInit() s32 cellMicSysShareInit()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicSysShareEnd() s32 cellMicSysShareEnd()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;
} }
int cellMicGetDeviceIdentifier() s32 cellMicGetDeviceIdentifier()
{ {
UNIMPLEMENTED_FUNC(cellMic); UNIMPLEMENTED_FUNC(cellMic);
return CELL_OK; return CELL_OK;

20
rpcs3/Emu/SysCalls/Modules/cellMouse.cpp
View file

@ -8,7 +8,7 @@
extern Module sys_io; extern Module sys_io;
int cellMouseInit(u32 max_connect) s32 cellMouseInit(u32 max_connect)
{ {
sys_io.Warning("cellMouseInit(max_connect=%d)", max_connect); sys_io.Warning("cellMouseInit(max_connect=%d)", max_connect);
if(Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_ALREADY_INITIALIZED; if(Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_ALREADY_INITIALIZED;
@ -19,7 +19,7 @@ int cellMouseInit(u32 max_connect)
} }
int cellMouseClearBuf(u32 port_no) s32 cellMouseClearBuf(u32 port_no)
{ {
sys_io.Log("cellMouseClearBuf(port_no=%d)", port_no); sys_io.Log("cellMouseClearBuf(port_no=%d)", port_no);
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -30,7 +30,7 @@ int cellMouseClearBuf(u32 port_no)
return CELL_OK; return CELL_OK;
} }
int cellMouseEnd() s32 cellMouseEnd()
{ {
sys_io.Log("cellMouseEnd()"); sys_io.Log("cellMouseEnd()");
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -38,7 +38,7 @@ int cellMouseEnd()
return CELL_OK; return CELL_OK;
} }
int cellMouseGetInfo(vm::ptr<CellMouseInfo> info) s32 cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
{ {
sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info.addr()); sys_io.Log("cellMouseGetInfo(info_addr=0x%x)", info.addr());
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -54,7 +54,7 @@ int cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
return CELL_OK; return CELL_OK;
} }
int cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info) s32 cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
{ {
sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.addr()); sys_io.Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.addr());
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -66,7 +66,7 @@ int cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
return CELL_OK; return CELL_OK;
} }
int cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data) s32 cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data)
{ {
sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.addr()); sys_io.Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.addr());
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED; if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -88,28 +88,28 @@ int cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data)
return CELL_OK; return CELL_OK;
} }
int cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data) s32 cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data)
{ {
UNIMPLEMENTED_FUNC(sys_io); UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK; return CELL_OK;
} }
int cellMouseSetTabletMode(u32 port_no, u32 mode) s32 cellMouseSetTabletMode(u32 port_no, u32 mode)
{ {
UNIMPLEMENTED_FUNC(sys_io); UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK; return CELL_OK;
} }
int cellMouseGetTabletDataList(u32 port_no, u32 data_addr) s32 cellMouseGetTabletDataList(u32 port_no, u32 data_addr)
{ {
UNIMPLEMENTED_FUNC(sys_io); UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK; return CELL_OK;
} }
int cellMouseGetRawData(u32 port_no, u32 data_addr) s32 cellMouseGetRawData(u32 port_no, u32 data_addr)
{ {
UNIMPLEMENTED_FUNC(sys_io); UNIMPLEMENTED_FUNC(sys_io);

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

@ -21,7 +21,7 @@ struct cellNetCtlInternal
cellNetCtlInternal cellNetCtlInstance; cellNetCtlInternal cellNetCtlInstance;
int cellNetCtlInit() s32 cellNetCtlInit()
{ {
cellNetCtl.Log("cellNetCtlInit()"); cellNetCtl.Log("cellNetCtlInit()");
@ -33,7 +33,7 @@ int cellNetCtlInit()
return CELL_OK; return CELL_OK;
} }
int cellNetCtlTerm() s32 cellNetCtlTerm()
{ {
cellNetCtl.Log("cellNetCtlTerm()"); cellNetCtl.Log("cellNetCtlTerm()");
@ -45,7 +45,7 @@ int cellNetCtlTerm()
return CELL_OK; return CELL_OK;
} }
int cellNetCtlGetState(vm::ptr<u32> state) s32 cellNetCtlGetState(vm::ptr<u32> state)
{ {
cellNetCtl.Log("cellNetCtlGetState(state_addr=0x%x)", state.addr()); cellNetCtl.Log("cellNetCtlGetState(state_addr=0x%x)", state.addr());
@ -69,21 +69,21 @@ int cellNetCtlGetState(vm::ptr<u32> state)
return CELL_OK; return CELL_OK;
} }
int cellNetCtlAddHandler(vm::ptr<cellNetCtlHandler> handler, vm::ptr<void> arg, vm::ptr<s32> hid) s32 cellNetCtlAddHandler(vm::ptr<cellNetCtlHandler> handler, vm::ptr<void> arg, vm::ptr<s32> hid)
{ {
cellNetCtl.Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid_addr=0x%x)", handler.addr(), arg.addr(), hid.addr()); cellNetCtl.Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid_addr=0x%x)", handler.addr(), arg.addr(), hid.addr());
return CELL_OK; return CELL_OK;
} }
int cellNetCtlDelHandler(s32 hid) s32 cellNetCtlDelHandler(s32 hid)
{ {
cellNetCtl.Todo("cellNetCtlDelHandler(hid=0x%x)", hid); cellNetCtl.Todo("cellNetCtlDelHandler(hid=0x%x)", hid);
return CELL_OK; return CELL_OK;
} }
int cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info) s32 cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
{ {
cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x, info_addr=0x%x)", code, info.addr()); cellNetCtl.Todo("cellNetCtlGetInfo(code=0x%x, info_addr=0x%x)", code, info.addr());
@ -95,7 +95,7 @@ int cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
return CELL_OK; return CELL_OK;
} }
int cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param) s32 cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param)
{ {
cellNetCtl.Warning("cellNetCtlNetStartDialogLoadAsync(param_addr=0x%x)", param.addr()); cellNetCtl.Warning("cellNetCtlNetStartDialogLoadAsync(param_addr=0x%x)", param.addr());
@ -105,14 +105,14 @@ int cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> par
return CELL_OK; return CELL_OK;
} }
int cellNetCtlNetStartDialogAbortAsync() s32 cellNetCtlNetStartDialogAbortAsync()
{ {
cellNetCtl.Todo("cellNetCtlNetStartDialogAbortAsync()"); cellNetCtl.Todo("cellNetCtlNetStartDialogAbortAsync()");
return CELL_OK; return CELL_OK;
} }
int cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result) s32 cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result)
{ {
cellNetCtl.Warning("cellNetCtlNetStartDialogUnloadAsync(result_addr=0x%x)", result.addr()); cellNetCtl.Warning("cellNetCtlNetStartDialogUnloadAsync(result_addr=0x%x)", result.addr());
@ -121,7 +121,7 @@ int cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult>
return CELL_OK; return CELL_OK;
} }
int cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo) s32 cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
{ {
cellNetCtl.Todo("cellNetCtlGetNatInfo(natInfo_addr=0x%x)", natInfo.addr()); cellNetCtl.Todo("cellNetCtlGetNatInfo(natInfo_addr=0x%x)", natInfo.addr());

8
rpcs3/Emu/SysCalls/Modules/cellOvis.cpp
View file

@ -14,25 +14,25 @@ enum
CELL_OVIS_ERROR_ALIGN = 0x80410410, CELL_OVIS_ERROR_ALIGN = 0x80410410,
}; };
int cellOvisGetOverlayTableSize(vm::cptr<char> elf) s32 cellOvisGetOverlayTableSize(vm::cptr<char> elf)
{ {
cellOvis.Todo("cellOvisGetOverlayTableSize(elf_addr=0x%x)", elf.addr()); cellOvis.Todo("cellOvisGetOverlayTableSize(elf_addr=0x%x)", elf.addr());
return CELL_OK; return CELL_OK;
} }
int cellOvisInitializeOverlayTable() s32 cellOvisInitializeOverlayTable()
{ {
UNIMPLEMENTED_FUNC(cellOvis); UNIMPLEMENTED_FUNC(cellOvis);
return CELL_OK; return CELL_OK;
} }
int cellOvisFixSpuSegments() s32 cellOvisFixSpuSegments()
{ {
UNIMPLEMENTED_FUNC(cellOvis); UNIMPLEMENTED_FUNC(cellOvis);
return CELL_OK; return CELL_OK;
} }
int cellOvisInvalidateOverlappedSegments() s32 cellOvisInvalidateOverlappedSegments()
{ {
UNIMPLEMENTED_FUNC(cellOvis); UNIMPLEMENTED_FUNC(cellOvis);
return CELL_OK; return CELL_OK;

78
rpcs3/Emu/SysCalls/Modules/cellResc.cpp
View file

@ -25,7 +25,7 @@ extern u32 cellGcmGetTiledPitchSize(u32 size);
CCellRescInternal* s_rescInternalInstance = nullptr; CCellRescInternal* s_rescInternalInstance = nullptr;
// Local Functions // Local Functions
int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved); s32 cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved);
// Help Functions // Help Functions
inline bool IsPal() { return s_rescInternalInstance->m_dstMode == CELL_RESC_720x576; } inline bool IsPal() { return s_rescInternalInstance->m_dstMode == CELL_RESC_720x576; }
@ -44,7 +44,7 @@ inline bool IsGcmFlip() {
return (IsNotPal() || (IsPal() && (s_rescInternalInstance->m_initConfig.palTemporalMode == CELL_RESC_PAL_50 return (IsNotPal() || (IsPal() && (s_rescInternalInstance->m_initConfig.palTemporalMode == CELL_RESC_PAL_50
|| s_rescInternalInstance->m_initConfig.palTemporalMode == CELL_RESC_PAL_60_FOR_HSYNC))); || s_rescInternalInstance->m_initConfig.palTemporalMode == CELL_RESC_PAL_60_FOR_HSYNC)));
} }
inline int GetNumColorBuffers(){ return IsPalInterpolate() ? 6 : (IsPalDrop() ? 3 : 2); } inline s32 GetNumColorBuffers(){ return IsPalInterpolate() ? 6 : (IsPalDrop() ? 3 : 2); }
inline bool IsInterlace() { return s_rescInternalInstance->m_initConfig.interlaceMode == CELL_RESC_INTERLACE_FILTER; } inline bool IsInterlace() { return s_rescInternalInstance->m_initConfig.interlaceMode == CELL_RESC_INTERLACE_FILTER; }
inline bool IsTextureNR() { return !IsInterlace(); } inline bool IsTextureNR() { return !IsInterlace(); }
@ -209,7 +209,7 @@ UN_PANSCAN:
return; return;
} }
inline int InternalVersion(vm::ptr<CellRescInitConfig> conf) inline s32 InternalVersion(vm::ptr<CellRescInitConfig> conf)
{ {
switch ((u32)conf->size) switch ((u32)conf->size)
{ {
@ -223,7 +223,7 @@ inline int InternalVersion(vm::ptr<CellRescInitConfig> conf)
} }
} }
inline int InternalVersion() { inline s32 InternalVersion() {
switch ((u32)s_rescInternalInstance->m_initConfig.size) switch ((u32)s_rescInternalInstance->m_initConfig.size)
{ {
case 20: case 20:
@ -296,7 +296,7 @@ u8 GcmSurfaceFormat2GcmTextureFormat(u8 surfaceFormat, u8 surfaceType)
return result; return result;
} }
int GetRescDestsIndex(u32 dstMode) s32 GetRescDestsIndex(u32 dstMode)
{ {
switch(dstMode) switch(dstMode)
{ {
@ -335,14 +335,14 @@ void GetScreenSize(u32 mode, s32 *width, s32 *height)
} }
} }
int CalculateSurfaceByteSize(u32 mode, CellRescDsts *dsts) s32 CalculateSurfaceByteSize(u32 mode, CellRescDsts *dsts)
{ {
s32 width, height; s32 width, height;
GetScreenSize(mode, &width, &height); GetScreenSize(mode, &width, &height);
return dsts->pitch * roundup(height, dsts->heightAlign); return dsts->pitch * roundup(height, dsts->heightAlign);
} }
int CalculateMaxColorBuffersSize() s32 CalculateMaxColorBuffersSize()
{ {
s32 oneBufSize, bufNum, totalBufSize, maxBufSize; s32 oneBufSize, bufNum, totalBufSize, maxBufSize;
maxBufSize = 0; maxBufSize = 0;
@ -433,7 +433,7 @@ void InitMembers()
//s_rescInternalInstance->m_feedback.interval60 = 1; //s_rescInternalInstance->m_feedback.interval60 = 1;
for (int i = 0; i<SRC_BUFFER_NUM; i++) { for (s32 i = 0; i<SRC_BUFFER_NUM; i++) {
s_rescInternalInstance->m_rescSrc[i].format = 0; s_rescInternalInstance->m_rescSrc[i].format = 0;
s_rescInternalInstance->m_rescSrc[i].pitch = 0; s_rescInternalInstance->m_rescSrc[i].pitch = 0;
s_rescInternalInstance->m_rescSrc[i].width = 0; s_rescInternalInstance->m_rescSrc[i].width = 0;
@ -441,11 +441,11 @@ void InitMembers()
s_rescInternalInstance->m_rescSrc[i].offset = 0; s_rescInternalInstance->m_rescSrc[i].offset = 0;
} }
for (int i = 0; i<MAX_DST_BUFFER_NUM; i++) { for (s32 i = 0; i<MAX_DST_BUFFER_NUM; i++) {
s_rescInternalInstance->m_dstOffsets[i] = 0; s_rescInternalInstance->m_dstOffsets[i] = 0;
} }
for (int i = 0; i<RESC_PARAM_NUM; i++) { for (s32 i = 0; i<RESC_PARAM_NUM; i++) {
s_rescInternalInstance->m_cgParamIndex[i] = 0xFF; s_rescInternalInstance->m_cgParamIndex[i] = 0xFF;
} }
{ {
@ -568,7 +568,7 @@ void SetupSurfaces(vm::ptr<CellGcmContextData>& cntxt)
} }
// Module Functions // Module Functions
int cellRescInit(vm::ptr<CellRescInitConfig> initConfig) s32 cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
{ {
cellResc.Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.addr()); cellResc.Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.addr());
@ -610,7 +610,7 @@ void cellRescExit()
if (IsPalInterpolate()) if (IsPalInterpolate())
{ {
// TODO: ExitSystemResource() // TODO: ExitSystemResource()
//int ret = ExitSystemResource(); //s32 ret = ExitSystemResource();
//if (ret != CELL_OK) //if (ret != CELL_OK)
//{ //{
// cellResc.Error("failed to clean up system resources.. continue. 0x%x\n", ret); // cellResc.Error("failed to clean up system resources.. continue. 0x%x\n", ret);
@ -621,7 +621,7 @@ void cellRescExit()
s_rescInternalInstance->m_bInitialized = false; s_rescInternalInstance->m_bInitialized = false;
} }
int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> bufferMode) s32 cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> bufferMode)
{ {
cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.addr()); cellResc.Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.addr());
@ -647,7 +647,7 @@ int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> b
return CELL_OK; return CELL_OK;
} }
int cellRescSetDsts(u32 dstsMode, vm::ptr<CellRescDsts> dsts) s32 cellRescSetDsts(u32 dstsMode, vm::ptr<CellRescDsts> dsts)
{ {
cellResc.Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.addr()); cellResc.Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.addr());
@ -714,7 +714,7 @@ void SetFlipHandler(vm::ptr<void(u32)> handler)
} }
} }
int cellRescSetDisplayMode(PPUThread& CPU, u32 displayMode) s32 cellRescSetDisplayMode(PPUThread& CPU, u32 displayMode)
{ {
cellResc.Warning("cellRescSetDisplayMode(displayMode=%d)", displayMode); cellResc.Warning("cellRescSetDisplayMode(displayMode=%d)", displayMode);
@ -775,7 +775,7 @@ int cellRescSetDisplayMode(PPUThread& CPU, u32 displayMode)
if (IsPalInterpolate()) if (IsPalInterpolate())
{ {
//int ret = InitSystemResource(); //s32 ret = InitSystemResource();
//if (ret) return ret; //if (ret) return ret;
//InitLabels(); //InitLabels();
cellGcmSetSecondVFrequency(CELL_GCM_DISPLAY_FREQUENCY_59_94HZ); cellGcmSetSecondVFrequency(CELL_GCM_DISPLAY_FREQUENCY_59_94HZ);
@ -804,7 +804,7 @@ int cellRescSetDisplayMode(PPUThread& CPU, u32 displayMode)
return CELL_OK; return CELL_OK;
} }
int cellRescAdjustAspectRatio(float horizontal, float vertical) s32 cellRescAdjustAspectRatio(float horizontal, float vertical)
{ {
cellResc.Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical); cellResc.Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
@ -838,7 +838,7 @@ int cellRescAdjustAspectRatio(float horizontal, float vertical)
return CELL_OK; return CELL_OK;
} }
int cellRescSetPalInterpolateDropFlexRatio(float ratio) s32 cellRescSetPalInterpolateDropFlexRatio(float ratio)
{ {
cellResc.Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio); cellResc.Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
@ -859,7 +859,7 @@ int cellRescSetPalInterpolateDropFlexRatio(float ratio)
return CELL_OK; return CELL_OK;
} }
int cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader) s32 cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader)
{ {
cellResc.Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", cellResc.Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)",
colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr()); colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
@ -903,7 +903,7 @@ int cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, v
return CELL_OK; return CELL_OK;
} }
int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved) s32 cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
{ {
cellResc.Log("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved); cellResc.Log("cellRescGetNumColorBuffers(dstMode=%d, palTemporalMode=%d, reserved=%d)", dstMode, palTemporalMode, reserved);
@ -924,7 +924,7 @@ int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
: 2; : 2;
} }
int cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellRescSrc> rescSrc) s32 cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellRescSrc> rescSrc)
{ {
cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.addr(), rescSrc.addr()); cellResc.Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.addr(), rescSrc.addr());
@ -955,7 +955,7 @@ int cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellR
return CELL_OK; return CELL_OK;
} }
int cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src) s32 cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
{ {
cellResc.Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.addr()); cellResc.Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.addr());
@ -984,7 +984,7 @@ int cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
return 0; return 0;
} }
int cellRescSetConvertAndFlip(PPUThread& CPU, vm::ptr<CellGcmContextData> cntxt, s32 idx) s32 cellRescSetConvertAndFlip(PPUThread& CPU, vm::ptr<CellGcmContextData> cntxt, s32 idx)
{ {
cellResc.Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.addr(), idx); cellResc.Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.addr(), idx);
@ -1022,7 +1022,7 @@ int cellRescSetConvertAndFlip(PPUThread& CPU, vm::ptr<CellGcmContextData> cntxt,
return CELL_OK; return CELL_OK;
} }
int cellRescSetWaitFlip() s32 cellRescSetWaitFlip()
{ {
cellResc.Log("cellRescSetWaitFlip()"); cellResc.Log("cellRescSetWaitFlip()");
GSLockCurrent lock(GS_LOCK_WAIT_FLIP); GSLockCurrent lock(GS_LOCK_WAIT_FLIP);
@ -1030,7 +1030,7 @@ int cellRescSetWaitFlip()
return CELL_OK; return CELL_OK;
} }
int cellRescSetBufferAddress(PPUThread& CPU, vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader) s32 cellRescSetBufferAddress(PPUThread& CPU, vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, vm::ptr<u32> fragmentShader)
{ {
cellResc.Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr()); cellResc.Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
@ -1053,14 +1053,14 @@ int cellRescSetBufferAddress(PPUThread& CPU, vm::ptr<u32> colorBuffers, vm::ptr<
vm::stackvar<be_t<u32>> dstOffset(CPU); vm::stackvar<be_t<u32>> dstOffset(CPU);
cellGcmAddressToOffset(s_rescInternalInstance->m_colorBuffersEA, dstOffset); cellGcmAddressToOffset(s_rescInternalInstance->m_colorBuffersEA, dstOffset);
for (int i=0; i<GetNumColorBuffers(); i++) for (s32 i=0; i<GetNumColorBuffers(); i++)
{ {
s_rescInternalInstance->m_dstOffsets[i] = dstOffset.value() + i * s_rescInternalInstance->m_dstBufInterval; s_rescInternalInstance->m_dstOffsets[i] = dstOffset.value() + i * s_rescInternalInstance->m_dstBufInterval;
} }
for (int i=0; i<GetNumColorBuffers(); i++) for (s32 i=0; i<GetNumColorBuffers(); i++)
{ {
int ret = cellGcmSetDisplayBuffer(i, s_rescInternalInstance->m_dstOffsets[i], s_rescInternalInstance->m_dstPitch, s_rescInternalInstance->m_dstWidth, s_rescInternalInstance->m_dstHeight); s32 ret = cellGcmSetDisplayBuffer(i, s_rescInternalInstance->m_dstOffsets[i], s_rescInternalInstance->m_dstPitch, s_rescInternalInstance->m_dstWidth, s_rescInternalInstance->m_dstHeight);
if (ret) return ret; if (ret) return ret;
} }
@ -1088,14 +1088,14 @@ void cellRescResetFlipStatus()
Emu.GetGSManager().GetRender().m_flip_status = 1; Emu.GetGSManager().GetRender().m_flip_status = 1;
} }
int cellRescGetFlipStatus() s32 cellRescGetFlipStatus()
{ {
cellResc.Log("cellRescGetFlipStatus()"); cellResc.Log("cellRescGetFlipStatus()");
return Emu.GetGSManager().GetRender().m_flip_status; return Emu.GetGSManager().GetRender().m_flip_status;
} }
int cellRescGetRegisterCount() s32 cellRescGetRegisterCount()
{ {
UNIMPLEMENTED_FUNC(cellResc); UNIMPLEMENTED_FUNC(cellResc);
return CELL_OK; return CELL_OK;
@ -1108,7 +1108,7 @@ u64 cellRescGetLastFlipTime()
return Emu.GetGSManager().GetRender().m_last_flip_time; return Emu.GetGSManager().GetRender().m_last_flip_time;
} }
int cellRescSetRegisterCount() s32 cellRescSetRegisterCount()
{ {
UNIMPLEMENTED_FUNC(cellResc); UNIMPLEMENTED_FUNC(cellResc);
return CELL_OK; return CELL_OK;
@ -1163,7 +1163,7 @@ static void blackman(float window[])
window[3] = ((100.f - SEVIRITY) / 100.f + SEVIRITY / 100.f*a3); window[3] = ((100.f - SEVIRITY) / 100.f + SEVIRITY / 100.f*a3);
} }
int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableElement depth, int length) s32 CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableElement depth, s32 length)
{ {
float phi[4], transient[4]; float phi[4], transient[4];
float y_fraction; float y_fraction;
@ -1175,7 +1175,7 @@ int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
blackman(window); blackman(window);
for (int i = 0; i<length; i++) for (s32 i = 0; i<length; i++)
{ {
y_fraction = (float)i / (float)length; y_fraction = (float)i / (float)length;
@ -1211,7 +1211,7 @@ int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
return CELL_OK; return CELL_OK;
} }
int cellRescCreateInterlaceTable(u32 ea_addr, float srcH, CellRescTableElement depth, int length) s32 cellRescCreateInterlaceTable(u32 ea_addr, float srcH, CellRescTableElement depth, s32 length)
{ {
cellResc.Warning("cellRescCreateInterlaceTable(ea_addr=0x%x, srcH=%f, depth=%d, length=%d)", ea_addr, srcH, depth, length); cellResc.Warning("cellRescCreateInterlaceTable(ea_addr=0x%x, srcH=%f, depth=%d, length=%d)", ea_addr, srcH, depth, length);
@ -1236,17 +1236,17 @@ int cellRescCreateInterlaceTable(u32 ea_addr, float srcH, CellRescTableElement d
float ratioModeCoefficient = (s_rescInternalInstance->m_initConfig.ratioMode != CELL_RESC_LETTERBOX) ? 1.f : (1.f - 2.f * XY_DELTA_LB); float ratioModeCoefficient = (s_rescInternalInstance->m_initConfig.ratioMode != CELL_RESC_LETTERBOX) ? 1.f : (1.f - 2.f * XY_DELTA_LB);
float dstH = s_rescInternalInstance->m_dstHeight * ratioModeCoefficient * s_rescInternalInstance->m_ratioAdjY; float dstH = s_rescInternalInstance->m_dstHeight * ratioModeCoefficient * s_rescInternalInstance->m_ratioAdjY;
if (int retValue = CreateInterlaceTable(ea_addr, srcH, dstH, depth, length) == CELL_OK) if (s32 retValue = CreateInterlaceTable(ea_addr, srcH, dstH, depth, length))
{
return retValue;
}
else
{ {
s_rescInternalInstance->m_interlaceTableEA = ea_addr; s_rescInternalInstance->m_interlaceTableEA = ea_addr;
s_rescInternalInstance->m_interlaceElement = depth; s_rescInternalInstance->m_interlaceElement = depth;
s_rescInternalInstance->m_interlaceTableLength = length; s_rescInternalInstance->m_interlaceTableLength = length;
return CELL_OK; return CELL_OK;
} }
else
{
return retValue;
}
} }

70
rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
View file

@ -7,14 +7,14 @@
extern Module cellRtc; extern Module cellRtc;
s64 convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years) s64 convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, s32 years)
{ {
return (s64)seconds + (s64)minutes * 60 + (s64)hours * 3600 + (s64)days * 86400 + return (s64)seconds + (s64)minutes * 60 + (s64)hours * 3600 + (s64)days * 86400 +
(s64)(years - 70) * 31536000 + (s64)((years - 69) / 4) * 86400 - (s64)(years - 70) * 31536000 + (s64)((years - 69) / 4) * 86400 -
(s64)((years - 1) / 100) * 86400 + (s64)((years + 299) / 400) * 86400; (s64)((years - 1) / 100) * 86400 + (s64)((years + 299) / 400) * 86400;
} }
u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int years) u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, s32 years)
{ {
s64 unixtime = convertToUNIXTime(seconds, minutes, hours, days, years); s64 unixtime = convertToUNIXTime(seconds, minutes, hours, days, years);
u64 win32time = u64(unixtime) * u64(10000000) + u64(116444736000000000); u64 win32time = u64(unixtime) * u64(10000000) + u64(116444736000000000);
@ -22,7 +22,7 @@ u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int ye
return win32filetime; return win32filetime;
} }
int cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick) s32 cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
{ {
cellRtc.Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.addr()); cellRtc.Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.addr());
@ -31,7 +31,7 @@ int cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
return CELL_OK; return CELL_OK;
} }
int cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone) s32 cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone)
{ {
cellRtc.Log("cellRtcGetCurrentClock(pClock=0x%x, time_zone=%d)", pClock.addr(), iTimeZone); cellRtc.Log("cellRtcGetCurrentClock(pClock=0x%x, time_zone=%d)", pClock.addr(), iTimeZone);
@ -52,7 +52,7 @@ int cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone)
return CELL_OK; return CELL_OK;
} }
int cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock) s32 cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
{ {
cellRtc.Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.addr()); cellRtc.Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.addr());
@ -69,7 +69,7 @@ int cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone) s32 cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
{ {
cellRtc.Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime.addr(), pUtc.addr(), iTimeZone); cellRtc.Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime.addr(), pUtc.addr(), iTimeZone);
@ -87,7 +87,7 @@ int cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc) s32 cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc)
{ {
cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime.addr(), pUtc.addr()); cellRtc.Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime.addr(), pUtc.addr());
@ -101,7 +101,7 @@ int cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone) s32 cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
{ {
cellRtc.Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime.addr(), pUtc.addr(), iTimeZone); cellRtc.Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime.addr(), pUtc.addr(), iTimeZone);
@ -119,7 +119,7 @@ int cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
return CELL_OK; return CELL_OK;
} }
int cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc) s32 cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc)
{ {
cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime.addr(), pUtc.addr()); cellRtc.Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime.addr(), pUtc.addr());
@ -133,7 +133,7 @@ int cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
return CELL_OK; return CELL_OK;
} }
int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime) s32 cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
{ {
cellRtc.Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr()); cellRtc.Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
@ -146,7 +146,7 @@ int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
return CELL_OK; return CELL_OK;
} }
int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime) s32 cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
{ {
cellRtc.Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr()); cellRtc.Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
@ -159,7 +159,7 @@ int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
return CELL_OK; return CELL_OK;
} }
int cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick) s32 cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
{ {
cellRtc.Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.addr(), pTick.addr()); cellRtc.Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.addr(), pTick.addr());
@ -169,7 +169,7 @@ int cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
return CELL_OK; return CELL_OK;
} }
int cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick) s32 cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
{ {
cellRtc.Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.addr(), pTick.addr()); cellRtc.Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.addr(), pTick.addr());
@ -186,7 +186,7 @@ int cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd) s32 cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd); cellRtc.Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
@ -194,7 +194,7 @@ int cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd) s32 cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd); cellRtc.Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
@ -206,7 +206,7 @@ int cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick>
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd) s32 cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd); cellRtc.Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
@ -218,7 +218,7 @@ int cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTic
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd) s32 cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
{ {
cellRtc.Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd); cellRtc.Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
@ -230,7 +230,7 @@ int cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTic
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd) s32 cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd); cellRtc.Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
@ -242,7 +242,7 @@ int cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd) s32 cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd); cellRtc.Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
@ -254,7 +254,7 @@ int cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1,
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd) s32 cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd); cellRtc.Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
@ -266,7 +266,7 @@ int cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd) s32 cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd); cellRtc.Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
@ -278,7 +278,7 @@ int cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick
return CELL_OK; return CELL_OK;
} }
int cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd) s32 cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
{ {
cellRtc.Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd); cellRtc.Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
@ -290,7 +290,7 @@ int cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
return CELL_OK; return CELL_OK;
} }
int cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick> pLocalTime) s32 cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick> pLocalTime)
{ {
cellRtc.Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.addr(), pLocalTime.addr()); cellRtc.Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.addr(), pLocalTime.addr());
@ -300,7 +300,7 @@ int cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick>
return CELL_OK; return CELL_OK;
} }
int cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRtcTick> pUtc) s32 cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRtcTick> pUtc)
{ {
cellRtc.Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.addr(), pUtc.addr()); cellRtc.Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.addr(), pUtc.addr());
@ -310,7 +310,7 @@ int cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRt
return CELL_OK; return CELL_OK;
} }
int cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u32> puiDosTime) s32 cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u32> puiDosTime)
{ {
cellRtc.Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.addr(), puiDosTime.addr()); cellRtc.Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.addr(), puiDosTime.addr());
@ -321,7 +321,7 @@ int cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u32> puiDosTim
return CELL_OK; return CELL_OK;
} }
int cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<s64> piTime) s32 cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<s64> piTime)
{ {
cellRtc.Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.addr(), piTime.addr()); cellRtc.Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.addr(), piTime.addr());
@ -333,7 +333,7 @@ int cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<s64> piTime)
return CELL_OK; return CELL_OK;
} }
int cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u64> pulWin32FileTime) s32 cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u64> pulWin32FileTime)
{ {
cellRtc.Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.addr(), pulWin32FileTime.addr()); cellRtc.Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.addr(), pulWin32FileTime.addr());
@ -345,7 +345,7 @@ int cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u64> pul
return CELL_OK; return CELL_OK;
} }
int cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime) s32 cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime)
{ {
cellRtc.Log("cellRtcSetDosTime(pDateTime=0x%x, uiDosTime=0x%x)", pDateTime.addr(), uiDosTime); cellRtc.Log("cellRtcSetDosTime(pDateTime=0x%x, uiDosTime=0x%x)", pDateTime.addr(), uiDosTime);
@ -363,7 +363,7 @@ int cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime)
return CELL_OK; return CELL_OK;
} }
int cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime) s32 cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
{ {
cellRtc.Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.addr(), iTime); cellRtc.Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.addr(), iTime);
@ -380,7 +380,7 @@ int cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
return CELL_OK; return CELL_OK;
} }
int cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileTime) s32 cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
{ {
cellRtc.Log("cellRtcSetWin32FileTime(pDateTime_addr=0x%x, ulWin32FileTime=0x%llx)", pDateTime.addr(), ulWin32FileTime); cellRtc.Log("cellRtcSetWin32FileTime(pDateTime_addr=0x%x, ulWin32FileTime=0x%llx)", pDateTime.addr(), ulWin32FileTime);
@ -397,7 +397,7 @@ int cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileT
return CELL_OK; return CELL_OK;
} }
int cellRtcIsLeapYear(s32 year) s32 cellRtcIsLeapYear(s32 year)
{ {
cellRtc.Log("cellRtcIsLeapYear(year=%d)", year); cellRtc.Log("cellRtcIsLeapYear(year=%d)", year);
@ -405,7 +405,7 @@ int cellRtcIsLeapYear(s32 year)
return datetime.IsLeapYear(year, rDateTime::Gregorian); return datetime.IsLeapYear(year, rDateTime::Gregorian);
} }
int cellRtcGetDaysInMonth(s32 year, s32 month) s32 cellRtcGetDaysInMonth(s32 year, s32 month)
{ {
cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month); cellRtc.Log("cellRtcGetDaysInMonth(year=%d, month=%d)", year, month);
@ -413,7 +413,7 @@ int cellRtcGetDaysInMonth(s32 year, s32 month)
return datetime.GetNumberOfDays((rDateTime::Month) month, year, rDateTime::Gregorian); return datetime.GetNumberOfDays((rDateTime::Month) month, year, rDateTime::Gregorian);
} }
int cellRtcGetDayOfWeek(s32 year, s32 month, s32 day) s32 cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
{ {
cellRtc.Log("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day); cellRtc.Log("cellRtcGetDayOfWeek(year=%d, month=%d, day=%d)", year, month, day);
@ -422,7 +422,7 @@ int cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
return datetime.GetWeekDay(); return datetime.GetWeekDay();
} }
int cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime) s32 cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
{ {
cellRtc.Log("cellRtcCheckValid(pTime=0x%x)", pTime.addr()); cellRtc.Log("cellRtcCheckValid(pTime=0x%x)", pTime.addr());
@ -436,7 +436,7 @@ int cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
else return CELL_OK; else return CELL_OK;
} }
int cellRtcCompareTick(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1) s32 cellRtcCompareTick(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1)
{ {
cellRtc.Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.addr(), pTick1.addr()); cellRtc.Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.addr(), pTick1.addr());

252
rpcs3/Emu/SysCalls/Modules/cellSail.cpp
View file

@ -8,7 +8,7 @@
extern Module cellSail; extern Module cellSail;
int cellSailMemAllocatorInitialize(vm::ptr<CellSailMemAllocator> pSelf, vm::ptr<CellSailMemAllocatorFuncs> pCallbacks) s32 cellSailMemAllocatorInitialize(vm::ptr<CellSailMemAllocator> pSelf, vm::ptr<CellSailMemAllocatorFuncs> pCallbacks)
{ {
cellSail.Warning("cellSailMemAllocatorInitialize(pSelf_addr=0x%x, pCallbacks_addr=0x%x)", pSelf.addr(), pCallbacks.addr()); cellSail.Warning("cellSailMemAllocatorInitialize(pSelf_addr=0x%x, pCallbacks_addr=0x%x)", pSelf.addr(), pCallbacks.addr());
@ -18,61 +18,61 @@ int cellSailMemAllocatorInitialize(vm::ptr<CellSailMemAllocator> pSelf, vm::ptr<
return CELL_OK; return CELL_OK;
} }
int cellSailFutureInitialize() s32 cellSailFutureInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailFutureFinalize() s32 cellSailFutureFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailFutureReset() s32 cellSailFutureReset()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailFutureSet() s32 cellSailFutureSet()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailFutureGet() s32 cellSailFutureGet()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailFutureIsDone() s32 cellSailFutureIsDone()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorGetStreamType() s32 cellSailDescriptorGetStreamType()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorGetUri() s32 cellSailDescriptorGetUri()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorGetMediaInfo() s32 cellSailDescriptorGetMediaInfo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorSetAutoSelection(vm::ptr<CellSailDescriptor> pSelf, bool autoSelection) s32 cellSailDescriptorSetAutoSelection(vm::ptr<CellSailDescriptor> pSelf, bool autoSelection)
{ {
cellSail.Warning("cellSailDescriptorSetAutoSelection(pSelf_addr=0x%x, autoSelection=%s)", pSelf.addr(), autoSelection ? "true" : "false"); cellSail.Warning("cellSailDescriptorSetAutoSelection(pSelf_addr=0x%x, autoSelection=%s)", pSelf.addr(), autoSelection ? "true" : "false");
@ -84,7 +84,7 @@ int cellSailDescriptorSetAutoSelection(vm::ptr<CellSailDescriptor> pSelf, bool a
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf) s32 cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
{ {
cellSail.Warning("cellSailDescriptorIsAutoSelection(pSelf_addr=0x%x)", pSelf.addr()); cellSail.Warning("cellSailDescriptorIsAutoSelection(pSelf_addr=0x%x)", pSelf.addr());
@ -94,7 +94,7 @@ int cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<void> pDatabase, u32 size, u64 arg) s32 cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<void> pDatabase, u32 size, u64 arg)
{ {
cellSail.Warning("cellSailDescriptorCreateDatabase(pSelf=0x%x, pDatabase=0x%x, size=0x%x, arg=0x%x", pSelf.addr(), pDatabase.addr(), size, arg); cellSail.Warning("cellSailDescriptorCreateDatabase(pSelf=0x%x, pDatabase=0x%x, size=0x%x, arg=0x%x", pSelf.addr(), pDatabase.addr(), size, arg);
@ -113,409 +113,409 @@ int cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorDestroyDatabase() s32 cellSailDescriptorDestroyDatabase()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorOpen() s32 cellSailDescriptorOpen()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorClose() s32 cellSailDescriptorClose()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorSetEs() s32 cellSailDescriptorSetEs()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorClearEs() s32 cellSailDescriptorClearEs()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorGetCapabilities() s32 cellSailDescriptorGetCapabilities()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorInquireCapability() s32 cellSailDescriptorInquireCapability()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailDescriptorSetParameter() s32 cellSailDescriptorSetParameter()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterInitialize() s32 cellSailSoundAdapterInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterFinalize() s32 cellSailSoundAdapterFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterSetPreferredFormat() s32 cellSailSoundAdapterSetPreferredFormat()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterGetFrame() s32 cellSailSoundAdapterGetFrame()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterGetFormat() s32 cellSailSoundAdapterGetFormat()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterUpdateAvSync() s32 cellSailSoundAdapterUpdateAvSync()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSoundAdapterPtsToTimePosition() s32 cellSailSoundAdapterPtsToTimePosition()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterInitialize() s32 cellSailGraphicsAdapterInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterFinalize() s32 cellSailGraphicsAdapterFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterSetPreferredFormat() s32 cellSailGraphicsAdapterSetPreferredFormat()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterGetFrame() s32 cellSailGraphicsAdapterGetFrame()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterGetFrame2() s32 cellSailGraphicsAdapterGetFrame2()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterGetFormat() s32 cellSailGraphicsAdapterGetFormat()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterUpdateAvSync() s32 cellSailGraphicsAdapterUpdateAvSync()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailGraphicsAdapterPtsToTimePosition() s32 cellSailGraphicsAdapterPtsToTimePosition()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAuReceiverInitialize() s32 cellSailAuReceiverInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAuReceiverFinalize() s32 cellSailAuReceiverFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAuReceiverGet() s32 cellSailAuReceiverGet()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererAudioInitialize() s32 cellSailRendererAudioInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererAudioFinalize() s32 cellSailRendererAudioFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererAudioNotifyCallCompleted() s32 cellSailRendererAudioNotifyCallCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererAudioNotifyFrameDone() s32 cellSailRendererAudioNotifyFrameDone()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererAudioNotifyOutputEos() s32 cellSailRendererAudioNotifyOutputEos()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererVideoInitialize() s32 cellSailRendererVideoInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererVideoFinalize() s32 cellSailRendererVideoFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererVideoNotifyCallCompleted() s32 cellSailRendererVideoNotifyCallCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererVideoNotifyFrameDone() s32 cellSailRendererVideoNotifyFrameDone()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailRendererVideoNotifyOutputEos() s32 cellSailRendererVideoNotifyOutputEos()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceInitialize() s32 cellSailSourceInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceFinalize() s32 cellSailSourceFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyCallCompleted() s32 cellSailSourceNotifyCallCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyInputEos() s32 cellSailSourceNotifyInputEos()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyStreamOut() s32 cellSailSourceNotifyStreamOut()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifySessionError() s32 cellSailSourceNotifySessionError()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyMediaStateChanged() s32 cellSailSourceNotifyMediaStateChanged()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceCheck() s32 cellSailSourceCheck()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyOpenCompleted() s32 cellSailSourceNotifyOpenCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyStartCompleted() s32 cellSailSourceNotifyStartCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyStopCompleted() s32 cellSailSourceNotifyStopCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyReadCompleted() s32 cellSailSourceNotifyReadCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceSetDiagHandler() s32 cellSailSourceSetDiagHandler()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailSourceNotifyCloseCompleted() s32 cellSailSourceNotifyCloseCompleted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4MovieGetBrand() s32 cellSailMp4MovieGetBrand()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4MovieIsCompatibleBrand() s32 cellSailMp4MovieIsCompatibleBrand()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4MovieGetMovieInfo() s32 cellSailMp4MovieGetMovieInfo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4MovieGetTrackByIndex() s32 cellSailMp4MovieGetTrackByIndex()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4MovieGetTrackById() s32 cellSailMp4MovieGetTrackById()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4MovieGetTrackByTypeAndIndex() s32 cellSailMp4MovieGetTrackByTypeAndIndex()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4TrackGetTrackInfo() s32 cellSailMp4TrackGetTrackInfo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4TrackGetTrackReferenceCount() s32 cellSailMp4TrackGetTrackReferenceCount()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4TrackGetTrackReference() s32 cellSailMp4TrackGetTrackReference()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailMp4ConvertTimeScale() s32 cellSailMp4ConvertTimeScale()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAviMovieGetMovieInfo() s32 cellSailAviMovieGetMovieInfo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAviMovieGetStreamByIndex() s32 cellSailAviMovieGetStreamByIndex()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAviMovieGetStreamByTypeAndIndex() s32 cellSailAviMovieGetStreamByTypeAndIndex()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAviMovieGetHeader() s32 cellSailAviMovieGetHeader()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAviStreamGetMediaType() s32 cellSailAviStreamGetMediaType()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailAviStreamGetHeader() s32 cellSailAviStreamGetHeader()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerInitialize() s32 cellSailPlayerInitialize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerInitialize2(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailMemAllocator> pAllocator, vm::ptr<CellSailPlayerFuncNotified> pCallback, u64 callbackArg, s32 cellSailPlayerInitialize2(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailMemAllocator> pAllocator, vm::ptr<CellSailPlayerFuncNotified> pCallback, u64 callbackArg,
vm::ptr<CellSailPlayerAttribute> pAttribute, vm::ptr<CellSailPlayerResource> pResource) vm::ptr<CellSailPlayerAttribute> pAttribute, vm::ptr<CellSailPlayerResource> pResource)
{ {
cellSail.Warning("cellSailPlayerInitialize2(pSelf_addr=0x%x, pAllocator_addr=0x%x, pCallback=0x%x, callbackArg=%d, pAttribute_addr=0x%x, pResource=0x%x)", pSelf.addr(), cellSail.Warning("cellSailPlayerInitialize2(pSelf_addr=0x%x, pAllocator_addr=0x%x, pCallback=0x%x, callbackArg=%d, pAttribute_addr=0x%x, pResource=0x%x)", pSelf.addr(),
@ -530,91 +530,91 @@ int cellSailPlayerInitialize2(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailMem
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerFinalize() s32 cellSailPlayerFinalize()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerRegisterSource() s32 cellSailPlayerRegisterSource()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerGetRegisteredProtocols() s32 cellSailPlayerGetRegisteredProtocols()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetSoundAdapter() s32 cellSailPlayerSetSoundAdapter()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetGraphicsAdapter() s32 cellSailPlayerSetGraphicsAdapter()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetAuReceiver() s32 cellSailPlayerSetAuReceiver()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetRendererAudio() s32 cellSailPlayerSetRendererAudio()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetRendererVideo() s32 cellSailPlayerSetRendererVideo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetParameter() s32 cellSailPlayerSetParameter()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerGetParameter() s32 cellSailPlayerGetParameter()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSubscribeEvent() s32 cellSailPlayerSubscribeEvent()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerUnsubscribeEvent() s32 cellSailPlayerUnsubscribeEvent()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerReplaceEventHandler() s32 cellSailPlayerReplaceEventHandler()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerBoot() s32 cellSailPlayerBoot()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc) s32 cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc)
{ {
cellSail.Warning("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), pDesc.addr()); cellSail.Warning("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), pDesc.addr());
@ -632,7 +632,7 @@ int cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailD
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType, vm::ptr<u32> pMediaInfo, vm::cptr<char> pUri, vm::ptr<u32> ppDesc) s32 cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType, vm::ptr<u32> pMediaInfo, vm::cptr<char> pUri, vm::ptr<u32> ppDesc)
{ {
cellSail.Warning("cellSailPlayerCreateDescriptor(pSelf_addr=0x%x, streamType=%d, pMediaInfo_addr=0x%x, pUri_addr=0x%x, ppDesc_addr=0x%x)", pSelf.addr(), streamType, cellSail.Warning("cellSailPlayerCreateDescriptor(pSelf_addr=0x%x, streamType=%d, pMediaInfo_addr=0x%x, pUri_addr=0x%x, ppDesc_addr=0x%x)", pSelf.addr(), streamType,
pMediaInfo.addr(), pUri.addr(), ppDesc.addr()); pMediaInfo.addr(), pUri.addr(), ppDesc.addr());
@ -685,7 +685,7 @@ int cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc) s32 cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> pDesc)
{ {
cellSail.Todo("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), pDesc.addr()); cellSail.Todo("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), pDesc.addr());
@ -695,7 +695,7 @@ int cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellS
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerRemoveDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> ppDesc) s32 cellSailPlayerRemoveDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailDescriptor> ppDesc)
{ {
cellSail.Warning("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), ppDesc.addr()); cellSail.Warning("cellSailPlayerAddDescriptor(pSelf_addr=0x%x, pDesc_addr=0x%x)", pSelf.addr(), ppDesc.addr());
@ -709,121 +709,121 @@ int cellSailPlayerRemoveDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSa
return pSelf->descriptors; return pSelf->descriptors;
} }
int cellSailPlayerGetDescriptorCount(vm::ptr<CellSailPlayer> pSelf) s32 cellSailPlayerGetDescriptorCount(vm::ptr<CellSailPlayer> pSelf)
{ {
cellSail.Warning("cellSailPlayerGetDescriptorCount(pSelf_addr=0x%x)", pSelf.addr()); cellSail.Warning("cellSailPlayerGetDescriptorCount(pSelf_addr=0x%x)", pSelf.addr());
return pSelf->descriptors; return pSelf->descriptors;
} }
int cellSailPlayerGetCurrentDescriptor() s32 cellSailPlayerGetCurrentDescriptor()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerOpenStream() s32 cellSailPlayerOpenStream()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerCloseStream() s32 cellSailPlayerCloseStream()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerOpenEsAudio() s32 cellSailPlayerOpenEsAudio()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerOpenEsVideo() s32 cellSailPlayerOpenEsVideo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerOpenEsUser() s32 cellSailPlayerOpenEsUser()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerReopenEsAudio() s32 cellSailPlayerReopenEsAudio()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerReopenEsVideo() s32 cellSailPlayerReopenEsVideo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerReopenEsUser() s32 cellSailPlayerReopenEsUser()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerCloseEsAudio() s32 cellSailPlayerCloseEsAudio()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerCloseEsVideo() s32 cellSailPlayerCloseEsVideo()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerCloseEsUser() s32 cellSailPlayerCloseEsUser()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerStart() s32 cellSailPlayerStart()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerStop() s32 cellSailPlayerStop()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerNext() s32 cellSailPlayerNext()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerCancel() s32 cellSailPlayerCancel()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetPaused(vm::ptr<CellSailPlayer> pSelf, bool paused) s32 cellSailPlayerSetPaused(vm::ptr<CellSailPlayer> pSelf, bool paused)
{ {
cellSail.Todo("cellSailPlayerSetPaused(pSelf_addr=0x%x, paused=%d)", pSelf.addr(), paused); cellSail.Todo("cellSailPlayerSetPaused(pSelf_addr=0x%x, paused=%d)", pSelf.addr(), paused);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerIsPaused(vm::ptr<CellSailPlayer> pSelf) s32 cellSailPlayerIsPaused(vm::ptr<CellSailPlayer> pSelf)
{ {
cellSail.Warning("cellSailPlayerIsPaused(pSelf_addr=0x%x)", pSelf.addr()); cellSail.Warning("cellSailPlayerIsPaused(pSelf_addr=0x%x)", pSelf.addr());
return pSelf->paused; return pSelf->paused;
} }
int cellSailPlayerSetRepeatMode(vm::ptr<CellSailPlayer> pSelf, s32 repeatMode, vm::ptr<CellSailStartCommand> pCommand) s32 cellSailPlayerSetRepeatMode(vm::ptr<CellSailPlayer> pSelf, s32 repeatMode, vm::ptr<CellSailStartCommand> pCommand)
{ {
cellSail.Warning("cellSailPlayerSetRepeatMode(pSelf_addr=0x%x, repeatMode=%d, pCommand_addr=0x%x)", pSelf.addr(), repeatMode, pCommand.addr()); cellSail.Warning("cellSailPlayerSetRepeatMode(pSelf_addr=0x%x, repeatMode=%d, pCommand_addr=0x%x)", pSelf.addr(), repeatMode, pCommand.addr());
@ -833,7 +833,7 @@ int cellSailPlayerSetRepeatMode(vm::ptr<CellSailPlayer> pSelf, s32 repeatMode, v
return pSelf->repeatMode; return pSelf->repeatMode;
} }
int cellSailPlayerGetRepeatMode(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailStartCommand> pCommand) s32 cellSailPlayerGetRepeatMode(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailStartCommand> pCommand)
{ {
cellSail.Warning("cellSailPlayerGetRepeatMode(pSelf_addr=0x%x, pCommand_addr=0x%x)", pSelf.addr(), pCommand.addr()); cellSail.Warning("cellSailPlayerGetRepeatMode(pSelf_addr=0x%x, pCommand_addr=0x%x)", pSelf.addr(), pCommand.addr());
@ -842,37 +842,37 @@ int cellSailPlayerGetRepeatMode(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailS
return pSelf->repeatMode; return pSelf->repeatMode;
} }
int cellSailPlayerSetEsAudioMuted() s32 cellSailPlayerSetEsAudioMuted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerSetEsVideoMuted() s32 cellSailPlayerSetEsVideoMuted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerIsEsAudioMuted() s32 cellSailPlayerIsEsAudioMuted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerIsEsVideoMuted() s32 cellSailPlayerIsEsVideoMuted()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerDumpImage() s32 cellSailPlayerDumpImage()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;
} }
int cellSailPlayerUnregisterSource() s32 cellSailPlayerUnregisterSource()
{ {
UNIMPLEMENTED_FUNC(cellSail); UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK; return CELL_OK;

18
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View file

@ -283,9 +283,9 @@ bool spursIsLibProfLoaded()
/// Create an LV2 event queue and attach it to the SPURS instance /// Create an LV2 event queue and attach it to the SPURS instance
s32 spursCreateLv2EventQueue(PPUThread& CPU, vm::ptr<CellSpurs> spurs, vm::ptr<u32> queueId, vm::ptr<u8> port, s32 size, vm::cptr<char> name) s32 spursCreateLv2EventQueue(PPUThread& CPU, vm::ptr<CellSpurs> spurs, vm::ptr<u32> queueId, vm::ptr<u8> port, s32 size, vm::cptr<char> name)
{ {
vm::stackvar<sys_event_queue_attr> attr(CPU); vm::stackvar<sys_event_queue_attribute_t> attr(CPU);
auto sys_event_queue_attribute_initialize = [](vm::ptr<sys_event_queue_attr> attr) auto sys_event_queue_attribute_initialize = [](vm::ptr<sys_event_queue_attribute_t> attr)
{ {
attr->protocol = SYS_SYNC_PRIORITY; attr->protocol = SYS_SYNC_PRIORITY;
attr->type = SYS_PPU_QUEUE; attr->type = SYS_PPU_QUEUE;
@ -1718,7 +1718,7 @@ s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> prior
} }
u64 prio = 0; u64 prio = 0;
for (int i = 0; i < CELL_SPURS_MAX_SPU; i++) for (s32 i = 0; i < CELL_SPURS_MAX_SPU; i++)
{ {
if (priorities[i] >= CELL_SPURS_MAX_PRIORITY) if (priorities[i] >= CELL_SPURS_MAX_PRIORITY)
{ {
@ -2812,8 +2812,8 @@ s32 cellSpursEventFlagSet(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag,
} }
} }
int i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1; s32 i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1;
int j = 0; s32 j = 0;
u16 relevantWaitSlots = eventFlag->spuTaskUsedWaitSlots & ~ctrl.spuTaskPendingRecv; u16 relevantWaitSlots = eventFlag->spuTaskUsedWaitSlots & ~ctrl.spuTaskPendingRecv;
while (relevantWaitSlots) while (relevantWaitSlots)
{ {
@ -2862,7 +2862,7 @@ s32 cellSpursEventFlagSet(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag,
if (pendingRecv) if (pendingRecv)
{ {
// Signal each SPU task whose conditions have been met to be woken up // Signal each SPU task whose conditions have been met to be woken up
for (int i = 0; i < CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS; i++) for (s32 i = 0; i < CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS; i++)
{ {
if (pendingRecv & (0x8000 >> i)) if (pendingRecv & (0x8000 >> i))
{ {
@ -2951,7 +2951,7 @@ s32 spursEventFlagWait(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag, vm
relevantWaitSlots &= eventFlag->spuTaskWaitMode; relevantWaitSlots &= eventFlag->spuTaskWaitMode;
} }
int i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1; s32 i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1;
while (relevantWaitSlots) while (relevantWaitSlots)
{ {
if (relevantWaitSlots & 0x0001) if (relevantWaitSlots & 0x0001)
@ -2995,7 +2995,7 @@ s32 spursEventFlagWait(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag, vm
if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY) if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
{ {
// Find an unsed wait slot // Find an unsed wait slot
int i = 0; s32 i = 0;
u16 spuTaskUsedWaitSlots = eventFlag->spuTaskUsedWaitSlots; u16 spuTaskUsedWaitSlots = eventFlag->spuTaskUsedWaitSlots;
while (spuTaskUsedWaitSlots & 0x0001) while (spuTaskUsedWaitSlots & 0x0001)
{ {
@ -3038,7 +3038,7 @@ s32 spursEventFlagWait(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag, vm
throw EXCEPTION("sys_event_queue_receive() failed (0x%x)", rc); throw EXCEPTION("sys_event_queue_receive() failed (0x%x)", rc);
} }
int i = 0; s32 i = 0;
if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY) if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
{ {
i = eventFlag->ctrl.data.ppuWaitSlotAndMode >> 4; i = eventFlag->ctrl.data.ppuWaitSlotAndMode >> 4;

20
rpcs3/Emu/SysCalls/Modules/cellSubdisplay.cpp
View file

@ -6,19 +6,19 @@
extern Module cellSubdisplay; extern Module cellSubdisplay;
int cellSubDisplayInit() s32 cellSubDisplayInit()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayEnd() s32 cellSubDisplayEnd()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam) s32 cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam)
{ {
cellSubdisplay.Warning("cellSubDisplayGetRequiredMemory(pParam_addr=0x%x)", pParam.addr()); cellSubdisplay.Warning("cellSubDisplayGetRequiredMemory(pParam_addr=0x%x)", pParam.addr());
@ -32,43 +32,43 @@ int cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam)
} }
} }
int cellSubDisplayStart() s32 cellSubDisplayStart()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayStop() s32 cellSubDisplayStop()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayGetVideoBuffer() s32 cellSubDisplayGetVideoBuffer()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayAudioOutBlocking() s32 cellSubDisplayAudioOutBlocking()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayAudioOutNonBlocking() s32 cellSubDisplayAudioOutNonBlocking()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayGetPeerNum() s32 cellSubDisplayGetPeerNum()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;
} }
int cellSubDisplayGetPeerList() s32 cellSubDisplayGetPeerList()
{ {
UNIMPLEMENTED_FUNC(cellSubdisplay); UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK; return CELL_OK;

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

@ -59,7 +59,7 @@ CHECK_SIZE_ALIGN(CellSyncMutex, 4, 4);
struct set_alignment(4) sync_barrier_t // CellSyncBarrier sync var struct set_alignment(4) sync_barrier_t // CellSyncBarrier sync var
{ {
be_t<s16> value; be_t<s16> value;
be_t<s16> count; be_t<u16> count;
bool try_notify() bool try_notify()
{ {

4
rpcs3/Emu/SysCalls/Modules/cellSysutilAp.cpp
View file

@ -25,13 +25,13 @@ s32 cellSysutilApGetRequiredMemSize()
return 1024*1024; // Return 1 MB as required size return 1024*1024; // Return 1 MB as required size
} }
int cellSysutilApOn() s32 cellSysutilApOn()
{ {
UNIMPLEMENTED_FUNC(cellSysutilAp); UNIMPLEMENTED_FUNC(cellSysutilAp);
return CELL_OK; return CELL_OK;
} }
int cellSysutilApOff() s32 cellSysutilApOff()
{ {
UNIMPLEMENTED_FUNC(cellSysutilAp); UNIMPLEMENTED_FUNC(cellSysutilAp);
return CELL_OK; return CELL_OK;

10
rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
View file

@ -9,7 +9,7 @@
extern Module cellUserInfo; extern Module cellUserInfo;
int cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat) s32 cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat)
{ {
cellUserInfo.Warning("cellUserInfoGetStat(id=%d, stat_addr=0x%x)", id, stat.addr()); cellUserInfo.Warning("cellUserInfoGetStat(id=%d, stat_addr=0x%x)", id, stat.addr());
@ -37,25 +37,25 @@ int cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat)
return CELL_OK; return CELL_OK;
} }
int cellUserInfoSelectUser_ListType() s32 cellUserInfoSelectUser_ListType()
{ {
UNIMPLEMENTED_FUNC(cellUserInfo); UNIMPLEMENTED_FUNC(cellUserInfo);
return CELL_OK; return CELL_OK;
} }
int cellUserInfoSelectUser_SetList() s32 cellUserInfoSelectUser_SetList()
{ {
UNIMPLEMENTED_FUNC(cellUserInfo); UNIMPLEMENTED_FUNC(cellUserInfo);
return CELL_OK; return CELL_OK;
} }
int cellUserInfoEnableOverlay() s32 cellUserInfoEnableOverlay()
{ {
UNIMPLEMENTED_FUNC(cellUserInfo); UNIMPLEMENTED_FUNC(cellUserInfo);
return CELL_OK; return CELL_OK;
} }
int cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserList> listBuf, vm::ptr<u32> currentUserId) s32 cellUserInfoGetList(vm::ptr<u32> listNum, vm::ptr<CellUserInfoUserList> listBuf, vm::ptr<u32> currentUserId)
{ {
cellUserInfo.Warning("cellUserInfoGetList(listNum_addr=0x%x, listBuf_addr=0x%x, currentUserId_addr=0x%x)", cellUserInfo.Warning("cellUserInfoGetList(listNum_addr=0x%x, listBuf_addr=0x%x, currentUserId_addr=0x%x)",
listNum.addr(), listBuf.addr(), currentUserId.addr()); listNum.addr(), listBuf.addr(), currentUserId.addr());

52
rpcs3/Emu/SysCalls/Modules/libmixer.cpp
View file

@ -20,7 +20,7 @@ u64 mixcount;
std::vector<SSPlayer> ssp; std::vector<SSPlayer> ssp;
int cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr, u32 samples) s32 cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr, u32 samples)
{ {
libmixer.Log("cellAANAddData(handle=0x%x, port=0x%x, offset=0x%x, addr_addr=0x%x, samples=%d)", aan_handle, aan_port, offset, addr.addr(), samples); libmixer.Log("cellAANAddData(handle=0x%x, port=0x%x, offset=0x%x, addr_addr=0x%x, samples=%d)", aan_handle, aan_port, offset, addr.addr(), samples);
@ -101,7 +101,7 @@ int cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr
return CELL_OK; return CELL_OK;
} }
int cellAANConnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo) s32 cellAANConnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
{ {
libmixer.Warning("cellAANConnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)", libmixer.Warning("cellAANConnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)",
receive, receivePortNo, source, sourcePortNo); receive, receivePortNo, source, sourcePortNo);
@ -119,7 +119,7 @@ int cellAANConnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
return CELL_OK; return CELL_OK;
} }
int cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo) s32 cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
{ {
libmixer.Warning("cellAANDisconnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)", libmixer.Warning("cellAANDisconnect(receive=0x%x, receivePortNo=0x%x, source=0x%x, sourcePortNo=0x%x)",
receive, receivePortNo, source, sourcePortNo); receive, receivePortNo, source, sourcePortNo);
@ -137,7 +137,7 @@ int cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePort
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config) s32 cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
{ {
libmixer.Warning("cellSSPlayerCreate(handle_addr=0x%x, config_addr=0x%x)", libmixer.Warning("cellSSPlayerCreate(handle_addr=0x%x, config_addr=0x%x)",
handle.addr(), config.addr()); handle.addr(), config.addr());
@ -162,7 +162,7 @@ int cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerRemove(u32 handle) s32 cellSSPlayerRemove(u32 handle)
{ {
libmixer.Warning("cellSSPlayerRemove(handle=0x%x)", handle); libmixer.Warning("cellSSPlayerRemove(handle=0x%x)", handle);
@ -181,7 +181,7 @@ int cellSSPlayerRemove(u32 handle)
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm::ptr<CellSSPlayerCommonParam> commonInfo) s32 cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm::ptr<CellSSPlayerCommonParam> commonInfo)
{ {
libmixer.Warning("cellSSPlayerSetWave(handle=0x%x, waveInfo_addr=0x%x, commonInfo_addr=0x%x)", libmixer.Warning("cellSSPlayerSetWave(handle=0x%x, waveInfo_addr=0x%x, commonInfo_addr=0x%x)",
handle, waveInfo.addr(), commonInfo.addr()); handle, waveInfo.addr(), commonInfo.addr());
@ -205,7 +205,7 @@ int cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm:
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info) s32 cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
{ {
libmixer.Warning("cellSSPlayerPlay(handle=0x%x, info_addr=0x%x)", handle, info.addr()); libmixer.Warning("cellSSPlayerPlay(handle=0x%x, info_addr=0x%x)", handle, info.addr());
@ -229,7 +229,7 @@ int cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerStop(u32 handle, u32 mode) s32 cellSSPlayerStop(u32 handle, u32 mode)
{ {
libmixer.Warning("cellSSPlayerStop(handle=0x%x, mode=0x%x)", handle, mode); libmixer.Warning("cellSSPlayerStop(handle=0x%x, mode=0x%x)", handle, mode);
@ -248,7 +248,7 @@ int cellSSPlayerStop(u32 handle, u32 mode)
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info) s32 cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
{ {
libmixer.Warning("cellSSPlayerSetParam(handle=0x%x, info_addr=0x%x)", handle, info.addr()); libmixer.Warning("cellSSPlayerSetParam(handle=0x%x, info_addr=0x%x)", handle, info.addr());
@ -271,7 +271,7 @@ int cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
return CELL_OK; return CELL_OK;
} }
int cellSSPlayerGetState(u32 handle) s32 cellSSPlayerGetState(u32 handle)
{ {
libmixer.Warning("cellSSPlayerGetState(handle=0x%x)", handle); libmixer.Warning("cellSSPlayerGetState(handle=0x%x)", handle);
@ -291,7 +291,7 @@ int cellSSPlayerGetState(u32 handle)
return CELL_SSPLAYER_STATE_OFF; return CELL_SSPLAYER_STATE_OFF;
} }
int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config) s32 cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
{ {
libmixer.Warning("cellSurMixerCreate(config_addr=0x%x)", config.addr()); libmixer.Warning("cellSurMixerCreate(config_addr=0x%x)", config.addr());
@ -364,10 +364,10 @@ int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
float right = 0.0f; float right = 0.0f;
float speed = fabs(p.m_speed); float speed = fabs(p.m_speed);
float fpos = 0.0f; float fpos = 0.0f;
for (int i = 0; i < 256; i++) if (p.m_active) for (s32 i = 0; i < 256; i++) if (p.m_active)
{ {
u32 pos = p.m_position; u32 pos = p.m_position;
int pos_inc = 0; s32 pos_inc = 0;
if (p.m_speed > 0.0f) // select direction if (p.m_speed > 0.0f) // select direction
{ {
pos_inc = 1; pos_inc = 1;
@ -376,7 +376,7 @@ int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
{ {
pos_inc = -1; pos_inc = -1;
} }
int shift = i - (int)fpos; // change playback speed (simple and rough) s32 shift = i - (int)fpos; // change playback speed (simple and rough)
if (shift > 0) if (shift > 0)
{ {
// slow playback // slow playback
@ -467,21 +467,21 @@ int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
return CELL_OK; return CELL_OK;
} }
int cellSurMixerGetAANHandle(vm::ptr<u32> handle) s32 cellSurMixerGetAANHandle(vm::ptr<u32> handle)
{ {
libmixer.Warning("cellSurMixerGetAANHandle(handle_addr=0x%x) -> %d", handle.addr(), 0x11111111); libmixer.Warning("cellSurMixerGetAANHandle(handle_addr=0x%x) -> %d", handle.addr(), 0x11111111);
*handle = 0x11111111; *handle = 0x11111111;
return CELL_OK; return CELL_OK;
} }
int cellSurMixerChStripGetAANPortNo(vm::ptr<u32> port, u32 type, u32 index) s32 cellSurMixerChStripGetAANPortNo(vm::ptr<u32> port, u32 type, u32 index)
{ {
libmixer.Warning("cellSurMixerChStripGetAANPortNo(port_addr=0x%x, type=0x%x, index=0x%x) -> 0x%x", port.addr(), type, index, (type << 16) | index); libmixer.Warning("cellSurMixerChStripGetAANPortNo(port_addr=0x%x, type=0x%x, index=0x%x) -> 0x%x", port.addr(), type, index, (type << 16) | index);
*port = (type << 16) | index; *port = (type << 16) | index;
return CELL_OK; return CELL_OK;
} }
int cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func, vm::ptr<void> arg) s32 cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func, vm::ptr<void> arg)
{ {
libmixer.Warning("cellSurMixerSetNotifyCallback(func_addr=0x%x, arg=0x%x)", func.addr(), arg.addr()); libmixer.Warning("cellSurMixerSetNotifyCallback(func_addr=0x%x, arg=0x%x)", func.addr(), arg.addr());
@ -494,7 +494,7 @@ int cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> fu
return CELL_OK; return CELL_OK;
} }
int cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func) s32 cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func)
{ {
libmixer.Warning("cellSurMixerRemoveNotifyCallback(func_addr=0x%x)", func.addr()); libmixer.Warning("cellSurMixerRemoveNotifyCallback(func_addr=0x%x)", func.addr());
@ -509,7 +509,7 @@ int cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction>
return CELL_OK; return CELL_OK;
} }
int cellSurMixerStart() s32 cellSurMixerStart()
{ {
libmixer.Warning("cellSurMixerStart()"); libmixer.Warning("cellSurMixerStart()");
@ -523,13 +523,13 @@ int cellSurMixerStart()
return CELL_OK; return CELL_OK;
} }
int cellSurMixerSetParameter(u32 param, float value) s32 cellSurMixerSetParameter(u32 param, float value)
{ {
libmixer.Todo("cellSurMixerSetParameter(param=0x%x, value=%f)", param, value); libmixer.Todo("cellSurMixerSetParameter(param=0x%x, value=%f)", param, value);
return CELL_OK; return CELL_OK;
} }
int cellSurMixerFinalize() s32 cellSurMixerFinalize()
{ {
libmixer.Warning("cellSurMixerFinalize()"); libmixer.Warning("cellSurMixerFinalize()");
@ -543,7 +543,7 @@ int cellSurMixerFinalize()
return CELL_OK; return CELL_OK;
} }
int cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 samples) s32 cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 samples)
{ {
if (busNo < 8 && samples == 256 && offset == 0) if (busNo < 8 && samples == 256 && offset == 0)
{ {
@ -566,13 +566,13 @@ int cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 sa
return CELL_OK; return CELL_OK;
} }
int cellSurMixerChStripSetParameter(u32 type, u32 index, vm::ptr<CellSurMixerChStripParam> param) s32 cellSurMixerChStripSetParameter(u32 type, u32 index, vm::ptr<CellSurMixerChStripParam> param)
{ {
libmixer.Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param_addr=0x%x)", type, index, param.addr()); libmixer.Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param_addr=0x%x)", type, index, param.addr());
return CELL_OK; return CELL_OK;
} }
int cellSurMixerPause(u32 type) s32 cellSurMixerPause(u32 type)
{ {
libmixer.Warning("cellSurMixerPause(type=%d)", type); libmixer.Warning("cellSurMixerPause(type=%d)", type);
@ -586,7 +586,7 @@ int cellSurMixerPause(u32 type)
return CELL_OK; return CELL_OK;
} }
int cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag) s32 cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
{ {
libmixer.Log("cellSurMixerGetCurrentBlockTag(tag_addr=0x%x)", tag.addr()); libmixer.Log("cellSurMixerGetCurrentBlockTag(tag_addr=0x%x)", tag.addr());
@ -594,7 +594,7 @@ int cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
return CELL_OK; return CELL_OK;
} }
int cellSurMixerGetTimestamp(u64 tag, vm::ptr<u64> stamp) s32 cellSurMixerGetTimestamp(u64 tag, vm::ptr<u64> stamp)
{ {
libmixer.Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp_addr=0x%x)", tag, stamp.addr()); libmixer.Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp_addr=0x%x)", tag, stamp.addr());

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

File diff suppressed because it is too large Load diff

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

@ -20,7 +20,7 @@ struct sceNpClansInternal
sceNpClansInternal sceNpClansInstance; sceNpClansInternal sceNpClansInstance;
int sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicationPassphrase> passphrase, vm::ptr<void> pool, vm::ptr<u32> poolSize, u32 flags) s32 sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicationPassphrase> passphrase, vm::ptr<void> pool, vm::ptr<u32> poolSize, u32 flags)
{ {
sceNpClans.Warning("sceNpClansInit(commId_addr=0x%x, passphrase_addr=0x%x, pool_addr=0x%x,poolSize_addr=0x%x, flags=%d)", commId.addr(), passphrase.addr(), pool.addr(), poolSize.addr(), flags); sceNpClans.Warning("sceNpClansInit(commId_addr=0x%x, passphrase_addr=0x%x, pool_addr=0x%x,poolSize_addr=0x%x, flags=%d)", commId.addr(), passphrase.addr(), pool.addr(), poolSize.addr(), flags);
@ -35,7 +35,7 @@ int sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicat
return CELL_OK; return CELL_OK;
} }
int sceNpClansTerm() s32 sceNpClansTerm()
{ {
sceNpClans.Warning("sceNpClansTerm()"); sceNpClans.Warning("sceNpClansTerm()");
@ -47,7 +47,7 @@ int sceNpClansTerm()
return CELL_OK; return CELL_OK;
} }
int sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle,u64 flags) s32 sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle,u64 flags)
{ {
sceNpClans.Todo("sceNpClansCreateRequest(handle_addr=0x%x, flags=0x%llx)", handle.addr(), flags); sceNpClans.Todo("sceNpClansCreateRequest(handle_addr=0x%x, flags=0x%llx)", handle.addr(), flags);
@ -60,7 +60,7 @@ int sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle,u64 flags)
return CELL_OK; return CELL_OK;
} }
int sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle) s32 sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -70,7 +70,7 @@ int sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle)
return CELL_OK; return CELL_OK;
} }
int sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle) s32 sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -80,7 +80,7 @@ int sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
return CELL_OK; return CELL_OK;
} }
int sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<char> name, vm::cptr<char> tag, vm::ptr<u32> clanId) s32 sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<char> name, vm::cptr<char> tag, vm::ptr<u32> clanId)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -90,7 +90,7 @@ int sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<char>
return CELL_OK; return CELL_OK;
} }
int sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId) s32 sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -100,7 +100,7 @@ int sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<SceNpClansPagingRequest> paging, vm::ptr<SceNpClansEntry> clanList, vm::ptr<SceNpClansPagingResult> pageResult) s32 sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<SceNpClansPagingRequest> paging, vm::ptr<SceNpClansEntry> clanList, vm::ptr<SceNpClansPagingResult> pageResult)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -110,7 +110,7 @@ int sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<SceN
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetClanListByNpId() s32 sceNpClansGetClanListByNpId()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -120,7 +120,7 @@ int sceNpClansGetClanListByNpId()
return CELL_OK; return CELL_OK;
} }
int sceNpClansSearchByProfile() s32 sceNpClansSearchByProfile()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -130,7 +130,7 @@ int sceNpClansSearchByProfile()
return CELL_OK; return CELL_OK;
} }
int sceNpClansSearchByName() s32 sceNpClansSearchByName()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -140,7 +140,7 @@ int sceNpClansSearchByName()
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetClanInfo() s32 sceNpClansGetClanInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -150,7 +150,7 @@ int sceNpClansGetClanInfo()
return CELL_OK; return CELL_OK;
} }
int sceNpClansUpdateClanInfo() s32 sceNpClansUpdateClanInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -160,7 +160,7 @@ int sceNpClansUpdateClanInfo()
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetMemberList() s32 sceNpClansGetMemberList()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -170,7 +170,7 @@ int sceNpClansGetMemberList()
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetMemberInfo() s32 sceNpClansGetMemberInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -180,7 +180,7 @@ int sceNpClansGetMemberInfo()
return CELL_OK; return CELL_OK;
} }
int sceNpClansUpdateMemberInfo() s32 sceNpClansUpdateMemberInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -190,7 +190,7 @@ int sceNpClansUpdateMemberInfo()
return CELL_OK; return CELL_OK;
} }
int sceNpClansChangeMemberRole() s32 sceNpClansChangeMemberRole()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -200,7 +200,7 @@ int sceNpClansChangeMemberRole()
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetAutoAcceptStatus() s32 sceNpClansGetAutoAcceptStatus()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -210,7 +210,7 @@ int sceNpClansGetAutoAcceptStatus()
return CELL_OK; return CELL_OK;
} }
int sceNpClansUpdateAutoAcceptStatus() s32 sceNpClansUpdateAutoAcceptStatus()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -220,7 +220,7 @@ int sceNpClansUpdateAutoAcceptStatus()
return CELL_OK; return CELL_OK;
} }
int sceNpClansJoinClan() s32 sceNpClansJoinClan()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -230,7 +230,7 @@ int sceNpClansJoinClan()
return CELL_OK; return CELL_OK;
} }
int sceNpClansLeaveClan() s32 sceNpClansLeaveClan()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -240,7 +240,7 @@ int sceNpClansLeaveClan()
return CELL_OK; return CELL_OK;
} }
int sceNpClansKickMember(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<u32> npid, vm::ptr<SceNpClansMessage> message) s32 sceNpClansKickMember(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<u32> npid, vm::ptr<SceNpClansMessage> message)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -250,7 +250,7 @@ int sceNpClansKickMember(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm
return CELL_OK; return CELL_OK;
} }
int sceNpClansSendInvitation(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<u32> npid, vm::ptr<SceNpClansMessage> message) s32 sceNpClansSendInvitation(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<u32> npid, vm::ptr<SceNpClansMessage> message)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -260,7 +260,7 @@ int sceNpClansSendInvitation(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId
return CELL_OK; return CELL_OK;
} }
int sceNpClansCancelInvitation() s32 sceNpClansCancelInvitation()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -270,7 +270,7 @@ int sceNpClansCancelInvitation()
return CELL_OK; return CELL_OK;
} }
int sceNpClansSendInvitationResponse(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<SceNpClansMessage> message, bool accept) s32 sceNpClansSendInvitationResponse(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<SceNpClansMessage> message, bool accept)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -280,7 +280,7 @@ int sceNpClansSendInvitationResponse(vm::ptr<SceNpClansRequestHandle> handle, u3
return CELL_OK; return CELL_OK;
} }
int sceNpClansSendMembershipRequest(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<SceNpClansMessage> message) s32 sceNpClansSendMembershipRequest(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm::ptr<SceNpClansMessage> message)
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -290,7 +290,7 @@ int sceNpClansSendMembershipRequest(vm::ptr<SceNpClansRequestHandle> handle, u32
return CELL_OK; return CELL_OK;
} }
int sceNpClansCancelMembershipRequest() s32 sceNpClansCancelMembershipRequest()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -300,7 +300,7 @@ int sceNpClansCancelMembershipRequest()
return CELL_OK; return CELL_OK;
} }
int sceNpClansSendMembershipResponse() s32 sceNpClansSendMembershipResponse()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -310,7 +310,7 @@ int sceNpClansSendMembershipResponse()
return CELL_OK; return CELL_OK;
} }
int sceNpClansGetBlacklist() s32 sceNpClansGetBlacklist()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -320,7 +320,7 @@ int sceNpClansGetBlacklist()
return CELL_OK; return CELL_OK;
} }
int sceNpClansAddBlacklistEntry() s32 sceNpClansAddBlacklistEntry()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -330,7 +330,7 @@ int sceNpClansAddBlacklistEntry()
return CELL_OK; return CELL_OK;
} }
int sceNpClansRemoveBlacklistEntry() s32 sceNpClansRemoveBlacklistEntry()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -340,7 +340,7 @@ int sceNpClansRemoveBlacklistEntry()
return CELL_OK; return CELL_OK;
} }
int sceNpClansRetrieveAnnouncements() s32 sceNpClansRetrieveAnnouncements()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -350,7 +350,7 @@ int sceNpClansRetrieveAnnouncements()
return CELL_OK; return CELL_OK;
} }
int sceNpClansPostAnnouncement() s32 sceNpClansPostAnnouncement()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -360,7 +360,7 @@ int sceNpClansPostAnnouncement()
return CELL_OK; return CELL_OK;
} }
int sceNpClansRemoveAnnouncement() s32 sceNpClansRemoveAnnouncement()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -370,7 +370,7 @@ int sceNpClansRemoveAnnouncement()
return CELL_OK; return CELL_OK;
} }
int sceNpClansPostChallenge(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, u32 targetClan, vm::ptr<SceNpClansMessage> message, vm::ptr<SceNpClansMessageData> data, u32 duration, vm::ptr<u32> mId) 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); UNIMPLEMENTED_FUNC(sceNpClans);
@ -385,7 +385,7 @@ int sceNpClansPostChallenge(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId,
return CELL_OK; return CELL_OK;
} }
int sceNpClansRetrievePostedChallenges() s32 sceNpClansRetrievePostedChallenges()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -397,7 +397,7 @@ int sceNpClansRetrievePostedChallenges()
return CELL_OK; return CELL_OK;
} }
int sceNpClansRemovePostedChallenge() s32 sceNpClansRemovePostedChallenge()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -407,7 +407,7 @@ int sceNpClansRemovePostedChallenge()
return CELL_OK; return CELL_OK;
} }
int sceNpClansRetrieveChallenges() s32 sceNpClansRetrieveChallenges()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);
@ -417,7 +417,7 @@ int sceNpClansRetrieveChallenges()
return CELL_OK; return CELL_OK;
} }
int sceNpClansRemoveChallenge() s32 sceNpClansRemoveChallenge()
{ {
UNIMPLEMENTED_FUNC(sceNpClans); UNIMPLEMENTED_FUNC(sceNpClans);

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

@ -18,19 +18,19 @@ struct sceNpCommerce2Internal
sceNpCommerce2Internal sceNpCommerce2Instance; sceNpCommerce2Internal sceNpCommerce2Instance;
int sceNpCommerce2ExecuteStoreBrowse() s32 sceNpCommerce2ExecuteStoreBrowse()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetStoreBrowseUserdata() s32 sceNpCommerce2GetStoreBrowseUserdata()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2Init() s32 sceNpCommerce2Init()
{ {
sceNpCommerce2.Warning("sceNpCommerce2Init()"); sceNpCommerce2.Warning("sceNpCommerce2Init()");
@ -42,7 +42,7 @@ int sceNpCommerce2Init()
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2Term() s32 sceNpCommerce2Term()
{ {
sceNpCommerce2.Warning("sceNpCommerce2Term()"); sceNpCommerce2.Warning("sceNpCommerce2Term()");
@ -54,259 +54,259 @@ int sceNpCommerce2Term()
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2CreateCtx() s32 sceNpCommerce2CreateCtx()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DestroyCtx() s32 sceNpCommerce2DestroyCtx()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2CreateSessionStart() s32 sceNpCommerce2CreateSessionStart()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2CreateSessionAbort() s32 sceNpCommerce2CreateSessionAbort()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2CreateSessionFinish() s32 sceNpCommerce2CreateSessionFinish()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetCategoryContentsCreateReq() s32 sceNpCommerce2GetCategoryContentsCreateReq()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetCategoryContentsStart() s32 sceNpCommerce2GetCategoryContentsStart()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetCategoryContentsGetResult() s32 sceNpCommerce2GetCategoryContentsGetResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2InitGetCategoryContentsResult() s32 sceNpCommerce2InitGetCategoryContentsResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetCategoryInfo() s32 sceNpCommerce2GetCategoryInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetContentInfo() s32 sceNpCommerce2GetContentInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetCategoryInfoFromContentInfo() s32 sceNpCommerce2GetCategoryInfoFromContentInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetGameProductInfoFromContentInfo() s32 sceNpCommerce2GetGameProductInfoFromContentInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DestroyGetCategoryContentsResult() s32 sceNpCommerce2DestroyGetCategoryContentsResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetProductInfoCreateReq() s32 sceNpCommerce2GetProductInfoCreateReq()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetProductInfoStart() s32 sceNpCommerce2GetProductInfoStart()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetProductInfoGetResult() s32 sceNpCommerce2GetProductInfoGetResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2InitGetProductInfoResult() s32 sceNpCommerce2InitGetProductInfoResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetGameProductInfo() s32 sceNpCommerce2GetGameProductInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DestroyGetProductInfoResult() s32 sceNpCommerce2DestroyGetProductInfoResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetProductInfoListCreateReq() s32 sceNpCommerce2GetProductInfoListCreateReq()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetProductInfoListStart() s32 sceNpCommerce2GetProductInfoListStart()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetProductInfoListGetResult() s32 sceNpCommerce2GetProductInfoListGetResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2InitGetProductInfoListResult() s32 sceNpCommerce2InitGetProductInfoListResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetGameProductInfoFromGetProductInfoListResult() s32 sceNpCommerce2GetGameProductInfoFromGetProductInfoListResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DestroyGetProductInfoListResult() s32 sceNpCommerce2DestroyGetProductInfoListResult()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetContentRatingInfoFromGameProductInfo() s32 sceNpCommerce2GetContentRatingInfoFromGameProductInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetContentRatingInfoFromCategoryInfo() s32 sceNpCommerce2GetContentRatingInfoFromCategoryInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetContentRatingDescriptor() s32 sceNpCommerce2GetContentRatingDescriptor()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetGameSkuInfoFromGameProductInfo() s32 sceNpCommerce2GetGameSkuInfoFromGameProductInfo()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetPrice() s32 sceNpCommerce2GetPrice()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoCheckoutStartAsync() s32 sceNpCommerce2DoCheckoutStartAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoCheckoutFinishAsync() s32 sceNpCommerce2DoCheckoutFinishAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoProductBrowseStartAsync() s32 sceNpCommerce2DoProductBrowseStartAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoProductBrowseFinishAsync() s32 sceNpCommerce2DoProductBrowseFinishAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoDlListStartAsync() s32 sceNpCommerce2DoDlListStartAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoDlListFinishAsync() s32 sceNpCommerce2DoDlListFinishAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoProductCodeStartAsync() s32 sceNpCommerce2DoProductCodeStartAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DoProductCodeFinishAsync() s32 sceNpCommerce2DoProductCodeFinishAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2GetBGDLAvailability() s32 sceNpCommerce2GetBGDLAvailability()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2SetBGDLAvailability() s32 sceNpCommerce2SetBGDLAvailability()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2AbortReq() s32 sceNpCommerce2AbortReq()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;
} }
int sceNpCommerce2DestroyReq() s32 sceNpCommerce2DestroyReq()
{ {
UNIMPLEMENTED_FUNC(sceNpCommerce2); UNIMPLEMENTED_FUNC(sceNpCommerce2);
return CELL_OK; return CELL_OK;

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

@ -19,7 +19,7 @@ struct sceNpTusInternal
sceNpTusInternal sceNpTusInstance; sceNpTusInternal sceNpTusInstance;
int sceNpTusInit() s32 sceNpTusInit()
{ {
sceNpTus.Warning("sceNpTusInit()"); sceNpTus.Warning("sceNpTusInit()");
@ -31,7 +31,7 @@ int sceNpTusInit()
return CELL_OK; return CELL_OK;
} }
int sceNpTusTerm() s32 sceNpTusTerm()
{ {
sceNpTus.Warning("sceNpTusTerm()"); sceNpTus.Warning("sceNpTusTerm()");
@ -43,7 +43,7 @@ int sceNpTusTerm()
return CELL_OK; return CELL_OK;
} }
int sceNpTusCreateTitleCtx() s32 sceNpTusCreateTitleCtx()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -53,7 +53,7 @@ int sceNpTusCreateTitleCtx()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDestroyTitleCtx() s32 sceNpTusDestroyTitleCtx()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -63,7 +63,7 @@ int sceNpTusDestroyTitleCtx()
return CELL_OK; return CELL_OK;
} }
int sceNpTusCreateTransactionCtx() s32 sceNpTusCreateTransactionCtx()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -73,7 +73,7 @@ int sceNpTusCreateTransactionCtx()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDestroyTransactionCtx() s32 sceNpTusDestroyTransactionCtx()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -83,7 +83,7 @@ int sceNpTusDestroyTransactionCtx()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetTimeout() s32 sceNpTusSetTimeout()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -93,7 +93,7 @@ int sceNpTusSetTimeout()
return CELL_OK; return CELL_OK;
} }
int sceNpTusAbortTransaction() s32 sceNpTusAbortTransaction()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -103,7 +103,7 @@ int sceNpTusAbortTransaction()
return CELL_OK; return CELL_OK;
} }
int sceNpTusWaitAsync() s32 sceNpTusWaitAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -113,7 +113,7 @@ int sceNpTusWaitAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusPollAsync() s32 sceNpTusPollAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -123,7 +123,7 @@ int sceNpTusPollAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetMultiSlotVariable() s32 sceNpTusSetMultiSlotVariable()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -133,7 +133,7 @@ int sceNpTusSetMultiSlotVariable()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetMultiSlotVariableVUser() s32 sceNpTusSetMultiSlotVariableVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -143,7 +143,7 @@ int sceNpTusSetMultiSlotVariableVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetMultiSlotVariableAsync() s32 sceNpTusSetMultiSlotVariableAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -153,7 +153,7 @@ int sceNpTusSetMultiSlotVariableAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetMultiSlotVariableVUserAsync() s32 sceNpTusSetMultiSlotVariableVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -163,7 +163,7 @@ int sceNpTusSetMultiSlotVariableVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotVariable() s32 sceNpTusGetMultiSlotVariable()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -173,7 +173,7 @@ int sceNpTusGetMultiSlotVariable()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotVariableVUser() s32 sceNpTusGetMultiSlotVariableVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -183,7 +183,7 @@ int sceNpTusGetMultiSlotVariableVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotVariableAsync() s32 sceNpTusGetMultiSlotVariableAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -193,7 +193,7 @@ int sceNpTusGetMultiSlotVariableAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotVariableVUserAsync() s32 sceNpTusGetMultiSlotVariableVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -203,7 +203,7 @@ int sceNpTusGetMultiSlotVariableVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserVariable() s32 sceNpTusGetMultiUserVariable()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -213,7 +213,7 @@ int sceNpTusGetMultiUserVariable()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserVariableVUser() s32 sceNpTusGetMultiUserVariableVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -223,7 +223,7 @@ int sceNpTusGetMultiUserVariableVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserVariableAsync() s32 sceNpTusGetMultiUserVariableAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -233,7 +233,7 @@ int sceNpTusGetMultiUserVariableAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserVariableVUserAsync() s32 sceNpTusGetMultiUserVariableVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -243,7 +243,7 @@ int sceNpTusGetMultiUserVariableVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusAddAndGetVariable() s32 sceNpTusAddAndGetVariable()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -253,7 +253,7 @@ int sceNpTusAddAndGetVariable()
return CELL_OK; return CELL_OK;
} }
int sceNpTusAddAndGetVariableVUser() s32 sceNpTusAddAndGetVariableVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -263,7 +263,7 @@ int sceNpTusAddAndGetVariableVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusAddAndGetVariableAsync() s32 sceNpTusAddAndGetVariableAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -273,7 +273,7 @@ int sceNpTusAddAndGetVariableAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusAddAndGetVariableVUserAsync() s32 sceNpTusAddAndGetVariableVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -283,7 +283,7 @@ int sceNpTusAddAndGetVariableVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusTryAndSetVariable() s32 sceNpTusTryAndSetVariable()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -293,7 +293,7 @@ int sceNpTusTryAndSetVariable()
return CELL_OK; return CELL_OK;
} }
int sceNpTusTryAndSetVariableVUser() s32 sceNpTusTryAndSetVariableVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -303,7 +303,7 @@ int sceNpTusTryAndSetVariableVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusTryAndSetVariableAsync() s32 sceNpTusTryAndSetVariableAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -313,7 +313,7 @@ int sceNpTusTryAndSetVariableAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusTryAndSetVariableVUserAsync() s32 sceNpTusTryAndSetVariableVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -323,7 +323,7 @@ int sceNpTusTryAndSetVariableVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotVariable() s32 sceNpTusDeleteMultiSlotVariable()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -333,7 +333,7 @@ int sceNpTusDeleteMultiSlotVariable()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotVariableVUser() s32 sceNpTusDeleteMultiSlotVariableVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -343,7 +343,7 @@ int sceNpTusDeleteMultiSlotVariableVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotVariableAsync() s32 sceNpTusDeleteMultiSlotVariableAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -353,7 +353,7 @@ int sceNpTusDeleteMultiSlotVariableAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotVariableVUserAsync() s32 sceNpTusDeleteMultiSlotVariableVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -363,7 +363,7 @@ int sceNpTusDeleteMultiSlotVariableVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetData() s32 sceNpTusSetData()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -373,7 +373,7 @@ int sceNpTusSetData()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetDataVUser() s32 sceNpTusSetDataVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -383,7 +383,7 @@ int sceNpTusSetDataVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetDataAsync() s32 sceNpTusSetDataAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -393,7 +393,7 @@ int sceNpTusSetDataAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusSetDataVUserAsync() s32 sceNpTusSetDataVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -403,7 +403,7 @@ int sceNpTusSetDataVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetData() s32 sceNpTusGetData()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -413,7 +413,7 @@ int sceNpTusGetData()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetDataVUser() s32 sceNpTusGetDataVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -423,7 +423,7 @@ int sceNpTusGetDataVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetDataAsync() s32 sceNpTusGetDataAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -433,7 +433,7 @@ int sceNpTusGetDataAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetDataVUserAsync() s32 sceNpTusGetDataVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -443,7 +443,7 @@ int sceNpTusGetDataVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotDataStatus() s32 sceNpTusGetMultiSlotDataStatus()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -453,7 +453,7 @@ int sceNpTusGetMultiSlotDataStatus()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotDataStatusVUser() s32 sceNpTusGetMultiSlotDataStatusVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -463,7 +463,7 @@ int sceNpTusGetMultiSlotDataStatusVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotDataStatusAsync() s32 sceNpTusGetMultiSlotDataStatusAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -473,7 +473,7 @@ int sceNpTusGetMultiSlotDataStatusAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiSlotDataStatusVUserAsync() s32 sceNpTusGetMultiSlotDataStatusVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -483,7 +483,7 @@ int sceNpTusGetMultiSlotDataStatusVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserDataStatus() s32 sceNpTusGetMultiUserDataStatus()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -493,7 +493,7 @@ int sceNpTusGetMultiUserDataStatus()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserDataStatusVUser() s32 sceNpTusGetMultiUserDataStatusVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -503,7 +503,7 @@ int sceNpTusGetMultiUserDataStatusVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserDataStatusAsync() s32 sceNpTusGetMultiUserDataStatusAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -513,7 +513,7 @@ int sceNpTusGetMultiUserDataStatusAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusGetMultiUserDataStatusVUserAsync() s32 sceNpTusGetMultiUserDataStatusVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -523,7 +523,7 @@ int sceNpTusGetMultiUserDataStatusVUserAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotData() s32 sceNpTusDeleteMultiSlotData()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -533,7 +533,7 @@ int sceNpTusDeleteMultiSlotData()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotDataVUser() s32 sceNpTusDeleteMultiSlotDataVUser()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -543,7 +543,7 @@ int sceNpTusDeleteMultiSlotDataVUser()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotDataAsync() s32 sceNpTusDeleteMultiSlotDataAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);
@ -553,7 +553,7 @@ int sceNpTusDeleteMultiSlotDataAsync()
return CELL_OK; return CELL_OK;
} }
int sceNpTusDeleteMultiSlotDataVUserAsync() s32 sceNpTusDeleteMultiSlotDataVUserAsync()
{ {
UNIMPLEMENTED_FUNC(sceNpTus); UNIMPLEMENTED_FUNC(sceNpTus);

2
rpcs3/Emu/SysCalls/Modules/sys_libc.cpp
View file

@ -12,7 +12,7 @@ namespace sys_libc_func
{ {
void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size) void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
{ {
sys_libc.Log("memcpy(dst=0x%x, src=0x%x, size=0x%x)", dst, src, size); sys_libc.Log("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
::memcpy(dst.get_ptr(), src.get_ptr(), size); ::memcpy(dst.get_ptr(), src.get_ptr(), size);
} }

230
rpcs3/Emu/SysCalls/Modules/sys_lv2dbg.cpp Normal file
View file

@ -0,0 +1,230 @@
#include "stdafx.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "Emu/IdManager.h"
#include "Emu/SysCalls/Modules.h"
#include "sys_lv2dbg.h"
extern Module sys_lv2dbg;
s32 sys_dbg_read_ppu_thread_context(u64 id, vm::ptr<sys_dbg_ppu_thread_context_t> ppu_context)
{
throw EXCEPTION("");
}
s32 sys_dbg_read_spu_thread_context(u32 id, vm::ptr<sys_dbg_spu_thread_context_t> spu_context)
{
throw EXCEPTION("");
}
s32 sys_dbg_read_spu_thread_context2(u32 id, vm::ptr<sys_dbg_spu_thread_context2_t> spu_context)
{
throw EXCEPTION("");
}
s32 sys_dbg_set_stacksize_ppu_exception_handler(u32 stacksize)
{
throw EXCEPTION("");
}
s32 sys_dbg_initialize_ppu_exception_handler(s32 prio)
{
throw EXCEPTION("");
}
s32 sys_dbg_finalize_ppu_exception_handler()
{
throw EXCEPTION("");
}
s32 sys_dbg_register_ppu_exception_handler(vm::ptr<dbg_exception_handler_t> callback, u64 ctrl_flags)
{
throw EXCEPTION("");
}
s32 sys_dbg_unregister_ppu_exception_handler()
{
throw EXCEPTION("");
}
s32 sys_dbg_signal_to_ppu_exception_handler(u64 flags)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_mutex_information(u32 id, vm::ptr<sys_dbg_mutex_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_cond_information(u32 id, vm::ptr<sys_dbg_cond_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_rwlock_information(u32 id, vm::ptr<sys_dbg_rwlock_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_event_queue_information(u32 id, vm::ptr<sys_dbg_event_queue_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_semaphore_information(u32 id, vm::ptr<sys_dbg_semaphore_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_lwmutex_information(u32 id, vm::ptr<sys_dbg_lwmutex_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_lwcond_information(u32 id, vm::ptr<sys_dbg_lwcond_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_event_flag_information(u32 id, vm::ptr<sys_dbg_event_flag_information_t> info)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_ppu_thread_ids(vm::ptr<u64> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_spu_thread_group_ids(vm::ptr<u32> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_spu_thread_ids(u32 group_id, vm::ptr<u32> ids, vm::ptr<u64> ids_num, vm::ptr<u64> all_ids_num)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_ppu_thread_name(u64 id, vm::ptr<char> name)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_spu_thread_name(u32 id, vm::ptr<char> name)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_spu_thread_group_name(u32 id, vm::ptr<char> name)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_ppu_thread_status(u64 id, vm::ptr<u32> status)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_spu_thread_group_status(u32 id, vm::ptr<u32> status)
{
throw EXCEPTION("");
}
s32 sys_dbg_enable_floating_point_enabled_exception(u64 id, u64 flags, u64 opt1, u64 opt2)
{
throw EXCEPTION("");
}
s32 sys_dbg_disable_floating_point_enabled_exception(u64 id, u64 flags, u64 opt1, u64 opt2)
{
throw EXCEPTION("");
}
s32 sys_dbg_vm_get_page_information(u32 addr, u32 num, vm::ptr<sys_vm_page_information_t> pageinfo)
{
throw EXCEPTION("");
}
s32 sys_dbg_set_address_to_dabr(u64 addr, u64 ctrl_flag)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_address_from_dabr(vm::ptr<u64> addr, vm::ptr<u64> ctrl_flag)
{
throw EXCEPTION("");
}
s32 sys_dbg_signal_to_coredump_handler(u64 data1, u64 data2, u64 data3)
{
throw EXCEPTION("");
}
s32 sys_dbg_mat_set_condition(u32 addr, u64 cond)
{
throw EXCEPTION("");
}
s32 sys_dbg_mat_get_condition(u32 addr, vm::ptr<u64> condp)
{
throw EXCEPTION("");
}
s32 sys_dbg_get_coredump_params(vm::ptr<s32> param)
{
throw EXCEPTION("");
}
s32 sys_dbg_set_mask_to_ppu_exception_handler(u64 mask, u64 flags)
{
throw EXCEPTION("");
}
Module sys_lv2dbg("sys_lv2dbg", []
{
REG_FUNC(sys_lv2dbg, sys_dbg_read_ppu_thread_context);
REG_FUNC(sys_lv2dbg, sys_dbg_read_spu_thread_context);
REG_FUNC(sys_lv2dbg, sys_dbg_read_spu_thread_context2);
REG_FUNC(sys_lv2dbg, sys_dbg_set_stacksize_ppu_exception_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_initialize_ppu_exception_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_finalize_ppu_exception_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_register_ppu_exception_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_unregister_ppu_exception_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_signal_to_ppu_exception_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_get_mutex_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_cond_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_rwlock_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_event_queue_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_semaphore_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_lwmutex_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_lwcond_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_event_flag_information);
REG_FUNC(sys_lv2dbg, sys_dbg_get_ppu_thread_ids);
REG_FUNC(sys_lv2dbg, sys_dbg_get_spu_thread_group_ids);
REG_FUNC(sys_lv2dbg, sys_dbg_get_spu_thread_ids);
REG_FUNC(sys_lv2dbg, sys_dbg_get_ppu_thread_name);
REG_FUNC(sys_lv2dbg, sys_dbg_get_spu_thread_name);
REG_FUNC(sys_lv2dbg, sys_dbg_get_spu_thread_group_name);
REG_FUNC(sys_lv2dbg, sys_dbg_get_ppu_thread_status);
REG_FUNC(sys_lv2dbg, sys_dbg_get_spu_thread_group_status);
REG_FUNC(sys_lv2dbg, sys_dbg_enable_floating_point_enabled_exception);
REG_FUNC(sys_lv2dbg, sys_dbg_disable_floating_point_enabled_exception);
REG_FUNC(sys_lv2dbg, sys_dbg_vm_get_page_information);
REG_FUNC(sys_lv2dbg, sys_dbg_set_address_to_dabr);
REG_FUNC(sys_lv2dbg, sys_dbg_get_address_from_dabr);
REG_FUNC(sys_lv2dbg, sys_dbg_signal_to_coredump_handler);
REG_FUNC(sys_lv2dbg, sys_dbg_mat_set_condition);
REG_FUNC(sys_lv2dbg, sys_dbg_mat_get_condition);
REG_FUNC(sys_lv2dbg, sys_dbg_get_coredump_params);
REG_FUNC(sys_lv2dbg, sys_dbg_set_mask_to_ppu_exception_handler);
});

290
rpcs3/Emu/SysCalls/Modules/sys_lv2dbg.h Normal file
View file

@ -0,0 +1,290 @@
#pragma once
#include "Emu/SysCalls/lv2/sys_mutex.h"
#include "Emu/SysCalls/lv2/sys_cond.h"
#include "Emu/SysCalls/lv2/sys_rwlock.h"
#include "Emu/SysCalls/lv2/sys_event.h"
#include "Emu/SysCalls/lv2/sys_semaphore.h"
#include "Emu/SysCalls/lv2/sys_lwmutex.h"
#include "Emu/SysCalls/lv2/sys_lwcond.h"
#include "Emu/SysCalls/lv2/sys_event_flag.h"
namespace vm { using namespace ps3; }
// Error Codes
enum
{
CELL_LV2DBG_ERROR_DEINVALIDPROCESSID = 0x80010401,
CELL_LV2DBG_ERROR_DEINVALIDTHREADID = 0x80010402,
CELL_LV2DBG_ERROR_DEILLEGALREGISTERTYPE = 0x80010403,
CELL_LV2DBG_ERROR_DEILLEGALREGISTERNUMBER = 0x80010404,
CELL_LV2DBG_ERROR_DEILLEGALTHREADSTATE = 0x80010405,
CELL_LV2DBG_ERROR_DEINVALIDEFFECTIVEADDRESS = 0x80010406,
CELL_LV2DBG_ERROR_DENOTFOUNDPROCESSID = 0x80010407,
CELL_LV2DBG_ERROR_DENOMEM = 0x80010408,
CELL_LV2DBG_ERROR_DEINVALIDARGUMENTS = 0x80010409,
CELL_LV2DBG_ERROR_DENOTFOUNDFILE = 0x8001040a,
CELL_LV2DBG_ERROR_DEINVALIDFILETYPE = 0x8001040b,
CELL_LV2DBG_ERROR_DENOTFOUNDTHREADID = 0x8001040c,
CELL_LV2DBG_ERROR_DEINVALIDTHREADSTATUS = 0x8001040d,
CELL_LV2DBG_ERROR_DENOAVAILABLEPROCESSID = 0x8001040e,
CELL_LV2DBG_ERROR_DENOTFOUNDEVENTHANDLER = 0x8001040f,
CELL_LV2DBG_ERROR_DESPNOROOM = 0x80010410,
CELL_LV2DBG_ERROR_DESPNOTFOUND = 0x80010411,
CELL_LV2DBG_ERROR_DESPINPROCESS = 0x80010412,
CELL_LV2DBG_ERROR_DEINVALIDPRIMARYSPUTHREADID = 0x80010413,
CELL_LV2DBG_ERROR_DETHREADSTATEISNOTSTOPPED = 0x80010414,
CELL_LV2DBG_ERROR_DEINVALIDTHREADTYPE = 0x80010415,
CELL_LV2DBG_ERROR_DECONTINUEFAILED = 0x80010416,
CELL_LV2DBG_ERROR_DESTOPFAILED = 0x80010417,
CELL_LV2DBG_ERROR_DENOEXCEPTION = 0x80010418,
CELL_LV2DBG_ERROR_DENOMOREEVENTQUE = 0x80010419,
CELL_LV2DBG_ERROR_DEEVENTQUENOTCREATED = 0x8001041a,
CELL_LV2DBG_ERROR_DEEVENTQUEOVERFLOWED = 0x8001041b,
CELL_LV2DBG_ERROR_DENOTIMPLEMENTED = 0x8001041c,
CELL_LV2DBG_ERROR_DEQUENOTREGISTERED = 0x8001041d,
CELL_LV2DBG_ERROR_DENOMOREEVENTPROCESS = 0x8001041e,
CELL_LV2DBG_ERROR_DEPROCESSNOTREGISTERED = 0x8001041f,
CELL_LV2DBG_ERROR_DEEVENTDISCARDED = 0x80010420,
CELL_LV2DBG_ERROR_DENOMORESYNCID = 0x80010421,
CELL_LV2DBG_ERROR_DESYNCIDALREADYADDED = 0x80010422,
CELL_LV2DBG_ERROR_DESYNCIDNOTFOUND = 0x80010423,
CELL_LV2DBG_ERROR_DESYNCIDNOTACQUIRED = 0x80010424,
CELL_LV2DBG_ERROR_DEPROCESSALREADYREGISTERED = 0x80010425,
CELL_LV2DBG_ERROR_DEINVALIDLSADDRESS = 0x80010426,
CELL_LV2DBG_ERROR_DEINVALIDOPERATION = 0x80010427,
CELL_LV2DBG_ERROR_DEINVALIDMODULEID = 0x80010428,
CELL_LV2DBG_ERROR_DEHANDLERALREADYREGISTERED = 0x80010429,
CELL_LV2DBG_ERROR_DEINVALIDHANDLER = 0x8001042a,
CELL_LV2DBG_ERROR_DEHANDLENOTREGISTERED = 0x8001042b,
CELL_LV2DBG_ERROR_DEOPERATIONDENIED = 0x8001042c,
CELL_LV2DBG_ERROR_DEHANDLERNOTINITIALIZED = 0x8001042d,
CELL_LV2DBG_ERROR_DEHANDLERALREADYINITIALIZED = 0x8001042e,
CELL_LV2DBG_ERROR_DEILLEGALCOREDUMPPARAMETER = 0x8001042f,
};
enum : u64
{
SYS_DBG_PPU_THREAD_STOP = 0x0000000000000001ull,
SYS_DBG_SPU_THREAD_GROUP_STOP = 0x0000000000000002ull,
SYS_DBG_SYSTEM_PPU_THREAD_NOT_STOP = 0x0000000000000004ull,
SYS_DBG_SYSTEM_SPU_THREAD_GROUP_NOT_STOP = 0x0000000000000008ull,
SYS_DBG_NOT_EXE_CTRL_BY_COREDUMP_EVENT = 0x0000000000000010ull,
};
enum : u64
{
SYS_DBG_PPU_EXCEPTION_TRAP = 0x0000000001000000ull,
SYS_DBG_PPU_EXCEPTION_PREV_INST = 0x0000000002000000ull,
SYS_DBG_PPU_EXCEPTION_ILL_INST = 0x0000000004000000ull,
SYS_DBG_PPU_EXCEPTION_TEXT_HTAB_MISS = 0x0000000008000000ull,
SYS_DBG_PPU_EXCEPTION_TEXT_SLB_MISS = 0x0000000010000000ull,
SYS_DBG_PPU_EXCEPTION_DATA_HTAB_MISS = 0x0000000020000000ull,
SYS_DBG_PPU_EXCEPTION_DATA_SLB_MISS = 0x0000000040000000ull,
SYS_DBG_PPU_EXCEPTION_FLOAT = 0x0000000080000000ull,
SYS_DBG_PPU_EXCEPTION_DABR_MATCH = 0x0000000100000000ull,
SYS_DBG_PPU_EXCEPTION_ALIGNMENT = 0x0000000200000000ull,
SYS_DBG_PPU_EXCEPTION_DATA_MAT = 0x0000002000000000ull,
};
enum : u64
{
SYS_DBG_EVENT_CORE_DUMPED = 0x0000000000001000ull,
SYS_DBG_EVENT_PPU_EXCEPTION_HANDLER_SIGNALED = 0x0000000000002000ull,
};
union sys_dbg_vr_t
{
u8 byte[16];
be_t<u16> halfword[8];
be_t<u32> word[8];
be_t<u64> dw[2];
};
struct sys_dbg_ppu_thread_context_t
{
be_t<u64> gpr[32];
be_t<u32> cr;
be_t<u64> xer;
be_t<u64> lr;
be_t<u64> ctr;
be_t<u64> pc;
be_t<u64> fpr[32];
be_t<u32> fpscr;
sys_dbg_vr_t vr[32];
sys_dbg_vr_t vscr;
};
union sys_dbg_spu_gpr_t
{
u8 byte[16];
be_t<u16> halfword[8];
be_t<u32> word[4];
be_t<u64> dw[2];
};
union sys_dbg_spu_fpscr_t
{
u8 byte[16];
be_t<u16> halfword[8];
be_t<u32> word[4];
be_t<u64> dw[2];
};
struct sys_dbg_spu_thread_context_t
{
sys_dbg_spu_gpr_t gpr[128];
be_t<u32> npc;
be_t<u32> fpscr;
be_t<u32> srr0;
be_t<u32> spu_status;
be_t<u64> spu_cfg;
be_t<u32> mb_stat;
be_t<u32> ppu_mb;
be_t<u32> spu_mb[4];
be_t<u32> decrementer;
be_t<u64> mfc_cq_sr[96];
};
struct sys_dbg_spu_thread_context2_t
{
sys_dbg_spu_gpr_t gpr[128];
be_t<u32> npc;
sys_dbg_spu_fpscr_t fpscr;
be_t<u32> srr0;
be_t<u32> spu_status;
be_t<u64> spu_cfg;
be_t<u32> mb_stat;
be_t<u32> ppu_mb;
be_t<u32> spu_mb[4];
be_t<u32> decrementer;
be_t<u64> mfc_cq_sr[96];
};
struct sys_dbg_mutex_information_t
{
sys_mutex_attribute_t attr;
be_t<u64> owner;
be_t<s32> lock_counter;
be_t<s32> cond_ref_counter;
be_t<u32> cond_id; // zero
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_cond_information_t
{
sys_cond_attribute_t attr;
be_t<u32> mutex_id;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_rwlock_information_t
{
sys_rwlock_attribute_t attr;
be_t<u64> owner;
vm::bptr<u64> r_wait_id_list;
be_t<u32> r_wait_threads_num;
be_t<u32> r_wait_all_threads_num;
vm::bptr<u64> w_wait_id_list;
be_t<u32> w_wait_threads_num;
be_t<u32> w_wait_all_threads_num;
};
struct sys_dbg_event_queue_information_t
{
sys_event_queue_attribute_t attr;
be_t<u64> event_queue_key;
be_t<s32> queue_size;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
vm::bptr<sys_event_t> equeue_list;
be_t<u32> readable_equeue_num;
be_t<u32> readable_all_equeue_num;
};
struct sys_dbg_semaphore_information_t
{
sys_semaphore_attribute_t attr;
be_t<s32> max_val;
be_t<s32> cur_val;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_lwmutex_information_t
{
sys_lwmutex_attribute_t attr;
be_t<u64> owner;
be_t<s32> lock_counter;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_lwcond_information_t
{
sys_lwcond_attribute_t attr;
vm::bptr<sys_lwmutex_t> lwmutex;
vm::bptr<u64> wait_id_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
struct sys_dbg_event_flag_wait_information_t
{
be_t<u64> bitptn;
be_t<u32> mode;
};
struct sys_dbg_event_flag_information_t
{
sys_event_flag_attribute_t attr;
be_t<u64> cur_bitptn;
vm::bptr<u64> wait_id_list;
vm::bptr<sys_dbg_event_flag_wait_information_t> wait_info_list;
be_t<u32> wait_threads_num;
be_t<u32> wait_all_threads_num;
};
using dbg_exception_handler_t = func_def<void(u64 exception_type, u64 thread_id, u64 dar)>;
enum : u64
{
SYS_VM_STATE_LOCKED = 0x0008ull,
SYS_VM_STATE_DIRTY = 0x0010ull,
};
struct sys_vm_page_information_t
{
be_t<u64> state;
};
enum : u64
{
SYS_DBG_DABR_CTRL_READ = 0x0000000000000005ull,
SYS_DBG_DABR_CTRL_WRITE = 0x0000000000000006ull,
SYS_DBG_DABR_CTRL_CLEAR = 0x0000000000000000ull,
};
enum
{
SYS_DBG_MAT_TRANSPARENT = 1,
SYS_DBG_MAT_WRITE = 2,
SYS_DBG_MAT_READ_WRITE = 4,
SYS_MAT_GRANULARITY = 4096,
};
enum sys_dbg_coredump_parameter_t : s32
{
SYS_DBG_COREDUMP_OFF,
SYS_DBG_COREDUMP_ON_SAVE_TO_APP_HOME,
SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_MS,
SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_USB,
SYS_DBG_COREDUMP_ON_SAVE_TO_DEV_HDD0,
};

1
rpcs3/Emu/SysCalls/SysCalls.cpp
View file

@ -29,6 +29,7 @@
#include "lv2/sys_tty.h" #include "lv2/sys_tty.h"
#include "lv2/sys_vm.h" #include "lv2/sys_vm.h"
#include "lv2/sys_fs.h" #include "lv2/sys_fs.h"
#include "lv2/sys_dbg.h"
#include "Emu/SysCalls/Modules/cellGcmSys.h" #include "Emu/SysCalls/Modules/cellGcmSys.h"

9
rpcs3/Emu/SysCalls/lv2/sys_dbg.cpp Normal file
View file

@ -0,0 +1,9 @@
#include "stdafx.h"
#include "Emu/Memory/Memory.h"
#include "Emu/System.h"
#include "Emu/IdManager.h"
#include "Emu/SysCalls/SysCalls.h"
#include "sys_dbg.h"
SysCallBase sys_dbg("sys_dbg");

3
rpcs3/Emu/SysCalls/lv2/sys_dbg.h Normal file
View file

@ -0,0 +1,3 @@
#pragma once
namespace vm { using namespace ps3; }

2
rpcs3/Emu/SysCalls/lv2/sys_event.cpp
View file

@ -26,7 +26,7 @@ lv2_event_queue_t::lv2_event_queue_t(u32 protocol, s32 type, u64 name, u64 key,
{ {
} }
s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size) s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attribute_t> attr, u64 event_queue_key, s32 size)
{ {
sys_event.Warning("sys_event_queue_create(equeue_id=*0x%x, attr=*0x%x, event_queue_key=0x%llx, size=%d)", equeue_id, attr, event_queue_key, size); sys_event.Warning("sys_event_queue_create(equeue_id=*0x%x, attr=*0x%x, event_queue_key=0x%llx, size=%d)", equeue_id, attr, event_queue_key, size);

4
rpcs3/Emu/SysCalls/lv2/sys_event.h
View file

@ -48,7 +48,7 @@ enum : u64
SYS_SPU_THREAD_EVENT_EXCEPTION_KEY = 0xFFFFFFFF53505503ull, SYS_SPU_THREAD_EVENT_EXCEPTION_KEY = 0xFFFFFFFF53505503ull,
}; };
struct sys_event_queue_attr struct sys_event_queue_attribute_t
{ {
be_t<u32> protocol; // SYS_SYNC_PRIORITY or SYS_SYNC_FIFO be_t<u32> protocol; // SYS_SYNC_PRIORITY or SYS_SYNC_FIFO
be_t<s32> type; // SYS_PPU_QUEUE or SYS_SPU_QUEUE be_t<s32> type; // SYS_PPU_QUEUE or SYS_SPU_QUEUE
@ -135,7 +135,7 @@ REG_ID_TYPE(lv2_event_port_t, 0x0E); // SYS_EVENT_PORT_OBJECT
class PPUThread; class PPUThread;
// SysCalls // SysCalls
s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, s32 size); s32 sys_event_queue_create(vm::ptr<u32> equeue_id, vm::ptr<sys_event_queue_attribute_t> attr, u64 event_queue_key, s32 size);
s32 sys_event_queue_destroy(u32 equeue_id, s32 mode); s32 sys_event_queue_destroy(u32 equeue_id, s32 mode);
s32 sys_event_queue_receive(PPUThread& CPU, u32 equeue_id, vm::ptr<sys_event_t> dummy_event, u64 timeout); s32 sys_event_queue_receive(PPUThread& CPU, u32 equeue_id, vm::ptr<sys_event_t> dummy_event, u64 timeout);
s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array, s32 size, vm::ptr<u32> number); s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_t> event_array, s32 size, vm::ptr<u32> number);

2
rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
View file

@ -12,7 +12,7 @@ SysCallBase sys_event_flag("sys_event_flag");
extern u64 get_system_time(); extern u64 get_system_time();
s32 sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attr> attr, u64 init) s32 sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attribute_t> attr, u64 init)
{ {
sys_event_flag.Warning("sys_event_flag_create(id=*0x%x, attr=*0x%x, init=0x%llx)", id, attr, init); sys_event_flag.Warning("sys_event_flag_create(id=*0x%x, attr=*0x%x, init=0x%llx)", id, attr, init);

4
rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
View file

@ -14,7 +14,7 @@ enum
SYS_EVENT_FLAG_WAIT_CLEAR_ALL = 0x20, SYS_EVENT_FLAG_WAIT_CLEAR_ALL = 0x20,
}; };
struct sys_event_flag_attr struct sys_event_flag_attribute_t
{ {
be_t<u32> protocol; be_t<u32> protocol;
be_t<u32> pshared; be_t<u32> pshared;
@ -55,7 +55,7 @@ struct lv2_event_flag_t
REG_ID_TYPE(lv2_event_flag_t, 0x98); // SYS_EVENT_FLAG_OBJECT REG_ID_TYPE(lv2_event_flag_t, 0x98); // SYS_EVENT_FLAG_OBJECT
s32 sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attr> attr, u64 init); s32 sys_event_flag_create(vm::ptr<u32> id, vm::ptr<sys_event_flag_attribute_t> attr, u64 init);
s32 sys_event_flag_destroy(u32 id); s32 sys_event_flag_destroy(u32 id);
s32 sys_event_flag_wait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result, u64 timeout); s32 sys_event_flag_wait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result, u64 timeout);
s32 sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result); s32 sys_event_flag_trywait(u32 id, u64 bitptn, u32 mode, vm::ptr<u64> result);

12
rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
View file

@ -29,6 +29,18 @@ struct ppu_thread_param_t
be_t<u32> tls; // vm::bptr<void> be_t<u32> tls; // vm::bptr<void>
}; };
enum : u32
{
PPU_THREAD_STATUS_IDLE,
PPU_THREAD_STATUS_RUNNABLE,
PPU_THREAD_STATUS_ONPROC,
PPU_THREAD_STATUS_SLEEP,
PPU_THREAD_STATUS_STOP,
PPU_THREAD_STATUS_ZOMBIE,
PPU_THREAD_STATUS_DELETED,
PPU_THREAD_STATUS_UNKNOWN,
};
// Aux // Aux
u32 ppu_thread_create(u32 entry, u64 arg, s32 prio, u32 stacksize, bool is_joinable, bool is_interrupt, std::string name, std::function<void(PPUThread&)> task = nullptr); u32 ppu_thread_create(u32 entry, u64 arg, s32 prio, u32 stacksize, bool is_joinable, bool is_interrupt, std::string name, std::function<void(PPUThread&)> task = nullptr);

2
rpcs3/Emu/SysCalls/lv2/sys_spu.h
View file

@ -46,7 +46,7 @@ enum : u32
SPU_THREAD_GROUP_STATUS_WAITING_AND_SUSPENDED, SPU_THREAD_GROUP_STATUS_WAITING_AND_SUSPENDED,
SPU_THREAD_GROUP_STATUS_RUNNING, SPU_THREAD_GROUP_STATUS_RUNNING,
SPU_THREAD_GROUP_STATUS_STOPPED, SPU_THREAD_GROUP_STATUS_STOPPED,
SPU_THREAD_GROUP_STATUS_UNKNOWN SPU_THREAD_GROUP_STATUS_UNKNOWN,
}; };
enum : s32 enum : s32

5
rpcs3/emucore.vcxproj
View file

@ -41,6 +41,7 @@
<ClCompile Include="Emu\RSX\Common\ShaderParam.cpp" /> <ClCompile Include="Emu\RSX\Common\ShaderParam.cpp" />
<ClCompile Include="Emu\RSX\Common\VertexProgramDecompiler.cpp" /> <ClCompile Include="Emu\RSX\Common\VertexProgramDecompiler.cpp" />
<ClCompile Include="Emu\RSX\GL\GLCommonDecompiler.cpp" /> <ClCompile Include="Emu\RSX\GL\GLCommonDecompiler.cpp" />
<ClCompile Include="Emu\SysCalls\lv2\sys_dbg.cpp" />
<ClCompile Include="Emu\SysCalls\lv2\sys_fs.cpp" /> <ClCompile Include="Emu\SysCalls\lv2\sys_fs.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellFs.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellFs.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSpursSpu.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellSpursSpu.cpp" />
@ -225,7 +226,6 @@
<ClCompile Include="Emu\SysCalls\Modules\cellJpgEnc.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellJpgEnc.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellKey2char.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellKey2char.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellL10n.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellL10n.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellLv2dbg.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellMic.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellMic.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellMsgDialog.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellMsgDialog.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellMusicDecode.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellMusicDecode.cpp" />
@ -276,6 +276,7 @@
<ClCompile Include="Emu\SysCalls\Modules\cellMouse.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellMouse.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellPad.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\cellPad.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sysPrxForUser.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sysPrxForUser.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_lv2dbg.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_http.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sys_http.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_io.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sys_io.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_libc.cpp" /> <ClCompile Include="Emu\SysCalls\Modules\sys_libc.cpp" />
@ -494,6 +495,7 @@
<ClInclude Include="Emu\SysCalls\LogBase.h" /> <ClInclude Include="Emu\SysCalls\LogBase.h" />
<ClInclude Include="Emu\SysCalls\lv2\sleep_queue.h" /> <ClInclude Include="Emu\SysCalls\lv2\sleep_queue.h" />
<ClInclude Include="Emu\SysCalls\lv2\sys_cond.h" /> <ClInclude Include="Emu\SysCalls\lv2\sys_cond.h" />
<ClInclude Include="Emu\SysCalls\lv2\sys_dbg.h" />
<ClInclude Include="Emu\SysCalls\lv2\sys_event.h" /> <ClInclude Include="Emu\SysCalls\lv2\sys_event.h" />
<ClInclude Include="Emu\SysCalls\lv2\sys_event_flag.h" /> <ClInclude Include="Emu\SysCalls\lv2\sys_event_flag.h" />
<ClInclude Include="Emu\SysCalls\lv2\sys_fs.h" /> <ClInclude Include="Emu\SysCalls\lv2\sys_fs.h" />
@ -570,6 +572,7 @@
<ClInclude Include="Emu\SysCalls\Modules\cellKb.h" /> <ClInclude Include="Emu\SysCalls\Modules\cellKb.h" />
<ClInclude Include="Emu\SysCalls\Modules\cellMouse.h" /> <ClInclude Include="Emu\SysCalls\Modules\cellMouse.h" />
<ClInclude Include="Emu\SysCalls\Modules\sysPrxForUser.h" /> <ClInclude Include="Emu\SysCalls\Modules\sysPrxForUser.h" />
<ClInclude Include="Emu\SysCalls\Modules\sys_lv2dbg.h" />
<ClInclude Include="Emu\SysCalls\Modules\sys_net.h" /> <ClInclude Include="Emu\SysCalls\Modules\sys_net.h" />
<ClInclude Include="Emu\SysCalls\SC_FUNC.h" /> <ClInclude Include="Emu\SysCalls\SC_FUNC.h" />
<ClInclude Include="Emu\SysCalls\SysCalls.h" /> <ClInclude Include="Emu\SysCalls\SysCalls.h" />

15
rpcs3/emucore.vcxproj.filters
View file

@ -431,9 +431,6 @@
<ClCompile Include="Emu\SysCalls\Modules\cellKey2char.cpp"> <ClCompile Include="Emu\SysCalls\Modules\cellKey2char.cpp">
<Filter>Emu\SysCalls\currently_unused</Filter> <Filter>Emu\SysCalls\currently_unused</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\cellLv2dbg.cpp">
<Filter>Emu\SysCalls\currently_unused</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\cellMusicDecode.cpp"> <ClCompile Include="Emu\SysCalls\Modules\cellMusicDecode.cpp">
<Filter>Emu\SysCalls\currently_unused</Filter> <Filter>Emu\SysCalls\currently_unused</Filter>
</ClCompile> </ClCompile>
@ -872,6 +869,12 @@
<ClCompile Include="Emu\RSX\GL\GLCommonDecompiler.cpp"> <ClCompile Include="Emu\RSX\GL\GLCommonDecompiler.cpp">
<Filter>Emu\GPU\RSX\GL</Filter> <Filter>Emu\GPU\RSX\GL</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Emu\SysCalls\lv2\sys_dbg.cpp">
<Filter>Emu\SysCalls\lv2</Filter>
</ClCompile>
<ClCompile Include="Emu\SysCalls\Modules\sys_lv2dbg.cpp">
<Filter>Emu\SysCalls\Modules</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="Crypto\aes.h"> <ClInclude Include="Crypto\aes.h">
@ -1717,5 +1720,11 @@
<ClInclude Include="Emu\ARMv7\Modules\sceXml.h"> <ClInclude Include="Emu\ARMv7\Modules\sceXml.h">
<Filter>Emu\CPU\ARMv7\Modules</Filter> <Filter>Emu\CPU\ARMv7\Modules</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Emu\SysCalls\lv2\sys_dbg.h">
<Filter>Emu\SysCalls\lv2</Filter>
</ClInclude>
<ClInclude Include="Emu\SysCalls\Modules\sys_lv2dbg.h">
<Filter>Emu\SysCalls\Modules</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>

15
rpcs3/rpcs3.vcxproj
View file

@ -88,8 +88,11 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>wxmsw31ud_adv.lib;wxbase31ud.lib;wxmsw31ud_core.lib;wxmsw31ud_aui.lib;wxtiffd.lib;wxjpegd.lib;wxpngd.lib;wxzlibd.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;libOpenAL32.dll.a;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>wxmsw31ud_adv.lib;wxbase31ud.lib;wxmsw31ud_core.lib;wxmsw31ud_aui.lib;wxtiffd.lib;wxjpegd.lib;wxpngd.lib;wxzlibd.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;libOpenAL32.dll.a;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies>
<IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries> <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<DataExecutionPrevention>false</DataExecutionPrevention> <DataExecutionPrevention>true</DataExecutionPrevention>
<AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
<BaseAddress>0x200000000</BaseAddress>
<FixedBaseAddress>true</FixedBaseAddress>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
</Link> </Link>
<PreBuildEvent> <PreBuildEvent>
<Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command> <Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>
@ -115,8 +118,11 @@
<GenerateDebugInformation>true</GenerateDebugInformation> <GenerateDebugInformation>true</GenerateDebugInformation>
<AdditionalDependencies>wxmsw31ud_adv.lib;wxbase31ud.lib;wxmsw31ud_core.lib;wxmsw31ud_aui.lib;wxtiffd.lib;wxjpegd.lib;wxpngd.lib;wxzlibd.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;libOpenAL32.dll.a;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies> <AdditionalDependencies>wxmsw31ud_adv.lib;wxbase31ud.lib;wxmsw31ud_core.lib;wxmsw31ud_aui.lib;wxtiffd.lib;wxjpegd.lib;wxpngd.lib;wxzlibd.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;avcodec.lib;avformat.lib;avutil.lib;swresample.lib;swscale.lib;libOpenAL32.dll.a;asmjit.lib;%(AdditionalDependencies)</AdditionalDependencies>
<IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries> <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<DataExecutionPrevention>false</DataExecutionPrevention> <DataExecutionPrevention>true</DataExecutionPrevention>
<AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
<BaseAddress>0x200000000</BaseAddress>
<FixedBaseAddress>true</FixedBaseAddress>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
</Link> </Link>
<PreBuildEvent> <PreBuildEvent>
<Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command> <Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>
@ -153,8 +159,11 @@
<IgnoreAllDefaultLibraries> <IgnoreAllDefaultLibraries>
</IgnoreAllDefaultLibraries> </IgnoreAllDefaultLibraries>
<IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries> <IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<DataExecutionPrevention>false</DataExecutionPrevention> <DataExecutionPrevention>true</DataExecutionPrevention>
<AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories> <AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
<BaseAddress>0x200000000</BaseAddress>
<FixedBaseAddress>true</FixedBaseAddress>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
</Link> </Link>
<PreBuildEvent> <PreBuildEvent>
<Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command> <Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>