Emulation/ppsspp
1
0
Fork 0
mirror of https://github.com/hrydgard/ppsspp.git synced 2025-04-02 11:01:50 -04:00
Code Issues Projects Releases Packages Wiki Activity

Always create CoreTiming timers during kernel init.

Browse source
This commit is contained in:
Unknown W. Brackets 2012-12-23 21:27:26 -08:00
parent 65cfc8de86
commit 9ba0ed46fd
13 changed files with 38 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
Core/HLE/sceCtrl.cpp
View file

@ -62,7 +62,6 @@ struct CtrlLatch {
//////////////////////////////////////////////////////////////////////////
// STATE BEGIN
static bool ctrlInited = false;
static bool analogEnabled = false;
static int ctrlLatchBufs = 0;
static u32 ctrlOldButtons = 0;
@ -259,13 +258,15 @@ void __CtrlTimerUpdate(u64 userdata, int cyclesLate)
void __CtrlInit()
{
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
ctrlTimer = CoreTiming::RegisterEvent("CtrlSampleTimer", __CtrlTimerUpdate);
__DisplayListenVblank(__CtrlVblank);
waitingThreads.clear();
if (!ctrlInited)
{
__DisplayListenVblank(__CtrlVblank);
ctrlInited = true;
}
ctrlIdleReset = -1;
ctrlIdleBack = -1;
ctrlCycle = 0;
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
ctrlBuf = 1;
ctrlBufRead = 0;
@ -282,14 +283,6 @@ void __CtrlInit()
for (int i = 0; i < NUM_CTRL_BUFFERS; i++)
memcpy(&ctrlBufs[i], &ctrlCurrent, sizeof(_ctrl_data));
ctrlIdleReset = -1;
ctrlIdleBack = -1;
ctrlCycle = 0;
waitingThreads.clear();
ctrlTimer = CoreTiming::RegisterEvent("CtrlSampleTimer", __CtrlTimerUpdate);
}
u32 sceCtrlSetSamplingCycle(u32 cycle)

6
Core/HLE/sceKernel.cpp
View file

@ -78,6 +78,10 @@ void __KernelInit()
__KernelMemoryInit();
__KernelThreadingInit();
__KernelMutexInit();
__KernelSemaInit();
__KernelAlarmInit();
__KernelEventFlagInit();
__KernelMbxInit();
__IoInit();
__AudioInit();
__SasInit();
@ -115,8 +119,8 @@ void __KernelShutdown()
__AudioShutdown();
__IoShutdown();
__InterruptsShutdown();
__KernelThreadingShutdown();
__KernelMutexShutdown();
__KernelThreadingShutdown();
__KernelMemoryShutdown();
CoreTiming::ClearPendingEvents();

20
Core/HLE/sceKernelAlarm.cpp
View file

@ -78,17 +78,7 @@ public:
Alarm *alarm;
};
bool alarmInitComplete = false;
int alarmTimer = 0;
void __KernelTriggerAlarm(u64 userdata, int cyclesLate);
void __KernelAlarmInit()
{
alarmTimer = CoreTiming::RegisterEvent("Alarm", __KernelTriggerAlarm);
alarmInitComplete = true;
}
static int alarmTimer = 0;
void __KernelTriggerAlarm(u64 userdata, int cyclesLate)
{
@ -100,6 +90,11 @@ void __KernelTriggerAlarm(u64 userdata, int cyclesLate)
__TriggerInterrupt(PSP_INTR_IMMEDIATE, PSP_SYSTIMER0_INTR, uid);
}
void __KernelAlarmInit()
{
alarmTimer = CoreTiming::RegisterEvent("Alarm", __KernelTriggerAlarm);
}
void __KernelScheduleAlarm(Alarm *alarm, u64 ticks)
{
alarm->alm.schedule = (CoreTiming::GetTicks() + ticks) / (u64) CoreTiming::GetClockFrequencyMHz();
@ -108,9 +103,6 @@ void __KernelScheduleAlarm(Alarm *alarm, u64 ticks)
SceUID __KernelSetAlarm(u64 ticks, u32 handlerPtr, u32 commonPtr)
{
if (!alarmInitComplete)
__KernelAlarmInit();
if (!Memory::IsValidAddress(handlerPtr))
return SCE_KERNEL_ERROR_ILLEGAL_ADDR;

4
Core/HLE/sceKernelAlarm.h
View file

@ -20,4 +20,6 @@
SceUID sceKernelSetAlarm(SceUInt clock, u32 handlerPtr, u32 commonPtr);
SceUID sceKernelSetSysClockAlarm(u32 sysClockPtr, u32 handlerPtr, u32 commonPtr);
int sceKernelCancelAlarm(SceUID uid);
int sceKernelReferAlarmStatus(SceUID uid, u32 infoPtr);
int sceKernelReferAlarmStatus(SceUID uid, u32 infoPtr);
void __KernelAlarmInit();

5
Core/HLE/sceKernelEventFlag.cpp
View file

@ -90,13 +90,11 @@ enum PspEventFlagWaitTypes
PSP_EVENT_WAITKNOWN = PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITCLEARALL | PSP_EVENT_WAITOR,
};
bool eventFlagInitComplete = false;
int eventFlagWaitTimer = 0;
void __KernelEventFlagInit()
{
eventFlagWaitTimer = CoreTiming::RegisterEvent("EventFlagTimeout", &__KernelEventFlagTimeout);
eventFlagInitComplete = true;
}
bool __KernelEventFlagMatches(u32 *pattern, u32 bits, u8 wait, u32 outAddr)
@ -168,9 +166,6 @@ bool __KernelClearEventFlagThreads(EventFlag *e, int reason)
//SceUID sceKernelCreateEventFlag(const char *name, int attr, int bits, SceKernelEventFlagOptParam *opt);
int sceKernelCreateEventFlag(const char *name, u32 flag_attr, u32 flag_initPattern, u32 optPtr)
{
if (!eventFlagInitComplete)
__KernelEventFlagInit();
if (!name)
{
WARN_LOG(HLE, "%08x=sceKernelCreateEventFlag(): invalid name", SCE_KERNEL_ERROR_ERROR);

2
Core/HLE/sceKernelEventFlag.h
View file

@ -26,3 +26,5 @@ int sceKernelWaitEventFlagCB(SceUID id, u32 bits, u32 wait, u32 outBitsPtr, u32
int sceKernelPollEventFlag(SceUID id, u32 bits, u32 wait, u32 outBitsPtr, u32 timeoutPtr);
u32 sceKernelReferEventFlagStatus(SceUID id, u32 statusPtr);
u32 sceKernelCancelEventFlag(SceUID uid, u32 pattern, u32 numWaitThreadsPtr);
void __KernelEventFlagInit();

8
Core/HLE/sceKernelMbx.cpp
View file

@ -30,8 +30,7 @@ const int PSP_MBX_ERROR_DUPLICATE_MSG = 0x800201C9;
typedef std::pair<SceUID, u32> MbxWaitingThread;
void __KernelMbxTimeout(u64 userdata, int cyclesLate);
bool mbxInitComplete = false;
int mbxWaitTimer = 0;
static int mbxWaitTimer = 0;
struct NativeMbx
{
@ -162,8 +161,6 @@ struct Mbx : public KernelObject
void __KernelMbxInit()
{
mbxWaitTimer = CoreTiming::RegisterEvent("MbxTimeout", &__KernelMbxTimeout);
mbxInitComplete = true;
}
bool __KernelUnlockMbxForThread(Mbx *m, MbxWaitingThread &th, u32 &error, int result, bool &wokeThreads)
@ -263,9 +260,6 @@ std::vector<MbxWaitingThread>::iterator __KernelMbxFindPriority(std::vector<MbxW
SceUID sceKernelCreateMbx(const char *name, u32 attr, u32 optAddr)
{
if (!mbxInitComplete)
__KernelMbxInit();
if (!name)
{
WARN_LOG(HLE, "%08x=%s(): invalid name", SCE_KERNEL_ERROR_ERROR, __FUNCTION__);

2
Core/HLE/sceKernelMbx.h
View file

@ -32,3 +32,5 @@ int 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);
void __KernelMbxInit();

6
Core/HLE/sceKernelMutex.cpp
View file

@ -107,11 +107,11 @@ struct LwMutex : public KernelObject
std::vector<SceUID> waitingThreads;
};
int mutexWaitTimer = 0;
int lwMutexWaitTimer = 0;
static int mutexWaitTimer = 0;
static int lwMutexWaitTimer = 0;
// Thread -> Mutex locks for thread end.
typedef std::multimap<SceUID, SceUID> MutexMap;
MutexMap mutexHeldLocks;
static MutexMap mutexHeldLocks;
void __KernelMutexInit()
{

7
Core/HLE/sceKernelSemaphore.cpp
View file

@ -61,13 +61,11 @@ struct Semaphore : public KernelObject
std::vector<SceUID> waitingThreads;
};
bool semaInitComplete = false;
int semaWaitTimer = 0;
static int semaWaitTimer = 0;
void __KernelSemaInit()
{
semaWaitTimer = CoreTiming::RegisterEvent("SemaphoreTimeout", &__KernelSemaTimeout);
semaInitComplete = true;
}
// Returns whether the thread should be removed.
@ -173,9 +171,6 @@ int sceKernelCancelSema(SceUID id, int newCount, u32 numWaitThreadsPtr)
//SceUID sceKernelCreateSema(const char *name, SceUInt attr, int initVal, int maxVal, SceKernelSemaOptParam *option);
int sceKernelCreateSema(const char* name, u32 attr, int initVal, int maxVal, u32 optionPtr)
{
if (!semaInitComplete)
__KernelSemaInit();
if (!name)
{
WARN_LOG(HLE, "%08x=sceKernelCreateSema(): invalid name", SCE_KERNEL_ERROR_ERROR);

2
Core/HLE/sceKernelSemaphore.h
View file

@ -27,3 +27,5 @@ int sceKernelWaitSema(SceUID semaid, int signal, u32 timeoutPtr);
int sceKernelWaitSemaCB(SceUID semaid, int signal, u32 timeoutPtr);
void __KernelSemaTimeout(u64 userdata, int cycleslate);
void __KernelSemaInit();

1
Core/HLE/sceKernelThread.cpp
View file

@ -435,6 +435,7 @@ void __KernelThreadingShutdown()
{
kernelMemory.Free(threadReturnHackAddr);
threadqueue.clear();
threadEndListeners.clear();
threadReturnHackAddr = 0;
cbReturnHackAddr = 0;
currentThread = 0;

8
Core/HLE/sceUmd.cpp
View file

@ -47,8 +47,11 @@ struct PspUmdInfo {
u32 type;
};
void __UmdStatTimeout(u64 userdata, int cyclesLate);
void __UmdInit() {
void __UmdInit()
{
umdStatTimer = CoreTiming::RegisterEvent("UmdTimeout", &__UmdStatTimeout);
umdActivated = 1;
umdStatus = 0;
umdErrorStat = 0;
@ -214,9 +217,6 @@ void __UmdStatTimeout(u64 userdata, int cyclesLate)
void __UmdWaitStat(u32 timeout)
{
if (umdStatTimer == 0)
umdStatTimer = CoreTiming::RegisterEvent("UmdTimeout", &__UmdStatTimeout);
// This happens to be how the hardware seems to time things.
if (timeout <= 4)
timeout = 15;