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

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
Show stats 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
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
std::lock_guard<std::mutex> lock(mutex);
cv.notify_all();
cv.notify_one();
}
ctrl->m_thread.detach();
@ -1359,7 +1361,7 @@ void thread_t::join()
// lock for reliable notification
std::lock_guard<std::mutex> lock(mutex);
cv.notify_all();
cv.notify_one();
}
ctrl->m_thread.join();

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

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

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

@ -19,18 +19,6 @@ enum
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
{
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 sysPrxForUser;
extern Module sys_libc;
extern Module sys_lv2dbg;
struct ModuleInfo
{
@ -107,7 +108,7 @@ static const g_module_list[] =
{ 0x0028, "cellAdecAtx", nullptr },
{ 0x0029, "cellAdecAt3", nullptr },
{ 0x002a, "cellDmuxPamf", nullptr },
{ 0x002e, "cellLv2dbg", nullptr },
{ 0x002e, "sys_lv2dbg", &sys_lv2dbg },
{ 0x0030, "cellUsbpspcm", nullptr },
{ 0x0031, "cellAvconfExt", &cellAvconfExt },
{ 0x0032, "cellUserInfo", &cellUserInfo },

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

@ -7,44 +7,40 @@ extern Module cellAtrac;
#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)",
pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
cellAtrac.Warning("cellAtracSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte=*0x%x)", pHandle, pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte);
*puiWorkMemByte = 0x1000; // unproved
*puiWorkMemByte = 0x1000;
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)",
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
cellAtrac.Warning("cellAtracCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority);
pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
pHandle->pucWorkMem = pucWorkMem;
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)",
pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr());
cellAtrac.Warning("cellAtracCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes);
pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
pHandle->pucWorkMem = pucWorkMem;
return CELL_OK;
}
s32 cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
{
cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr());
cellAtrac.Warning("cellAtracDeleteDecoder(pHandle=*0x%x)", pHandle);
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)",
pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
cellAtrac.Warning("cellAtracDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame);
*puiSamples = 0;
*puiFinishflag = 1;
@ -52,12 +48,11 @@ s32 cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<u32
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)",
pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
cellAtrac.Warning("cellAtracGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition);
*ppucWritePointer = pHandle->data.pucWorkMem_addr;
*ppucWritePointer = pHandle->pucWorkMem;
*puiWritableByte = 0x1000;
*puiReadPosition = 0;
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)
{
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;
}
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;
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)
{
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;
return CELL_OK;
@ -88,32 +83,30 @@ s32 cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<u32> puiVac
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)
{
cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr());
cellAtrac.Warning("cellAtracGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte);
*puiReadPosition = 0;
*puiDataByte = 0; // write to null block will occur
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)",
pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte);
cellAtrac.Warning("cellAtracSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte);
return CELL_OK;
}
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;
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)
{
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;
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)
{
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;
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)",
pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
cellAtrac.Warning("cellAtracGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample);
*piEndSample = 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)
{
cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
pHandle.addr(), puiSamplePosition.addr());
cellAtrac.Warning("cellAtracGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition);
*puiSamplePosition = 0;
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)
{
cellAtrac.Warning("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
pHandle.addr(), puiBitrate.addr());
cellAtrac.Warning("cellAtracGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate);
*puiBitrate = 128;
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)",
pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr());
cellAtrac.Warning("cellAtracGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus);
*piLoopNum = 0;
*puiLoopStatus = 0;
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;
}
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)",
pHandle.addr(), uiSample, pBufferInfo.addr());
cellAtrac.Warning("cellAtracGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo);
pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr;
pBufferInfo->pucWriteAddr = pHandle->pucWorkMem;
pBufferInfo->uiWritableByte = 0x1000;
pBufferInfo->uiMinWriteByte = 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)
{
cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
pHandle.addr(), uiSample, uiWriteByte);
cellAtrac.Warning("cellAtracResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x)", pHandle, uiSample, uiWriteByte);
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)",
pHandle.addr(), piResult.addr());
cellAtrac.Warning("cellAtracGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult);
*piResult = 0;
return CELL_OK;

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

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

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

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

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

@ -11,7 +11,7 @@ extern Module cellFont;
CCellFontInternal* s_fontInternalInstance = nullptr;
// 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());
@ -30,13 +30,13 @@ int cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> co
return CELL_FONT_OK;
}
int cellFontGetRevisionFlags(vm::ptr<u64> revisionFlags)
s32 cellFontGetRevisionFlags(vm::ptr<u64> revisionFlags)
{
UNIMPLEMENTED_FUNC(cellFont);
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());
@ -46,7 +46,7 @@ int cellFontInit(PPUThread& CPU, vm::ptr<CellFontConfig> config)
return cellFontInitializeWithRevision(revisionFlags.value(), config);
}
int cellFontEnd()
s32 cellFontEnd()
{
cellFont.Log("cellFontEnd()");
@ -64,7 +64,7 @@ s32 cellFontSetFontsetOpenMode(u32 openMode)
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)",
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;
}
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());
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 bufferAddr = (u32)Memory.Alloc(fileSize, 1); // Freed in cellFontCloseFont
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;
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)",
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);
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;
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());
@ -205,7 +205,7 @@ s32 cellFontSetFontOpenMode(u32 openMode)
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)",
library.addr(), config.addr(), Renderer.addr());
@ -244,7 +244,7 @@ void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32
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);
@ -253,12 +253,12 @@ int cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
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)",
font.addr(), layout.addr());
int ascent, descent, lineGap;
s32 ascent, descent, lineGap;
float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap);
@ -268,7 +268,7 @@ int cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizont
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)",
font.addr(), renderer.addr());
@ -280,7 +280,7 @@ int cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> rende
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());
@ -291,13 +291,13 @@ int cellFontUnbindRenderer(vm::ptr<CellFont> font)
return CELL_FONT_OK;
}
int cellFontDestroyRenderer()
s32 cellFontDestroyRenderer()
{
UNIMPLEMENTED_FUNC(cellFont);
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);
@ -308,7 +308,7 @@ int cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
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)",
font.addr(), code, metrics.addr());
@ -320,7 +320,7 @@ int cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<
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)",
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;
// Render the character
int width, height, xoff, yoff;
s32 width, height, xoff, yoff;
float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
unsigned char* box = stbtt_GetCodepointBitmap(font->stbfont, scale, scale, code, &width, &height, &xoff, &yoff);
if (!box) return CELL_OK;
// Get the baseLineY value
int baseLineY;
int ascent, descent, lineGap;
s32 baseLineY;
s32 ascent, descent, lineGap;
stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap);
baseLineY = (int)((float)ascent * scale); // ???
@ -358,13 +358,13 @@ int cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellF
return CELL_FONT_OK;
}
int cellFontEndLibrary()
s32 cellFontEndLibrary()
{
UNIMPLEMENTED_FUNC(cellFont);
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);
@ -375,7 +375,7 @@ int cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
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());
@ -383,7 +383,7 @@ int cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<float> slantParam)
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());
@ -391,7 +391,7 @@ int cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<u32> fontId,
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());
@ -403,12 +403,12 @@ int cellFontCloseFont(vm::ptr<CellFont> font)
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());
int x0, y0, x1, y1;
int advanceWidth, leftSideBearing;
s32 x0, y0, x1, y1;
s32 advanceWidth, leftSideBearing;
float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
stbtt_GetCodepointBox(font->stbfont, code, &x0, &y0, &x1, &y1);
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;
}
int cellFontGraphicsSetFontRGBA()
s32 cellFontGraphicsSetFontRGBA()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontOpenFontsetOnMemory()
s32 cellFontOpenFontsetOnMemory()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGraphicsSetScalePixel()
s32 cellFontGraphicsSetScalePixel()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGraphicsGetScalePixel()
s32 cellFontGraphicsGetScalePixel()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontSetEffectWeight()
s32 cellFontSetEffectWeight()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGlyphSetupVertexesGlyph()
s32 cellFontGlyphSetupVertexesGlyph()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGetVerticalLayout()
s32 cellFontGetVerticalLayout()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGetRenderCharGlyphMetricsVertical()
s32 cellFontGetRenderCharGlyphMetricsVertical()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontSetScalePoint()
s32 cellFontSetScalePoint()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontSetupRenderEffectSlant()
s32 cellFontSetupRenderEffectSlant()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGraphicsSetLineRGBA()
s32 cellFontGraphicsSetLineRGBA()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGraphicsSetDrawType()
s32 cellFontGraphicsSetDrawType()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontEndGraphics()
s32 cellFontEndGraphics()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGraphicsSetupDrawContext()
s32 cellFontGraphicsSetupDrawContext()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontSetupRenderEffectWeight()
s32 cellFontSetupRenderEffectWeight()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGlyphGetOutlineControlDistance()
s32 cellFontGlyphGetOutlineControlDistance()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGlyphGetVertexesGlyphSize()
s32 cellFontGlyphGetVertexesGlyphSize()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGenerateCharGlyph()
s32 cellFontGenerateCharGlyph()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontDeleteGlyph()
s32 cellFontDeleteGlyph()
{
UNIMPLEMENTED_FUNC(cellFont);
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);
//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;
}
int cellFontRenderCharGlyphImageVertical()
s32 cellFontRenderCharGlyphImageVertical()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontSetResolutionDpi()
s32 cellFontSetResolutionDpi()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;
}
int cellFontGetCharGlyphMetricsVertical()
s32 cellFontGetCharGlyphMetricsVertical()
{
UNIMPLEMENTED_FUNC(cellFont);
return CELL_FONT_OK;

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

@ -9,7 +9,7 @@ extern Module cellFontFT;
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",
revisionFlags, config.addr(), lib_addr_addr);
@ -22,13 +22,13 @@ int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontL
return CELL_OK;
}
int cellFontFTGetRevisionFlags()
s32 cellFontFTGetRevisionFlags()
{
UNIMPLEMENTED_FUNC(cellFontFT);
return CELL_OK;
}
int cellFontFTGetInitializedRevisionFlags()
s32 cellFontFTGetInitializedRevisionFlags()
{
UNIMPLEMENTED_FUNC(cellFontFT);
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;
}
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> 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
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";
int ret = sdata_unpack(path, unpacked_path);
s32 ret = sdata_unpack(path, unpacked_path);
if (ret) return ret;
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;
int cellGemCalibrate()
s32 cellGemCalibrate()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -29,7 +29,7 @@ int cellGemCalibrate()
return CELL_OK;
}
int cellGemClearStatusFlags()
s32 cellGemClearStatusFlags()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -39,7 +39,7 @@ int cellGemClearStatusFlags()
return CELL_OK;
}
int cellGemConvertVideoFinish()
s32 cellGemConvertVideoFinish()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -49,7 +49,7 @@ int cellGemConvertVideoFinish()
return CELL_OK;
}
int cellGemConvertVideoStart()
s32 cellGemConvertVideoStart()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -59,7 +59,7 @@ int cellGemConvertVideoStart()
return CELL_OK;
}
int cellGemEnableCameraPitchAngleCorrection()
s32 cellGemEnableCameraPitchAngleCorrection()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -69,7 +69,7 @@ int cellGemEnableCameraPitchAngleCorrection()
return CELL_OK;
}
int cellGemEnableMagnetometer()
s32 cellGemEnableMagnetometer()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -79,7 +79,7 @@ int cellGemEnableMagnetometer()
return CELL_OK;
}
int cellGemEnd()
s32 cellGemEnd()
{
cellGem.Warning("cellGemEnd()");
@ -91,7 +91,7 @@ int cellGemEnd()
return CELL_OK;
}
int cellGemFilterState()
s32 cellGemFilterState()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -101,7 +101,7 @@ int cellGemFilterState()
return CELL_OK;
}
int cellGemForceRGB()
s32 cellGemForceRGB()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -111,7 +111,7 @@ int cellGemForceRGB()
return CELL_OK;
}
int cellGemGetAccelerometerPositionInDevice()
s32 cellGemGetAccelerometerPositionInDevice()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -121,7 +121,7 @@ int cellGemGetAccelerometerPositionInDevice()
return CELL_OK;
}
int cellGemGetAllTrackableHues()
s32 cellGemGetAllTrackableHues()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -131,7 +131,7 @@ int cellGemGetAllTrackableHues()
return CELL_OK;
}
int cellGemGetCameraState()
s32 cellGemGetCameraState()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -141,7 +141,7 @@ int cellGemGetCameraState()
return CELL_OK;
}
int cellGemGetEnvironmentLightingColor()
s32 cellGemGetEnvironmentLightingColor()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -151,7 +151,7 @@ int cellGemGetEnvironmentLightingColor()
return CELL_OK;
}
int cellGemGetHuePixels()
s32 cellGemGetHuePixels()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -161,7 +161,7 @@ int cellGemGetHuePixels()
return CELL_OK;
}
int cellGemGetImageState()
s32 cellGemGetImageState()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -171,7 +171,7 @@ int cellGemGetImageState()
return CELL_OK;
}
int cellGemGetInertialState()
s32 cellGemGetInertialState()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -181,7 +181,7 @@ int cellGemGetInertialState()
return CELL_OK;
}
int cellGemGetInfo(vm::ptr<CellGemInfo> info)
s32 cellGemGetInfo(vm::ptr<CellGemInfo> info)
{
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
}
int cellGemGetRGB()
s32 cellGemGetRGB()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -217,7 +217,7 @@ int cellGemGetRGB()
return CELL_OK;
}
int cellGemGetRumble()
s32 cellGemGetRumble()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -227,7 +227,7 @@ int cellGemGetRumble()
return CELL_OK;
}
int cellGemGetState()
s32 cellGemGetState()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -237,7 +237,7 @@ int cellGemGetState()
return CELL_OK;
}
int cellGemGetStatusFlags()
s32 cellGemGetStatusFlags()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -247,7 +247,7 @@ int cellGemGetStatusFlags()
return CELL_OK;
}
int cellGemGetTrackerHue()
s32 cellGemGetTrackerHue()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -257,13 +257,13 @@ int cellGemGetTrackerHue()
return CELL_OK;
}
int cellGemHSVtoRGB()
s32 cellGemHSVtoRGB()
{
UNIMPLEMENTED_FUNC(cellGem);
return CELL_OK;
}
int cellGemInit(vm::ptr<CellGemAttribute> attribute)
s32 cellGemInit(vm::ptr<CellGemAttribute> attribute)
{
cellGem.Warning("cellGemInit(attribute_addr=0x%x)", attribute.addr());
@ -276,7 +276,7 @@ int cellGemInit(vm::ptr<CellGemAttribute> attribute)
return CELL_OK;
}
int cellGemInvalidateCalibration()
s32 cellGemInvalidateCalibration()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -286,13 +286,13 @@ int cellGemInvalidateCalibration()
return CELL_OK;
}
int cellGemIsTrackableHue()
s32 cellGemIsTrackableHue()
{
UNIMPLEMENTED_FUNC(cellGem);
return CELL_OK;
}
int cellGemPrepareCamera()
s32 cellGemPrepareCamera()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -302,7 +302,7 @@ int cellGemPrepareCamera()
return CELL_OK;
}
int cellGemPrepareVideoConvert()
s32 cellGemPrepareVideoConvert()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -312,7 +312,7 @@ int cellGemPrepareVideoConvert()
return CELL_OK;
}
int cellGemReset()
s32 cellGemReset()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -322,7 +322,7 @@ int cellGemReset()
return CELL_OK;
}
int cellGemSetRumble()
s32 cellGemSetRumble()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -332,7 +332,7 @@ int cellGemSetRumble()
return CELL_OK;
}
int cellGemSetYaw()
s32 cellGemSetYaw()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -342,7 +342,7 @@ int cellGemSetYaw()
return CELL_OK;
}
int cellGemTrackHues()
s32 cellGemTrackHues()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -352,7 +352,7 @@ int cellGemTrackHues()
return CELL_OK;
}
int cellGemUpdateFinish()
s32 cellGemUpdateFinish()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -362,7 +362,7 @@ int cellGemUpdateFinish()
return CELL_OK;
}
int cellGemUpdateStart()
s32 cellGemUpdateStart()
{
UNIMPLEMENTED_FUNC(cellGem);
@ -372,7 +372,7 @@ int cellGemUpdateStart()
return CELL_OK;
}
int cellGemWriteExternalPort()
s32 cellGemWriteExternalPort()
{
UNIMPLEMENTED_FUNC(cellGem);

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

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

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

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

@ -8,7 +8,7 @@
extern Module sys_io;
int cellMouseInit(u32 max_connect)
s32 cellMouseInit(u32 max_connect)
{
sys_io.Warning("cellMouseInit(max_connect=%d)", max_connect);
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);
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -30,7 +30,7 @@ int cellMouseClearBuf(u32 port_no)
return CELL_OK;
}
int cellMouseEnd()
s32 cellMouseEnd()
{
sys_io.Log("cellMouseEnd()");
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -38,7 +38,7 @@ int cellMouseEnd()
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());
if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
@ -54,7 +54,7 @@ int cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
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());
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;
}
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());
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;
}
int cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data)
s32 cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data)
{
UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK;
}
int cellMouseSetTabletMode(u32 port_no, u32 mode)
s32 cellMouseSetTabletMode(u32 port_no, u32 mode)
{
UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK;
}
int cellMouseGetTabletDataList(u32 port_no, u32 data_addr)
s32 cellMouseGetTabletDataList(u32 port_no, u32 data_addr)
{
UNIMPLEMENTED_FUNC(sys_io);
return CELL_OK;
}
int cellMouseGetRawData(u32 port_no, u32 data_addr)
s32 cellMouseGetRawData(u32 port_no, u32 data_addr)
{
UNIMPLEMENTED_FUNC(sys_io);

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

@ -21,7 +21,7 @@ struct cellNetCtlInternal
cellNetCtlInternal cellNetCtlInstance;
int cellNetCtlInit()
s32 cellNetCtlInit()
{
cellNetCtl.Log("cellNetCtlInit()");
@ -33,7 +33,7 @@ int cellNetCtlInit()
return CELL_OK;
}
int cellNetCtlTerm()
s32 cellNetCtlTerm()
{
cellNetCtl.Log("cellNetCtlTerm()");
@ -45,7 +45,7 @@ int cellNetCtlTerm()
return CELL_OK;
}
int cellNetCtlGetState(vm::ptr<u32> state)
s32 cellNetCtlGetState(vm::ptr<u32> state)
{
cellNetCtl.Log("cellNetCtlGetState(state_addr=0x%x)", state.addr());
@ -69,21 +69,21 @@ int cellNetCtlGetState(vm::ptr<u32> state)
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());
return CELL_OK;
}
int cellNetCtlDelHandler(s32 hid)
s32 cellNetCtlDelHandler(s32 hid)
{
cellNetCtl.Todo("cellNetCtlDelHandler(hid=0x%x)", hid);
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());
@ -95,7 +95,7 @@ int cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
return CELL_OK;
}
int cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param)
s32 cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param)
{
cellNetCtl.Warning("cellNetCtlNetStartDialogLoadAsync(param_addr=0x%x)", param.addr());
@ -105,14 +105,14 @@ int cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> par
return CELL_OK;
}
int cellNetCtlNetStartDialogAbortAsync()
s32 cellNetCtlNetStartDialogAbortAsync()
{
cellNetCtl.Todo("cellNetCtlNetStartDialogAbortAsync()");
return CELL_OK;
}
int cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result)
s32 cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result)
{
cellNetCtl.Warning("cellNetCtlNetStartDialogUnloadAsync(result_addr=0x%x)", result.addr());
@ -121,7 +121,7 @@ int cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult>
return CELL_OK;
}
int cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
s32 cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
{
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,
};
int cellOvisGetOverlayTableSize(vm::cptr<char> elf)
s32 cellOvisGetOverlayTableSize(vm::cptr<char> elf)
{
cellOvis.Todo("cellOvisGetOverlayTableSize(elf_addr=0x%x)", elf.addr());
return CELL_OK;
}
int cellOvisInitializeOverlayTable()
s32 cellOvisInitializeOverlayTable()
{
UNIMPLEMENTED_FUNC(cellOvis);
return CELL_OK;
}
int cellOvisFixSpuSegments()
s32 cellOvisFixSpuSegments()
{
UNIMPLEMENTED_FUNC(cellOvis);
return CELL_OK;
}
int cellOvisInvalidateOverlappedSegments()
s32 cellOvisInvalidateOverlappedSegments()
{
UNIMPLEMENTED_FUNC(cellOvis);
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;
// Local Functions
int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved);
s32 cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved);
// Help Functions
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
|| 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 IsTextureNR() { return !IsInterlace(); }
@ -209,7 +209,7 @@ UN_PANSCAN:
return;
}
inline int InternalVersion(vm::ptr<CellRescInitConfig> conf)
inline s32 InternalVersion(vm::ptr<CellRescInitConfig> conf)
{
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)
{
case 20:
@ -296,7 +296,7 @@ u8 GcmSurfaceFormat2GcmTextureFormat(u8 surfaceFormat, u8 surfaceType)
return result;
}
int GetRescDestsIndex(u32 dstMode)
s32 GetRescDestsIndex(u32 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;
GetScreenSize(mode, &width, &height);
return dsts->pitch * roundup(height, dsts->heightAlign);
}
int CalculateMaxColorBuffersSize()
s32 CalculateMaxColorBuffersSize()
{
s32 oneBufSize, bufNum, totalBufSize, maxBufSize;
maxBufSize = 0;
@ -433,7 +433,7 @@ void InitMembers()
//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].pitch = 0;
s_rescInternalInstance->m_rescSrc[i].width = 0;
@ -441,11 +441,11 @@ void InitMembers()
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;
}
for (int i = 0; i<RESC_PARAM_NUM; i++) {
for (s32 i = 0; i<RESC_PARAM_NUM; i++) {
s_rescInternalInstance->m_cgParamIndex[i] = 0xFF;
}
{
@ -568,7 +568,7 @@ void SetupSurfaces(vm::ptr<CellGcmContextData>& cntxt)
}
// Module Functions
int cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
s32 cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
{
cellResc.Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.addr());
@ -610,7 +610,7 @@ void cellRescExit()
if (IsPalInterpolate())
{
// TODO: ExitSystemResource()
//int ret = ExitSystemResource();
//s32 ret = ExitSystemResource();
//if (ret != CELL_OK)
//{
// cellResc.Error("failed to clean up system resources.. continue. 0x%x\n", ret);
@ -621,7 +621,7 @@ void cellRescExit()
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());
@ -647,7 +647,7 @@ int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<u32> b
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());
@ -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);
@ -775,7 +775,7 @@ int cellRescSetDisplayMode(PPUThread& CPU, u32 displayMode)
if (IsPalInterpolate())
{
//int ret = InitSystemResource();
//s32 ret = InitSystemResource();
//if (ret) return ret;
//InitLabels();
cellGcmSetSecondVFrequency(CELL_GCM_DISPLAY_FREQUENCY_59_94HZ);
@ -804,7 +804,7 @@ int cellRescSetDisplayMode(PPUThread& CPU, u32 displayMode)
return CELL_OK;
}
int cellRescAdjustAspectRatio(float horizontal, float vertical)
s32 cellRescAdjustAspectRatio(float horizontal, float vertical)
{
cellResc.Warning("cellRescAdjustAspectRatio(horizontal=%f, vertical=%f)", horizontal, vertical);
@ -838,7 +838,7 @@ int cellRescAdjustAspectRatio(float horizontal, float vertical)
return CELL_OK;
}
int cellRescSetPalInterpolateDropFlexRatio(float ratio)
s32 cellRescSetPalInterpolateDropFlexRatio(float ratio)
{
cellResc.Warning("cellRescSetPalInterpolateDropFlexRatio(ratio=%f)", ratio);
@ -859,7 +859,7 @@ int cellRescSetPalInterpolateDropFlexRatio(float ratio)
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)",
colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
@ -903,7 +903,7 @@ int cellRescGetBufferSize(vm::ptr<u32> colorBuffers, vm::ptr<u32> vertexArray, v
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);
@ -924,7 +924,7 @@ int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
: 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());
@ -955,7 +955,7 @@ int cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellR
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());
@ -984,7 +984,7 @@ int cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
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);
@ -1022,7 +1022,7 @@ int cellRescSetConvertAndFlip(PPUThread& CPU, vm::ptr<CellGcmContextData> cntxt,
return CELL_OK;
}
int cellRescSetWaitFlip()
s32 cellRescSetWaitFlip()
{
cellResc.Log("cellRescSetWaitFlip()");
GSLockCurrent lock(GS_LOCK_WAIT_FLIP);
@ -1030,7 +1030,7 @@ int cellRescSetWaitFlip()
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());
@ -1053,14 +1053,14 @@ int cellRescSetBufferAddress(PPUThread& CPU, vm::ptr<u32> colorBuffers, vm::ptr<
vm::stackvar<be_t<u32>> dstOffset(CPU);
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;
}
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;
}
@ -1088,14 +1088,14 @@ void cellRescResetFlipStatus()
Emu.GetGSManager().GetRender().m_flip_status = 1;
}
int cellRescGetFlipStatus()
s32 cellRescGetFlipStatus()
{
cellResc.Log("cellRescGetFlipStatus()");
return Emu.GetGSManager().GetRender().m_flip_status;
}
int cellRescGetRegisterCount()
s32 cellRescGetRegisterCount()
{
UNIMPLEMENTED_FUNC(cellResc);
return CELL_OK;
@ -1108,7 +1108,7 @@ u64 cellRescGetLastFlipTime()
return Emu.GetGSManager().GetRender().m_last_flip_time;
}
int cellRescSetRegisterCount()
s32 cellRescSetRegisterCount()
{
UNIMPLEMENTED_FUNC(cellResc);
return CELL_OK;
@ -1163,7 +1163,7 @@ static void blackman(float window[])
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 y_fraction;
@ -1175,7 +1175,7 @@ int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
blackman(window);
for (int i = 0; i<length; i++)
for (s32 i = 0; i<length; i++)
{
y_fraction = (float)i / (float)length;
@ -1211,7 +1211,7 @@ int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
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);
@ -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 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_interlaceElement = depth;
s_rescInternalInstance->m_interlaceTableLength = length;
return CELL_OK;
}
else
{
return retValue;
}
}

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

