void button_callback(int curr, int last, void *arg)
{
if((curr & TRIGGER) == TRIGGER)
{
sceKernelSetEventFlag(g_eventflag, START_MENU);
}
}
s32 sceUmdModuleStart(s32 argc, void *argp)
{
s32 intrState;
(void)argc;
(void)argp;
memset(&g_mediaMan, 0, sizeof g_mediaMan);
// TODO: Check assignment order; might be :DMU
g_umdFileSystem[0] = 'U';
g_umdFileSystem[1] = 'M';
g_umdFileSystem[2] = 'D';
g_umdFileSystem[3] = ':';
g_eventId = sceKernelCreateEventFlag("SceMediaManUser", SCE_KERNEL_EA_MULTI | 0x1, 0, NULL);
if (g_eventId < 0)
return SCE_KERNEL_NO_RESIDENT;
g_isAssigned = SCE_UMD_DEVICE_NOT_ASSIGNED;
intrState = sceKernelCpuSuspendIntr();
g_driveState |= SCE_UMD_MEDIA_OUT;
sceKernelSetEventFlag(g_eventId, 1);
sceKernelCpuResumeIntr(intrState);
return SCE_KERNEL_RESIDENT;
}
static int waitTestFunc(SceSize argSize, void* argPointer) {
sceKernelDelayThread(1000);
SCHED_LOG(C, 2);
schedulingResult = sceKernelSetEventFlag(*(int*) argPointer, 0xFFFFFFFF);
SCHED_LOG(D, 2);
return 0;
}
// Read out the interrupt state and clear it
static int intr_handler(void *arg) {
u32 stat;
stat = _lw(0xBE500040);
_sw(stat, 0xBE500044);
sceKernelDisableIntr(PSP_HPREMOTE_INT);
sceKernelSetEventFlag(g_eventflag, EVENT_SIO);
return -1;
}
//Subroutine sceUmd_982272FE - Address 0x00000444
void sceUmdSetDriveStatus(s32 state)
{
s32 intrState;
intrState = sceKernelCpuSuspendIntr();
g_driveState |= state;
sceKernelSetEventFlag(g_eventId, state);
sceKernelCpuResumeIntr(intrState);
}
static void PutCharDebug(unsigned short *data, unsigned int type)
{
int total = 0;
if((type & 0xFF00) == 0)
{
if((type == '\n') || (type == '\r') || (type >= 32))
{
total = add_char((unsigned char) type);
}
}
/* If we receive end of string or the buffer is full signal */
if((type == 0x201) || (total == KPRINTF_BUF_SIZE))
{
/* Set event flag */
sceKernelSetEventFlag(g_eventflag, KPRINTF_EVENT);
}
}
int interruptHandler(int a0 __attribute__((unused)), int SceMediaEngineRpcWait)
{
sceKernelSetEventFlag(SceMediaEngineRpcWait, 1);
return -1;
}
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);
);
