int usleep(useconds_t usec)
{
unsigned long delay;
delay = MIN(usec, 0xffffffffUL);
sceKernelDelayThreadCB(delay);
return 0;
}
void SDL_Delay(Uint32 ms)
{
const Uint32 max_delay = 0xffffffffUL / 1000;
if(ms > max_delay)
ms = max_delay;
sceKernelDelayThreadCB(ms * 1000);
}
virtual int hit(int arg1, int arg2) {
checkpoint(" Callback hit %08x, %08x, returning %08x", arg1, arg2, ret_);
if (!done_) {
done_ = true;
checkpoint(" Notifying self within callback: %08x", sceKernelNotifyCallback(cb_, 0xABCD));
checkpoint(" sceKernelDelayThreadCB within callback: %08x", sceKernelDelayThreadCB(1000));
}
return ret_;
}
void System::msleep(int msecs)
{
if (msecs < 0)
return;
#ifdef __PSP__
sceKernelDelayThreadCB(msecs*1000);
#elif defined(__AROS__)
// usleep is not implemented on AROS
sleep(msecs < 1000 ? 1 : msecs/1000);
#else
usleep(msecs*1000);
#endif
}
int main_thread(SceSize args, void *argp)
{
FILE *fp;
int argc = 1;
char *argv[] = {save_argv0};
#ifdef WITH_PSP2D
sceGuInit();
#endif
Py_Initialize();
PySys_SetPath("ms0:/python");
PySys_SetArgv(argc, argv);
fp = fopen("script.py", "r");
if (fp)
{
PyRun_SimpleFile(fp, "script.py");
fclose(fp);
}
else
{
#ifndef DEBUG
pspDebugScreenInit();
#endif
pspDebugScreenPrintf("Error - could not open script.py\n");
}
#ifdef DEBUG
sceKernelDelayThreadCB(1e7);
#endif
Py_Finalize();
#ifdef WITH_PSP2D
sceGuTerm();
#endif
sceKernelExitGame();
return 0;
}
/* psp_timer_thread:
* This PSP thread measures the elapsed time.
*/
static int psp_timer_thread()
{
uint64_t old_tick, new_tick;
int interval;
long delay;
sceRtcGetCurrentTick(&old_tick);
while (psp_timer_on) {
/* Calculate actual time elapsed. */
sceRtcGetCurrentTick(&new_tick);
interval = PSPTIMER_TO_TIMER(new_tick - old_tick);
old_tick = new_tick;
/* Handle a tick and rest. */
delay = _handle_timer_tick(interval);
sceKernelDelayThreadCB(TIMER_TO_USEC(delay));
}
sceKernelExitThread(0);
return 0;
}
void myexit() {
printf("Returning to XMB...");
sceKernelDelayThreadCB(3000000);
sceKernelExitGame();
}
int main(int argc, char *argv[])
{
SceCtrlData pad;
int result;
int oldButtons = 0;
int cbid = -1;
int waitStatThid = -1;
pspDebugScreenInit();
if (argc > 0) {
printf("Bootpath: %s\n", argv[0]);
}
printf("Triangle - Exit\n");
printf("Left - sceUmdActivate\n");
printf("Right - sceUmdDeactivate\n");
printf("Cross - Delay CB\n");
printf("Circle - Display umd info\n");
printf("Square - Refer umd callback\n");
printf("L-Trigger - IO test\n");
printf("R-Trigger - Start/Stop wait stat test\n");
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
{
printUmdInfo();
// result:
// callback events are generated if we launch from iso or immediately after psplink has reset
cbid = sceKernelCreateCallback("UMD Callback (not active)", umd_callback, (void*)0x34343434);
result = sceUmdRegisterUMDCallBack(cbid);
printf("sceUmdRegisterUMDCallBack result %08X\n", result);
// Register a second UMD callback: it will overwrite the first one.
cbid = sceKernelCreateCallback("UMD Callback", umd_callback, (void*)0x11111111);
result = sceUmdRegisterUMDCallBack(cbid);
printf("sceUmdRegisterUMDCallBack result %08X\n", result);
}
while (!done)
{
sceCtrlReadBufferPositive(&pad, 1); // context switch in here
//sceCtrlPeekBufferPositive(&pad, 1); // no context switch version
int buttonDown = (oldButtons ^ pad.Buttons) & pad.Buttons;
if (buttonDown & PSP_CTRL_LEFT)
{
result = sceUmdActivate(1, "disc0:");
printf("sceUmdActivate result %08x\n", result);
}
if (buttonDown & PSP_CTRL_RIGHT)
{
result = sceUmdDeactivate(1, "disc0:");
printf("sceUmdDeactivate result %08x\n", result);
}
if (buttonDown & PSP_CTRL_CROSS)
{
printf("sceKernelDelayThreadCB ...\n");
sceKernelDelayThreadCB(10000);
}
if (buttonDown & PSP_CTRL_CIRCLE)
{
printUmdInfo();
}
if (buttonDown & PSP_CTRL_SQUARE)
{
SceKernelCallbackInfo info;
memset(&info, 0xee, sizeof(info));
info.size = sizeof(info);
result = sceKernelReferCallbackStatus(cbid, &info);
printf("sceKernelReferCallbackStatus result %08x\n", result);
printf(" size %d (%d)\n", info.size, sizeof(info));
printf(" name '%s'\n", info.name);
printf(" threadId %08x (%08x)\n", info.threadId, sceKernelGetThreadId());
printf(" callback %p common %p\n", info.callback, info.common);
printf(" notifyCount %08x\n", info.notifyCount);
printf(" notifyArg %08x\n", info.notifyArg);
}
if (buttonDown & PSP_CTRL_LTRIGGER)
{
test_io();
}
if (buttonDown & PSP_CTRL_RTRIGGER)
{
if (waitStatThid >= 0)
{
printf("Cleaning up wait stat test ...\n");
referThread(waitStatThid);
result = sceUmdCancelWaitDriveStat();
printf("sceUmdCancelWaitDriveStat result %08x\n", result);
referThread(waitStatThid);
result = sceKernelDeleteThread(waitStatThid);
printf("sceKernelDeleteThread result %08x\n", result);
//result = sceKernelTerminateDeleteThread(waitStatThid);
//printf("sceKernelTerminateDeleteThread result %08x\n", result);
waitStatThid = -1;
}
else
{
printf("Starting wait stat test ...\n");
// test timeout:
// Press Right (deactivate UMD)
// Press R-Trigger:
// - Press R-Trigger again before 3 seconds:
// 0x800201a9 wait cancelled
// - Or wait 3 seconds:
// 0x800201a8 wait timeout
struct WaitStatParams params = { 0x20, 3000000 };
// test internal workings:
// - (wantStat & curStat) == wantStat
// - (wantStat & curStat) != 0 <-- looks like this is the correct one
//struct WaitStatParams params = { 0xFF, 3000000 };
waitStatThid = sceKernelCreateThread("WaitUMDStat", waitstat_thread, 0x20, 0x4000, 0, 0);
printf("sceKernelCreateThread result %08x\n", waitStatThid);
if (waitStatThid >= 0)
{
result = sceKernelStartThread(waitStatThid, sizeof(params), ¶ms);
printf("sceKernelStartThread result %08x\n", result);
}
}
}
if (buttonDown & PSP_CTRL_TRIANGLE)
done = 1;
oldButtons = pad.Buttons;
sceDisplayWaitVblank(); // only catch callback when we press Cross (sceKernelDelayThreadCB)
//sceDisplayWaitVblankCB(); // catch all callback events
}
sceKernelExitGame();
return 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;
}
extern "C" int main(int argc, char *argv[]) {
Callback cb("notify", &cbFunc, NULL);
checkpointNext("Objects:");
testNotify(" Normal", cb, 0x1337);
testNotify(" NULL", 0, 0x1337);
testNotify(" Invalid", 0xDEADBEEF, 0x1337);
cb.Delete();
testNotify(" Deleted", cb, 0x1337);
cb.Create("notify", &cbFunc, NULL);
checkpointNext("Values:");
testNotify(" Zero", cb, 0);
testNotify(" DEADBEEF", cb, 0xDEADBEEF);
checkpointNext("Notifies:");
int result = 0;
for (int i = 0; i < 10000; ++i) {
result = sceKernelNotifyCallback(cb, 1);
if (result != 0) {
checkpoint(" Failed at %d: %08x", i, result);
break;
}
}
if (result == 0) {
checkpoint(" 10000 notifies: OK");
}
checkpoint("sceKernelDelayThreadCB: %08x", sceKernelDelayThreadCB(1000));
checkpointNext("Different thread:");
{
CallbackSleeper waiter1("better priority sleeping thread", 0x10);
CallbackSleeper waiter2("worse priority sleeping thread", 0x30);
sceKernelDelayThread(1000);
sceKernelNotifyCallback(waiter1.callbackID(), 0x1337);
sceKernelNotifyCallback(waiter2.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Return value:");
{
CallbackSleeper waiter("sleeping thread");
waiter.setReturn(0x1337);
sceKernelDelayThread(1000);
testNotify(" Notify #1", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
testNotify(" Notify #2", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Recursion:");
{
SelfNotifier waiter("sleeping thread");
sceKernelDelayThread(1000);
testNotify(" Notify #1", waiter.callbackID(), 0x1337);
sceKernelDelayThread(1000);
}
checkpointNext("Mixing types:");
checkpoint(" scePowerRegisterCallback (causes notify): %08x", scePowerRegisterCallback(0, cb));
testNotify(" Manual notify", cb, 0x1337);
checkpoint(" sceKernelDelayThreadCB: %08x", sceKernelDelayThreadCB(1000));
checkpointNext("Order:");
Callback cb1("notify1", &cbFunc, (void *)0xABC00001);
Callback cb2("notify2", &cbFunc, (void *)0xABC00002);
Callback cb3("notify3", &cbFunc, (void *)0xABC00003);
testNotify(" Notify cb #2", cb2, 0xDEF00001);
testNotify(" Notify cb #1", cb1, 0xDEF00002);
testNotify(" Notify cb #3", cb3, 0xDEF00003);
checkpoint(" sceKernelCheckCallback: %08x", sceKernelCheckCallback());
return 0;
}