@ -7,14 +7,14 @@
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 +
(s64)(years - 70) * 31536000 + (s64)((years - 69) / 4) * 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);
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;
}
int cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
s32 cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
{
cellRtc.Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.addr());
@ -31,7 +31,7 @@ int cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
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);
@ -52,7 +52,7 @@ int cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone)
return CELL_OK;
}
int cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
s32 cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
{
cellRtc.Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.addr());
@ -69,7 +69,7 @@ int cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
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);
@ -87,7 +87,7 @@ int cellRtcFormatRfc2822(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
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());
@ -101,7 +101,7 @@ int cellRtcFormatRfc2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
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);
@ -119,7 +119,7 @@ int cellRtcFormatRfc3339(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick> pUtc, s
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());
@ -133,7 +133,7 @@ int cellRtcFormatRfc3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<CellRtcTick
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());
@ -146,7 +146,7 @@ int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
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());
@ -159,7 +159,7 @@ int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::cptr<char> pszDateTime)
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());
@ -169,7 +169,7 @@ int cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
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());
@ -186,7 +186,7 @@ int cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
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);
@ -194,7 +194,7 @@ int cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
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);
@ -206,7 +206,7 @@ int cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick>
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);
@ -218,7 +218,7 @@ int cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTic
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);
@ -230,7 +230,7 @@ int cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTic
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);
@ -242,7 +242,7 @@ int cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
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);
@ -254,7 +254,7 @@ int cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1,
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);
@ -266,7 +266,7 @@ int cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
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);
@ -278,7 +278,7 @@ int cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick
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);
@ -290,7 +290,7 @@ int cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1
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());
@ -300,7 +300,7 @@ int cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick>
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());
@ -310,7 +310,7 @@ int cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRt
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());
@ -321,7 +321,7 @@ int cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u32> puiDosTim
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());
@ -333,7 +333,7 @@ int cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<s64> piTime)
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());
@ -345,7 +345,7 @@ int cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<u64> pul
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);
@ -363,7 +363,7 @@ int cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime)
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);
@ -380,7 +380,7 @@ int cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
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);
@ -397,7 +397,7 @@ int cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileT
return CELL_OK;
}
int cellRtcIsLeapYear(s32 year)
s32 cellRtcIsLeapYear(s32 year)
{
cellRtc.Log("cellRtcIsLeapYear(year=%d)", year);
@ -405,7 +405,7 @@ int cellRtcIsLeapYear(s32 year)
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);
@ -413,7 +413,7 @@ int cellRtcGetDaysInMonth(s32 year, s32 month)
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);
@ -422,7 +422,7 @@ int cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
return datetime.GetWeekDay();
}
int cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
s32 cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
{
cellRtc.Log("cellRtcCheckValid(pTime=0x%x)", pTime.addr());
@ -436,7 +436,7 @@ int cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
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());

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

