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)); }
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; }
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 initRpc() { meRpc.mutex = sceKernelCreateMutex("SceMediaEngineRpc", 0x101, 0, 0); if (meRpc.mutex < 0) return meRpc.mutex; meRpc.sema = sceKernelCreateSema("SceMediaEngineAvcPower" , 0x101, 1, 1, 0); if (meRpc.sema < 0) return meRpc.sema; meRpc.event = sceKernelCreateEventFlag("SceMediaEngineRpcWait", 0x201, 0, 0); if (meRpc.event < 0) return meRpc.event; sceSysregIntrEnd(); int ret = sceKernelRegisterIntrHandler(SCE_MECODEC_INT, 2, (void*)&interruptHandler, (void*)meRpc.event, 0); if (ret < 0) return ret; return sceKernelEnableIntr(SCE_MECODEC_INT); }
int main(int argc, char **argv) { SceUID flag = sceKernelCreateEventFlag("refer1", 0, 0, NULL); SceKernelEventFlagInfo flaginfo; // Crashes. //REFER_TEST("NULL info", flag, NULL); REFER_TEST("Normal", flag, &flaginfo); sceKernelDeleteEventFlag(flag); REFER_TEST("NULL", 0, &flaginfo); REFER_TEST("Invalid", 0xDEADBEEF, &flaginfo); REFER_TEST("Deleted", flag, &flaginfo); BASIC_SCHED_TEST("NULL", result = sceKernelReferEventFlagStatus(NULL, &flaginfo); );
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; }
void sceGuInit(void) { PspGeCallbackData callback; callback.signal_func = callbackSig; callback.signal_arg = &gu_settings; callback.finish_func = callbackFin; callback.finish_arg = &gu_settings; gu_settings.ge_callback_id = sceGeSetCallback(&callback); gu_settings.swapBuffersCallback = 0; gu_settings.swapBuffersBehaviour = PSP_DISPLAY_SETBUF_IMMEDIATE; ge_edram_address = sceGeEdramGetAddr(); // initialize graphics hardware ge_list_executed[0] = sceGeListEnQueue((void*)((unsigned int)ge_init_list & 0x1fffffff),0,gu_settings.ge_callback_id,0); resetValues(); gu_settings.kernel_event_flag = sceKernelCreateEventFlag("SceGuSignal",512,3,0); // wait for init to complete sceGeListSync(ge_list_executed[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); );
int main_thread(SceSize args, void *argp) { int ret; int intc; unsigned char *plow, *phigh; int low, high; memset(g_buf, 0, KPRINTF_BUF_SIZE); g_writepos = 0; g_readpos = 0; g_total = 0; plow = NULL; phigh = NULL; g_eventflag = sceKernelCreateEventFlag("UsbKprintfEvent", 0, 0, 0); if(g_eventflag < 0) { printf("Error creating event flag %08X\n", g_eventflag); } sceKernelRegisterDebugPutchar(PutCharDebug); while(1) { ret = sceKernelWaitEventFlag(g_eventflag, KPRINTF_EVENT, 0x21, 0, 0); if(ret < 0) { sceKernelExitDeleteThread(0); } low = 0; high = 0; intc = pspSdkDisableInterrupts(); if(g_total > 0) { plow = &g_buf[g_readpos]; low = (KPRINTF_BUF_SIZE - g_readpos) < g_total ? (KPRINTF_BUF_SIZE - g_readpos) : g_total ; if(low < g_total) { phigh = g_buf; high = g_total - low; } } pspSdkEnableInterrupts(intc); if((low != 0) && (high == 0)) { printf("%.*s", low, plow); } else if((low != 0) && (high != 0)) { printf("%.*s%.*s", low, plow, high, phigh); } intc = pspSdkDisableInterrupts(); g_total -= (low+high); g_readpos += (low+high); g_readpos %= KPRINTF_BUF_SIZE; pspSdkEnableInterrupts(intc); } return 0; }