libretro/ppsspp
1
0
Fork 0
mirror of https://github.com/libretro/ppsspp.git synced 2025-02-02 14:52:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #24 from artart78/master

Browse Source 
Message boxes and two small bugfixes
This commit is contained in:
Henrik Rydgård 2012-11-08 07:26:25 -08:00
commit 606e83a3e9
10 changed files with 303 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Core/FileSystems/ISOFileSystem.cpp
View File

@ -260,6 +260,8 @@ ISOFileSystem::TreeEntry *ISOFileSystem::GetFromPath(std::string path)
if (path.length() == 0 || (path.length()==1 && path[0] == '/'))
return e;
path.erase(0, 1);
while (path[0] == '/')
path.erase(0, 1);
}
else
{

28
Core/HLE/FunctionWrappers.h
View File

@ -38,6 +38,16 @@ template<u32 func(u32)> void WrapU_U() {
RETURN(retval);
}
template<int func(u32)> void WrapI_U() {
int retval = func(PARAM(0));
RETURN(retval);
}
template<int func(int)> void WrapI_I() {
int retval = func(PARAM(0));
RETURN(retval);
}
template<void func(u32)> void WrapV_U() {
func(PARAM(0));
}
@ -51,6 +61,15 @@ template<u32 func(u32, u32)> void WrapU_UU() {
RETURN(retval);
}
template<int func(int, u32)> void WrapI_IU() {
int retval = func(PARAM(0), PARAM(1));
RETURN(retval);
}
template<void func(int, u32)> void WrapV_IU() {
func(PARAM(0), PARAM(1));
}
template<int func(const char *, u32)> void WrapI_CU() {
int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1));
RETURN(retval);
@ -71,6 +90,10 @@ template<u32 func(u32, u32, u32)> void WrapU_UUU() {
RETURN(retval);
}
template<void func(int, u32, u32)> void WrapV_IUU() {
func(PARAM(0), PARAM(1), PARAM(2));
}
template<void func(u32, u32, u32)> void WrapV_UUU() {
func(PARAM(0), PARAM(1), PARAM(2));
}
@ -89,6 +112,11 @@ template<u32 func(u32, u32, u32, u32, u32)> void WrapU_UUUUU() {
RETURN(retval);
}
template<int func(const char *, int, u32, int, u32)> void WrapU_CIUIU() {
int retval = func(Memory::GetCharPointer(PARAM(0)), PARAM(1), PARAM(2), PARAM(3), PARAM(4));
RETURN(retval);
}
template<u32 func(u32, u32, u32, u32, u32, u32)> void WrapU_UUUUUU() {
u32 retval = func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4), PARAM(5));
RETURN(retval);

16
Core/HLE/sceKernel.cpp
View File

@ -387,14 +387,14 @@ const HLEFunction ThreadManForUser[] =
{0x2A3D44FF,sceKernelGetCallbackCount,"sceKernelGetCallbackCount"},
{0x730ED8BC,sceKernelReferCallbackStatus,"sceKernelReferCallbackStatus"},
{0x8125221D,sceKernelCreateMbx,"sceKernelCreateMbx"},
{0x86255ADA,sceKernelDeleteMbx,"sceKernelDeleteMbx"},
{0xE9B3061E,sceKernelSendMbx,"sceKernelSendMbx"},
{0x18260574,sceKernelReceiveMbx,"sceKernelReceiveMbx"},
{0xF3986382,sceKernelReceiveMbxCB,"sceKernelReceiveMbxCB"},
{0x0D81716A,sceKernelPollMbx,"sceKernelPollMbx"},
{0x87D4DD36,sceKernelCancelReceiveMbx,"sceKernelCancelReceiveMbx"},
{0xA8E8C846,sceKernelReferMbxStatus,"sceKernelReferMbxStatus"},
{0x8125221D,&WrapU_CIUIU<sceKernelCreateMbx>,"sceKernelCreateMbx"},
{0x86255ADA,&WrapI_I<sceKernelDeleteMbx>,"sceKernelDeleteMbx"},
{0xE9B3061E,&WrapV_IU<sceKernelSendMbx>,"sceKernelSendMbx"},
{0x18260574,&WrapV_IUU<sceKernelReceiveMbx>,"sceKernelReceiveMbx"},
{0xF3986382,&WrapV_IUU<sceKernelReceiveMbxCB>,"sceKernelReceiveMbxCB"},
{0x0D81716A,&WrapI_IU<sceKernelPollMbx>,"sceKernelPollMbx"},
{0x87D4DD36,&WrapI_IU<sceKernelCancelReceiveMbx>,"sceKernelCancelReceiveMbx"},
{0xA8E8C846,&WrapI_IU<sceKernelReferMbxStatus>,"sceKernelReferMbxStatus"},
{0x7C0DC2A0,sceKernelCreateMsgPipe,"sceKernelCreateMsgPipe"},
{0xF0B7DA1C,sceKernelDeleteMsgPipe,"sceKernelDeleteMsgPipe"},