@ -8,7 +8,7 @@
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());
@ -18,61 +18,61 @@ int cellSailMemAllocatorInitialize(vm::ptr<CellSailMemAllocator> pSelf, vm::ptr<
return CELL_OK;
}
int cellSailFutureInitialize()
s32 cellSailFutureInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailFutureFinalize()
s32 cellSailFutureFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailFutureReset()
s32 cellSailFutureReset()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailFutureSet()
s32 cellSailFutureSet()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailFutureGet()
s32 cellSailFutureGet()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailFutureIsDone()
s32 cellSailFutureIsDone()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorGetStreamType()
s32 cellSailDescriptorGetStreamType()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorGetUri()
s32 cellSailDescriptorGetUri()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorGetMediaInfo()
s32 cellSailDescriptorGetMediaInfo()
{
UNIMPLEMENTED_FUNC(cellSail);
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");
@ -84,7 +84,7 @@ int cellSailDescriptorSetAutoSelection(vm::ptr<CellSailDescriptor> pSelf, bool a
return CELL_OK;
}
int cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
s32 cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
{
cellSail.Warning("cellSailDescriptorIsAutoSelection(pSelf_addr=0x%x)", pSelf.addr());
@ -94,7 +94,7 @@ int cellSailDescriptorIsAutoSelection(vm::ptr<CellSailDescriptor> pSelf)
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);
@ -113,409 +113,409 @@ int cellSailDescriptorCreateDatabase(vm::ptr<CellSailDescriptor> pSelf, vm::ptr<
return CELL_OK;
}
int cellSailDescriptorDestroyDatabase()
s32 cellSailDescriptorDestroyDatabase()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorOpen()
s32 cellSailDescriptorOpen()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorClose()
s32 cellSailDescriptorClose()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorSetEs()
s32 cellSailDescriptorSetEs()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorClearEs()
s32 cellSailDescriptorClearEs()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorGetCapabilities()
s32 cellSailDescriptorGetCapabilities()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorInquireCapability()
s32 cellSailDescriptorInquireCapability()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailDescriptorSetParameter()
s32 cellSailDescriptorSetParameter()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterInitialize()
s32 cellSailSoundAdapterInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterFinalize()
s32 cellSailSoundAdapterFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterSetPreferredFormat()
s32 cellSailSoundAdapterSetPreferredFormat()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterGetFrame()
s32 cellSailSoundAdapterGetFrame()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterGetFormat()
s32 cellSailSoundAdapterGetFormat()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterUpdateAvSync()
s32 cellSailSoundAdapterUpdateAvSync()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSoundAdapterPtsToTimePosition()
s32 cellSailSoundAdapterPtsToTimePosition()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterInitialize()
s32 cellSailGraphicsAdapterInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterFinalize()
s32 cellSailGraphicsAdapterFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterSetPreferredFormat()
s32 cellSailGraphicsAdapterSetPreferredFormat()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterGetFrame()
s32 cellSailGraphicsAdapterGetFrame()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterGetFrame2()
s32 cellSailGraphicsAdapterGetFrame2()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterGetFormat()
s32 cellSailGraphicsAdapterGetFormat()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterUpdateAvSync()
s32 cellSailGraphicsAdapterUpdateAvSync()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailGraphicsAdapterPtsToTimePosition()
s32 cellSailGraphicsAdapterPtsToTimePosition()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAuReceiverInitialize()
s32 cellSailAuReceiverInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAuReceiverFinalize()
s32 cellSailAuReceiverFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAuReceiverGet()
s32 cellSailAuReceiverGet()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererAudioInitialize()
s32 cellSailRendererAudioInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererAudioFinalize()
s32 cellSailRendererAudioFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererAudioNotifyCallCompleted()
s32 cellSailRendererAudioNotifyCallCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererAudioNotifyFrameDone()
s32 cellSailRendererAudioNotifyFrameDone()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererAudioNotifyOutputEos()
s32 cellSailRendererAudioNotifyOutputEos()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererVideoInitialize()
s32 cellSailRendererVideoInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererVideoFinalize()
s32 cellSailRendererVideoFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererVideoNotifyCallCompleted()
s32 cellSailRendererVideoNotifyCallCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererVideoNotifyFrameDone()
s32 cellSailRendererVideoNotifyFrameDone()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailRendererVideoNotifyOutputEos()
s32 cellSailRendererVideoNotifyOutputEos()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceInitialize()
s32 cellSailSourceInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceFinalize()
s32 cellSailSourceFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyCallCompleted()
s32 cellSailSourceNotifyCallCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyInputEos()
s32 cellSailSourceNotifyInputEos()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyStreamOut()
s32 cellSailSourceNotifyStreamOut()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifySessionError()
s32 cellSailSourceNotifySessionError()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyMediaStateChanged()
s32 cellSailSourceNotifyMediaStateChanged()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceCheck()
s32 cellSailSourceCheck()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyOpenCompleted()
s32 cellSailSourceNotifyOpenCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyStartCompleted()
s32 cellSailSourceNotifyStartCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyStopCompleted()
s32 cellSailSourceNotifyStopCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyReadCompleted()
s32 cellSailSourceNotifyReadCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceSetDiagHandler()
s32 cellSailSourceSetDiagHandler()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailSourceNotifyCloseCompleted()
s32 cellSailSourceNotifyCloseCompleted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4MovieGetBrand()
s32 cellSailMp4MovieGetBrand()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4MovieIsCompatibleBrand()
s32 cellSailMp4MovieIsCompatibleBrand()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4MovieGetMovieInfo()
s32 cellSailMp4MovieGetMovieInfo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4MovieGetTrackByIndex()
s32 cellSailMp4MovieGetTrackByIndex()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4MovieGetTrackById()
s32 cellSailMp4MovieGetTrackById()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4MovieGetTrackByTypeAndIndex()
s32 cellSailMp4MovieGetTrackByTypeAndIndex()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4TrackGetTrackInfo()
s32 cellSailMp4TrackGetTrackInfo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4TrackGetTrackReferenceCount()
s32 cellSailMp4TrackGetTrackReferenceCount()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4TrackGetTrackReference()
s32 cellSailMp4TrackGetTrackReference()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailMp4ConvertTimeScale()
s32 cellSailMp4ConvertTimeScale()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAviMovieGetMovieInfo()
s32 cellSailAviMovieGetMovieInfo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAviMovieGetStreamByIndex()
s32 cellSailAviMovieGetStreamByIndex()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAviMovieGetStreamByTypeAndIndex()
s32 cellSailAviMovieGetStreamByTypeAndIndex()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAviMovieGetHeader()
s32 cellSailAviMovieGetHeader()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAviStreamGetMediaType()
s32 cellSailAviStreamGetMediaType()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailAviStreamGetHeader()
s32 cellSailAviStreamGetHeader()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerInitialize()
s32 cellSailPlayerInitialize()
{
UNIMPLEMENTED_FUNC(cellSail);
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)
{
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;
}
int cellSailPlayerFinalize()
s32 cellSailPlayerFinalize()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerRegisterSource()
s32 cellSailPlayerRegisterSource()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerGetRegisteredProtocols()
s32 cellSailPlayerGetRegisteredProtocols()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetSoundAdapter()
s32 cellSailPlayerSetSoundAdapter()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetGraphicsAdapter()
s32 cellSailPlayerSetGraphicsAdapter()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetAuReceiver()
s32 cellSailPlayerSetAuReceiver()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetRendererAudio()
s32 cellSailPlayerSetRendererAudio()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetRendererVideo()
s32 cellSailPlayerSetRendererVideo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetParameter()
s32 cellSailPlayerSetParameter()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerGetParameter()
s32 cellSailPlayerGetParameter()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSubscribeEvent()
s32 cellSailPlayerSubscribeEvent()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerUnsubscribeEvent()
s32 cellSailPlayerUnsubscribeEvent()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerReplaceEventHandler()
s32 cellSailPlayerReplaceEventHandler()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerBoot()
s32 cellSailPlayerBoot()
{
UNIMPLEMENTED_FUNC(cellSail);
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());
@ -632,7 +632,7 @@ int cellSailPlayerAddDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailD
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,
pMediaInfo.addr(), pUri.addr(), ppDesc.addr());
@ -685,7 +685,7 @@ int cellSailPlayerCreateDescriptor(vm::ptr<CellSailPlayer> pSelf, s32 streamType
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());
@ -695,7 +695,7 @@ int cellSailPlayerDestroyDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellS
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());
@ -709,121 +709,121 @@ int cellSailPlayerRemoveDescriptor(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSa
return pSelf->descriptors;
}
int cellSailPlayerGetDescriptorCount(vm::ptr<CellSailPlayer> pSelf)
s32 cellSailPlayerGetDescriptorCount(vm::ptr<CellSailPlayer> pSelf)
{
cellSail.Warning("cellSailPlayerGetDescriptorCount(pSelf_addr=0x%x)", pSelf.addr());
return pSelf->descriptors;
}
int cellSailPlayerGetCurrentDescriptor()
s32 cellSailPlayerGetCurrentDescriptor()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerOpenStream()
s32 cellSailPlayerOpenStream()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerCloseStream()
s32 cellSailPlayerCloseStream()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerOpenEsAudio()
s32 cellSailPlayerOpenEsAudio()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerOpenEsVideo()
s32 cellSailPlayerOpenEsVideo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerOpenEsUser()
s32 cellSailPlayerOpenEsUser()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerReopenEsAudio()
s32 cellSailPlayerReopenEsAudio()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerReopenEsVideo()
s32 cellSailPlayerReopenEsVideo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerReopenEsUser()
s32 cellSailPlayerReopenEsUser()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerCloseEsAudio()
s32 cellSailPlayerCloseEsAudio()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerCloseEsVideo()
s32 cellSailPlayerCloseEsVideo()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerCloseEsUser()
s32 cellSailPlayerCloseEsUser()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerStart()
s32 cellSailPlayerStart()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerStop()
s32 cellSailPlayerStop()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerNext()
s32 cellSailPlayerNext()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerCancel()
s32 cellSailPlayerCancel()
{
UNIMPLEMENTED_FUNC(cellSail);
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);
return CELL_OK;
}
int cellSailPlayerIsPaused(vm::ptr<CellSailPlayer> pSelf)
s32 cellSailPlayerIsPaused(vm::ptr<CellSailPlayer> pSelf)
{
cellSail.Warning("cellSailPlayerIsPaused(pSelf_addr=0x%x)", pSelf.addr());
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());
@ -833,7 +833,7 @@ int cellSailPlayerSetRepeatMode(vm::ptr<CellSailPlayer> pSelf, s32 repeatMode, v
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());
@ -842,37 +842,37 @@ int cellSailPlayerGetRepeatMode(vm::ptr<CellSailPlayer> pSelf, vm::ptr<CellSailS
return pSelf->repeatMode;
}
int cellSailPlayerSetEsAudioMuted()
s32 cellSailPlayerSetEsAudioMuted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerSetEsVideoMuted()
s32 cellSailPlayerSetEsVideoMuted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerIsEsAudioMuted()
s32 cellSailPlayerIsEsAudioMuted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerIsEsVideoMuted()
s32 cellSailPlayerIsEsVideoMuted()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerDumpImage()
s32 cellSailPlayerDumpImage()
{
UNIMPLEMENTED_FUNC(cellSail);
return CELL_OK;
}
int cellSailPlayerUnregisterSource()
s32 cellSailPlayerUnregisterSource()
{
UNIMPLEMENTED_FUNC(cellSail);
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
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->type = SYS_PPU_QUEUE;
@ -1718,7 +1718,7 @@ s32 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 wid, vm::cptr<u8> prior
}
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)
{
@ -2812,8 +2812,8 @@ s32 cellSpursEventFlagSet(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag,
}
}
int i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1;
int j = 0;
s32 i = CELL_SPURS_EVENT_FLAG_MAX_WAIT_SLOTS - 1;
s32 j = 0;
u16 relevantWaitSlots = eventFlag->spuTaskUsedWaitSlots & ~ctrl.spuTaskPendingRecv;
while (relevantWaitSlots)
{
@ -2862,7 +2862,7 @@ s32 cellSpursEventFlagSet(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag,
if (pendingRecv)
{
// 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))
{
@ -2951,7 +2951,7 @@ s32 spursEventFlagWait(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag, vm
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)
{
if (relevantWaitSlots & 0x0001)
@ -2995,7 +2995,7 @@ s32 spursEventFlagWait(PPUThread& CPU, vm::ptr<CellSpursEventFlag> eventFlag, vm
if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
{
// Find an unsed wait slot
int i = 0;
s32 i = 0;
u16 spuTaskUsedWaitSlots = eventFlag->spuTaskUsedWaitSlots;
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);
}
int i = 0;
s32 i = 0;
if (eventFlag->direction == CELL_SPURS_EVENT_FLAG_ANY2ANY)
{
i = eventFlag->ctrl.data.ppuWaitSlotAndMode >> 4;

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

@ -6,19 +6,19 @@
extern Module cellSubdisplay;
int cellSubDisplayInit()
s32 cellSubDisplayInit()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayEnd()
s32 cellSubDisplayEnd()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam)
s32 cellSubDisplayGetRequiredMemory(vm::ptr<CellSubDisplayParam> pParam)
{
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);
return CELL_OK;
}
int cellSubDisplayStop()
s32 cellSubDisplayStop()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayGetVideoBuffer()
s32 cellSubDisplayGetVideoBuffer()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayAudioOutBlocking()
s32 cellSubDisplayAudioOutBlocking()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayAudioOutNonBlocking()
s32 cellSubDisplayAudioOutNonBlocking()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayGetPeerNum()
s32 cellSubDisplayGetPeerNum()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
return CELL_OK;
}
int cellSubDisplayGetPeerList()
s32 cellSubDisplayGetPeerList()
{
UNIMPLEMENTED_FUNC(cellSubdisplay);
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
{
be_t<s16> value;
be_t<s16> count;
be_t<u16> count;
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
}
int cellSysutilApOn()
s32 cellSysutilApOn()
{
UNIMPLEMENTED_FUNC(cellSysutilAp);
return CELL_OK;
}
int cellSysutilApOff()
s32 cellSysutilApOff()
{
UNIMPLEMENTED_FUNC(cellSysutilAp);
return CELL_OK;

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

@ -9,7 +9,7 @@
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());
@ -37,25 +37,25 @@ int cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat)
return CELL_OK;
}
int cellUserInfoSelectUser_ListType()
s32 cellUserInfoSelectUser_ListType()
{
UNIMPLEMENTED_FUNC(cellUserInfo);
return CELL_OK;
}
int cellUserInfoSelectUser_SetList()
s32 cellUserInfoSelectUser_SetList()
{
UNIMPLEMENTED_FUNC(cellUserInfo);
return CELL_OK;
}
int cellUserInfoEnableOverlay()
s32 cellUserInfoEnableOverlay()
{
UNIMPLEMENTED_FUNC(cellUserInfo);
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)",
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;
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);
@ -101,7 +101,7 @@ int cellAANAddData(u32 aan_handle, u32 aan_port, u32 offset, vm::ptr<float> addr
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)",
receive, receivePortNo, source, sourcePortNo);
@ -119,7 +119,7 @@ int cellAANConnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePortNo)
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)",
receive, receivePortNo, source, sourcePortNo);
@ -137,7 +137,7 @@ int cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePort
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)",
handle.addr(), config.addr());
@ -162,7 +162,7 @@ int cellSSPlayerCreate(vm::ptr<u32> handle, vm::ptr<CellSSPlayerConfig> config)
return CELL_OK;
}
int cellSSPlayerRemove(u32 handle)
s32 cellSSPlayerRemove(u32 handle)
{
libmixer.Warning("cellSSPlayerRemove(handle=0x%x)", handle);
@ -181,7 +181,7 @@ int cellSSPlayerRemove(u32 handle)
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)",
handle, waveInfo.addr(), commonInfo.addr());
@ -205,7 +205,7 @@ int cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm:
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());
@ -229,7 +229,7 @@ int cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
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);
@ -248,7 +248,7 @@ int cellSSPlayerStop(u32 handle, u32 mode)
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());
@ -271,7 +271,7 @@ int cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
return CELL_OK;
}
int cellSSPlayerGetState(u32 handle)
s32 cellSSPlayerGetState(u32 handle)
{
libmixer.Warning("cellSSPlayerGetState(handle=0x%x)", handle);
@ -291,7 +291,7 @@ int cellSSPlayerGetState(u32 handle)
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());
@ -364,10 +364,10 @@ int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
float right = 0.0f;
float speed = fabs(p.m_speed);
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;
int pos_inc = 0;
s32 pos_inc = 0;
if (p.m_speed > 0.0f) // select direction
{
pos_inc = 1;
@ -376,7 +376,7 @@ int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
{
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)
{
// slow playback
@ -467,21 +467,21 @@ int cellSurMixerCreate(vm::cptr<CellSurMixerConfig> config)
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);
*handle = 0x11111111;
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);
*port = (type << 16) | index;
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());
@ -494,7 +494,7 @@ int cellSurMixerSetNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> fu
return CELL_OK;
}
int cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func)
s32 cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction> func)
{
libmixer.Warning("cellSurMixerRemoveNotifyCallback(func_addr=0x%x)", func.addr());
@ -509,7 +509,7 @@ int cellSurMixerRemoveNotifyCallback(vm::ptr<CellSurMixerNotifyCallbackFunction>
return CELL_OK;
}
int cellSurMixerStart()
s32 cellSurMixerStart()
{
libmixer.Warning("cellSurMixerStart()");
@ -523,13 +523,13 @@ int cellSurMixerStart()
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);
return CELL_OK;
}
int cellSurMixerFinalize()
s32 cellSurMixerFinalize()
{
libmixer.Warning("cellSurMixerFinalize()");
@ -543,7 +543,7 @@ int cellSurMixerFinalize()
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)
{
@ -566,13 +566,13 @@ int cellSurMixerSurBusAddData(u32 busNo, u32 offset, vm::ptr<float> addr, u32 sa
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());
return CELL_OK;
}
int cellSurMixerPause(u32 type)
s32 cellSurMixerPause(u32 type)
{
libmixer.Warning("cellSurMixerPause(type=%d)", type);
@ -586,7 +586,7 @@ int cellSurMixerPause(u32 type)
return CELL_OK;
}
int cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
s32 cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
{
libmixer.Log("cellSurMixerGetCurrentBlockTag(tag_addr=0x%x)", tag.addr());
@ -594,7 +594,7 @@ int cellSurMixerGetCurrentBlockTag(vm::ptr<u64> tag)
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());

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;
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);
@ -35,7 +35,7 @@ int sceNpClansInit(vm::ptr<SceNpCommunicationId> commId, vm::ptr<SceNpCommunicat
return CELL_OK;
}
int sceNpClansTerm()
s32 sceNpClansTerm()
{
sceNpClans.Warning("sceNpClansTerm()");
@ -47,7 +47,7 @@ int sceNpClansTerm()
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);
@ -60,7 +60,7 @@ int sceNpClansCreateRequest(vm::ptr<SceNpClansRequestHandle> handle,u64 flags)
return CELL_OK;
}
int sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle)
s32 sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle)
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -70,7 +70,7 @@ int sceNpClansDestroyRequest(vm::ptr<SceNpClansRequestHandle> handle)
return CELL_OK;
}
int sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
s32 sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -80,7 +80,7 @@ int sceNpClansAbortRequest(vm::ptr<SceNpClansRequestHandle> handle)
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);
@ -90,7 +90,7 @@ int sceNpClansCreateClan(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<char>
return CELL_OK;
}
int sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
s32 sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -100,7 +100,7 @@ int sceNpClansDisbandClan(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId)
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);
@ -110,7 +110,7 @@ int sceNpClansGetClanList(vm::ptr<SceNpClansRequestHandle> handle, vm::cptr<SceN
return CELL_OK;
}
int sceNpClansGetClanListByNpId()
s32 sceNpClansGetClanListByNpId()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -120,7 +120,7 @@ int sceNpClansGetClanListByNpId()
return CELL_OK;
}
int sceNpClansSearchByProfile()
s32 sceNpClansSearchByProfile()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -130,7 +130,7 @@ int sceNpClansSearchByProfile()
return CELL_OK;
}
int sceNpClansSearchByName()
s32 sceNpClansSearchByName()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -140,7 +140,7 @@ int sceNpClansSearchByName()
return CELL_OK;
}
int sceNpClansGetClanInfo()
s32 sceNpClansGetClanInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -150,7 +150,7 @@ int sceNpClansGetClanInfo()
return CELL_OK;
}
int sceNpClansUpdateClanInfo()
s32 sceNpClansUpdateClanInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -160,7 +160,7 @@ int sceNpClansUpdateClanInfo()
return CELL_OK;
}
int sceNpClansGetMemberList()
s32 sceNpClansGetMemberList()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -170,7 +170,7 @@ int sceNpClansGetMemberList()
return CELL_OK;
}
int sceNpClansGetMemberInfo()
s32 sceNpClansGetMemberInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -180,7 +180,7 @@ int sceNpClansGetMemberInfo()
return CELL_OK;
}
int sceNpClansUpdateMemberInfo()
s32 sceNpClansUpdateMemberInfo()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -190,7 +190,7 @@ int sceNpClansUpdateMemberInfo()
return CELL_OK;
}
int sceNpClansChangeMemberRole()
s32 sceNpClansChangeMemberRole()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -200,7 +200,7 @@ int sceNpClansChangeMemberRole()
return CELL_OK;
}
int sceNpClansGetAutoAcceptStatus()
s32 sceNpClansGetAutoAcceptStatus()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -210,7 +210,7 @@ int sceNpClansGetAutoAcceptStatus()
return CELL_OK;
}
int sceNpClansUpdateAutoAcceptStatus()
s32 sceNpClansUpdateAutoAcceptStatus()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -220,7 +220,7 @@ int sceNpClansUpdateAutoAcceptStatus()
return CELL_OK;
}
int sceNpClansJoinClan()
s32 sceNpClansJoinClan()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -230,7 +230,7 @@ int sceNpClansJoinClan()
return CELL_OK;
}
int sceNpClansLeaveClan()
s32 sceNpClansLeaveClan()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -240,7 +240,7 @@ int sceNpClansLeaveClan()
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);
@ -250,7 +250,7 @@ int sceNpClansKickMember(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId, vm
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);
@ -260,7 +260,7 @@ int sceNpClansSendInvitation(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId
return CELL_OK;
}
int sceNpClansCancelInvitation()
s32 sceNpClansCancelInvitation()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -270,7 +270,7 @@ int sceNpClansCancelInvitation()
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);
@ -280,7 +280,7 @@ int sceNpClansSendInvitationResponse(vm::ptr<SceNpClansRequestHandle> handle, u3
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);
@ -290,7 +290,7 @@ int sceNpClansSendMembershipRequest(vm::ptr<SceNpClansRequestHandle> handle, u32
return CELL_OK;
}
int sceNpClansCancelMembershipRequest()
s32 sceNpClansCancelMembershipRequest()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -300,7 +300,7 @@ int sceNpClansCancelMembershipRequest()
return CELL_OK;
}
int sceNpClansSendMembershipResponse()
s32 sceNpClansSendMembershipResponse()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -310,7 +310,7 @@ int sceNpClansSendMembershipResponse()
return CELL_OK;
}
int sceNpClansGetBlacklist()
s32 sceNpClansGetBlacklist()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -320,7 +320,7 @@ int sceNpClansGetBlacklist()
return CELL_OK;
}
int sceNpClansAddBlacklistEntry()
s32 sceNpClansAddBlacklistEntry()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -330,7 +330,7 @@ int sceNpClansAddBlacklistEntry()
return CELL_OK;
}
int sceNpClansRemoveBlacklistEntry()
s32 sceNpClansRemoveBlacklistEntry()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -340,7 +340,7 @@ int sceNpClansRemoveBlacklistEntry()
return CELL_OK;
}
int sceNpClansRetrieveAnnouncements()
s32 sceNpClansRetrieveAnnouncements()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -350,7 +350,7 @@ int sceNpClansRetrieveAnnouncements()
return CELL_OK;
}
int sceNpClansPostAnnouncement()
s32 sceNpClansPostAnnouncement()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -360,7 +360,7 @@ int sceNpClansPostAnnouncement()
return CELL_OK;
}
int sceNpClansRemoveAnnouncement()
s32 sceNpClansRemoveAnnouncement()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -370,7 +370,7 @@ int sceNpClansRemoveAnnouncement()
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);
@ -385,7 +385,7 @@ int sceNpClansPostChallenge(vm::ptr<SceNpClansRequestHandle> handle, u32 clanId,
return CELL_OK;
}
int sceNpClansRetrievePostedChallenges()
s32 sceNpClansRetrievePostedChallenges()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -397,7 +397,7 @@ int sceNpClansRetrievePostedChallenges()
return CELL_OK;
}
int sceNpClansRemovePostedChallenge()
s32 sceNpClansRemovePostedChallenge()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -407,7 +407,7 @@ int sceNpClansRemovePostedChallenge()
return CELL_OK;
}
int sceNpClansRetrieveChallenges()
s32 sceNpClansRetrieveChallenges()
{
UNIMPLEMENTED_FUNC(sceNpClans);
@ -417,7 +417,7 @@ int sceNpClansRetrieveChallenges()
return CELL_OK;
}
int sceNpClansRemoveChallenge()
s32 sceNpClansRemoveChallenge()
{
UNIMPLEMENTED_FUNC(sceNpClans);

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

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

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

@ -37,4 +37,4 @@ struct SceNpSnsFbInitParams
{
be_t<u32> pool;
be_t<u32> poolSize;
};
};

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

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

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_vm.h"
#include "lv2/sys_fs.h"
#include "lv2/sys_dbg.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);

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

