From b214a1a1daebe42bb648c63b914c573ee9bf69d7 Mon Sep 17 00:00:00 2001 From: Henrik Rydgard Date: Mon, 5 Nov 2012 10:05:09 +0100 Subject: [PATCH] Revert "Better wrapper system, and fixed warnings" This reverts commit a00b1855cb6427f8eb36341137dbb81004ff29fd. Conflicts: Core/HLE/FunctionWrappers.h Core/HLE/sceCtrl.cpp Core/HLE/sceKernelModule.cpp --- Common/CPUDetect.cpp | 4 +- Common/FixedSizeUnorderedSet.h | 6 +- Common/x64Analyzer.cpp | 6 + Common/x64Emitter.h | 2 +- Core/ELF/ElfReader.cpp | 3 + Core/HLE/FunctionWrappers.h | 104 ++----- Core/HLE/HLE.h | 1 - Core/HLE/HLETables.cpp | 32 +-- Core/HLE/sceAtrac.cpp | 193 +++++++------ Core/HLE/sceAudio.cpp | 32 +-- Core/HLE/sceCtrl.cpp | 30 +- Core/HLE/sceDisplay.cpp | 72 ++--- Core/HLE/sceDmac.cpp | 2 +- Core/HLE/sceGe.cpp | 42 +-- Core/HLE/sceHprm.cpp | 2 +- Core/HLE/sceIo.cpp | 420 +++++++++++++++------------- Core/HLE/sceKernel.cpp | 224 +++++++-------- Core/HLE/sceKernel.h | 12 +- Core/HLE/sceKernelEventFlag.cpp | 19 +- Core/HLE/sceKernelInterrupt.cpp | 25 +- Core/HLE/sceKernelModule.cpp | 39 +-- Core/HLE/sceKernelMsgPipe.cpp | 5 +- Core/HLE/sceKernelSemaphore.cpp | 4 +- Core/HLE/sceKernelThread.cpp | 14 +- Core/HLE/sceKernelTime.cpp | 31 +- Core/HLE/sceKernelTime.h | 12 +- Core/HLE/sceNet.cpp | 4 +- Core/HLE/scePower.cpp | 2 +- Core/HLE/scePsmf.cpp | 8 +- Core/HLE/sceRtc.cpp | 6 +- Core/HLE/sceRtc.h | 2 +- Core/HLE/sceSas.cpp | 8 +- GPU/GLES/DisplayListInterpreter.cpp | 10 +- GPU/GLES/TransformPipeline.cpp | 3 +- 34 files changed, 680 insertions(+), 699 deletions(-) diff --git a/Common/CPUDetect.cpp b/Common/CPUDetect.cpp index 44f7a1a17f..8222117669 100644 --- a/Common/CPUDetect.cpp +++ b/Common/CPUDetect.cpp @@ -173,9 +173,9 @@ void CPUInfo::Detect() if (max_ex_fn >= 0x80000001) { // Check for more features. __cpuid(cpu_id, 0x80000001); - //bool cmp_legacy = false; + bool cmp_legacy = false; if (cpu_id[2] & 1) bLAHFSAHF64 = true; - //if (cpu_id[2] & 2) cmp_legacy = true; //wtf is this? + if (cpu_id[2] & 2) cmp_legacy = true; //wtf is this? if ((cpu_id[3] >> 29) & 1) bLongMode = true; } diff --git a/Common/FixedSizeUnorderedSet.h b/Common/FixedSizeUnorderedSet.h index 9745938e61..87552f2baa 100644 --- a/Common/FixedSizeUnorderedSet.h +++ b/Common/FixedSizeUnorderedSet.h @@ -20,7 +20,7 @@ public: bool remove(T item) { - for (u32 i = 0; i < count_; i++) + for (int i = 0; i < count_; i++) { if (data_[i] == item) { @@ -62,5 +62,5 @@ public: private: T data_[maxCount]; - u32 count_; -}; + int count_; +}; \ No newline at end of file diff --git a/Common/x64Analyzer.cpp b/Common/x64Analyzer.cpp index a3e389feb8..1940416d6a 100644 --- a/Common/x64Analyzer.cpp +++ b/Common/x64Analyzer.cpp @@ -31,9 +31,12 @@ bool DisassembleMov(const unsigned char *codePtr, InstructionInfo &info, int acc info.hasImmediate = false; info.isMemoryWrite = false; + int addressSize = 8; u8 modRMbyte = 0; u8 sibByte = 0; bool hasModRM = false; + bool hasSIBbyte = false; + bool hasDisplacement = false; int displacementSize = 0; @@ -44,6 +47,7 @@ bool DisassembleMov(const unsigned char *codePtr, InstructionInfo &info, int acc } else if (*codePtr == 0x67) { + addressSize = 4; codePtr++; } @@ -109,6 +113,7 @@ bool DisassembleMov(const unsigned char *codePtr, InstructionInfo &info, int acc info.otherReg = (sibByte & 7); if (rex & 2) info.scaledReg += 8; if (rex & 1) info.otherReg += 8; + hasSIBbyte = true; } else { @@ -117,6 +122,7 @@ bool DisassembleMov(const unsigned char *codePtr, InstructionInfo &info, int acc } if (mrm.mod == 1 || mrm.mod == 2) { + hasDisplacement = true; if (mrm.mod == 1) displacementSize = 1; else diff --git a/Common/x64Emitter.h b/Common/x64Emitter.h index dce568be9f..9e9c39f110 100644 --- a/Common/x64Emitter.h +++ b/Common/x64Emitter.h @@ -24,7 +24,7 @@ #include "MemoryUtil.h" #if !defined(_M_IX86) && !defined(_M_X64) -#error Do not build this on arm. +#error Don't build this on arm. #endif namespace Gen diff --git a/Core/ELF/ElfReader.cpp b/Core/ELF/ElfReader.cpp index e574afea17..068c27f754 100644 --- a/Core/ELF/ElfReader.cpp +++ b/Core/ELF/ElfReader.cpp @@ -166,6 +166,7 @@ bool ElfReader::LoadInto(u32 vaddr) if (s->sh_type == SHT_PSPREL) { //We have a relocation table! + int symbolSection = s->sh_link; int sectionToModify = s->sh_info; if (!(sections[sectionToModify].sh_flags & SHF_ALLOC)) @@ -300,6 +301,7 @@ bool ElfReader::LoadInto(u32 vaddr) else { //We have a relocation table! + int symbolSection = s->sh_link; int sectionToModify = s->sh_info; if (!(sections[sectionToModify].sh_flags & SHF_ALLOC)) { @@ -351,6 +353,7 @@ bool ElfReader::LoadSymbols() if (size == 0) continue; + int bind = symtab[sym].st_info >> 4; int type = symtab[sym].st_info & 0xF; int sectionIndex = symtab[sym].st_shndx; int value = symtab[sym].st_value; diff --git a/Core/HLE/FunctionWrappers.h b/Core/HLE/FunctionWrappers.h index 0185d326b9..0059edc8b1 100644 --- a/Core/HLE/FunctionWrappers.h +++ b/Core/HLE/FunctionWrappers.h @@ -21,141 +21,71 @@ // For easy parameter parsing and return value processing. -template void Wrap() { +template void WrapV_V() { func(); } -template void Wrap() { +template void WrapU_V() { RETURN(func()); } -template void Wrap() { +template void WrapF_V() { RETURNF(func()); } -template void Wrap() { - u32 retval = func(PARAM(0)); - RETURN(retval); -} -template void Wrap() { - int retval = func(PARAM(0)); - RETURN(retval); -} -template void Wrap() { +template void WrapU_U() { u32 retval = func(PARAM(0)); RETURN(retval); } -template void Wrap() { +template void WrapV_U() { func(PARAM(0)); } -template void Wrap() { - u32 retval = func((time_t*)Memory::GetPointer(PARAM(0))); - RETURN(retval); -} - -template void Wrap() { +template void WrapV_UU() { func(PARAM(0), PARAM(1)); } -template void Wrap() { - u32 retval = func(PARAM(0), PARAM(1)); - RETURN(retval); -} -template void Wrap() { - u32 retval = func((timeval*)Memory::GetPointer(PARAM(0)), PARAM(1)); - RETURN(retval); -} -template void Wrap() { +template void WrapU_UU() { u32 retval = func(PARAM(0), PARAM(1)); RETURN(retval); } -template void Wrap() { +template void WrapI_CU() { int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); - RETURN((u32)retval); -} -template void Wrap() { - int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); - RETURN((u32)retval); -} -template void Wrap() { - u32 retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); RETURN(retval); } -template void Wrap() { - int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); +template void WrapU_CU() { + int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1)); RETURN((u32)retval); } -template void Wrap() { + +template void WrapU_CUU() { int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2)); RETURN((u32)retval); } -template void Wrap() { - u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); - RETURN(retval); -} -template void Wrap() { - u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); - RETURN(retval); -} -template void Wrap() { +template void WrapU_UUU() { u32 retval = func(PARAM(0), PARAM(1), PARAM(2)); RETURN(retval); } -template void Wrap() { +template void WrapV_UUU() { func(PARAM(0), PARAM(1), PARAM(2)); } -template void Wrap() { - u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); - RETURN(retval); -} -template void Wrap() { - u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); - RETURN(retval); -} -template void Wrap() { +template void WrapU_UUUU() { u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)); RETURN(retval); } -template void Wrap() { +template void WrapU_UUUUU() { u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)); RETURN(retval); } -template void Wrap() { +template void WrapU_UUUUUU() { u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); RETURN(retval); } -template void Wrap() { - u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5)); - RETURN(retval); -} - -template void Wrap() { - u32 retval = func(((u64)PARAM(1) << 32) | PARAM(0)); - RETURN(retval); -} - -template void Wrap() { - u64 retval = func(PARAM(0), ((u64)PARAM(3) << 32) | PARAM(2), PARAM(4)); - RETURN(retval); - RETURN2(retval >> 32); -} -template void Wrap() { - u64 retval = func(PARAM(0), ((u64)PARAM(3) << 32) | PARAM(2), PARAM(4)); - RETURN(retval); - RETURN2(retval >> 32); -} - -template void Wrap() { - u32 retval = func(PARAM(0), ((u64)PARAM(3) << 32) | PARAM(2), PARAM(4)); - RETURN(retval); -} - diff --git a/Core/HLE/HLE.h b/Core/HLE/HLE.h index e5319ea6b6..171a7a2814 100644 --- a/Core/HLE/HLE.h +++ b/Core/HLE/HLE.h @@ -49,7 +49,6 @@ struct Syscall #define PARAM(n) currentMIPS->r[4+n] #define RETURN(n) currentMIPS->r[2]=n -#define RETURN2(n) currentMIPS->r[3]=n #define RETURNF(fl) currentMIPS->f[0]=fl #ifndef ARRAY_SIZE diff --git a/Core/HLE/HLETables.cpp b/Core/HLE/HLETables.cpp index 597f1947dc..985e79fafd 100644 --- a/Core/HLE/HLETables.cpp +++ b/Core/HLE/HLETables.cpp @@ -65,9 +65,9 @@ const HLEFunction FakeSysCalls[] = const HLEFunction UtilsForUser[] = { - {0x91E4F6A7, &Wrap, "sceKernelLibcClock"}, - {0x27CC57F0, &Wrap, "sceKernelLibcTime"}, - {0x71EC4271, &Wrap, "sceKernelLibcGettimeofday"}, + {0x91E4F6A7, sceKernelLibcClock, "sceKernelLibcClock"}, + {0x27CC57F0, sceKernelLibcTime, "sceKernelLibcTime"}, + {0x71EC4271, sceKernelLibcGettimeofday, "sceKernelLibcGettimeofday"}, {0xBFA98062, 0, "sceKernelDcacheInvalidateRange"}, {0xC8186A58, 0, "sceKernelUtilsMd5Digest"}, {0x9E5C5086, 0, "sceKernelUtilsMd5BlockInit"}, @@ -79,28 +79,28 @@ const HLEFunction UtilsForUser[] = {0x585F1C09, 0, "sceKernelUtilsSha1BlockResult"}, {0xE860E75E, 0, "sceKernelUtilsMt19937Init"}, {0x06FB8A63, 0, "sceKernelUtilsMt19937UInt"}, - {0x37FB5C42, &Wrap, "sceKernelGetGPI"}, - {0x6AD345D7, &Wrap, "sceKernelSetGPO"}, - {0x79D1C3FA, &Wrap, "sceKernelDcacheWritebackAll"}, - {0xB435DEC5, &Wrap, "sceKernelDcacheWritebackInvalidateAll"}, - {0x3EE30821, &Wrap, "sceKernelDcacheWritebackRange"}, - {0x34B9FA9E, &Wrap, "sceKernelDcacheWritebackInvalidateRange"}, + {0x37FB5C42, sceKernelGetGPI, "sceKernelGetGPI"}, + {0x6AD345D7, sceKernelSetGPO, "sceKernelSetGPO"}, + {0x79D1C3FA, sceKernelDcacheWritebackAll, "sceKernelDcacheWritebackAll"}, + {0xB435DEC5, sceKernelDcacheWritebackInvalidateAll, "sceKernelDcacheWritebackInvalidateAll"}, + {0x3EE30821, sceKernelDcacheWritebackRange, "sceKernelDcacheWritebackRange"}, + {0x34B9FA9E, sceKernelDcacheWritebackInvalidateRange, "sceKernelDcacheWritebackInvalidateRange"}, {0x80001C4C, 0, "sceKernelDcacheProbe"}, {0x16641D70, 0, "sceKernelDcacheReadTag"}, {0x4FD31C9D, 0, "sceKernelIcacheProbe"}, {0xFB05FAD0, 0, "sceKernelIcacheReadTag"}, - {0x920f104a, &Wrap, "sceKernelIcacheInvalidateAll"} + {0x920f104a, sceKernelIcacheInvalidateAll, "sceKernelIcacheInvalidateAll"} }; const HLEFunction sceRtc[] = { - {0xC41C2853, &Wrap, "sceRtcGetTickResolution"}, - {0x3f7ad767, &Wrap, "sceRtcGetCurrentTick"}, + {0xC41C2853, sceRtcGetTickResolution, "sceRtcGetTickResolution"}, + {0x3f7ad767, sceRtcGetCurrentTick, "sceRtcGetCurrentTick"}, {0x011F03C1, 0, "sceRtcGetAccumulativeTime"}, {0x029CA3B3, 0, "sceRtcGetAccumlativeTime"}, {0x4cfa57b0, 0, "sceRtcGetCurrentClock"}, - {0xE7C27D1B, &Wrap, "sceRtcGetCurrentClockLocalTime"}, + {0xE7C27D1B, sceRtcGetCurrentClockLocalTime, "sceRtcGetCurrentClockLocalTime"}, {0x34885E0D, 0, "sceRtcConvertUtcToLocalTime"}, {0x779242A2, 0, "sceRtcConvertLocalTimeToUTC"}, {0x42307A17, 0, "sceRtcIsLeapYear"}, @@ -114,7 +114,7 @@ const HLEFunction sceRtc[] = {0x7ACE4C04, 0, "sceRtcSetWin32FileTime"}, {0xCF561893, 0, "sceRtcGetWin32FileTime"}, {0x7ED29E40, 0, "sceRtcSetTick"}, - {0x6FF40ACC, &Wrap, "sceRtcGetTick"}, + {0x6FF40ACC, sceRtcGetTick, "sceRtcGetTick"}, {0x9ED0AE87, 0, "sceRtcCompareTick"}, {0x44F45E05, 0, "sceRtcTickAddTicks"}, {0x26D25A5D, 0, "sceRtcTickAddMicroseconds"}, @@ -179,7 +179,7 @@ const HLEFunction LoadCoreForKernel[] = {0xCCE4A157, 0, "sceKernelFindModuleByUID"}, {0x82CE54ED, 0, "sceKernelModuleCount"}, {0xC0584F0C, 0, "sceKernelGetModuleList"}, - {0xCF8A41B1, &Wrap,"sceKernelFindModuleByName"}, + {0xCF8A41B1, sceKernelFindModuleByName,"sceKernelFindModuleByName"}, }; @@ -189,7 +189,7 @@ const HLEFunction KDebugForKernel[] = {0x2FF4E9F9, 0, "sceKernelAssert"}, {0x9B868276, 0, "sceKernelGetDebugPutchar"}, {0xE146606D, 0, "sceKernelRegisterDebugPutchar"}, - {0x7CEB2C09, &Wrap, "sceKernelRegisterKprintfHandler"}, + {0x7CEB2C09, sceKernelRegisterKprintfHandler, "sceKernelRegisterKprintfHandler"}, {0x84F370BC, 0, "Kprintf"}, {0x5CE9838B, 0, "sceKernelDebugWrite"}, {0x66253C4E, 0, "sceKernelRegisterDebugWrite"}, diff --git a/Core/HLE/sceAtrac.cpp b/Core/HLE/sceAtrac.cpp index f8a61787bb..a13bfc15ad 100644 --- a/Core/HLE/sceAtrac.cpp +++ b/Core/HLE/sceAtrac.cpp @@ -28,14 +28,19 @@ #define ATRAC_ERROR_API_FAIL 0x80630002 #define ATRAC_ERROR_ALL_DATA_DECODED 0x80630024 -u32 sceAtracAddStreamData(u32 atracID, u32 addByte) +void sceAtracAddStreamData() { - ERROR_LOG(HLE, "UNIMPL sceAtracAddStreamData(%i, %i)", atracID, addByte); - return 0; + ERROR_LOG(HLE, "UNIMPL sceAtracAddStreamData(%i, %i)", PARAM(0), PARAM(1)); + RETURN(0); } -u32 sceAtracDecodeData(u32 atracID, u32 outAddr, u32 numSamplesAddr, u32 finishFlagAddr, u32 remainAddr) +void sceAtracDecodeData() { + u32 atracID = PARAM(0); + u32 outAddr = PARAM(1); + u32 numSamplesAddr = PARAM(2); + u32 finishFlagAddr = PARAM(3); + u32 remainAddr = PARAM(4); ERROR_LOG(HLE, "FAKE sceAtracDecodeData(%i, %08x, %08x, %08x, %08x)", atracID, outAddr, numSamplesAddr, finishFlagAddr, remainAddr); Memory::Write_U16(0, outAddr); // Write a single 16-bit stereo @@ -45,193 +50,199 @@ u32 sceAtracDecodeData(u32 atracID, u32 outAddr, u32 numSamplesAddr, u32 finishF Memory::Write_U32(1, finishFlagAddr); // Lie that decoding is finished Memory::Write_U32(0, remainAddr); // Lie that decoding is finished - return 0; + RETURN(0); } -u32 sceAtracEndEntry() +void sceAtracEndEntry() { ERROR_LOG(HLE, "UNIMPL sceAtracEndEntry"); - return 0; + RETURN(0); } -u32 sceAtracGetAtracID(u32) +void sceAtracGetAtracID() { ERROR_LOG(HLE, "UNIMPL sceAtracGetAtracID"); - return 0; + RETURN(0); } -u32 sceAtracGetBufferInfoForReseting(u32, u32, u32) +void sceAtracGetBufferInfoForReseting() { ERROR_LOG(HLE, "UNIMPL sceAtracGetBufferInfoForReseting"); - return 0; + RETURN(0); } -u32 sceAtracGetBitrate(u32, u32) +void sceAtracGetBitrate() { ERROR_LOG(HLE, "UNIMPL sceAtracGetBitrate"); - return 0; + RETURN(0); } -u32 sceAtracGetChannel(u32, u32) +void sceAtracGetChannel() { ERROR_LOG(HLE, "UNIMPL sceAtracGetChannel"); - return 0; + RETURN(0); } -u32 sceAtracGetLoopStatus(u32, u32, u32) +void sceAtracGetLoopStatus() { ERROR_LOG(HLE, "UNIMPL sceAtracGetLoopStatus"); - return 0; + RETURN(0); } -u32 sceAtracGetInternalErrorInfo(u32, u32) +void sceAtracGetInternalErrorInfo() { ERROR_LOG(HLE, "UNIMPL sceAtracGetInternalErrorInfo"); - return 0; + RETURN(0); } -u32 sceAtracGetMaxSample(u32, u32) +void sceAtracGetMaxSample() { ERROR_LOG(HLE, "UNIMPL sceAtracGetMaxSample"); - return 0; + RETURN(0); } -u32 sceAtracGetNextDecodePosition(u32 atracID, u32 samplePositionAddr) +void sceAtracGetNextDecodePosition() { - ERROR_LOG(HLE, "UNIMPL sceAtracGetNextDecodePosition(%i, %08x)", atracID, samplePositionAddr); - u32 *outPos = (u32*)Memory::GetPointer(samplePositionAddr); + ERROR_LOG(HLE, "UNIMPL sceAtracGetNextDecodePosition(%i, %08x)", PARAM(0), PARAM(1)); + u32 *outPos = (u32*)Memory::GetPointer(PARAM(1)); *outPos = 1; - return 0; + RETURN(0); } -u32 sceAtracGetNextSample(u32 atracID, u32 outN) +void sceAtracGetNextSample() { + u32 atracID = PARAM(0); + u32 outN = PARAM(1); ERROR_LOG(HLE, "FAKE sceAtracGetNextSample(%i, %08x)", atracID, outN); Memory::Write_U32(0, outN); - return 0; + RETURN(0); } -u32 sceAtracGetRemainFrame(u32 atracID, u32 remainAddr) +void sceAtracGetRemainFrame() { - ERROR_LOG(HLE, "sceAtracGetRemainFrame(%i, %08x)",atracID,remainAddr); - u32 *outPos = (u32*)Memory::GetPointer(remainAddr); + ERROR_LOG(HLE, "sceAtracGetRemainFrame(%i, %08x)",PARAM(0),PARAM(1)); + u32 *outPos = (u32*)Memory::GetPointer(PARAM(1)); *outPos = 12; - return 0; + RETURN(0); } -u32 sceAtracGetSecondBufferInfo(u32 atracID, u32 positionAddr, u32 dataAddr) +void sceAtracGetSecondBufferInfo() { - ERROR_LOG(HLE, "sceAtracGetSecondBufferInfo(%i, %08x, %08x)",atracID,positionAddr,dataAddr); - u32 *outPos = (u32*)Memory::GetPointer(positionAddr); - u32 *outBytes = (u32*)Memory::GetPointer(dataAddr); + ERROR_LOG(HLE, "sceAtracGetSecondBufferInfo(%i, %08x, %08x)",PARAM(0),PARAM(1),PARAM(2)); + u32 *outPos = (u32*)Memory::GetPointer(PARAM(1)); + u32 *outBytes = (u32*)Memory::GetPointer(PARAM(2)); *outPos = 0; *outBytes = 0x10000; - return 0; + RETURN(0); } -u32 sceAtracGetSoundSample(u32 atracID, u32 endSampleAddr, u32 loopStartAddr, u32 loopEndAddr) +void sceAtracGetSoundSample() { - ERROR_LOG(HLE, "UNIMPL sceAtracGetSoundSample(%i, %08x, %08x, %08x)",atracID,endSampleAddr,loopStartAddr,loopEndAddr); - u32 *outEndSample = (u32*)Memory::GetPointer(endSampleAddr); - u32 *outLoopStartSample = (u32*)Memory::GetPointer(loopStartAddr); - u32 *outLoopEndSample = (u32*)Memory::GetPointer(loopEndAddr); + ERROR_LOG(HLE, "UNIMPL sceAtracGetSoundSample(%i, %08x, %08x, %08x)",PARAM(0),PARAM(1),PARAM(2),PARAM(3)); + u32 *outEndSample = (u32*)Memory::GetPointer(PARAM(1)); + u32 *outLoopStartSample = (u32*)Memory::GetPointer(PARAM(2)); + u32 *outLoopEndSample = (u32*)Memory::GetPointer(PARAM(2)); *outEndSample = 0x10000; *outLoopStartSample = -1; *outLoopEndSample = -1; - return 0; + RETURN(0); } -u32 sceAtracGetStreamDataInfo(u32 atracID, u32 writePointerAddr, u32 availableBytesAddr, u32 readOffsetAddr) +void sceAtracGetStreamDataInfo() { + u32 atracID = PARAM(0); + u32 writePointerAddr = PARAM(1); + u32 availableBytesAddr = PARAM(2); + u32 readOffsetAddr = PARAM(3); ERROR_LOG(HLE, "FAKE sceAtracGetStreamDataInfo(%i, %08x, %08x, %08x)", atracID, writePointerAddr, availableBytesAddr, readOffsetAddr); Memory::Write_U32(0, readOffsetAddr); Memory::Write_U32(0, availableBytesAddr); Memory::Write_U32(0, writePointerAddr); - return 0; + RETURN(0); } -u32 sceAtracReleaseAtracID(u32) +void sceAtracReleaseAtracID() { ERROR_LOG(HLE, "UNIMPL sceAtracReleaseAtracID"); - return 0; + RETURN(0); } -u32 sceAtracResetPlayPosition(u32, u32, u32, u32) +void sceAtracResetPlayPosition() { ERROR_LOG(HLE, "UNIMPL sceAtracResetPlayPosition"); - return 0; + RETURN(0); } -u32 sceAtracSetHalfwayBuffer(u32, u32, u32, u32) +void sceAtracSetHalfwayBuffer() { ERROR_LOG(HLE, "UNIMPL sceAtracSetHalfwayBuffer"); - return 0; + RETURN(0); } -u32 sceAtracSetSecondBuffer(u32 atracID, u32 secondBufferAddr, u32 secondBufferSize) +void sceAtracSetSecondBuffer() { - ERROR_LOG(HLE, "UNIMPL sceAtracSetSecondBuffer(%i, %08x, %i)", atracID, secondBufferAddr, secondBufferSize); - return 0; + ERROR_LOG(HLE, "UNIMPL sceAtracSetSecondBuffer(%i, %08x, %i)", PARAM(0),PARAM(1),PARAM(2)); + RETURN(0); } -u32 sceAtracSetData(u32, u32, u32) +void sceAtracSetData() { ERROR_LOG(HLE, "UNIMPL sceAtracSetData"); - return 0; -} + RETURN(0); +} //? -u32 sceAtracSetDataAndGetID(u32 bufferAddr, u32 bufferSize) +void sceAtracSetDataAndGetID() { - ERROR_LOG(HLE, "UNIMPL sceAtracSetDataAndGetID(%08x, %i)", bufferAddr, bufferSize); - return 1; + ERROR_LOG(HLE, "UNIMPL sceAtracSetDataAndGetID(%08x, %i)", PARAM(0), PARAM(1)); + RETURN(1); } -u32 sceAtracSetHalfwayBufferAndGetID(u32, u32, u32) +void sceAtracSetHalfwayBufferAndGetID() { ERROR_LOG(HLE, "UNIMPL sceAtracSetHalfwayBufferAndGetID"); - return 0; + RETURN(0); } -u32 sceAtracStartEntry() +void sceAtracStartEntry() { ERROR_LOG(HLE, "UNIMPL sceAtracStartEntry"); - return 0; + RETURN(0); } -u32 sceAtracSetLoopNum(u32 atracID, u32 loopNum) +void sceAtracSetLoopNum() { - ERROR_LOG(HLE, "UNIMPL sceAtracSetLoopNum(%i, %i)", atracID, loopNum); - return 0; + ERROR_LOG(HLE, "UNIMPL sceAtracSetLoopNum(%i, %i)", PARAM(0), PARAM(1)); + RETURN(0); } const HLEFunction sceAtrac3plus[] = { - {0x7db31251,&Wrap,"sceAtracAddStreamData"}, - {0x6a8c3cd5,&Wrap,"sceAtracDecodeData"}, - {0xd5c28cc0,&Wrap,"sceAtracEndEntry"}, - {0x780f88d1,&Wrap,"sceAtracGetAtracID"}, - {0xca3ca3d2,&Wrap,"sceAtracGetBufferInfoForReseting"}, - {0xa554a158,&Wrap,"sceAtracGetBitrate"}, - {0x31668baa,&Wrap,"sceAtracGetChannel"}, - {0xfaa4f89b,&Wrap,"sceAtracGetLoopStatus"}, - {0xe88f759b,&Wrap,"sceAtracGetInternalErrorInfo"}, - {0xd6a5f2f7,&Wrap,"sceAtracGetMaxSample"}, - {0xe23e3a35,&Wrap,"sceAtracGetNextDecodePosition"}, - {0x36faabfb,&Wrap,"sceAtracGetNextSample"}, - {0x9ae849a7,&Wrap,"sceAtracGetRemainFrame"}, - {0x83e85ea0,&Wrap,"sceAtracGetSecondBufferInfo"}, - {0xa2bba8be,&Wrap,"sceAtracGetSoundSample"}, - {0x5d268707,&Wrap,"sceAtracGetStreamDataInfo"}, - {0x61eb33f5,&Wrap,"sceAtracReleaseAtracID"}, - {0x644e5607,&Wrap,"sceAtracResetPlayPosition"}, - {0x3f6e26b5,&Wrap,"sceAtracSetHalfwayBuffer"}, - {0x83bf7afd,&Wrap,"sceAtracSetSecondBuffer"}, - {0x0E2A73AB,&Wrap,"sceAtracSetData"}, //? - {0x7a20e7af,&Wrap,"sceAtracSetDataAndGetID"}, - {0x0eb8dc38,&Wrap,"sceAtracSetHalfwayBufferAndGetID"}, - {0xd1f59fdb,&Wrap,"sceAtracStartEntry"}, - {0x868120b5,&Wrap,"sceAtracSetLoopNum"}, + {0x7db31251,sceAtracAddStreamData,"sceAtracAddStreamData"}, + {0x6a8c3cd5,sceAtracDecodeData,"sceAtracDecodeData"}, + {0xd5c28cc0,sceAtracEndEntry,"sceAtracEndEntry"}, + {0x780f88d1,sceAtracGetAtracID,"sceAtracGetAtracID"}, + {0xca3ca3d2,sceAtracGetBufferInfoForReseting,"sceAtracGetBufferInfoForReseting"}, + {0xa554a158,sceAtracGetBitrate,"sceAtracGetBitrate"}, + {0x31668baa,sceAtracGetChannel,"sceAtracGetChannel"}, + {0xfaa4f89b,sceAtracGetLoopStatus,"sceAtracGetLoopStatus"}, + {0xe88f759b,sceAtracGetInternalErrorInfo,"sceAtracGetInternalErrorInfo"}, + {0xd6a5f2f7,sceAtracGetMaxSample,"sceAtracGetMaxSample"}, + {0xe23e3a35,sceAtracGetNextDecodePosition,"sceAtracGetNextDecodePosition"}, + {0x36faabfb,sceAtracGetNextSample,"sceAtracGetNextSample"}, + {0x9ae849a7,sceAtracGetRemainFrame,"sceAtracGetRemainFrame"}, + {0x83e85ea0,sceAtracGetSecondBufferInfo,"sceAtracGetSecondBufferInfo"}, + {0xa2bba8be,sceAtracGetSoundSample,"sceAtracGetSoundSample"}, + {0x5d268707,sceAtracGetStreamDataInfo,"sceAtracGetStreamDataInfo"}, + {0x61eb33f5,sceAtracReleaseAtracID,"sceAtracReleaseAtracID"}, + {0x644e5607,sceAtracResetPlayPosition,"sceAtracResetPlayPosition"}, + {0x3f6e26b5,sceAtracSetHalfwayBuffer,"sceAtracSetHalfwayBuffer"}, + {0x83bf7afd,sceAtracSetSecondBuffer,"sceAtracSetSecondBuffer"}, + {0x0E2A73AB,sceAtracSetData,"sceAtracSetData"}, //? + {0x7a20e7af,sceAtracSetDataAndGetID,"sceAtracSetDataAndGetID"}, + {0x0eb8dc38,sceAtracSetHalfwayBufferAndGetID,"sceAtracSetHalfwayBufferAndGetID"}, + {0xd1f59fdb,sceAtracStartEntry,"sceAtracStartEntry"}, + {0x868120b5,sceAtracSetLoopNum,"sceAtracSetLoopNum"}, {0x132f1eca,0,"sceAtracReinit"}, {0xeca32a99,0,"sceAtracIsSecondBufferNeeded"}, {0x0fae370e,0,"sceAtracSetHalfwayBufferAndGetID"}, diff --git a/Core/HLE/sceAudio.cpp b/Core/HLE/sceAudio.cpp index 706e59dd7c..1cf7644ff9 100644 --- a/Core/HLE/sceAudio.cpp +++ b/Core/HLE/sceAudio.cpp @@ -59,11 +59,11 @@ u32 sceAudioOutputPannedBlocking(u32 chan, u32 volume1, u32 volume2, u32 sampleP } } -u32 sceAudioGetChannelRestLen(u32 chanId) +void sceAudioGetChannelRestLen() { - ERROR_LOG(HLE,"UNIMPL sceAudioGetChannelRestLen(%i)", chanId); + ERROR_LOG(HLE,"UNIMPL sceAudioGetChannelRestLen(%i)", PARAM(0)); // Remaining samples in that channel buffer. - return 0; + RETURN(0); } u32 sceAudioOutputPanned(u32 chan, u32 leftVol, u32 rightVol, u32 samplePtr) @@ -147,7 +147,7 @@ u32 sceAudioChReserve(u32 channel, u32 sampleCount, u32 format) //.Allocate soun { WARN_LOG(HLE, "WARNING: Reserving already reserved channel. Error?"); } - DEBUG_LOG(HLE,"%i = sceAudioChReserve(%i, %i, %i)", channel, channel, sampleCount, format); + DEBUG_LOG(HLE,"%i = sceAudioChReserve(%i, %i, %i)", channel, PARAM(0), sampleCount, format); chans[channel].sampleCount = sampleCount; chans[channel].reserved = true; @@ -230,10 +230,10 @@ u32 sceAudioChangeChannelVolume(u32 chan, u32 lvolume, u32 rvolume) } } -u32 sceAudioInit() +void sceAudioInit() { ERROR_LOG(HLE,"UNIMPL sceAudioInit"); - return 0; + RETURN(0); } const HLEFunction sceAudio[] = @@ -246,7 +246,7 @@ const HLEFunction sceAudio[] = {0x210567F7, 0, "sceAudioEnd"}, {0x38553111, 0, "sceAudioSRCChReserve"}, {0x5C37C0AE, 0, "sceAudioSRCChRelease"}, - {0x80F1F7E0, Wrap, "sceAudioInit"}, + {0x80F1F7E0, sceAudioInit, "sceAudioInit"}, {0x927AC32B, 0, "sceAudioSetVolumeOffset"}, {0xA2BEAA6C, 0, "sceAudioSetFrequency"}, {0xA633048E, 0, "sceAudioPollInputEnd"}, @@ -255,15 +255,15 @@ const HLEFunction sceAudio[] = {0xE0727056, 0, "sceAudioSRCOutputBlocking"}, {0xE926D3FB, 0, "sceAudioInputInitEx"}, {0x8c1009b2, 0, "sceAudioOutput"}, - {0x136CAF51, Wrap, "sceAudioOutputBlocking"}, - {0xE2D56B2D, Wrap, "sceAudioOutputPanned"}, - {0x13F592BC, Wrap, "sceAudioOutputPannedBlocking"}, //(u32, u32, u32, void *)Output sound, blocking - {0x5EC81C55, Wrap, "sceAudioChReserve"}, //(u32, u32 samplecount, u32) Initialize channel and allocate buffer long, long samplecount, long);//init buffer? returns handle, minus if error - {0x6FC46853, Wrap, "sceAudioChRelease"}, //(long handle)Terminate channel and deallocate buffer //free buffer? - {0xE9D97901, Wrap, "sceAudioGetChannelRestLen"}, - {0xCB2E439E, Wrap, "sceAudioSetChannelDataLen"}, //(u32, u32) - {0x95FD0C2D, Wrap, "sceAudioChangeChannelConfig"}, - {0xB7E1D8E7, Wrap, "sceAudioChangeChannelVolume"}, + {0x136CAF51, WrapU_UUU, "sceAudioOutputBlocking"}, + {0xE2D56B2D, WrapU_UUUU, "sceAudioOutputPanned"}, + {0x13F592BC, WrapU_UUUU, "sceAudioOutputPannedBlocking"}, //(u32, u32, u32, void *)Output sound, blocking + {0x5EC81C55, WrapU_UUU, "sceAudioChReserve"}, //(u32, u32 samplecount, u32) Initialize channel and allocate buffer long, long samplecount, long);//init buffer? returns handle, minus if error + {0x6FC46853, WrapU_U, "sceAudioChRelease"}, //(long handle)Terminate channel and deallocate buffer //free buffer? + {0xE9D97901, sceAudioGetChannelRestLen, "sceAudioGetChannelRestLen"}, + {0xCB2E439E, WrapU_UU, "sceAudioSetChannelDataLen"}, //(u32, u32) + {0x95FD0C2D, WrapU_UU, "sceAudioChangeChannelConfig"}, + {0xB7E1D8E7, WrapU_UUU, "sceAudioChangeChannelVolume"}, {0x41efade7, 0, "sceAudioOneshotOutput"}, {0x086e5895, 0, "sceAudioInputBlocking"}, {0x6d4bec68, 0, "sceAudioInput"}, diff --git a/Core/HLE/sceCtrl.cpp b/Core/HLE/sceCtrl.cpp index 8f9ec23a7b..a482759af6 100644 --- a/Core/HLE/sceCtrl.cpp +++ b/Core/HLE/sceCtrl.cpp @@ -72,15 +72,14 @@ void __CtrlSetAnalog(float x, float y) ctrl.analog[1] = (u8)(y * 127.f + 128.f); } -u32 sceCtrlInit() +void sceCtrlInit() { ctrlInited = true; memset(&ctrl, 0, sizeof(ctrl)); DEBUG_LOG(HLE,"sceCtrlInit"); - return 0; } -u32 sceCtrlSetSamplingMode(u32) +void sceCtrlSetSamplingMode() { DEBUG_LOG(HLE,"sceCtrlSetSamplingMode"); if (ctrlInited) @@ -88,17 +87,18 @@ u32 sceCtrlSetSamplingMode(u32) // Looks odd analogEnabled = true; } - return 0; } -u32 sceCtrlSetIdleCancelThreshold(u32, u32) +void sceCtrlSetIdleCancelThreshold() { DEBUG_LOG(HLE,"UNIMPL sceCtrlSetIdleCancelThreshold"); - return 0; } -u32 sceCtrlReadBufferPositive(u32 ctrlData, u32 nBufs) +void sceCtrlReadBufferPositive() { + u32 ctrlData = PARAM(0); + // u32 nBufs = PARAM(1); + std::lock_guard guard(ctrlMutex); // Let's just ignore if ctrl is inited or not; some games don't init it (Super Fruit Fall) //if (ctrlInited) @@ -152,19 +152,19 @@ u32 sceCtrlReadBufferPositive(u32 ctrlData, u32 nBufs) memcpy(Memory::GetPointer(ctrlData), &data, sizeof(_ctrl_data)); //} - return 1; + RETURN(1); } static const HLEFunction sceCtrl[] = { - {0x6a2774f3, Wrap, "sceCtrlInit"}, - {0x1f4011e6, Wrap, "sceCtrlSetSamplingMode"}, - {0x1f803938, Wrap, "sceCtrlReadBufferPositive"}, - {0x6A2774F3, 0, "sceCtrlSetSamplingCycle"}, - {0x6A2774F3, Wrap,"sceCtrlSetSamplingCycle"}, + {0x6a2774f3, sceCtrlInit, "sceCtrlInit"}, //(int unknown), init with 0 + {0x1f4011e6, sceCtrlSetSamplingMode, "sceCtrlSetSamplingMode"}, //(int on); + {0x1f803938, sceCtrlReadBufferPositive, "sceCtrlReadBufferPositive"}, //(ctrl_data_t* paddata, int unknown) // unknown should be 1 + {0x6A2774F3, 0, "sceCtrlSetSamplingCycle"}, //? + {0x6A2774F3,sceCtrlInit,"sceCtrlSetSamplingCycle"}, {0x02BAAD91,0,"sceCtrlGetSamplingCycle"}, {0xDA6B76A1,0,"sceCtrlGetSamplingMode"}, - {0x3A622550, Wrap,"sceCtrlPeekBufferPositive"}, + {0x3A622550,sceCtrlReadBufferPositive,"sceCtrlPeekBufferPositive"}, {0xC152080A,0,"sceCtrlPeekBufferNegative"}, {0x60B81F86,0,"sceCtrlReadBufferNegative"}, {0xB1D0E5CD,0,"sceCtrlPeekLatch"}, @@ -173,7 +173,7 @@ static const HLEFunction sceCtrl[] = {0xAF5960F3,0,"sceCtrl_AF5960F3"}, {0xA68FD260,0,"sceCtrlClearRapidFire"}, {0x6841BE1A,0,"sceCtrlSetRapidFire"}, - {0xa7144800, Wrap,"sceCtrlSetIdleCancelThreshold"}, + {0xa7144800,sceCtrlSetIdleCancelThreshold,"sceCtrlSetIdleCancelThreshold"}, {0x687660fa,0,"sceCtrlGetIdleCancelThreshold"}, }; diff --git a/Core/HLE/sceDisplay.cpp b/Core/HLE/sceDisplay.cpp index 42cd864660..e0acade146 100644 --- a/Core/HLE/sceDisplay.cpp +++ b/Core/HLE/sceDisplay.cpp @@ -66,7 +66,7 @@ static int enterVblankEvent = -1; static int leaveVblankEvent = -1; static int hCount = 0; -//static int hCountTotal = 0; //unused +static int hCountTotal = 0; //unused static int vCount = 0; static int isVblank = 0; // STATE END @@ -163,10 +163,10 @@ void hleLeaveVblank(u64 userdata, int cyclesLate) CoreTiming::ScheduleEvent(msToCycles(frameMs - vblankMs) - cyclesLate, enterVblankEvent, userdata); } -u32 sceDisplayIsVblank() +void sceDisplayIsVblank() { DEBUG_LOG(HLE,"%i=sceDisplayIsVblank()",isVblank); - return isVblank; + RETURN(isVblank); } u32 sceDisplaySetMode(u32 unknown, u32 xres, u32 yres) @@ -181,8 +181,14 @@ u32 sceDisplaySetMode(u32 unknown, u32 xres, u32 yres) return 0; } -u32 sceDisplaySetFramebuf(u32 topaddr, int linesize, int pixelformat, int sync) +void sceDisplaySetFramebuf() { + //host->EndFrame(); + u32 topaddr = PARAM(0); + int linesize = PARAM(1); + int pixelformat = PARAM(2); + int sync = PARAM(3); + FrameBufferState *fbstate = 0; if (sync == PSP_DISPLAY_SETBUF_IMMEDIATE) { @@ -209,60 +215,56 @@ u32 sceDisplaySetFramebuf(u32 topaddr, int linesize, int pixelformat, int sync) fbstate->pspFramebufLinesize = linesize; } - return 0; + RETURN(0); } -u32 sceDisplayGetFramebuf(u32 topAddrAddr, u32 bufferWidthAddr, u32 pixelFormatAddr, int sync) +void sceDisplayGetFramebuf() { - DEBUG_LOG(HLE,"sceDisplayGetFramebuf"); - Memory::Write_U32(topAddrAddr, framebuf.topaddr); - Memory::Write_U32(bufferWidthAddr, framebuf.pspFramebufLinesize); - Memory::Write_U32(pixelFormatAddr, framebuf.pspFramebufFormat); - return 0; + DEBUG_LOG(HLE,"sceDisplayGetFramebuf"); + RETURN(framebuf.topaddr); } -u32 sceDisplayWaitVblankStart() +void sceDisplayWaitVblankStart() { DEBUG_LOG(HLE,"sceDisplayWaitVblankStart"); __KernelWaitCurThread(WAITTYPE_VBLANK, 0, 0, 0, false); - return 0; + RETURN(0); } -u32 sceDisplayWaitVblank() +void sceDisplayWaitVblank() { DEBUG_LOG(HLE,"sceDisplayWaitVblank"); __KernelWaitCurThread(WAITTYPE_VBLANK, 0, 0, 0, false); - return sceDisplayWaitVblankStart(); + sceDisplayWaitVblankStart(); } -u32 sceDisplayWaitVblankStartCB() +void sceDisplayWaitVblankStartCB() { DEBUG_LOG(HLE,"sceDisplayWaitVblankStartCB"); __KernelWaitCurThread(WAITTYPE_VBLANK, 0, 0, 0, true); - return sceDisplayWaitVblankStart(); } -u32 sceDisplayGetVcount() +void sceDisplayGetVcount() { // Too spammy // DEBUG_LOG(HLE,"%i=sceDisplayGetVcount()", vCount); // Games like Puyo Puyo call this in a tight loop at end-of-frame. We could have it consume some time from CoreTiming? CoreTiming::Idle(100000); - return vCount; + RETURN(vCount); } -u32 sceDisplayGetCurrentHcount() +void sceDisplayGetCurrentHcount() { - return (hCount++); + RETURN(hCount++); } -u32 sceDisplayGetAccumulatedHcount() +void sceDisplayGetAccumulatedHcount() { // Just do an estimate u32 accumHCount = CoreTiming::GetTicks() / (222000000 / 60 / 272); DEBUG_LOG(HLE,"%i=sceDisplayGetAccumulatedHcount()", accumHCount); - return accumHCount; + RETURN(accumHCount); } float sceDisplayGetFramePerSec() @@ -274,26 +276,26 @@ float sceDisplayGetFramePerSec() const HLEFunction sceDisplay[] = { - {0x0E20F177,&Wrap, "sceDisplaySetMode"}, - {0x289D82FE,&Wrap, "sceDisplaySetFramebuf"}, - {0x36CDFADE,&Wrap, "sceDisplayWaitVblank"}, - {0x984C27E7,&Wrap, "sceDisplayWaitVblankStart"}, - {0x46F186C3,&Wrap,"sceDisplayWaitVblankStartCB"}, - {0x8EB9EC49,&Wrap,"sceDisplayWaitVblankCB"}, + {0x0E20F177,&WrapU_UUU, "sceDisplaySetMode"}, + {0x289D82FE,sceDisplaySetFramebuf, "sceDisplaySetFramebuf"}, + {0x36CDFADE,sceDisplayWaitVblank, "sceDisplayWaitVblank"}, + {0x984C27E7,sceDisplayWaitVblankStart, "sceDisplayWaitVblankStart"}, + {0x46F186C3,sceDisplayWaitVblankStartCB,"sceDisplayWaitVblankStartCB"}, + {0x8EB9EC49,sceDisplayWaitVblankStartCB,"sceDisplayWaitVblankCB"}, - {0xdba6c4c4,&Wrap,"sceDisplayGetFramePerSec"}, - {0x773dd3a3,&Wrap,"sceDisplayGetCurrentHcount"}, - {0x210eab3a,&Wrap,"sceDisplayGetAccumulatedHcount"}, - {0x9C6EAAD7,&Wrap,"sceDisplayGetVcount"}, + {0xdba6c4c4,&WrapF_V,"sceDisplayGetFramePerSec"}, + {0x773dd3a3,sceDisplayGetCurrentHcount,"sceDisplayGetCurrentHcount"}, + {0x210eab3a,sceDisplayGetAccumulatedHcount,"sceDisplayGetAccumulatedHcount"}, + {0x9C6EAAD7,sceDisplayGetVcount,"sceDisplayGetVcount"}, {0x984C27E7,0,"sceDisplayWaitVblankStart"}, {0xDEA197D4,0,"sceDisplayGetMode"}, {0x7ED59BC4,0,"sceDisplaySetHoldMode"}, {0xA544C486,0,"sceDisplaySetResumeMode"}, {0x289D82FE,0,"sceDisplaySetFrameBuf"}, - {0xEEDA2E54,&Wrap,"sceDisplayGetFrameBuf"}, + {0xEEDA2E54,sceDisplayGetFramebuf,"sceDisplayGetFrameBuf"}, {0xB4F378FA,0,"sceDisplayIsForeground"}, {0x31C4BAA8,0,"sceDisplayGetBrightness"}, - {0x4D4E10EC,&Wrap,"sceDisplayIsVblank"}, + {0x4D4E10EC,sceDisplayIsVblank,"sceDisplayIsVblank"}, }; void Register_sceDisplay() diff --git a/Core/HLE/sceDmac.cpp b/Core/HLE/sceDmac.cpp index 70c564234d..921f62468e 100644 --- a/Core/HLE/sceDmac.cpp +++ b/Core/HLE/sceDmac.cpp @@ -28,7 +28,7 @@ u32 sceDmacMemcpy(u32 dst, u32 src, u32 size) const HLEFunction sceDmac[] = { - {0x617f3fe6, &Wrap, "sceDmacMemcpy"}, + {0x617f3fe6, &WrapU_UUU, "sceDmacMemcpy"}, }; void Register_sceDmac() diff --git a/Core/HLE/sceGe.cpp b/Core/HLE/sceGe.cpp index 0a148df6ce..680e6b822d 100644 --- a/Core/HLE/sceGe.cpp +++ b/Core/HLE/sceGe.cpp @@ -110,9 +110,10 @@ void sceGeListSync(u32 displayListID, u32 mode) //0 : wait for completion 1:che DEBUG_LOG(HLE,"sceGeListSync(dlid=%08x, mode=%08x)", displayListID,mode); } -u32 sceGeDrawSync(u32 mode) +u32 sceGeDrawSync(u32) { //wait/check entire drawing state + u32 mode = PARAM(0); //0 : wait for completion 1:check and return DEBUG_LOG(HLE,"FAKE sceGeDrawSync(mode=%d)",mode); if (mode == 1) { @@ -124,16 +125,16 @@ u32 sceGeDrawSync(u32 mode) } } -u32 sceGeBreak(u32 mode, u32) +void sceGeBreak() { + u32 mode = PARAM(0); //0 : current dlist 1: all drawing ERROR_LOG(HLE,"UNIMPL sceGeBreak(mode=%d)",mode); - return 0; } -u32 sceGeContinue() +void sceGeContinue() { ERROR_LOG(HLE,"UNIMPL sceGeContinue"); - return 0; + // no arguments } u32 sceGeSetCallback(u32 structAddr) @@ -172,31 +173,32 @@ void sceGeGetMtx() ERROR_LOG(HLE,"UNIMPL sceGeGetMtx()"); } -int sceGeEdramSetAddrTranslation(int new_size) +void sceGeEdramSetAddrTranslation() { + int new_size = PARAM(0); INFO_LOG(HLE,"sceGeEdramSetAddrTranslation(%i)", new_size); static int EDRamWidth; int last = EDRamWidth; EDRamWidth = new_size; - return last; + RETURN(last); } const HLEFunction sceGe_user[] = { - {0xE47E40E4,&Wrap, "sceGeEdramGetAddr"}, - {0xAB49E76A,&Wrap, "sceGeListEnQueue"}, - {0x1C0D95A6,&Wrap, "sceGeListEnQueueHead"}, - {0xE0D68148,&Wrap, "sceGeListUpdateStallAddr"}, - {0x03444EB4,&Wrap, "sceGeListSync"}, - {0xB287BD61,&Wrap, "sceGeDrawSync"}, - {0xB448EC0D,&Wrap, "sceGeBreak"}, - {0x4C06E472,&Wrap, "sceGeContinue"}, - {0xA4FC06A4,&Wrap, "sceGeSetCallback"}, - {0x05DB22CE,&Wrap, "sceGeUnsetCallback"}, - {0x1F6752AD,&Wrap, "sceGeEdramGetSize"}, - {0xB77905EA,&Wrap,"sceGeEdramSetAddrTranslation"}, + {0xE47E40E4,&WrapU_V, "sceGeEdramGetAddr"}, + {0xAB49E76A,&WrapU_UUUU, "sceGeListEnQueue"}, + {0x1C0D95A6,&WrapU_UUUU, "sceGeListEnQueueHead"}, + {0xE0D68148,&WrapV_UU, "sceGeListUpdateStallAddr"}, + {0x03444EB4,&WrapV_UU, "sceGeListSync"}, + {0xB287BD61,&WrapU_U, "sceGeDrawSync"}, + {0xB448EC0D,sceGeBreak, "sceGeBreak"}, + {0x4C06E472,sceGeContinue, "sceGeContinue"}, + {0xA4FC06A4,&WrapU_U, "sceGeSetCallback"}, + {0x05DB22CE,&WrapV_U, "sceGeUnsetCallback"}, + {0x1F6752AD,&WrapU_V, "sceGeEdramGetSize"}, + {0xB77905EA,&sceGeEdramSetAddrTranslation,"sceGeEdramSetAddrTranslation"}, {0xDC93CFEF,0,"sceGeGetCmd"}, - {0x57C8945B,&Wrap,"sceGeGetMtx"}, + {0x57C8945B,&sceGeGetMtx,"sceGeGetMtx"}, {0x438A385A,0,"sceGeSaveContext"}, {0x0BF608FB,0,"sceGeRestoreContext"}, {0x5FB86AB0,0,"sceGeListDeQueue"}, diff --git a/Core/HLE/sceHprm.cpp b/Core/HLE/sceHprm.cpp index 1f9a8c399d..63490c960d 100644 --- a/Core/HLE/sceHprm.cpp +++ b/Core/HLE/sceHprm.cpp @@ -30,7 +30,7 @@ u32 sceHprmPeekCurrentKey(u32 keyAddress) const HLEFunction sceHprm[] = { {0x089fdfa4, 0, "sceHprm_0x089fdfa4"}, - {0x1910B327, &Wrap, "sceHprmPeekCurrentKey"}, + {0x1910B327, &WrapU_U, "sceHprmPeekCurrentKey"}, {0x208DB1BD, 0, "sceHprmIsRemoteExist"}, {0x7E69EDA4, 0, "sceHprmIsHeadphoneExist"}, {0x219C58F1, 0, "sceHprmIsMicrophoneExist"}, diff --git a/Core/HLE/sceIo.cpp b/Core/HLE/sceIo.cpp index ce988838a2..2b26c9a9e1 100644 --- a/Core/HLE/sceIo.cpp +++ b/Core/HLE/sceIo.cpp @@ -189,31 +189,31 @@ void __IoShutdown() } -u32 sceIoAssign(u32 aliasNameAddr, u32 physNameAddr, u32 devNameAddr, u32 flag, u32, u32) +void sceIoAssign() { - const char *aliasname = Memory::GetCharPointer(aliasNameAddr); - const char *physname = Memory::GetCharPointer(physNameAddr); - const char *devname = Memory::GetCharPointer(devNameAddr); + const char *aliasname = Memory::GetCharPointer(PARAM(0)); + const char *physname = Memory::GetCharPointer(PARAM(1)); + const char *devname = Memory::GetCharPointer(PARAM(2)); + u32 flag = PARAM(3); ERROR_LOG(HLE,"UNIMPL sceIoAssign(%s, %s, %s, %08x, ...)",aliasname,physname,devname,flag); - return 0; + RETURN(0); } -u32 sceKernelStdin() +void sceKernelStdin() { DEBUG_LOG(HLE,"3=sceKernelStdin()"); - return 3; + RETURN(3); } - -u32 sceKernelStdout() +void sceKernelStdout() { DEBUG_LOG(HLE,"1=sceKernelStdout()"); - return 1; + RETURN(1); } -u32 sceKernelStderr() +void sceKernelStderr() { DEBUG_LOG(HLE,"2=sceKernelStderr()"); - return 2; + RETURN(2); } void __IoCompleteAsyncIO(SceUID id) @@ -247,87 +247,97 @@ void __IoGetStat(SceIoStat *stat, PSPFileInfo &info) } -u32 sceIoGetstat(u32 fileAddr, u32 statAddr) +void sceIoGetstat() { - const char *filename = Memory::GetCharPointer(fileAddr); - DEBUG_LOG(HLE,"sceIoGetstat(%s, %08x)",filename,statAddr); + const char *filename = Memory::GetCharPointer(PARAM(0)); + u32 addr = PARAM(1); + DEBUG_LOG(HLE,"sceIoGetstat(%s, %08x)",filename,addr); - SceIoStat *stat = (SceIoStat*)Memory::GetPointer(statAddr); + SceIoStat *stat = (SceIoStat*)Memory::GetPointer(addr); PSPFileInfo info = pspFileSystem.GetFileInfo(filename); __IoGetStat(stat, info); - return 0; + RETURN(0); } -u32 sceIoRead(SceUID fd, u32 dataAddr, SceSize size) +void sceIoRead() //(int fd, void *data, int size); { - if (fd == 3) + SceUID id = PARAM(0); + if (id == 3) { DEBUG_LOG(HLE,"sceIoRead STDIN"); - return 0; + RETURN(0); //stdin + return; } u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - if (dataAddr) + if (PARAM(1)) { - u8 *data = (u8*)Memory::GetPointer(dataAddr); - f->asyncResult = (u32)pspFileSystem.ReadFile(f->handle, data, size); - DEBUG_LOG(HLE,"%i=sceIoRead(%d, %08x , %i)",f->asyncResult, fd, dataAddr, size); - return f->asyncResult; + u8 *data = (u8*)Memory::GetPointer(PARAM(1)); + int size = PARAM(2); + f->asyncResult = RETURN((u32)pspFileSystem.ReadFile(f->handle, data, size)); + DEBUG_LOG(HLE,"%i=sceIoRead(%d, %08x , %i)",f->asyncResult, id, PARAM(1), size); } else { ERROR_LOG(HLE,"sceIoRead Reading into zero pointer"); - return -1; + RETURN(-1); } } else { ERROR_LOG(HLE,"sceIoRead ERROR: no file open"); - return error; + RETURN(error); } } -u32 sceIoWrite(SceUID fd, u32 dataAddr, SceSize size) +void sceIoWrite() //(int fd, void *data, int size); { - if (fd == 2) + SceUID id = PARAM(0); + int size = PARAM(2); + if (PARAM(0) == 2) { //stderr! - const char *str = Memory::GetCharPointer(dataAddr); + const char *str = Memory::GetCharPointer(PARAM(1)); DEBUG_LOG(HLE,"stderr: %s", str); - return size; + RETURN(size); + return; } - if (fd == 1) + if (PARAM(0) == 1) { //stdout! - char *str = (char *)Memory::GetPointer(dataAddr); + char *str = (char *)Memory::GetPointer(PARAM(1)); char temp = str[size]; str[size]=0; DEBUG_LOG(HLE,"stdout: %s", str); str[size]=temp; - return size; + RETURN(size); + return; } u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - u8 *data = (u8*)Memory::GetPointer(dataAddr); - return (f->asyncResult = (u32)pspFileSystem.WriteFile(f->handle,data,size)); + u8 *data = (u8*)Memory::GetPointer(PARAM(1)); + f->asyncResult = RETURN((u32)pspFileSystem.WriteFile(f->handle,data,size)); } else { ERROR_LOG(HLE,"sceIoWrite ERROR: no file open"); - return error; + RETURN(error); } } -u64 sceIoLseek(SceUID fd, s64 offset, u32 whence) +void sceIoLseek() //(int fd, int64 offset, int whence); { + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); + s64 offset = ((s64)PARAM(2)) | ((s64)(PARAM(3))<<32); + int whence = PARAM(4); if (f) { FileMove seek = FILEMOVE_BEGIN; @@ -338,24 +348,26 @@ u64 sceIoLseek(SceUID fd, s64 offset, u32 whence) case 2: seek=FILEMOVE_END;break; } - f->asyncResult = (u32)pspFileSystem.SeekFile(f->handle, offset, seek); - DEBUG_LOG(HLE,"%i = sceIoLseek(%d,%lli,%i)",f->asyncResult, fd, offset,whence); - return f->asyncResult; + f->asyncResult = RETURN((u32)pspFileSystem.SeekFile(f->handle, (s32)offset, seek)); + DEBUG_LOG(HLE,"%i = sceIoLseek(%d,%i,%i)",f->asyncResult, id,(int)offset,whence); } else { - ERROR_LOG(HLE,"sceIoLseek(%d, %lli, %i) - ERROR: invalid file", fd, offset, whence); - return error; + ERROR_LOG(HLE,"sceIoLseek(%d, %i, %i) - ERROR: invalid file", id, (int)offset, whence); + RETURN(error); } } -u32 sceIoLseek32(SceUID fd, int offset, u32 whence) +void sceIoLseek32() //(int fd, int offset, int whence); { + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - DEBUG_LOG(HLE,"sceIoLseek32(%d,%08x,%i)",fd,offset,whence); + s32 offset = (s32)PARAM(2); + int whence = PARAM(3); + DEBUG_LOG(HLE,"sceIoLseek32(%d,%08x,%i)",id,(int)offset,whence); FileMove seek=FILEMOVE_BEGIN; switch (whence) @@ -365,29 +377,34 @@ u32 sceIoLseek32(SceUID fd, int offset, u32 whence) case 2: seek=FILEMOVE_END;break; } - return (f->asyncResult = (u32)pspFileSystem.SeekFile(f->handle, (s32)offset, seek)); + f->asyncResult = RETURN((u32)pspFileSystem.SeekFile(f->handle, (s32)offset, seek)); } else { ERROR_LOG(HLE,"sceIoLseek32 ERROR: no file open"); - return error; + RETURN(error); } } -u32 sceIoOpen(const char *filename, int flags, SceMode) +// Try WrapI_CU +void sceIoOpen() //(const char* file, int mode); { + const char *filename = Memory::GetCharPointer(PARAM(0)); + int mode = PARAM(1); + //memory stick filename int access=FILEACCESS_NONE; - if (flags & O_RDONLY) access |= FILEACCESS_READ; - if (flags & O_WRONLY) access |= FILEACCESS_WRITE; - if (flags & O_APPEND) access |= FILEACCESS_APPEND; - if (flags & O_CREAT) access |= FILEACCESS_CREATE; + if (mode & O_RDONLY) access |= FILEACCESS_READ; + if (mode & O_WRONLY) access |= FILEACCESS_WRITE; + if (mode & O_APPEND) access |= FILEACCESS_APPEND; + if (mode & O_CREAT) access |= FILEACCESS_CREATE; u32 h = pspFileSystem.OpenFile(filename, (FileAccess)access); if (h == 0) { - ERROR_LOG(HLE,"ERROR_ERRNO_FILE_NOT_FOUND=sceIoOpen(%s, %08x) - file not found", filename, flags); - return ERROR_ERRNO_FILE_NOT_FOUND; + ERROR_LOG(HLE,"ERROR_ERRNO_FILE_NOT_FOUND=sceIoOpen(%s, %08x) - file not found", filename, mode); + RETURN(ERROR_ERRNO_FILE_NOT_FOUND); + return; } FileNode *f = new FileNode(); @@ -395,43 +412,46 @@ u32 sceIoOpen(const char *filename, int flags, SceMode) f->handle = h; f->fullpath = filename; f->asyncResult = id; - DEBUG_LOG(HLE,"%i=sceIoOpen(%s, %08x)",id,filename,flags); - return id; + DEBUG_LOG(HLE,"%i=sceIoOpen(%s, %08x)",id,filename,mode); + RETURN(id); } -u32 sceIoClose(SceUID fd) +void sceIoClose() //(int fd); { - DEBUG_LOG(HLE,"sceIoClose(%d)",fd); - return kernelObjects.Destroy(fd); + SceUID f = PARAM(0); + DEBUG_LOG(HLE,"sceIoClose(%d)",f); + RETURN(kernelObjects.Destroy(f)); } -u32 sceIoRemove(u32 filenameAddr) +void sceIoRemove() //(const char *file); { - const char *filename = Memory::GetCharPointer(filenameAddr); - DEBUG_LOG(HLE,"sceIoRemove(%s)", filename); + const char *filename = Memory::GetCharPointer(PARAM(0)); if (pspFileSystem.DeleteFile(filename)) - return 0; + RETURN(0); else - return -1; + RETURN(-1); + DEBUG_LOG(HLE,"sceIoRemove(%s)", filename); } -u32 sceIoMkdir(const char *filename, int mode) +void sceIoMkdir() //(const char *dir, int mode); { - DEBUG_LOG(HLE,"sceIoMkdir(%s, %i)", filename, mode); + const char *filename = Memory::GetCharPointer(PARAM(0)); + int mode = PARAM(1); if (pspFileSystem.MkDir(filename)) - return 0; + RETURN(0); else - return -1; + RETURN(-1); + DEBUG_LOG(HLE,"sceIoMkdir(%s, %i)", filename, mode); } -u32 sceIoRmdir(u32 dirAddr) +void sceIoRmdir() //(const char *dir); { - const char *filename = Memory::GetCharPointer(dirAddr); - DEBUG_LOG(HLE,"sceIoRmdir(%s)", filename); + const char *filename = Memory::GetCharPointer(PARAM(0)); if (pspFileSystem.RmDir(filename)) - return 0; + RETURN(0); else - return -1; + RETURN(-1); + DEBUG_LOG(HLE,"sceIoRmdir(%s)", filename); } void sceIoSync() @@ -448,9 +468,14 @@ struct DeviceSize u32 freeClusters; }; -u32 sceIoDevctl(u32 nameAddr, int cmd, u32 argAddr, int argLen, u32 outPtr, int outLen) +void sceIoDevctl() //(const char *name, int cmd, void *arg, size_t arglen, void *buf, size_t *buflen); { - const char *name = Memory::GetCharPointer(nameAddr); + const char *name = Memory::GetCharPointer(PARAM(0)); + int cmd = PARAM(1); + u32 argAddr = PARAM(2); + int argLen = PARAM(3); + u32 outPtr = PARAM(4); + int outLen = PARAM(5); int retVal = 0; DEBUG_LOG(HLE,"%i=sceIoDevctl(\"%s\", %08x, %08x, %i, %08x, %i)", retVal, name, cmd,argAddr,argLen,outPtr,outLen); @@ -465,7 +490,8 @@ u32 sceIoDevctl(u32 nameAddr, int cmd, u32 argAddr, int argLen, u32 outPtr, int case 0x02025806: // Memory stick inserted? case 0x02025801: // Memstick Driver status? Memory::Write_U32(1, outPtr); - return 0; + RETURN(0); + return; case 0x02425818: // Pretend we have a 2GB memory stick. { @@ -478,7 +504,8 @@ u32 sceIoDevctl(u32 nameAddr, int cmd, u32 argAddr, int argLen, u32 outPtr, int deviceSize.totalClusters = (u32)((totalSize * 95 / 100) / (deviceSize.sectorSize * deviceSize.sectorsPerCluster)); deviceSize.freeClusters = (u32)((freeSize * 95 / 100) / (deviceSize.sectorSize * deviceSize.sectorsPerCluster)); Memory::WriteStruct(outPtr, &deviceSize); - return 0; + RETURN(0); + return; } } @@ -489,7 +516,8 @@ u32 sceIoDevctl(u32 nameAddr, int cmd, u32 argAddr, int argLen, u32 outPtr, int if (Memory::IsValidAddress(outPtr)) Memory::Write_U32(1, outPtr); // TODO: Make a headless mode for running tests! - return 0; + RETURN(0); + return; } @@ -536,33 +564,33 @@ u32 sceIoDevctl(u32 nameAddr, int cmd, u32 argAddr, int argLen, u32 outPtr, int 089c6c78 ]: HLE: sceIoDevctl("fatms0:", 02415821, 09ffb9c4, 4, 00000000, 0) (z_un_089c6bc4) 089c6cac ]: HLE: sceIoDevctl("mscmhc0:", 02025806, 00000000, 0, 09ffb9c8, 4) (z_un_089c6bc4) */ - return retVal; + RETURN(retVal); } -u32 sceIoRename(u32 oldNameAddr, u32 newNameAddr) +void sceIoRename() //(const char *oldname, const char *newname); { - const char *from = Memory::GetCharPointer(oldNameAddr); - const char *to = Memory::GetCharPointer(newNameAddr); + const char *from = Memory::GetCharPointer(PARAM(0)); + const char *to = Memory::GetCharPointer(PARAM(1)); ERROR_LOG(HLE,"UNIMPL sceIoRename(%s, %s)", from, to); - return 0; + RETURN(0); } -u32 sceIoChdir(u32 dirAddr) +void sceIoChdir() { - const char *dir = Memory::GetCharPointer(dirAddr); + const char *dir = Memory::GetCharPointer(PARAM(0)); pspFileSystem.ChDir(dir); DEBUG_LOG(HLE,"sceIoChdir(%s)",dir); - return 1; + RETURN(1); } typedef u32 (*DeferredAction)(SceUID id, int param); DeferredAction defAction = 0; u32 defParam; -u32 sceIoChangeAsyncPriority(u32 prio) +void sceIoChangeAsyncPriority() { - ERROR_LOG(HLE,"UNIMPL sceIoChangeAsyncPriority(%d)", prio); - return 0; + ERROR_LOG(HLE,"UNIMPL sceIoChangeAsyncPriority(%d)", PARAM(0)); + RETURN(0); } u32 __IoClose(SceUID id, int param) @@ -572,150 +600,154 @@ u32 __IoClose(SceUID id, int param) return kernelObjects.Destroy(id); } -u32 sceIoCloseAsync(SceUID fd) +void sceIoCloseAsync() { - DEBUG_LOG(HLE,"sceIoCloseAsync(%d)",fd); + DEBUG_LOG(HLE,"sceIoCloseAsync(%d)",PARAM(0)); //sceIoClose(); defAction = &__IoClose; - return 0; + RETURN(0); } -u32 sceIoLseekAsync(SceUID fd, SceOff offset, u32 whence) +void sceIoLseekAsync() { - sceIoLseek(fd, offset, whence); - __IoCompleteAsyncIO(fd); - return 0; + sceIoLseek(); + __IoCompleteAsyncIO(PARAM(0)); + RETURN(0); } -u32 sceIoSetAsyncCallback(SceUID fd, SceUID cb, u32 argAddr) +void sceIoSetAsyncCallback() { - DEBUG_LOG(HLE,"sceIoSetAsyncCallback(%d, %i, %08x)", fd, cb, argAddr); + DEBUG_LOG(HLE,"sceIoSetAsyncCallback(%d, %i, %08x)",PARAM(0), PARAM(1), PARAM(2)); + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - f->callbackID = cb; - f->callbackArg = argAddr; - return 0; + f->callbackID = PARAM(1); + f->callbackArg = PARAM(2); + RETURN(0); } else { - return error; + RETURN(error); } } -u32 sceIoLseek32Async(SceUID fd, int offset, u32 whence) +void sceIoLseek32Async() { - DEBUG_LOG(HLE,"sceIoLseek32Async(%d) sorta implemented",fd); - sceIoLseek32(fd, offset, whence); - __IoCompleteAsyncIO(fd); - return 0; + DEBUG_LOG(HLE,"sceIoLseek32Async(%d) sorta implemented",PARAM(0)); + sceIoLseek32(); + __IoCompleteAsyncIO(PARAM(0)); + RETURN(0); } -u32 sceIoOpenAsync(const char *filename, int flags, SceMode mode) +void sceIoOpenAsync() { DEBUG_LOG(HLE,"sceIoOpenAsync() sorta implemented"); - return sceIoOpen(filename, flags, mode); + sceIoOpen(); // __IoCompleteAsyncIO(currentMIPS->r[2]); // The return value // We have to return a UID here, which may have been destroyed when we reach Wait if it failed. // Now that we're just faking it, we just don't RETURN(0) here. } -u32 sceIoReadAsync(SceUID fd, u32 dataAddr, SceSize size) +void sceIoReadAsync() { - DEBUG_LOG(HLE,"sceIoReadAsync(%d)",fd); - sceIoRead(fd, dataAddr, size); - __IoCompleteAsyncIO(fd); - return 0; + DEBUG_LOG(HLE,"sceIoReadAsync(%d)",PARAM(0)); + sceIoRead(); + __IoCompleteAsyncIO(PARAM(0)); + RETURN(0); } -u32 sceIoGetAsyncStat(SceUID fd, int poll, u32 resAddr) +void sceIoGetAsyncStat() { + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - u64 *resPtr = (u64*)Memory::GetPointer(resAddr); + u64 *resPtr = (u64*)Memory::GetPointer(PARAM(2)); *resPtr = f->asyncResult; - DEBUG_LOG(HLE,"%i = sceIoGetAsyncStat(%i, %i, %08x) (HACK)", (u32)*resPtr, fd, poll, resAddr); - return 0; + DEBUG_LOG(HLE,"%i = sceIoGetAsyncStat(%i, %i, %08x) (HACK)", (u32)*resPtr, id, PARAM(1), PARAM(2)); + RETURN(0); //completed } else { - ERROR_LOG(HLE,"ERROR - sceIoGetAsyncStat with invalid id %i", fd); - return -1; + ERROR_LOG(HLE,"ERROR - sceIoGetAsyncStat with invalid id %i", id); + RETURN(-1); } } -u32 sceIoWaitAsync(SceUID fd, u32 resAddr) +void sceIoWaitAsync() { + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - u64 *resPtr = (u64*)Memory::GetPointer(resAddr); + u64 *resPtr = (u64*)Memory::GetPointer(PARAM(1)); *resPtr = f->asyncResult; if (defAction) { - *resPtr = defAction(fd, defParam); + *resPtr = defAction(id, defParam); defAction = 0; } - DEBUG_LOG(HLE,"%i = sceIoWaitAsync(%i, %08x) (HACK)", (u32)*resPtr, fd, resAddr); - return 0; + DEBUG_LOG(HLE,"%i = sceIoWaitAsync(%i, %08x) (HACK)", (u32)*resPtr, id, PARAM(1)); + RETURN(0); //completed } else { - ERROR_LOG(HLE,"ERROR - sceIoWaitAsync waiting for invalid id %i", fd); - return -1; + ERROR_LOG(HLE,"ERROR - sceIoWaitAsync waiting for invalid id %i", id); + RETURN(-1); } } -u32 sceIoWaitAsyncCB(SceUID fd, u32 resAddr) +void sceIoWaitAsyncCB() { // Should process callbacks here + + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - u64 *resPtr = (u64*)Memory::GetPointer(resAddr); + u64 *resPtr = (u64*)Memory::GetPointer(PARAM(1)); *resPtr = f->asyncResult; if (defAction) { - *resPtr = defAction(fd, defParam); + *resPtr = defAction(id, defParam); defAction = 0; } - DEBUG_LOG(HLE,"%i = sceIoWaitAsyncCB(%i, %08x) (HACK)", (u32)*resPtr, fd, resAddr); - return 0; + DEBUG_LOG(HLE,"%i = sceIoWaitAsyncCB(%i, %08x) (HACK)", (u32)*resPtr, id, PARAM(1)); + RETURN(0); //completed } else { - ERROR_LOG(HLE,"ERROR - sceIoWaitAsyncCB waiting for invalid id %i", fd); - return error; + ERROR_LOG(HLE,"ERROR - sceIoWaitAsyncCB waiting for invalid id %i", id); } } -u32 sceIoPollAsync(SceUID fd, u32 resAddr) +void sceIoPollAsync() { + SceUID id = PARAM(0); u32 error; - FileNode *f = kernelObjects.Get(fd, error); + FileNode *f = kernelObjects.Get(id, error); if (f) { - u64 *resPtr = (u64*)Memory::GetPointer(resAddr); + u64 *resPtr = (u64*)Memory::GetPointer(PARAM(1)); *resPtr = f->asyncResult; if (defAction) { - *resPtr = defAction(fd, defParam); + *resPtr = defAction(id, defParam); defAction = 0; } - DEBUG_LOG(HLE,"%i = sceIoPollAsync(%i, %08x) (HACK)", (u32)*resPtr, fd, resAddr); - return 0; + DEBUG_LOG(HLE,"%i = sceIoPollAsync(%i, %08x) (HACK)", (u32)*resPtr, id, PARAM(1)); + RETURN(0); //completed } else { - ERROR_LOG(HLE,"ERROR - sceIoPollAsync waiting for invalid id %i", fd); - return error; + ERROR_LOG(HLE,"ERROR - sceIoPollAsync waiting for invalid id %i", id); } } @@ -732,9 +764,9 @@ public: int index; }; -u32 sceIoDopen(u32 pathAddr) +void sceIoDopen() //(const char *path); { - const char *path = Memory::GetCharPointer(pathAddr); + const char *path = Memory::GetCharPointer(PARAM(0)); DEBUG_LOG(HLE,"sceIoDopen(\"%s\")",path); DirListing *dir = new DirListing(); @@ -746,84 +778,86 @@ u32 sceIoDopen(u32 pathAddr) dir->index = 0; dir->name = std::string(path); - return id; + RETURN(id); } -u32 sceIoDread(SceUID id, u32 dirEntAddr) +void sceIoDread() { + SceUID id = PARAM(0); u32 error; DirListing *dir = kernelObjects.Get(id, error); if (dir) { if (dir->index == (int)dir->listing.size()) { - return 0; + RETURN(0); + return; } PSPFileInfo &info = dir->listing[dir->index]; - SceIoDirEnt *entry = (SceIoDirEnt*)Memory::GetPointer(dirEntAddr); + SceIoDirEnt *entry = (SceIoDirEnt*)Memory::GetPointer(PARAM(1)); __IoGetStat(&entry->d_stat, info); strncpy(entry->d_name, info.name.c_str(), 256); entry->d_private = 0xC0DEBABE; - DEBUG_LOG(HLE,"sceIoDread( %d %08x ) = %s", id, dirEntAddr, entry->d_name); + DEBUG_LOG(HLE,"sceIoDread( %d %08x ) = %s", PARAM(0), PARAM(1), entry->d_name); dir->index++; - return (u32)(dir->listing.size()-dir->index+1); + RETURN((u32)(dir->listing.size()-dir->index+1)); } else { DEBUG_LOG(HLE,"sceIoDread - invalid listing %i, error %08x", id, error); - return error; } } -u32 sceIoDclose(SceUID id) +void sceIoDclose() { + u32 id = PARAM(0); DEBUG_LOG(HLE,"sceIoDclose(%d)",id); - return kernelObjects.Destroy(id); + RETURN(kernelObjects.Destroy(id)); } const HLEFunction IoFileMgrForUser[] = { - {0xb29ddf9c,&Wrap, "sceIoDopen"}, - {0xe3eb004c,&Wrap, "sceIoDread"}, - {0xeb092469,&Wrap,"sceIoDclose"}, + {0xb29ddf9c,sceIoDopen, "sceIoDopen"}, + {0xe3eb004c,sceIoDread, "sceIoDread"}, + {0xeb092469,sceIoDclose,"sceIoDclose"}, {0xe95a012b,0,"sceIoIoctlAsync"}, {0x63632449,0,"sceIoIoctl"}, - {0xace946e8,&Wrap,"sceIoGetstat"}, + {0xace946e8,sceIoGetstat,"sceIoGetstat"}, {0xb8a740f4,0,"sceIoChstat"}, - {0x55f4717d,&Wrap,"sceIoChdir"}, + {0x55f4717d,sceIoChdir,"sceIoChdir"}, {0x08bd7374,0,"sceIoGetDevType"}, - {0xB2A628C1,&Wrap,"sceIoAssign"}, + {0xB2A628C1,sceIoAssign,"sceIoAssign"}, {0xe8bc6571,0,"sceIoCancel"}, - {0xb293727f,&Wrap,"sceIoChangeAsyncPriority"}, - {0x810C4BC3,&Wrap, "sceIoClose"}, //(int fd); - {0xff5940b6,&Wrap,"sceIoCloseAsync"}, - {0x54F5FB11,&Wrap,"sceIoDevctl"}, //(const char *name int cmd, void *arg, size_t arglen, void *buf, size_t *buflen); - {0xcb05f8d6,&Wrap,"sceIoGetAsyncStat"}, - {0x27EB27B8,&Wrap, "sceIoLseek"}, //(int fd, int offset, int whence); - {0x68963324,&Wrap,"sceIoLseek32"}, - {0x1b385d8f,&Wrap,"sceIoLseek32Async"}, - {0x71b19e77,&Wrap,"sceIoLseekAsync"}, - {0x109F50BC,&Wrap, "sceIoOpen"}, //(const char* file, int mode); - {0x89AA9906,&Wrap,"sceIoOpenAsync"}, - {0x06A70004,&Wrap,"sceIoMkdir"}, //(const char *dir, int mode); - {0x3251ea56,&Wrap,"sceIoPollAsync"}, - {0x6A638D83,&Wrap, "sceIoRead"}, //(int fd, void *data, int size); - {0xa0b5a7c2,&Wrap,"sceIoReadAsync"}, - {0xF27A9C51,&Wrap,"sceIoRemove"}, //(const char *file); - {0x779103A0,&Wrap,"sceIoRename"}, //(const char *oldname, const char *newname); - {0x1117C65F,&Wrap,"sceIoRmdir"}, //(const char *dir); - {0xA12A0514,&Wrap,"sceIoSetAsyncCallback"}, - {0xab96437f,&Wrap,"sceIoSync"}, + {0xb293727f,sceIoChangeAsyncPriority,"sceIoChangeAsyncPriority"}, + {0x810C4BC3,sceIoClose, "sceIoClose"}, //(int fd); + {0xff5940b6,sceIoCloseAsync,"sceIoCloseAsync"}, + {0x54F5FB11,sceIoDevctl,"sceIoDevctl"}, //(const char *name int cmd, void *arg, size_t arglen, void *buf, size_t *buflen); + {0xcb05f8d6,sceIoGetAsyncStat,"sceIoGetAsyncStat"}, + {0x27EB27B8,sceIoLseek, "sceIoLseek"}, //(int fd, int offset, int whence); + {0x68963324,sceIoLseek32,"sceIoLseek32"}, + {0x1b385d8f,sceIoLseek32Async,"sceIoLseek32Async"}, + {0x71b19e77,sceIoLseekAsync,"sceIoLseekAsync"}, + {0x109F50BC,sceIoOpen, "sceIoOpen"}, //(const char* file, int mode); + {0x89AA9906,sceIoOpenAsync,"sceIoOpenAsync"}, + {0x06A70004,sceIoMkdir,"sceIoMkdir"}, //(const char *dir, int mode); + {0x3251ea56,sceIoPollAsync,"sceIoPollAsync"}, + {0x6A638D83,sceIoRead, "sceIoRead"}, //(int fd, void *data, int size); + {0xa0b5a7c2,sceIoReadAsync,"sceIoReadAsync"}, + {0xF27A9C51,sceIoRemove,"sceIoRemove"}, //(const char *file); + {0x779103A0,sceIoRename,"sceIoRename"}, //(const char *oldname, const char *newname); + {0x1117C65F,sceIoRmdir,"sceIoRmdir"}, //(const char *dir); + {0xA12A0514,sceIoSetAsyncCallback,"sceIoSetAsyncCallback"}, + {0xab96437f,sceIoSync,"sceIoSync"}, {0x6d08a871,0,"sceIoUnassign"}, - {0x42EC03AC,&Wrap, "sceIoWrite"}, //(int fd, void *data, int size); + {0x42EC03AC,sceIoWrite, "sceIoWrite"}, //(int fd, void *data, int size); {0x0facab19,0,"sceIoWriteAsync"}, - {0x35dbd746,&Wrap,"sceIoWaitAsyncCB"}, - {0xe23eec33,&Wrap,"sceIoWaitAsync"}, + {0x35dbd746,sceIoWaitAsyncCB,"sceIoWaitAsyncCB"}, + {0xe23eec33,sceIoWaitAsync,"sceIoWaitAsync"}, }; void Register_IoFileMgrForUser() @@ -834,9 +868,9 @@ void Register_IoFileMgrForUser() const HLEFunction StdioForUser[] = { - {0x172D316E,&Wrap,"sceKernelStdin"}, - {0xA6BAB2E9,&Wrap,"sceKernelStdout"}, - {0xF78BA90A,&Wrap,"sceKernelStderr"}, + {0x172D316E,sceKernelStdin,"sceKernelStdin"}, + {0xA6BAB2E9,sceKernelStdout,"sceKernelStdout"}, + {0xF78BA90A,sceKernelStderr,"sceKernelStderr"}, }; void Register_StdioForUser() diff --git a/Core/HLE/sceKernel.cpp b/Core/HLE/sceKernel.cpp index e5e95208f3..8f1d562617 100644 --- a/Core/HLE/sceKernel.cpp +++ b/Core/HLE/sceKernel.cpp @@ -137,45 +137,45 @@ void sceKernelDevkitVersion() ////////////////////////////////////////////////////////////////////////// -void sceKernelRegisterKprintfHandler(u32, u32) +void sceKernelRegisterKprintfHandler() { ERROR_LOG(HLE,"UNIMPL sceKernelRegisterKprintfHandler()"); RETURN(0); } - void sceKernelRegisterDefaultExceptionHandler() { ERROR_LOG(HLE,"UNIMPL sceKernelRegisterDefaultExceptionHandler()"); RETURN(0); } -void sceKernelSetGPO(u32 num) +void sceKernelSetGPO() { // Sets debug LEDs. - INFO_LOG(HLE,"sceKernelSetGPO(%02x)", num); + INFO_LOG(HLE,"sceKernelSetGPO(%02x)", PARAM(0)); } -u32 sceKernelGetGPI() +void sceKernelGetGPI() { // Always returns 0 on production systems. INFO_LOG(HLE,"0=sceKernelGetGPI()"); - return 0; + RETURN(0); } void sceKernelDcacheWritebackAll() { + //RETURN(0); } - -void sceKernelDcacheWritebackRange(u32, u32) +void sceKernelDcacheWritebackRange() { + //RETURN(0); } - -void sceKernelDcacheWritebackInvalidateRange(u32, u32) +void sceKernelDcacheWritebackInvalidateRange() { + //RETURN(0); } - void sceKernelDcacheWritebackInvalidateAll() { + // RETURN(0) } KernelObjectPool kernelObjects; @@ -269,71 +269,71 @@ void sceKernelIcacheInvalidateAll() const HLEFunction ThreadManForUser[] = { - {0x55C20A00,&Wrap, "sceKernelCreateEventFlag"}, - {0x812346E4,&Wrap, "sceKernelClearEventFlag"}, - {0xEF9E4C70,&Wrap, "sceKernelDeleteEventFlag"}, - {0x1fb15a32,&Wrap, "sceKernelSetEventFlag"}, - {0x402FCF22,&Wrap, "sceKernelWaitEventFlag"}, - {0x328C546A,&Wrap, "sceKernelWaitEventFlagCB"}, - {0x30FD48F0,&Wrap, "sceKernelPollEventFlag"}, - {0xCD203292,&Wrap, "sceKernelCancelEventFlag"}, - {0xA66B0120,&Wrap,"sceKernelReferEventFlagStatus"}, + {0x55C20A00,sceKernelCreateEventFlag, "sceKernelCreateEventFlag"}, + {0x812346E4,sceKernelClearEventFlag, "sceKernelClearEventFlag"}, + {0xEF9E4C70,sceKernelDeleteEventFlag, "sceKernelDeleteEventFlag"}, + {0x1fb15a32,sceKernelSetEventFlag, "sceKernelSetEventFlag"}, + {0x402FCF22,sceKernelWaitEventFlag, "sceKernelWaitEventFlag"}, + {0x328C546A,sceKernelWaitEventFlagCB, "sceKernelWaitEventFlagCB"}, + {0x30FD48F0,sceKernelPollEventFlag, "sceKernelPollEventFlag"}, + {0xCD203292,sceKernelCancelEventFlag, "sceKernelCancelEventFlag"}, + {0xA66B0120,sceKernelReferEventFlagStatus,"sceKernelReferEventFlagStatus"}, - {0x8FFDF9A2,&Wrap, "sceKernelCancelSema"}, - {0xD6DA4BA1,&Wrap, "sceKernelCreateSema"}, - {0x28b6489c,&Wrap, "sceKernelDeleteSema"}, - {0x58b1f937,&Wrap, "sceKernelPollSema"}, - {0xBC6FEBC5,&Wrap,"sceKernelReferSemaStatus"}, - {0x3F53E640,&Wrap, "sceKernelSignalSema"}, - {0x4E3A1105,&Wrap, "sceKernelWaitSema"}, - {0x6d212bac,&Wrap, "sceKernelWaitSemaCB"}, + {0x8FFDF9A2,sceKernelCancelSema, "sceKernelCancelSema"}, + {0xD6DA4BA1,sceKernelCreateSema, "sceKernelCreateSema"}, + {0x28b6489c,sceKernelDeleteSema, "sceKernelDeleteSema"}, + {0x58b1f937,sceKernelPollSema, "sceKernelPollSema"}, + {0xBC6FEBC5,sceKernelReferSemaStatus,"sceKernelReferSemaStatus"}, + {0x3F53E640,sceKernelSignalSema, "sceKernelSignalSema"}, + {0x4E3A1105,sceKernelWaitSema, "sceKernelWaitSema"}, + {0x6d212bac,sceKernelWaitSemaCB, "sceKernelWaitSemaCB"}, {0x60107536,0,"sceKernelDeleteLwMutex"}, {0x19CFF145,0,"sceKernelCreateLwMutex"}, - {0xf8170fbe,&Wrap,"sceKernelDeleteMutex"}, - {0xB011B11F,&Wrap,"sceKernelLockMutex"}, - {0x5bf4dd27,&Wrap,"sceKernelLockMutexCB"}, - {0x6b30100f,&Wrap,"sceKernelUnlockMutex"}, - {0xb7d098c6,&Wrap,"sceKernelCreateMutex"}, + {0xf8170fbe,&WrapU_U,"sceKernelDeleteMutex"}, + {0xB011B11F,&WrapU_UUU,"sceKernelLockMutex"}, + {0x5bf4dd27,&WrapU_UUU,"sceKernelLockMutexCB"}, + {0x6b30100f,&WrapU_UU,"sceKernelUnlockMutex"}, + {0xb7d098c6,&WrapU_CUU,"sceKernelCreateMutex"}, // NOTE: LockLwMutex and UnlockLwMutex are in Kernel_Library, see sceKernelInterrupt.cpp. {0xFCCFAD26,0,"sceKernelCancelWakeupThread"}, - {0xea748e31,&Wrap,"sceKernelChangeCurrentThreadAttr"}, - {0x71bc9871,&Wrap,"sceKernelChangeThreadPriority"}, - {0x446D8DE6,&Wrap,"sceKernelCreateThread"}, - {0x9fa03cd3,&Wrap,"sceKernelDeleteThread"}, + {0xea748e31,sceKernelChangeCurrentThreadAttr,"sceKernelChangeCurrentThreadAttr"}, + {0x71bc9871,sceKernelChangeThreadPriority,"sceKernelChangeThreadPriority"}, + {0x446D8DE6,sceKernelCreateThread,"sceKernelCreateThread"}, + {0x9fa03cd3,sceKernelDeleteThread,"sceKernelDeleteThread"}, {0xBD123D9E,0,"sceKernelDelaySysClockThread"}, {0x1181E963,0,"sceKernelDelaySysClockThreadCB"}, - {0xceadeb47,&Wrap,"sceKernelDelayThread"}, - {0x68da9e36,&Wrap,"sceKernelDelayThreadCB"}, - {0xaa73c935,&Wrap,"sceKernelExitThread"}, - {0x809ce29b,&Wrap,"sceKernelExitDeleteThread"}, + {0xceadeb47,sceKernelDelayThread,"sceKernelDelayThread"}, + {0x68da9e36,sceKernelDelayThreadCB,"sceKernelDelayThreadCB"}, + {0xaa73c935,sceKernelExitThread,"sceKernelExitThread"}, + {0x809ce29b,sceKernelExitDeleteThread,"sceKernelExitDeleteThread"}, {0x94aa61ee,0,"sceKernelGetThreadCurrentPriority"}, - {0x293b45b8,&Wrap,"sceKernelGetThreadId"}, - {0x3B183E26,&Wrap,"sceKernelGetThreadExitStatus"}, - {0x52089CA1,&Wrap,"sceKernelGetThreadStackFreeSize"}, + {0x293b45b8,sceKernelGetThreadId,"sceKernelGetThreadId"}, + {0x3B183E26,sceKernelGetThreadExitStatus,"sceKernelGetThreadExitStatus"}, + {0x52089CA1,sceKernelGetThreadStackFreeSize,"sceKernelGetThreadStackFreeSize"}, {0xFFC36A14,0,"sceKernelReferThreadRunStatus"}, - {0x17c1684e,&Wrap,"sceKernelReferThreadStatus"}, + {0x17c1684e,sceKernelReferThreadStatus,"sceKernelReferThreadStatus"}, {0x2C34E053,0,"sceKernelReleaseWaitThread"}, - {0x75156e8f,&Wrap,"sceKernelResumeThread"}, + {0x75156e8f,sceKernelResumeThread,"sceKernelResumeThread"}, {0x27e22ec2,0,"sceKernelResumeDispatchThread"}, - {0x912354a7,&Wrap,"sceKernelRotateThreadReadyQueue"}, - {0x9ACE131E,&Wrap,"sceKernelSleepThread"}, - {0x82826f70,&Wrap,"sceKernelSleepThreadCB"}, - {0xF475845D,&Wrap,"sceKernelStartThread"}, - {0x9944f31f,&Wrap,"sceKernelSuspendThread"}, + {0x912354a7,sceKernelRotateThreadReadyQueue,"sceKernelRotateThreadReadyQueue"}, + {0x9ACE131E,sceKernelSleepThread,"sceKernelSleepThread"}, + {0x82826f70,sceKernelSleepThreadCB,"sceKernelSleepThreadCB"}, + {0xF475845D,&WrapU_V,"sceKernelStartThread"}, + {0x9944f31f,sceKernelSuspendThread,"sceKernelSuspendThread"}, {0x3ad58b8c,0,"sceKernelSuspendDispatchThread"}, {0x616403ba,0,"sceKernelTerminateThread"}, - {0x383f7bcc,&Wrap,"sceKernelTerminateDeleteThread"}, - {0x840E8133,&Wrap,"sceKernelWaitThreadEndCB"}, - {0xd13bde95,&Wrap,"sceKernelCheckThreadStack"}, + {0x383f7bcc,sceKernelTerminateDeleteThread,"sceKernelTerminateDeleteThread"}, + {0x840E8133,sceKernelWaitThreadEndCB,"sceKernelWaitThreadEndCB"}, + {0xd13bde95,sceKernelCheckThreadStack,"sceKernelCheckThreadStack"}, {0x94416130,0,"sceKernelGetThreadmanIdList"}, - {0x57CF62DD,&Wrap,"sceKernelGetThreadmanIdType"}, + {0x57CF62DD,sceKernelGetThreadmanIdType,"sceKernelGetThreadmanIdType"}, - {0x20fff560,&Wrap,"sceKernelCreateVTimer"}, + {0x20fff560,sceKernelCreateVTimer,"sceKernelCreateVTimer"}, {0x328F9E52,0,"sceKernelDeleteVTimer"}, - {0xc68d9437,&Wrap,"sceKernelStartVTimer"}, + {0xc68d9437,sceKernelStartVTimer,"sceKernelStartVTimer"}, {0xD0AEEE87,0,"sceKernelStopVTimer"}, {0xD2D615EF,0,"sceKernelCancelVTimerHandler"}, {0xB3A59970,0,"sceKernelGetVTimerBase"}, @@ -343,82 +343,82 @@ const HLEFunction ThreadManForUser[] = {0x5F32BEAA,0,"sceKernelReferVTimerStatus"}, {0x542AD630,0,"sceKernelSetVTimerTime"}, {0xFB6425C3,0,"sceKernelSetVTimerTimeWide"}, - {0xd8b299ae,&Wrap,"sceKernelSetVTimerHandler"}, + {0xd8b299ae,sceKernelSetVTimerHandler,"sceKernelSetVTimerHandler"}, {0x53B00E9A,0,"sceKernelSetVTimerHandlerWide"}, - {0x82BC5777,&Wrap,"sceKernelGetSystemTimeWide"}, - {0xdb738f35,&Wrap,"sceKernelGetSystemTime"}, - {0x369ed59d,&Wrap,"sceKernelGetSystemTimeLow"}, + {0x82BC5777,sceKernelGetSystemTimeWide,"sceKernelGetSystemTimeWide"}, + {0xdb738f35,sceKernelGetSystemTime,"sceKernelGetSystemTime"}, + {0x369ed59d,sceKernelGetSystemTimeLow,"sceKernelGetSystemTimeLow"}, {0x8218B4DD,0,"sceKernelReferGlobalProfiler"}, {0x627E6F3A,0,"sceKernelReferSystemStatus"}, {0x64D4540E,0,"sceKernelReferThreadProfiler"}, //Fifa Street 2 uses alarms - {0x6652b8ca,&Wrap,"sceKernelSetAlarm"}, - {0xB2C25152,&Wrap,"sceKernelSetSysClockAlarm"}, - {0x7e65b999,&Wrap,"sceKernelCancelAlarm"}, - {0xDAA3F564,&Wrap,"sceKernelReferAlarmStatus"}, + {0x6652b8ca,sceKernelSetAlarm,"sceKernelSetAlarm"}, + {0xB2C25152,sceKernelSetSysClockAlarm,"sceKernelSetSysClockAlarm"}, + {0x7e65b999,sceKernelCancelAlarm,"sceKernelCancelAlarm"}, + {0xDAA3F564,sceKernelReferAlarmStatus,"sceKernelReferAlarmStatus"}, - {0xba6b92e2,&Wrap,"sceKernelSysClock2USec"}, + {0xba6b92e2,sceKernelSysClock2USec,"sceKernelSysClock2USec"}, {0x110DEC9A,0,"sceKernelUSec2SysClock"}, {0xC8CD158C,0,"sceKernelUSec2SysClockWide"}, - {0xE1619D7C,&Wrap,"sceKernelSysClock2USecWide"}, + {0xE1619D7C,sceKernelSysClock2USecWide,"sceKernelSysClock2USecWide"}, - {0x110dec9a,&Wrap,"sceKernelUSec2SysClock"}, - {0x278C0DF5,&Wrap,"sceKernelWaitThreadEnd"}, - {0xd59ead2f,&Wrap,"sceKernelWakeupThread"}, //AI Go, audio? + {0x110dec9a,sceKernelUSec2SysClock,"sceKernelUSec2SysClock"}, + {0x278C0DF5,sceKernelWaitThreadEnd,"sceKernelWaitThreadEnd"}, + {0xd59ead2f,sceKernelWakeupThread,"sceKernelWakeupThread"}, //AI Go, audio? {0x0C106E53,0,"sceKernelRegisterThreadEventHandler"}, {0x72F3C145,0,"sceKernelReleaseThreadEventHandler"}, {0x369EEB6B,0,"sceKernelReferThreadEventHandlerStatus"}, - {0x349d6d6c,&Wrap,"sceKernelCheckCallback"}, - {0xE81CAF8F,&Wrap,"sceKernelCreateCallback"}, - {0xEDBA5844,&Wrap,"sceKernelDeleteCallback"}, - {0xC11BA8C4,&Wrap,"sceKernelNotifyCallback"}, - {0xBA4051D6,&Wrap,"sceKernelCancelCallback"}, - {0x2A3D44FF,&Wrap,"sceKernelGetCallbackCount"}, - {0x349D6D6C,&Wrap,"sceKernelCheckCallback"}, - {0x730ED8BC,&Wrap,"sceKernelReferCallbackStatus"}, + {0x349d6d6c,&WrapU_V,"sceKernelCheckCallback"}, + {0xE81CAF8F,sceKernelCreateCallback,"sceKernelCreateCallback"}, + {0xEDBA5844,sceKernelDeleteCallback,"sceKernelDeleteCallback"}, + {0xC11BA8C4,sceKernelNotifyCallback,"sceKernelNotifyCallback"}, + {0xBA4051D6,sceKernelCancelCallback,"sceKernelCancelCallback"}, + {0x2A3D44FF,sceKernelGetCallbackCount,"sceKernelGetCallbackCount"}, + {0x349D6D6C,&WrapU_V,"sceKernelCheckCallback"}, + {0x730ED8BC,sceKernelReferCallbackStatus,"sceKernelReferCallbackStatus"}, - {0x8125221D,&Wrap,"sceKernelCreateMbx"}, - {0x86255ADA,&Wrap,"sceKernelDeleteMbx"}, - {0xE9B3061E,&Wrap,"sceKernelSendMbx"}, - {0x18260574,&Wrap,"sceKernelReceiveMbx"}, - {0xF3986382,&Wrap,"sceKernelReceiveMbxCB"}, - {0x0D81716A,&Wrap,"sceKernelPollMbx"}, - {0x87D4DD36,&Wrap,"sceKernelCancelReceiveMbx"}, - {0xA8E8C846,&Wrap,"sceKernelReferMbxStatus"}, + {0x8125221D,sceKernelCreateMbx,"sceKernelCreateMbx"}, + {0x86255ADA,sceKernelDeleteMbx,"sceKernelDeleteMbx"}, + {0xE9B3061E,sceKernelSendMbx,"sceKernelSendMbx"}, + {0x18260574,sceKernelReceiveMbx,"sceKernelReceiveMbx"}, + {0xF3986382,sceKernelReceiveMbxCB,"sceKernelReceiveMbxCB"}, + {0x0D81716A,sceKernelPollMbx,"sceKernelPollMbx"}, + {0x87D4DD36,sceKernelCancelReceiveMbx,"sceKernelCancelReceiveMbx"}, + {0xA8E8C846,sceKernelReferMbxStatus,"sceKernelReferMbxStatus"}, - {0x7C0DC2A0,&Wrap,"sceKernelCreateMsgPipe"}, - {0xF0B7DA1C,&Wrap,"sceKernelDeleteMsgPipe"}, - {0x876DBFAD,&Wrap,"sceKernelSendMsgPipe"}, - {0x7C41F2C2,&Wrap,"sceKernelSendMsgPipeCB"}, - {0x884C9F90,&Wrap,"sceKernelTrySendMsgPipe"}, - {0x74829B76,&Wrap,"sceKernelReceiveMsgPipe"}, - {0xFBFA697D,&Wrap,"sceKernelReceiveMsgPipeCB"}, - {0xDF52098F,&Wrap,"sceKernelTryReceiveMsgPipe"}, - {0x349B864D,&Wrap,"sceKernelCancelMsgPipe"}, - {0x33BE4024,&Wrap,"sceKernelReferMsgPipeStatus"}, + {0x7C0DC2A0,sceKernelCreateMsgPipe,"sceKernelCreateMsgPipe"}, + {0xF0B7DA1C,sceKernelDeleteMsgPipe,"sceKernelDeleteMsgPipe"}, + {0x876DBFAD,sceKernelSendMsgPipe,"sceKernelSendMsgPipe"}, + {0x7C41F2C2,sceKernelSendMsgPipeCB,"sceKernelSendMsgPipeCB"}, + {0x884C9F90,sceKernelTrySendMsgPipe,"sceKernelTrySendMsgPipe"}, + {0x74829B76,sceKernelReceiveMsgPipe,"sceKernelReceiveMsgPipe"}, + {0xFBFA697D,sceKernelReceiveMsgPipeCB,"sceKernelReceiveMsgPipeCB"}, + {0xDF52098F,sceKernelTryReceiveMsgPipe,"sceKernelTryReceiveMsgPipe"}, + {0x349B864D,sceKernelCancelMsgPipe,"sceKernelCancelMsgPipe"}, + {0x33BE4024,sceKernelReferMsgPipeStatus,"sceKernelReferMsgPipeStatus"}, - {0x56C039B5,&Wrap,"sceKernelCreateVpl"}, - {0x89B3D48C,&Wrap,"sceKernelDeleteVpl"}, - {0xBED27435,&Wrap,"sceKernelAllocateVpl"}, - {0xEC0A693F,&Wrap,"sceKernelAllocateVplCB"}, - {0xAF36D708,&Wrap,"sceKernelTryAllocateVpl"}, - {0xB736E9FF,&Wrap,"sceKernelFreeVpl"}, - {0x1D371B8A,&Wrap,"sceKernelCancelVpl"}, - {0x39810265,&Wrap,"sceKernelReferVplStatus"}, + {0x56C039B5,sceKernelCreateVpl,"sceKernelCreateVpl"}, + {0x89B3D48C,sceKernelDeleteVpl,"sceKernelDeleteVpl"}, + {0xBED27435,sceKernelAllocateVpl,"sceKernelAllocateVpl"}, + {0xEC0A693F,sceKernelAllocateVplCB,"sceKernelAllocateVplCB"}, + {0xAF36D708,sceKernelTryAllocateVpl,"sceKernelTryAllocateVpl"}, + {0xB736E9FF,sceKernelFreeVpl,"sceKernelFreeVpl"}, + {0x1D371B8A,sceKernelCancelVpl,"sceKernelCancelVpl"}, + {0x39810265,sceKernelReferVplStatus,"sceKernelReferVplStatus"}, - {0xC07BB470,&Wrap,"sceKernelCreateFpl"}, - {0xED1410E0,&Wrap,"sceKernelDeleteFpl"}, - {0xD979E9BF,&Wrap,"sceKernelAllocateFpl"}, - {0xE7282CB6,&Wrap,"sceKernelAllocateFplCB"}, - {0x623AE665,&Wrap,"sceKernelTryAllocateFpl"}, - {0xF6414A71,&Wrap,"sceKernelFreeFpl"}, - {0xA8AA591F,&Wrap,"sceKernelCancelFpl"}, - {0xD8199E4C,&Wrap,"sceKernelReferFplStatus"}, + {0xC07BB470,sceKernelCreateFpl,"sceKernelCreateFpl"}, + {0xED1410E0,sceKernelDeleteFpl,"sceKernelDeleteFpl"}, + {0xD979E9BF,sceKernelAllocateFpl,"sceKernelAllocateFpl"}, + {0xE7282CB6,sceKernelAllocateFplCB,"sceKernelAllocateFplCB"}, + {0x623AE665,sceKernelTryAllocateFpl,"sceKernelTryAllocateFpl"}, + {0xF6414A71,sceKernelFreeFpl,"sceKernelFreeFpl"}, + {0xA8AA591F,sceKernelCancelFpl,"sceKernelCancelFpl"}, + {0xD8199E4C,sceKernelReferFplStatus,"sceKernelReferFplStatus"}, {0x0E927AED, _sceKernelReturnFromTimerHandler, "_sceKernelReturnFromTimerHandler"}, {0x532A522E, _sceKernelExitThread,"_sceKernelExitThread"}, diff --git a/Core/HLE/sceKernel.h b/Core/HLE/sceKernel.h index 1fba50e3c8..8721d40eb5 100644 --- a/Core/HLE/sceKernel.h +++ b/Core/HLE/sceKernel.h @@ -253,16 +253,16 @@ void sceKernelSleepThreadCB(); void sceKernelDevkitVersion(); -void sceKernelRegisterKprintfHandler(u32, u32); +void sceKernelRegisterKprintfHandler(); void sceKernelRegisterDefaultExceptionHandler(); -u32 sceKernelFindModuleByName(u32); +void sceKernelFindModuleByName(); -void sceKernelSetGPO(u32); -u32 sceKernelGetGPI(); +void sceKernelSetGPO(); +void sceKernelGetGPI(); void sceKernelDcacheWritebackAll(); -void sceKernelDcacheWritebackRange(u32, u32); -void sceKernelDcacheWritebackInvalidateRange(u32, u32); +void sceKernelDcacheWritebackRange(); +void sceKernelDcacheWritebackInvalidateRange(); void sceKernelDcacheWritebackInvalidateAll(); void sceKernelGetThreadStackFreeSize(); void sceKernelIcacheInvalidateAll(); diff --git a/Core/HLE/sceKernelEventFlag.cpp b/Core/HLE/sceKernelEventFlag.cpp index 35c8531b5e..a1b91fea21 100644 --- a/Core/HLE/sceKernelEventFlag.cpp +++ b/Core/HLE/sceKernelEventFlag.cpp @@ -178,13 +178,6 @@ retry: goto retry; } } - - if (wokeThreads) - { - // Probably useful to make things go faster: trigger thread change directly after the event flag has been set - __KernelReSchedule(); - } - RETURN(0); } else @@ -218,9 +211,9 @@ void sceKernelWaitEventFlag() th.wait = wait; th.outAddr = outBitsPtr; e->waitingThreads.push_back(th); - //u32 timeout; - //if (Memory::IsValidAddress(timeoutPtr)) - // timeout = Memory::Read_U32(timeoutPtr); + u32 timeout; + if (Memory::IsValidAddress(timeoutPtr)) + timeout = Memory::Read_U32(timeoutPtr); __KernelWaitCurThread(WAITTYPE_EVENTFLAG, id, 0, 0, false); } @@ -257,9 +250,9 @@ void sceKernelWaitEventFlagCB() th.wait = wait; th.outAddr = outBitsPtr; e->waitingThreads.push_back(th); - //u32 timeout; - //if (Memory::IsValidAddress(timeoutPtr)) - // timeout = Memory::Read_U32(timeoutPtr); + u32 timeout; + if (Memory::IsValidAddress(timeoutPtr)) + timeout = Memory::Read_U32(timeoutPtr); __KernelWaitCurThread(WAITTYPE_EVENTFLAG, id, 0, 0, true); } diff --git a/Core/HLE/sceKernelInterrupt.cpp b/Core/HLE/sceKernelInterrupt.cpp index 4249acbf4f..db53d54a22 100644 --- a/Core/HLE/sceKernelInterrupt.cpp +++ b/Core/HLE/sceKernelInterrupt.cpp @@ -183,7 +183,6 @@ public: if (has(subIntrNum)) return subIntrHandlers[subIntrNum]; // what to do, what to do... - return voidSubIntr; } void queueUp() @@ -198,8 +197,6 @@ public: private: std::map subIntrHandlers; - // Only useful to handle when the subIntr doesn't exist - SubIntrHandler voidSubIntr; }; @@ -264,7 +261,7 @@ bool __RunOnePendingInterrupt() void __TriggerInterrupt(PSPInterrupt intno) { intrHandlers[intno].queueUp(); - DEBUG_LOG(HLE, "Triggering subinterrupts for interrupt %i (%li in queue)", intno, pendingInterrupts.size()); + DEBUG_LOG(HLE, "Triggering subinterrupts for interrupt %i (%i in queue)", intno, pendingInterrupts.size()); if (!inInterrupt) __RunOnePendingInterrupt(); } @@ -385,12 +382,12 @@ void sceKernelMemset() const HLEFunction Kernel_Library[] = { - {0x092968F4,&Wrap,"sceKernelCpuSuspendIntr"}, - {0x5F10D406,&Wrap, "sceKernelCpuResumeIntr"}, //int oldstat - {0x3b84732d,&Wrap, "sceKernelCpuResumeIntrWithSync"}, - {0x47a0b729,&Wrap, "sceKernelIsCpuIntrSuspended"}, //flags - {0xb55249d2,&Wrap, "sceKernelIsCpuIntrEnable"}, - {0xa089eca4,&Wrap, "sceKernelMemset"}, + {0x092968F4,sceKernelCpuSuspendIntr,"sceKernelCpuSuspendIntr"}, + {0x5F10D406,WrapV_U, "sceKernelCpuResumeIntr"}, //int oldstat + {0x3b84732d,WrapV_U, "sceKernelCpuResumeIntrWithSync"}, + {0x47a0b729,sceKernelIsCpuIntrSuspended, "sceKernelIsCpuIntrSuspended"}, //flags + {0xb55249d2,sceKernelIsCpuIntrEnable, "sceKernelIsCpuIntrEnable"}, + {0xa089eca4,sceKernelMemset, "sceKernelMemset"}, {0xbea46419,0, "sceKernelLockLwMutex"}, {0x15b6446b,0, "sceKernelUnlockLwMutex"}, {0x293b45b8,0, "sceKernelGetThreadId"}, @@ -406,10 +403,10 @@ void Register_Kernel_Library() const HLEFunction InterruptManager[] = { - {0xCA04A2B9, &Wrap, "sceKernelRegisterSubIntrHandler"}, - {0xD61E6961, &Wrap, "sceKernelReleaseSubIntrHandler"}, - {0xFB8E22EC, &Wrap, "sceKernelEnableSubIntr"}, - {0x8A389411, &Wrap, "sceKernelDisableSubIntr"}, + {0xCA04A2B9, WrapU_UUUU, "sceKernelRegisterSubIntrHandler"}, + {0xD61E6961, WrapU_UU, "sceKernelReleaseSubIntrHandler"}, + {0xFB8E22EC, WrapU_UU, "sceKernelEnableSubIntr"}, + {0x8A389411, WrapU_UU, "sceKernelDisableSubIntr"}, {0x5CB5A78B, 0, "sceKernelSuspendSubIntr"}, {0x7860E0DC, 0, "sceKernelResumeSubIntr"}, {0xFC4374B8, 0, "sceKernelIsSubInterruptOccurred"}, diff --git a/Core/HLE/sceKernelModule.cpp b/Core/HLE/sceKernelModule.cpp index 94cedd818a..641baba4fa 100644 --- a/Core/HLE/sceKernelModule.cpp +++ b/Core/HLE/sceKernelModule.cpp @@ -238,6 +238,7 @@ Module *__KernelLoadELFFromPtr(const u8 *ptr, u32 loadAddress, std::string *erro { const char *modulename = (const char*)Memory::GetPointer(entry[m].name); u32 *nidDataPtr = (u32*)Memory::GetPointer(entry[m].nidData); + // u32 *stubs = (u32*)Memory::GetPointer(entry[m].firstSymAddr); DEBUG_LOG(LOADER,"Importing Module %s, stubs at %08x",modulename,entry[m].firstSymAddr); @@ -314,11 +315,11 @@ Module *__KernelLoadELFFromPtr(const u8 *ptr, u32 loadAddress, std::string *erro bool __KernelLoadPBP(const char *filename, std::string *error_string) { - //static const char *FileNames[] = - //{ - // "PARAM.SFO", "ICON0.PNG", "ICON1.PMF", "UNKNOWN.PNG", - // "PIC1.PNG", "SND0.AT3", "UNKNOWN.PSP", "UNKNOWN.PSAR" - //}; + static const char *FileNames[] = + { + "PARAM.SFO", "ICON0.PNG", "ICON1.PMF", "UNKNOWN.PNG", + "PIC1.PNG", "SND0.AT3", "UNKNOWN.PSP", "UNKNOWN.PSAR" + }; std::ifstream in(filename, std::ios::binary); @@ -524,9 +525,9 @@ void sceKernelStartModule() int argsize = PARAM(1); u32 argptr = PARAM(2); u32 ptrReturn = PARAM(3); - //if (PARAM(4)) { - //SceKernelSMOption *smoption = (SceKernelSMOption*)Memory::GetPointer(PARAM(4)); - //} + if (PARAM(4)) { + SceKernelSMOption *smoption = (SceKernelSMOption*)Memory::GetPointer(PARAM(4)); + } ERROR_LOG(HLE,"UNIMPL sceKernelStartModule(%d,asize=%08x,aptr=%08x,retptr=%08x,...)", id,argsize,argptr,ptrReturn); RETURN(0); @@ -554,33 +555,35 @@ void sceKernelGetModuleIdByAddress() else RETURN(0); } + void sceKernelGetModuleId() { ERROR_LOG(HLE,"UNIMPL sceKernelGetModuleId"); RETURN(0); - } -u32 sceKernelFindModuleByName(u32) +void sceKernelFindModuleByName() { ERROR_LOG(HLE,"UNIMPL sceKernelFindModuleByName()"); - return 1; + RETURN(1); } + + const HLEFunction ModuleMgrForUser[] = { - {0x977DE386,&Wrap,"sceKernelLoadModule"}, + {0x977DE386,&WrapU_CU,"sceKernelLoadModule"}, {0xb7f46618,0,"sceKernelLoadModuleByID"}, - {0x50F0C1EC,&Wrap,"sceKernelStartModule"}, - {0xD675EBB8,&Wrap,"sceKernelSelfStopUnloadModule"}, //HACK - {0xd1ff982a,&Wrap,"sceKernelStopModule"}, - {0x2e0911aa,&Wrap,"sceKernelUnloadModule"}, + {0x50F0C1EC,&sceKernelStartModule,"sceKernelStartModule"}, + {0xD675EBB8,&sceKernelExitGame,"sceKernelSelfStopUnloadModule"}, //HACK + {0xd1ff982a,&sceKernelStopModule,"sceKernelStopModule"}, + {0x2e0911aa,&sceKernelUnloadModule,"sceKernelUnloadModule"}, {0x710F61B5,0,"sceKernelLoadModuleMs"}, {0xF9275D98,0,"sceKernelLoadModuleBufferUsbWlan"}, ///??? {0xCC1D3699,0,"sceKernelStopUnloadSelfModule"}, {0x748CBED9,0,"sceKernelQueryModuleInfo"}, - {0xd8b73127,&Wrap, "sceKernelGetModuleIdByAddress"}, - {0xf0a26395,&Wrap, "sceKernelGetModuleId"}, + {0xd8b73127,&sceKernelGetModuleIdByAddress, "sceKernelGetModuleIdByAddress"}, + {0xf0a26395,&sceKernelGetModuleId, "sceKernelGetModuleId"}, {0x8f2df740,0,"sceKernel_ModuleMgr_8f2df740"}, }; diff --git a/Core/HLE/sceKernelMsgPipe.cpp b/Core/HLE/sceKernelMsgPipe.cpp index de220735ab..39ffb032e9 100644 --- a/Core/HLE/sceKernelMsgPipe.cpp +++ b/Core/HLE/sceKernelMsgPipe.cpp @@ -49,10 +49,10 @@ struct MsgPipe : public KernelObject void sceKernelCreateMsgPipe() { const char *name = Memory::GetCharPointer(PARAM(0)); - //int memoryPartition = PARAM(1); + int memoryPartition = PARAM(1); SceUInt attr = PARAM(2); int size = PARAM(3); - //int opt = PARAM(4); + int opt = PARAM(4); MsgPipe *m = new MsgPipe(); SceUID id = kernelObjects.Create(m); @@ -188,4 +188,3 @@ void sceKernelReferMsgPipeStatus() RETURN(error); } } - diff --git a/Core/HLE/sceKernelSemaphore.cpp b/Core/HLE/sceKernelSemaphore.cpp index 72bfc627a0..dbd1626076 100644 --- a/Core/HLE/sceKernelSemaphore.cpp +++ b/Core/HLE/sceKernelSemaphore.cpp @@ -127,7 +127,7 @@ void sceKernelSignalSema() s->ns.currentCount += signal; DEBUG_LOG(HLE,"sceKernelSignalSema(%i, %i) (old: %i, new: %i)", id, signal, oldval, s->ns.currentCount); - //bool wokeThreads = false; + bool wokeThreads = false; retry: //TODO: check for threads to wake up - wake them std::vector::iterator iter; @@ -139,7 +139,7 @@ retry: { __KernelResumeThread(id); s->ns.currentCount -= wVal; - //wokeThreads = true; + wokeThreads = true; s->waitingThreads.erase(iter); goto retry; } diff --git a/Core/HLE/sceKernelThread.cpp b/Core/HLE/sceKernelThread.cpp index b90251e3ac..00c2f72712 100644 --- a/Core/HLE/sceKernelThread.cpp +++ b/Core/HLE/sceKernelThread.cpp @@ -312,10 +312,10 @@ void __KernelNotifyCallback(SceUID threadID, SceUID cbid, u32 notifyArg) return; } } - //CallbackNotification cb; - //cb.cbid = cbid; - //cb.arg = notifyArg; - //cb.count = 1; + CallbackNotification cb; + cb.cbid = cbid; + cb.arg = notifyArg; + cb.count = 1; } // TODO: error checking } @@ -457,7 +457,7 @@ void __KernelLoadContext(ThreadContext *ctx) // If any changes were made, it will context switch bool __KernelTriggerWait(WaitType type, int id, bool dontSwitch) { - //bool doneAnything = false; + bool doneAnything = false; for (std::vector::iterator iter = threadqueue.begin(); iter != threadqueue.end(); iter++) { @@ -472,7 +472,7 @@ bool __KernelTriggerWait(WaitType type, int id, bool dontSwitch) { t->nt.status = THREADSTATUS_READY; } - //doneAnything = true; + doneAnything = true; } } } @@ -544,7 +544,7 @@ void __KernelScheduleWakeup(SceUID threadID, int usFromNow) void __KernelRemoveFromThreadQueue(Thread *t) { - for (u32 i = 0; i < threadqueue.size(); i++) + for (int i = 0; i < threadqueue.size(); i++) { if (threadqueue[i] == t) { diff --git a/Core/HLE/sceKernelTime.cpp b/Core/HLE/sceKernelTime.cpp index 70d970902b..62da410b64 100644 --- a/Core/HLE/sceKernelTime.cpp +++ b/Core/HLE/sceKernelTime.cpp @@ -95,21 +95,24 @@ void sceKernelSysClock2USecWide() RETURN(0); } -u32 sceKernelLibcClock() +void sceKernelLibcClock() { u32 retVal = clock()*1000; DEBUG_LOG(HLE,"%i = sceKernelLibcClock",retVal); - return retVal; // TODO: fix + RETURN(retVal); // TODO: fix } -u32 sceKernelLibcTime(time_t *t) +void sceKernelLibcTime() { + time_t *t = 0; + if (PARAM(0)) + t = (time_t*)Memory::GetPointer(PARAM(0)); u32 retVal = (u32)time(t); DEBUG_LOG(HLE,"%i = sceKernelLibcTime()",retVal); - return retVal; + RETURN(retVal); } -u32 sceKernelLibcGettimeofday(timeval *tv, u32) +void sceKernelLibcGettimeofday() { #ifdef _WIN32 union { @@ -123,30 +126,28 @@ u32 sceKernelLibcGettimeofday(timeval *tv, u32) u32 tv_usec; }; + timeval *tv = (timeval*)Memory::GetPointer(PARAM(0)); DEBUG_LOG(HLE,"sceKernelLibcGettimeofday()"); GetSystemTimeAsFileTime (&now.ft); tv->tv_usec = (long) ((now.ns100 / 10LL) % 1000000LL); tv->tv_sec = (long) ((now.ns100 - 116444736000000000LL) / 10000000LL); #endif - return 0; + RETURN(0); } - -u32 sceRtcGetCurrentClockLocalTime(u32) +void sceRtcGetCurrentClockLocalTime() { DEBUG_LOG(HLE,"0=sceRtcGetCurrentClockLocalTime()"); - return 0; + RETURN(0); } - -u32 sceRtcGetTick(u32, u32) +void sceRtcGetTick() { DEBUG_LOG(HLE,"0=sceRtcGetTick()"); - return 0; + RETURN(0); } -u32 sceRtcGetTickResolution() +void sceRtcGetTickResolution() { DEBUG_LOG(HLE,"100=sceRtcGetTickResolution()"); - return 100; + RETURN(100); } - diff --git a/Core/HLE/sceKernelTime.h b/Core/HLE/sceKernelTime.h index cc0f90a27f..0905a61a6b 100644 --- a/Core/HLE/sceKernelTime.h +++ b/Core/HLE/sceKernelTime.h @@ -17,15 +17,15 @@ #pragma once -u32 sceKernelLibcGettimeofday(timeval *tv, u32); -u32 sceKernelLibcClock(); -u32 sceKernelLibcTime(time_t*); +void sceKernelLibcGettimeofday(); +void sceKernelLibcClock(); +void sceKernelLibcTime(); void sceKernelUSec2SysClock(); void sceKernelGetSystemTime(); void sceKernelGetSystemTimeLow(); void sceKernelGetSystemTimeWide(); void sceKernelSysClock2USec(); void sceKernelSysClock2USecWide(); -u32 sceRtcGetCurrentClockLocalTime(u32); -u32 sceRtcGetTickResolution(); -u32 sceRtcGetTick(u32, u32); +void sceRtcGetCurrentClockLocalTime(); +void sceRtcGetTickResolution(); +void sceRtcGetTick(); diff --git a/Core/HLE/sceNet.cpp b/Core/HLE/sceNet.cpp index d83871ba0b..032fc80274 100644 --- a/Core/HLE/sceNet.cpp +++ b/Core/HLE/sceNet.cpp @@ -175,8 +175,8 @@ const HLEFunction sceNetApctl[] = const HLEFunction sceWlanDrv[] = { {0xd7763699, 0, "sceWlanGetSwitchState"}, - {0x0c622081, Wrap, "sceWlanGetEtherAddr"}, - {0x93440B11, Wrap, "sceWlanDevIsPowerOn"}, + {0x0c622081, WrapU_U, "sceWlanGetEtherAddr"}, + {0x93440B11, WrapU_V, "sceWlanDevIsPowerOn"}, }; void Register_sceNet() diff --git a/Core/HLE/scePower.cpp b/Core/HLE/scePower.cpp index 2dc3650da9..30ccb75179 100644 --- a/Core/HLE/scePower.cpp +++ b/Core/HLE/scePower.cpp @@ -175,7 +175,7 @@ static const HLEFunction scePower[] = {0xBD681969,0,"scePowerGetBusClockFrequencyInt"}, {0xB1A52C83,0,"scePowerGetCpuClockFrequencyFloat"}, {0x9BADB3EB,0,"scePowerGetBusClockFrequencyFloat"}, - {0x737486F2,&Wrap,"scePowerSetClockFrequency"}, + {0x737486F2,&WrapV_UUU,"scePowerSetClockFrequency"}, {0x34f9c463,0,"scePowerGetPllClockFrequencyInt"}, {0xea382a27,0,"scePowerGetPllClockFrequencyFloat"}, {0xebd177d6,0,"scePower_driver_EBD177D6"}, diff --git a/Core/HLE/scePsmf.cpp b/Core/HLE/scePsmf.cpp index 64f21698df..00f96c6aca 100644 --- a/Core/HLE/scePsmf.cpp +++ b/Core/HLE/scePsmf.cpp @@ -60,19 +60,19 @@ u32 scePsmfSpecifyStreamWithStreamType(u32 psmfStruct, u32 streamType) // possib const HLEFunction scePsmf[] = { - {0xc22c8327,&Wrap,"scePsmfSetPsmfFunction"}, + {0xc22c8327,&WrapU_UU,"scePsmfSetPsmfFunction"}, {0xC7DB3A5B,0,"scePsmfGetCurrentStreamTypeFunction"}, {0x28240568,0,"scePsmfGetCurrentStreamNumberFunction"}, - {0x1E6D9013,&Wrap,"scePsmfSpecifyStreamWithStreamTypeFunction"}, + {0x1E6D9013,&WrapU_UU,"scePsmfSpecifyStreamWithStreamTypeFunction"}, {0x4BC9BDE0,0,"scePsmfSpecifyStreamFunction"}, {0x76D3AEBA,0,"scePsmfGetPresentationStartTimeFunction"}, {0xBD8AE0D8,0,"scePsmfGetPresentationEndTimeFunction"}, - {0xEAED89CD,&Wrap,"scePsmfGetNumberOfStreamsFunction"}, + {0xEAED89CD,&WrapU_U,"scePsmfGetNumberOfStreamsFunction"}, {0x7491C438,0,"scePsmfGetNumberOfEPentriesFunction"}, {0x0BA514E5,0,"scePsmfGetVideoInfoFunction"}, {0xA83F7113,0,"scePsmfGetAudioInfoFunction"}, {0x971A3A90,0,"scePsmfCheckEPmapFunction"}, - {0x68d42328,&Wrap,"scePsmfGetNumberOfSpecificStreamsFunction"}, + {0x68d42328,&WrapU_UU,"scePsmfGetNumberOfSpecificStreamsFunction"}, {0x5b70fcc1,0,"scePsmfQueryStreamOffsetFunction"}, {0x9553cc91,0,"scePsmfQueryStreamSizeFunction"}, {0x0C120E1D,0,"scePsmfSpecifyStreamWithStreamTypeNumberFunction"}, diff --git a/Core/HLE/sceRtc.cpp b/Core/HLE/sceRtc.cpp index 3c7556b9e3..2eb31eba5a 100644 --- a/Core/HLE/sceRtc.cpp +++ b/Core/HLE/sceRtc.cpp @@ -26,12 +26,12 @@ #include "sceRtc.h" -u32 sceRtcGetCurrentTick(u64) +void sceRtcGetCurrentTick() { #ifdef _WIN32 - return GetTickCount(); + RETURN(GetTickCount()); #else time_update(); - return time_now_d(); + RETURN(time_now_d()); #endif } diff --git a/Core/HLE/sceRtc.h b/Core/HLE/sceRtc.h index 9aa2a9ee52..95d7c03858 100644 --- a/Core/HLE/sceRtc.h +++ b/Core/HLE/sceRtc.h @@ -17,4 +17,4 @@ #pragma once -u32 sceRtcGetCurrentTick(u64); +void sceRtcGetCurrentTick(); diff --git a/Core/HLE/sceSas.cpp b/Core/HLE/sceSas.cpp index ad08d0a1dc..11c5c2baec 100644 --- a/Core/HLE/sceSas.cpp +++ b/Core/HLE/sceSas.cpp @@ -391,10 +391,10 @@ void sceSasGetOutputMode() const HLEFunction sceSasCore[] = { - {0x42778a9f, Wrap, "__sceSasInit"}, // (SceUID * sasCore, int grain, int maxVoices, int outputMode, int sampleRate) + {0x42778a9f, WrapU_UUUUU, "__sceSasInit"}, // (SceUID * sasCore, int grain, int maxVoices, int outputMode, int sampleRate) {0xa3589d81, _sceSasCore, "__sceSasCore"}, {0x50a14dfc, _sceSasCoreWithMix, "__sceSasCoreWithMix"}, // Process and mix into buffer (int sasCore, int sasInOut, int leftVolume, int rightVolume) - {0x68a46b95, Wrap, "__sceSasGetEndFlag"}, // int sasCore + {0x68a46b95, WrapU_V, "__sceSasGetEndFlag"}, // int sasCore {0x440ca7d8, sceSasSetVolume, "__sceSasSetVolume"}, {0xad84d37f, sceSasSetPitch, "__sceSasSetPitch"}, {0x99944089, sceSasSetVoice, "__sceSasSetVoice"}, // (int sasCore, int voice, int vagAddr, int size, int loopmode) @@ -402,8 +402,8 @@ const HLEFunction sceSasCore[] = {0x019b25eb, sceSasSetADSR, "__sceSasSetADSR"}, {0x9ec3676a, sceSasSetADSRMode, "__sceSasSetADSRmode"}, {0x5f9529f6, 0, "__sceSasSetSL"}, - {0x74ae582a, Wrap, "__sceSasGetEnvelopeHeight"}, - {0xcbcd4f79, Wrap, "__sceSasSetSimpleADSR"}, + {0x74ae582a, WrapU_UU, "__sceSasGetEnvelopeHeight"}, + {0xcbcd4f79, WrapU_UUUU, "__sceSasSetSimpleADSR"}, {0xa0cf2fa4, sceSasSetKeyOff, "__sceSasSetKeyOff"}, {0x76f01aca, sceSasSetKeyOn, "__sceSasSetKeyOn"}, // (int sasCore, int voice) {0xf983b186, sceSasRevVON, "__sceSasRevVON"}, // int sasCore, int dry, int wet diff --git a/GPU/GLES/DisplayListInterpreter.cpp b/GPU/GLES/DisplayListInterpreter.cpp index baf44ca60e..79f0656c20 100644 --- a/GPU/GLES/DisplayListInterpreter.cpp +++ b/GPU/GLES/DisplayListInterpreter.cpp @@ -891,11 +891,11 @@ void GPU::ExecuteOp(u32 op, u32 diff) case GE_CMD_ZTEST: { - //static const GLuint ztests[8] = - //{ - // GL_NEVER, GL_ALWAYS, GL_EQUAL, GL_NOTEQUAL, - // GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL - //}; + static const GLuint ztests[8] = + { + GL_NEVER, GL_ALWAYS, GL_EQUAL, GL_NOTEQUAL, + GL_LESS, GL_LEQUAL, GL_GREATER, GL_GEQUAL + }; //glDepthFunc(ztests[data&7]); glDepthFunc(GL_LEQUAL); DEBUG_LOG(G3D,"DL Z test mode: %i", data); diff --git a/GPU/GLES/TransformPipeline.cpp b/GPU/GLES/TransformPipeline.cpp index bcdbde7831..475141a7af 100644 --- a/GPU/GLES/TransformPipeline.cpp +++ b/GPU/GLES/TransformPipeline.cpp @@ -134,7 +134,7 @@ void Light(float colorOut[4], const float colorIn[4], Vec3 pos, Vec3 normal, flo else toLight = Vec3(gstate.lightpos[l]) - pos; - //Vec3 dir = Vec3(gstate.lightdir[l]); + Vec3 dir = Vec3(gstate.lightdir[l]); bool doSpecular = (comp != GE_LIGHTCOMP_ONLYDIFFUSE); bool poweredDiffuse = comp == GE_LIGHTCOMP_BOTHWITHPOWDIFFUSE; @@ -225,6 +225,7 @@ void TransformAndDrawPrim(void *verts, void *inds, int prim, int vertexCount, Li // TODO: Split up into multiple draw calls for Android where you can't guarantee support for more than 0x10000 verts. + int i = 0; #ifdef ANDROID if (vertexCount > 0x10000/3)