313
Core/HLE/sceKernelMbx.cpp
View File

@ -20,14 +20,10 @@
#include "sceKernelMbx.h"
#include "HLE.h"
struct NativeMbxPacket
{
u32 next;
u8 priority;
u8 padding[3];
#define SCE_KERNEL_MBA_THPRI 0x100
#define SCE_KERNEL_MBA_MSPRI 0x400
// data follows
};
// TODO: when a thread is being resumed (message received or cancellation), sceKernelReceiveMbx() always returns 0
struct NativeMbx
{
@ -46,20 +42,34 @@ struct Mbx : public KernelObject
static u32 GetMissingErrorCode() { return SCE_KERNEL_ERROR_UNKNOWN_MBXID; }
int GetIDType() const { return SCE_KERNEL_TMID_Mbox; }
void AddWaitingThread(SceUID id, u32 addr)
{
if (nmb.attr & SCE_KERNEL_MBA_THPRI)
{
for (std::vector<std::pair<SceUID, u32>>::iterator it = waitingThreads.begin(); it != waitingThreads.end(); it++)
{
if (__KernelGetThreadPrio(id) >= __KernelGetThreadPrio((*it).first))
{
waitingThreads.insert(it, std::make_pair(id, addr));
break;
}
}
}
else
{
waitingThreads.push_back(std::make_pair(id, addr));
}
}
NativeMbx nmb;
std::vector<SceUID> receiveWaitingThreads;
std::vector<std::pair<SceUID, u32>> waitingThreads;
std::vector<u32> messageQueue;
};
void sceKernelCreateMbx()
SceUID sceKernelCreateMbx(const char *name, int memoryPartition, SceUInt attr, int size, u32 optAddr)
{
const char *name = Memory::GetCharPointer(PARAM(0));
int memoryPartition = PARAM(1);
SceUInt attr = PARAM(2);
int size = PARAM(3);
int opt = PARAM(4);
ERROR_LOG(HLE, "sceKernelCreateMbx(%s, %i, %08x, %i, %08x)", name, memoryPartition, attr, size, opt);
DEBUG_LOG(HLE, "sceKernelCreateMbx(%s, %i, %08x, %i, %08x)", name, memoryPartition, attr, size, optAddr);
Mbx *m = new Mbx();
SceUID id = kernelObjects.Create(m);
@ -71,89 +81,216 @@ void sceKernelCreateMbx()
m->nmb.numMessages = 0;
m->nmb.packetListHead = 0;
RETURN(id);
return id;
}
void sceKernelDeleteMbx()
int sceKernelDeleteMbx(SceUID id)
{
SceUInt uid = PARAM(0);
ERROR_LOG(HLE, "sceKernelDeleteMbx(%i)", uid);
RETURN(kernelObjects.Destroy<Mbx>(uid));
DEBUG_LOG(HLE, "sceKernelDeleteMbx(%i)", id);
return kernelObjects.Destroy<Mbx>(id);
}
void sceKernelSendMbx()
void sceKernelSendMbx(SceUID id, u32 packetAddr)
{
SceUInt uid = PARAM(0);
u32 packetAddr = PARAM(1);
ERROR_LOG(HLE, "UNIMPL sceKernelSendMbx(%i, %08x)", uid, packetAddr);
RETURN(0);
}
void sceKernelReceiveMbx()
{
SceUInt uid = PARAM(0);
u32 packetAddrPtr = PARAM(1);
u32 timeoutPtr = PARAM(2);
ERROR_LOG(HLE, "UNIMPL sceKernelReceiveMbx(%i, %08x, %08x)", uid, packetAddrPtr, timeoutPtr);
RETURN(SCE_KERNEL_ERROR_MBOX_NOMSG);
}
void sceKernelReceiveMbxCB()
{
SceUInt uid = PARAM(0);
u32 packetAddrPtr = PARAM(1);
u32 timeoutPtr = PARAM(2);
__KernelCheckCallbacks();
ERROR_LOG(HLE, "UNIMPL sceKernelReceiveMbxCB(%i, %08x, %08x)", uid, packetAddrPtr, timeoutPtr);
RETURN(SCE_KERNEL_ERROR_MBOX_NOMSG);
}
void sceKernelPollMbx()
{
SceUInt uid = PARAM(0);
u32 packetAddrPtr = PARAM(1);
ERROR_LOG(HLE, "UNIMPL sceKernelPollMbx(%i, %08x)", uid, packetAddrPtr);
RETURN(SCE_KERNEL_ERROR_MBOX_NOMSG);
}
void sceKernelCancelReceiveMbx()
{
SceUInt uid = PARAM(0);
int numWaitingThreadsAddr = PARAM(1);
ERROR_LOG(HLE, "UNIMPL sceKernelCancelReceiveMbx(%i, %i)", uid, numWaitingThreadsAddr);
RETURN(0);
}
void sceKernelCancelMbx()
{
SceUInt uid = PARAM(0);
u32 numSendThreads = PARAM(1);
u32 numReceiveThreads = PARAM(2);
ERROR_LOG(HLE, "UNIMPL sceKernelCancelMbx(%i, %i, %i)", uid, numSendThreads, numReceiveThreads);
RETURN(0);
}
void sceKernelReferMbxStatus()
{
SceUInt uid = PARAM(0);
u32 mbxStatusAddr = PARAM(1);
ERROR_LOG(HLE, "sceKernelReferMbxStatus(%i, %08x)", uid, mbxStatusAddr);
u32 error;
Mbx *mp = kernelObjects.Get<Mbx>(uid, error);
if (mp)
Mbx *m = kernelObjects.Get<Mbx>(id, error);
NativeMbxPacket *addPacket = (NativeMbxPacket*)Memory::GetPointer(packetAddr);
if (addPacket == 0)
{
Memory::WriteStruct(mbxStatusAddr, &mp->nmb);
ERROR_LOG(HLE, "sceKernelSendMbx(%i, %08x): invalid packet address", id, packetAddr);
RETURN(-1);
return;
}
if (!m)
{
ERROR_LOG(HLE, "sceKernelSendMbx(%i, %08x): invalid mbx id", id, packetAddr);
RETURN(error);
return;
}
if (m->waitingThreads.empty())
{
DEBUG_LOG(HLE, "sceKernelSendMbx(%i, %08x): no threads currently waiting, adding message to queue", id, packetAddr);
if (m->nmb.attr & SCE_KERNEL_MBA_MSPRI)
{
for (std::vector<u32>::iterator it = m->messageQueue.begin(); it != m->messageQueue.end(); it++)
{
NativeMbxPacket *p = (NativeMbxPacket*)Memory::GetPointer(*it);
if (addPacket->priority >= p->priority)
{
m->messageQueue.insert(it, packetAddr);
break;
}
}
}
else
{
m->messageQueue.push_back(packetAddr);
}
RETURN(0);
}
else if (m->messageQueue.empty())
{
Memory::Write_U32(packetAddr, m->waitingThreads.front().second);
__KernelResumeThreadFromWait(m->waitingThreads.front().first);
DEBUG_LOG(HLE, "sceKernelSendMbx(%i, %08x): threads waiting, resuming %d", id, packetAddr, m->waitingThreads.front().first);
m->waitingThreads.erase(m->waitingThreads.begin());
RETURN(0);
__KernelReSchedule();
}
else
{
ERROR_LOG(HLE, "sceKernelSendMbx(%i, %08x): WTF!? thread waiting while there is a message in the queue?", id, packetAddr);
RETURN(-1);
}
}
void sceKernelReceiveMbx(SceUID id, u32 packetAddrPtr, u32 timeoutPtr)
{
u32 error;
Mbx *m = kernelObjects.Get<Mbx>(id, error);
if (!m)
{
ERROR_LOG(HLE, "sceKernelReceiveMbx(%i, %08x, %08x): invalid mbx id", id, packetAddrPtr, timeoutPtr);
RETURN(error);
return;
}
if (!m->messageQueue.empty())
{
DEBUG_LOG(HLE, "sceKernelReceiveMbx(%i, %08x, %08x): sending first queue message", id, packetAddrPtr, timeoutPtr);
Memory::Write_U32(m->messageQueue.front(), packetAddrPtr);
m->messageQueue.erase(m->messageQueue.begin());
RETURN(0);
}
else
{
RETURN(error);
DEBUG_LOG(HLE, "sceKernelReceiveMbx(%i, %08x, %08x): no message in queue, waiting", id, packetAddrPtr, timeoutPtr);
m->AddWaitingThread(__KernelGetCurThread(), packetAddrPtr);
RETURN(0);
__KernelWaitCurThread(WAITTYPE_MBX, 0, 0, 0, false); // ?
}
}
void sceKernelReceiveMbxCB(SceUID id, u32 packetAddrPtr, u32 timeoutPtr)
{
u32 error;
Mbx *m = kernelObjects.Get<Mbx>(id, error);
__KernelCheckCallbacks();
if (!m)
{
ERROR_LOG(HLE, "sceKernelReceiveMbxCB(%i, %08x, %08x): invalid mbx id", id, packetAddrPtr, timeoutPtr);
RETURN(error);
return;
}
if (!m->messageQueue.empty())
{
DEBUG_LOG(HLE, "sceKernelReceiveMbxCB(%i, %08x, %08x): sending first queue message", id, packetAddrPtr, timeoutPtr);
Memory::Write_U32(m->messageQueue.front(), packetAddrPtr);
m->messageQueue.erase(m->messageQueue.begin());
RETURN(0);
}
else
{
DEBUG_LOG(HLE, "sceKernelReceiveMbxCB(%i, %08x, %08x): no message in queue, waiting", id, packetAddrPtr, timeoutPtr);
m->AddWaitingThread(id, packetAddrPtr);
RETURN(0);
__KernelWaitCurThread(WAITTYPE_MBX, 0, 0, 0, true); // ?
}
}
int sceKernelPollMbx(SceUID id, u32 packetAddrPtr)
{
u32 error;
Mbx *m = kernelObjects.Get<Mbx>(id, error);
if (!m)
{
ERROR_LOG(HLE, "sceKernelPollMbx(%i, %08x): invalid mbx id", id, packetAddrPtr);
return error;
}
if (!m->messageQueue.empty())
{
DEBUG_LOG(HLE, "sceKernelPollMbx(%i, %08x): sending first queue message", id, packetAddrPtr);
Memory::Write_U32(m->messageQueue.front(), packetAddrPtr);
m->messageQueue.erase(m->messageQueue.begin());
return 0;
}
else
{
DEBUG_LOG(HLE, "SCE_KERNEL_ERROR_MBOX_NOMSG=sceKernelPollMbx(%i, %08x): no message in queue", id, packetAddrPtr);
return SCE_KERNEL_ERROR_MBOX_NOMSG;
}
}
int sceKernelCancelReceiveMbx(SceUID id, u32 numWaitingThreadsAddr)
{
u32 error;
Mbx *m = kernelObjects.Get<Mbx>(id, error);
int *numWaitingThreads = (int*)Memory::GetPointer(numWaitingThreadsAddr);
if (!m)
{
ERROR_LOG(HLE, "sceKernelCancelReceiveMbx(%i, %08x): invalid mbx id", id, numWaitingThreadsAddr);
return error;
}
u32 count = m->waitingThreads.size();
DEBUG_LOG(HLE, "sceKernelCancelReceiveMbx(%i, %08x): cancelling %d threads", id, numWaitingThreadsAddr, count);
for (size_t i = 0; i < m->waitingThreads.size(); i++)
{
Memory::Write_U32(0, m->waitingThreads[i].second);
__KernelResumeThreadFromWait(m->waitingThreads[i].first);
}
m->waitingThreads.clear();
if (numWaitingThreads)
*numWaitingThreads = count;
return 0;
}
int sceKernelReferMbxStatus(SceUID id, u32 infoAddr)
{
u32 error;
Mbx *m = kernelObjects.Get<Mbx>(id, error);
if (!m)
{
ERROR_LOG(HLE, "sceKernelReferMbxStatus(%i, %08x): invalid mbx id", id, infoAddr);
return error;
}
SceKernelMbxInfo *info = (SceKernelMbxInfo*)Memory::GetPointer(infoAddr);
DEBUG_LOG(HLE, "sceKernelReferMbxStatus(%i, %08x)", id, infoAddr);
if (info)
{
strncpy(info->name, m->nmb.name, 32);
info->attr = m->nmb.attr;
info->numWaitThreads = m->waitingThreads.size();
info->numMessage = m->messageQueue.size();
// Fill the 'next' parameter of packets which we don't use by default but could be used by a game
if (m->messageQueue.size() != 0)
{
info->topPacketAddr = m->messageQueue[0];
for (u32 i = 0; i < m->messageQueue.size() - 1; i++)
{
Memory::Write_U32(m->messageQueue[i + 1], Memory::Read_U32(m->messageQueue[i]));
}
Memory::Write_U32(m->messageQueue[m->messageQueue.size() - 1], 0);
}
else
{
info->topPacketAddr = 0;
}
}
else
{
return -1;
}
return 0;
}