@ -48,7 +48,7 @@ enum : u64
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<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;
// 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_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);

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();
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);

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

@ -14,7 +14,7 @@ enum
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> pshared;
@ -55,7 +55,7 @@ struct lv2_event_flag_t
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_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);

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>
};
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
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_RUNNING,
SPU_THREAD_GROUP_STATUS_STOPPED,
SPU_THREAD_GROUP_STATUS_UNKNOWN
SPU_THREAD_GROUP_STATUS_UNKNOWN,
};
enum : s32

7
rpcs3/emucore.vcxproj
View file

@ -41,6 +41,7 @@
<ClCompile Include="Emu\RSX\Common\ShaderParam.cpp" />
<ClCompile Include="Emu\RSX\Common\VertexProgramDecompiler.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\Modules\cellFs.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellSpursSpu.cpp" />
@ -225,7 +226,6 @@
<ClCompile Include="Emu\SysCalls\Modules\cellJpgEnc.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellKey2char.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\cellMsgDialog.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellMusicDecode.cpp" />
@ -276,6 +276,7 @@
<ClCompile Include="Emu\SysCalls\Modules\cellMouse.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\cellPad.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_io.cpp" />
<ClCompile Include="Emu\SysCalls\Modules\sys_libc.cpp" />
@ -494,6 +495,7 @@
<ClInclude Include="Emu\SysCalls\LogBase.h" />
<ClInclude Include="Emu\SysCalls\lv2\sleep_queue.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_flag.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\cellMouse.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\SC_FUNC.h" />
<ClInclude Include="Emu\SysCalls\SysCalls.h" />
@ -776,4 +779,4 @@
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
</Project>

