void checkEventFlag(int doDispatch) {
SceUID flag = sceKernelCreateEventFlag("eventflag", 0, 0xFFFFFFFF, NULL);
dispatchCheckpoint("sceKernelCreateEventFlag: %08x", flag >= 0 ? 1 : flag);
dispatchCheckpoint("sceKernelClearEventFlag: %08x", sceKernelClearEventFlag(flag, 1));
dispatchCheckpoint("sceKernelWaitEventFlag: %08x", sceKernelWaitEventFlag(flag, 1, PSP_EVENT_WAITAND, NULL, NULL));
dispatchCheckpoint("sceKernelWaitEventFlag invalid: %08x", sceKernelWaitEventFlag(flag, 0, 0, NULL, NULL));
dispatchCheckpoint("sceKernelDeleteEventFlag: %08x", sceKernelDeleteEventFlag(flag));
flag = sceKernelCreateEventFlag("test", 0, 0xFFFFFFFF, NULL);
dispatchCheckpoint("sceKernelCreateEventFlag: %08x", flag >= 0 ? 1 : flag);
startLockThreadEventFlag(flag);
int state;
if (doDispatch) {
++ignoreResched;
state = sceKernelSuspendDispatchThread();
dispatchCheckpoint("sceKernelSuspendDispatchThread: %08x", state);
}
SceUInt timeout = 300;
dispatchCheckpoint("sceKernelWaitEventFlag: %08x", sceKernelWaitEventFlag(flag, 1, PSP_EVENT_WAITAND, NULL, &timeout));
dispatchCheckpoint("sceKernelClearEventFlag: %08x", sceKernelClearEventFlag(flag, 1));
if (doDispatch) {
dispatchCheckpoint("sceKernelResumeDispatchThread: %08x", sceKernelResumeDispatchThread(state));
--ignoreResched;
}
endLockThreadEventFlag(flag);
dispatchCheckpoint("sceKernelPollEventFlag: %08x", sceKernelPollEventFlag(flag, 1, PSP_EVENT_WAITAND, NULL));
dispatchCheckpoint("sceKernelDeleteEventFlag: %08x", sceKernelDeleteEventFlag(flag));
}
int sub_16389()
{
volatile int *hwAddress = (int*)0xbfc00700;
*hwAddress = -1;
int* meTable = (int*)0xbfc00600;
meTable[0] = 399;//copy sceKernelGetMEeDramSaveSize() bytes on me main memory to sceKernelGetMEeDramSaveAddr() then halt me
meTable[2] = sceKernelGetMEeDramSaveAddr();
meTable[3] = sceKernelGetMEeDramSaveSize();
meTable[4] = 0;
meTable[5] = 0;
meTable[6] = 0;
meTable[7] = 0;
meTable[8] = 0;
meTable[9] = 0;
sceDdrFlush(5);
sceSysregInterruptToOther();
while (*hwAddress != -2)
;
sceDdrFlush(8);
sceSysregMeResetEnable();
sceSysregMeBusClockDisable();
*(int*)0xbfc00718 = *(int*)0xbc100070 & 4;
sceKernelClearEventFlag(meRpc.event, 0);
return 0;
}
int lockThreadEventFlag(SceSize argc, void *argp) {
SceUID flag = *(SceUID *)argp;
dispatchCheckpoint("T sceKernelWaitEventFlag: %08x", sceKernelWaitEventFlag(flag, 3, PSP_EVENT_WAITAND, NULL, NULL));
dispatchCheckpoint("T sceKernelDelayThread: %08x", sceKernelDelayThread(3000));
dispatchCheckpoint("T sceKernelClearEventFlag: %08x", sceKernelClearEventFlag(flag, 1));
return 0;
}
static void testClear(const char *title, SceUID flag, u32 bits) {
int result = sceKernelClearEventFlag(flag, bits);
if (result == 0) {
printf("%s: OK\n", title);
} else {
printf("%s: Failed (%X)\n", title, result);
}
PRINT_FLAG(flag);
}
//Subroutine sceUmd_6EDF57F1 - Address 0x000003E8
void sceUmdClearDriveStatus(s32 state)
{
s32 intrState;
intrState = sceKernelCpuSuspendIntr();
sceKernelClearEventFlag(g_eventId, ~state);
g_driveState &= (~state);
sceKernelCpuResumeIntr(intrState);
}
int main_thread(SceSize args, void *argp)
{
SceUID block_id;
void *vram;
block_id = sceKernelAllocPartitionMemory(4, "debugmenu", PSP_SMEM_Low, 512*272*2, NULL);
if(block_id < 0)
{
Kprintf("Error could not allocate memory buffer 0x%08X\n", block_id);
goto error;
}
vram = (void*) (0xA0000000 | (unsigned int) sceKernelGetBlockHeadAddr(block_id));
g_eventflag = sceKernelCreateEventFlag("DebugMenuEvent", 0, 0, NULL);
if(g_eventflag < 0)
{
Kprintf("Could not create event flag %08X\n", g_eventflag);
goto error;
}
//sceCtrlRegisterButtonCallback(0, PSP_CTRL_HOME, button_callback, NULL);
sceCtrlRegisterButtonCallback(3, TRIGGER, button_callback, NULL);
while(1)
{
unsigned int bits;
if(sceKernelWaitEventFlag(g_eventflag, START_MENU,
PSP_EVENT_WAITOR | PSP_EVENT_WAITCLEAR, &bits, NULL) < 0)
{
break;
}
sceCtrlSetButtonMasks(0xFFFF, 1); // Mask lower 16bits
sceCtrlSetButtonMasks(0x10000, 2); // Always return HOME key
sceDisplaySetFrameBufferInternal(0, vram, 512, 0, 1);
pspDebugScreenInitEx(vram, 0, 0);
do_menu();
sceDisplaySetFrameBufferInternal(0, 0, 512, 0, 1);
sceCtrlSetButtonMasks(0x10000, 0); // Unset HOME key
sceCtrlSetButtonMasks(0xFFFF, 0); // Unset mask
sceKernelClearEventFlag(g_eventflag, ~START_MENU);
}
error:
sceKernelExitDeleteThread(0);
return 0;
}
int main(int argc, char **argv) {
SceUID flag = sceKernelCreateEventFlag("set", 0, 0, NULL);
PRINT_FLAG(flag);
testClear("Basic 0x2", flag, 0x2);
testClear("Basic 0x1", flag, 0x1);
testClear("Basic 0x1", flag, 0x1);
testClear("Basic 0xF000", flag, 0xF000);
testClear("Zero", flag, 0);
sceKernelDeleteEventFlag(flag);
flag = sceKernelCreateEventFlag("signal", 0, 0xFFFFFFFE, NULL);
PRINT_FLAG(flag);
testClear("All but 0x1 + 0x1", flag, 0x1);
sceKernelDeleteEventFlag(flag);
testClear("NULL", 0, 1);
testClear("Invalid", 0xDEADBEEF, 1);
testClear("Deleted", flag, 1);
BASIC_SCHED_TEST("NULL",
result = sceKernelClearEventFlag(0, 0);
);
int main(int argc, char *argv[])
{
SceCtrlData pad;
int result;
int oldButtons = 0;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
printf("Triangle - Exit\n");
printf("Square - Set lower 16-bits\n");
printf("Circle - Clear lower 16-bits\n");
printf("Cross - Delay + refer status\n");
printf("R-Trigger - Cancel event flag\n\n");
printf("L-Trigger - Delete event flag\n\n");
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
evid = sceKernelCreateEventFlag("test_ef", PSP_EVENT_WAITMULTIPLE, INITIAL_PATTERN, 0);
//evid = sceKernelCreateEventFlag("test_ef", 0, INITIAL_PATTERN, 0);
printf("EVID: %08x pattern %08x\n", evid, INITIAL_PATTERN);
if (evid >= 0)
{
createStartThread("and", and_thread);
createStartThread("or", or_thread);
createStartThread("clear", clear_thread);
#if 0
// testing context switch timing
sceKernelSetEventFlag(evid, 0x0000FFFF);
//int buf[64]; for(;;) sceCtrlReadLatch(buf); // sceCtrlReadLatch does not context switch
for(;;) sceKernelDelayThread(0); // does not wait forever
#else
while(!done)
{
sceCtrlReadBufferPositive(&pad, 1); // context switch in here
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (buttonDown & PSP_CTRL_SQUARE)
{
result = sceKernelSetEventFlag(evid, 0x0000FFFF);
printf("\nsceKernelSetEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
//result = sceKernelClearEventFlag(evid, 0x0000FFFF); // bits to clear - bad
result = sceKernelClearEventFlag(evid, 0xFFFF0000); // bits to keep - ok
printf("\nsceKernelClearEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_CROSS)
{
printf("\nsceKernelDelayThreadCB ...\n");
sceKernelDelayThreadCB(1000);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_RTRIGGER)
{
//result = sceKernelCancelEventFlag(evid, newPattern, addr);
result = sceKernelCancelEventFlag(evid, INITIAL_PATTERN, 0);
printf("sceKernelCancelEventFlag result %08x\n", result);
printSceKernelEventFlagInfo(evid);
}
if (buttonDown & PSP_CTRL_LTRIGGER)
{
//result = sceKernelCancelEventFlag(evid, newPattern, addr);
result = sceKernelDeleteEventFlag(evid);
printf("sceKernelDeleteEventFlag result %08x\n", result);
evid = 0;
}
if (buttonDown & PSP_CTRL_TRIANGLE)
done = 1;
oldButtons = pad.Buttons;
//sceKernelDelayThread(0); // ok, not infinite :)
}
#endif
}
else
{
printf("sceKernelCreateEventFlag failed %08x\n", evid);
sceKernelSleepThreadCB();
}
sceKernelExitGame();
return 0;
}
int main(int argc, char **argv) {
SceUID flag = sceKernelCreateEventFlag("wait1", 0, 0xFFFFFFFF, NULL);
SceKernelEventFlagInfo flaginfo;
// Something weird is happening: first time status is garbled?
sceKernelReferEventFlagStatus(flag, &flaginfo);
WAIT_TEST_SIMPLE("And 0x00000000", flag, 0, PSP_EVENT_WAITAND, 1);
WAIT_TEST_SIMPLE("Or 0x00000000", flag, 0, PSP_EVENT_WAITOR, 1);
WAIT_TEST_SIMPLE("Clear 0x00000000", flag, 0, PSP_EVENT_WAITCLEAR, 1);
WAIT_TEST_SIMPLE("Wrong (0x04) 0x00000000", flag, 0, 0x04, 1);
WAIT_TEST_SIMPLE("Wrong (0xFF) 0x00000000", flag, 0, 0xFF, 1);
WAIT_TEST_SIMPLE("And 0x00000001", flag, 1, PSP_EVENT_WAITAND, 1);
WAIT_TEST_SIMPLE("Or 0x00000001", flag, 1, PSP_EVENT_WAITOR, 1);
WAIT_TEST_SIMPLE("Clear 0x00000001", flag, 1, PSP_EVENT_WAITCLEAR, 1);
WAIT_TEST_SIMPLE("Wrong (0x02) 0x00000001", flag, 1, 0x02, 1);
WAIT_TEST_SIMPLE("Wrong (0x04) 0x00000001", flag, 1, 0x04, 1);
WAIT_TEST_SIMPLE("Wrong (0x08) 0x00000001", flag, 1, 0x08, 1);
WAIT_TEST_SIMPLE("Wrong (0x40) 0x00000001", flag, 1, 0x40, 1);
WAIT_TEST_SIMPLE("Wrong (0x80) 0x00000001", flag, 1, 0x80, 1);
WAIT_TEST_SIMPLE("Wrong (0xFF) 0x00000001", flag, 1, 0xFF, 1);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE("Clear/Or 0x00000000", flag, 0, PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITOR, 1);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE("Clear/Or 0x00000001", flag, 1, PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITOR, 1);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE("Clear/Or 0x00000001 (no out bits)", flag, 1, PSP_EVENT_WAITCLEAR | PSP_EVENT_WAITOR, 0);
sceKernelSetEventFlag(flag, 0xFFFFFFFF);
WAIT_TEST_SIMPLE_TIMEOUT("0xFFFFFFFF & 0x00000000", flag, 0x00000000, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0xFFFFFFFF & 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0xFFFFFFFF | 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR, 500);
sceKernelClearEventFlag(flag, 0x0000FFFF);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF & 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF | 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF & 0xFFFFFFFF with clear", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND | PSP_EVENT_WAITCLEAR, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF | 0xFFFFFFFF with clear", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR | PSP_EVENT_WAITCLEAR, 500);
sceKernelClearEventFlag(flag, 0x0000FFFF);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF & 0xFFFFFFFF with clear all", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND | PSP_EVENT_WAITCLEARALL, 500);
WAIT_TEST_SIMPLE_TIMEOUT("0x0000FFFF | 0xFFFFFFFF with clear all", flag, 0xFFFFFFFF, PSP_EVENT_WAITOR | PSP_EVENT_WAITCLEARALL, 500);
sceKernelClearEventFlag(flag, 0x00000000);
WAIT_TEST_SIMPLE_TIMEOUT("0x00000000 & 0xFFFFFFFF", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 500);
WAIT_TEST_SIMPLE_TIMEOUT("Zero timeout", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 0);
WAIT_TEST_SIMPLE_TIMEOUT("5ms timeout", flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, 5);
// Set off thread.
schedulingLogPos = 0;
schedulingPlacement = 1;
SCHED_LOG(A, 1);
SceUInt timeout = 5000;
SceUID thread = sceKernelCreateThread("waitTest", (void *)&waitTestFunc, 0x12, 0x10000, 0, NULL);
sceKernelStartThread(thread, sizeof(flag), &flag);
SCHED_LOG(B, 1);
int result = sceKernelWaitEventFlag(flag, 0xFFFFFFFF, PSP_EVENT_WAITAND, NULL, &timeout);
SCHED_LOG(E, 1);
printf("Wait timeout: %s (thread=%08X, main=%08X, remaining=%d)\n", schedulingLog, schedulingResult, result, (timeout + 5) / 1000);
sceKernelDeleteEventFlag(flag);
SceUID deleteThread = CREATE_SIMPLE_THREAD(deleteMeFunc);
flag = sceKernelCreateEventFlag("wait1", 0, 0x00000000, NULL);
sceKernelStartThread(deleteThread, sizeof(int), &flag);
sceKernelDelayThread(500);
sceKernelDeleteEventFlag(flag);
WAIT_TEST_SIMPLE("NULL", 0, 0, PSP_EVENT_WAITAND, 0);
WAIT_TEST_SIMPLE("Invalid", 0xDEADBEEF, 0, PSP_EVENT_WAITAND, 0);
WAIT_TEST_SIMPLE("Deleted", flag, 0, PSP_EVENT_WAITAND, 0);
BASIC_SCHED_TEST("NULL",
result = sceKernelWaitEventFlag(0, 0xFFFFFFFF, PSP_EVENT_WAITAND, NULL, NULL);
);