34
Core/HLE/sceKernelMbx.h
View File

@ -17,11 +17,29 @@
#pragma once
void sceKernelCreateMbx();
void sceKernelDeleteMbx();
void sceKernelSendMbx();
void sceKernelReceiveMbx();
void sceKernelReceiveMbxCB();
void sceKernelPollMbx();
void sceKernelCancelReceiveMbx();
void sceKernelReferMbxStatus();
struct NativeMbxPacket
{
u32 next;
u8 priority;
u8 padding[3];
};
struct SceKernelMbxInfo
{
SceSize size;
char name[KERNELOBJECT_MAX_NAME_LENGTH+1];
SceUInt attr;
int numWaitThreads;
int numMessage;
u32 topPacketAddr;
};
SceUID sceKernelCreateMbx(const char *name, int memoryPartition, SceUInt attr, int size, u32 optAddr);
int sceKernelDeleteMbx(SceUID id);
void sceKernelSendMbx(SceUID id, u32 addPacketAddr);
void sceKernelReceiveMbx(SceUID id, u32 packetAddrPtr, u32 timeoutPtr);
void sceKernelReceiveMbxCB(SceUID id, u32 packetAddrPtr, u32 timeoutPtr);
int sceKernelPollMbx(SceUID id, u32 packetAddrPtr);
int sceKernelCancelReceiveMbx(SceUID id, u32 numWaitingThreadsAddr);
int sceKernelReferMbxStatus(SceUID id, u32 infoAddr);