15
rpcs3/emucore.vcxproj.filters
View file

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

15
rpcs3/rpcs3.vcxproj
View file

@ -88,8 +88,11 @@
<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>
<IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<DataExecutionPrevention>false</DataExecutionPrevention>
<DataExecutionPrevention>true</DataExecutionPrevention>
<AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
<BaseAddress>0x200000000</BaseAddress>
<FixedBaseAddress>true</FixedBaseAddress>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
</Link>
<PreBuildEvent>
<Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>
@ -115,8 +118,11 @@
<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>
<IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<DataExecutionPrevention>false</DataExecutionPrevention>
<DataExecutionPrevention>true</DataExecutionPrevention>
<AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
<BaseAddress>0x200000000</BaseAddress>
<FixedBaseAddress>true</FixedBaseAddress>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
</Link>
<PreBuildEvent>
<Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>
@ -153,8 +159,11 @@
<IgnoreAllDefaultLibraries>
</IgnoreAllDefaultLibraries>
<IgnoreSpecificDefaultLibraries>%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>
<DataExecutionPrevention>false</DataExecutionPrevention>
<DataExecutionPrevention>true</DataExecutionPrevention>
<AdditionalLibraryDirectories>..\wxWidgets\lib\vc_x64_lib;..\ffmpeg\Windows\x86_64\lib;..\OpenAL\Win64</AdditionalLibraryDirectories>
<BaseAddress>0x200000000</BaseAddress>
<FixedBaseAddress>true</FixedBaseAddress>
<RandomizedBaseAddress>false</RandomizedBaseAddress>
</Link>
<PreBuildEvent>
<Command>"$(SolutionDir)\Utilities\git-version-gen.cmd"</Command>