2
Core/HLE/sceKernelMemory.cpp
View File

@ -349,7 +349,7 @@ public:
PartitionMemoryBlock(BlockAllocator *_alloc, u32 size, bool fromEnd)
{
alloc = _alloc;
address = alloc->Alloc(size, fromEnd);
address = alloc->Alloc(size, fromEnd, "PMB");
alloc->ListBlocks();
}
~PartitionMemoryBlock()

9
Core/HLE/sceKernelThread.cpp
View File

@ -1103,6 +1103,15 @@ void sceKernelDelayThread()
__KernelWaitCurThread(WAITTYPE_DELAY, curThread, 0, 0, false);
}
u32 __KernelGetThreadPrio(SceUID id)
{
u32 error;
Thread *thread = kernelObjects.Get<Thread>(id, error);
if (thread)
return thread->nt.currentPriority;
return 0;
}
//////////////////////////////////////////////////////////////////////////
// WAIT/SLEEP ETC
//////////////////////////////////////////////////////////////////////////

1
Core/HLE/sceKernelThread.h
View File

@ -133,6 +133,7 @@ SceUID __KernelGetCurThread();
void __KernelSetupRootThread(SceUID moduleId, int args, const char *argp, int prio, int stacksize, int attr); //represents the real PSP elf loader, run before execution
void __KernelStartIdleThreads();
void __KernelReturnFromThread(); // Called as HLE function
u32 __KernelGetThreadPrio(SceUID id);
void _sceKernelIdle();

3
Core/MIPS/MIPSIntVFPU.cpp
View File

@ -1124,8 +1124,9 @@ namespace MIPSInt
case VC_GE: c = s[i] >= t[i]; break;
case VC_NZ: c = s[i] != 0; break;
case VC_ES: c = (s[i] != s[i]) || (s[i] == std::numeric_limits<float>::infinity()); break; // Tekken Dark Resurrection
case VC_EN: c = isnan(s[i]); break;
default:
_dbg_assert_msg_(CPU,0,"Unsupported vcmp condition code"); //, cond);
_dbg_assert_msg_(CPU,0,"Unsupported vcmp condition code %d", cond);
return;
}
cc |= (c<<i);

1
Globals.h
View File

@ -20,6 +20,7 @@
#include <cstdio>
#include <vector>
#include <string>
#include <utility>
#include "Log.h"