X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=psp%2Fpsp.c;h=9ddb9527364f1212f597793d38fd016d1b34d021;hb=ca69c3e5a0ecf407c02dc85c6f3282ebb1efc5a2;hp=a21507f0265e58b08e1ecee6e4ef983f5bf6704d;hpb=16e89bed918ec39b1e43956b903f7986af86a6b2;p=libpicofe.git diff --git a/psp/psp.c b/psp/psp.c index a21507f..9ddb952 100644 --- a/psp/psp.c +++ b/psp/psp.c @@ -1,6 +1,13 @@ +// (c) Copyright 2007 notaz, All rights reserved. +// Free for non-commercial use. + +// For commercial use, separate licencing terms must be obtained. + #include +#include #include #include +#include #include #include @@ -8,17 +15,59 @@ #include #include #include +#include #include "psp.h" +#include "emu.h" #include "../common/lprintf.h" +#include "version.h" + +extern int pico_main(void); + +#ifndef FW15 + +PSP_MODULE_INFO("PicoDrive", 0, 1, 51); +PSP_HEAP_SIZE_MAX(); + +int main() { return pico_main(); } /* just a wrapper */ + +#else + +PSP_MODULE_INFO("PicoDrive", 0x1000, 1, 51); +PSP_MAIN_THREAD_ATTR(0); -PSP_MODULE_INFO("PicoDrive", 0, 1, 34); +int main() +{ + SceUID thid; + + /* this is the thing we need the kernel mode for */ + pspSdkInstallNoDeviceCheckPatch(); + + thid = sceKernelCreateThread("pico_main", (SceKernelThreadEntry) pico_main, 32, 0x2000, PSP_THREAD_ATTR_USER, NULL); + if (thid >= 0) + sceKernelStartThread(thid, 0, 0); +#ifndef GCOV + sceKernelExitDeleteThread(0); +#else + while (engineState != PGS_Quit) + sceKernelDelayThread(1024 * 1024); +#endif + + return 0; +} + +#endif + +int psp_unhandled_suspend = 0; unsigned int __attribute__((aligned(16))) guCmdList[GU_CMDLIST_SIZE]; void *psp_screen = VRAM_FB0; + static int current_screen = 0; /* front bufer */ +static SceUID main_thread_id = -1; + #define ANALOG_DEADZONE 80 /* Exit callback */ @@ -28,16 +77,40 @@ static int exit_callback(int arg1, int arg2, void *common) return 0; } +/* Power Callback */ +static int power_callback(int unknown, int pwrflags, void *common) +{ + lprintf("power_callback: flags: 0x%08X\n", pwrflags); + + /* check for power switch and suspending as one is manual and the other automatic */ + if (pwrflags & PSP_POWER_CB_POWER_SWITCH || pwrflags & PSP_POWER_CB_SUSPENDING || pwrflags & PSP_POWER_CB_STANDBY) + { + psp_unhandled_suspend = 1; + if (engineState != PGS_Suspending) + engineStateSuspend = engineState; + sceKernelDelayThread(100000); // ?? + } + else if (pwrflags & PSP_POWER_CB_RESUME_COMPLETE) + { + engineState = PGS_SuspendWake; + } + + //sceDisplayWaitVblankStart(); + return 0; +} + /* Callback thread */ static int callback_thread(SceSize args, void *argp) { int cbid; - lprintf("callback_thread started with id %i, priority %i\n", + lprintf("callback_thread started with id %08x, priority %i\n", sceKernelGetThreadId(), sceKernelGetThreadCurrentPriority()); cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL); sceKernelRegisterExitCallback(cbid); + cbid = sceKernelCreateCallback("Power Callback", power_callback, NULL); + scePowerRegisterCallback(0, cbid); sceKernelSleepThreadCB(); @@ -47,12 +120,20 @@ static int callback_thread(SceSize args, void *argp) void psp_init(void) { SceUID thid; + char buff[128], *r; - lprintf("running in %08x kernel\n", sceKernelDevkitVersion()), - lprintf("entered psp_init, threadId %i, priority %i\n", sceKernelGetThreadId(), + /* fw 1.5 sometimes returns 8002032c, although getcwd works */ + r = getcwd(buff, sizeof(buff)); + if (r) sceIoChdir(buff); + + main_thread_id = sceKernelGetThreadId(); + + lprintf("\n%s\n", "PicoDrive v" VERSION " " __DATE__ " " __TIME__); + lprintf("running on %08x kernel\n", sceKernelDevkitVersion()), + lprintf("entered psp_init, threadId %08x, priority %i\n", main_thread_id, sceKernelGetThreadCurrentPriority()); - thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, 0); + thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, NULL); if (thid >= 0) { sceKernelStartThread(thid, 0, 0); @@ -100,6 +181,7 @@ void psp_init(void) void psp_finish(void) { + lprintf("psp_finish..\n"); sceGuTerm(); //sceKernelSleepThread(); @@ -142,11 +224,11 @@ unsigned int psp_pad_read(int blocking) buttons = pad.Buttons; // analog.. - buttons &= ~(BTN_NUB_UP|BTN_NUB_DOWN|BTN_NUB_LEFT|BTN_NUB_RIGHT); - if (pad.Lx < 128 - ANALOG_DEADZONE) buttons |= BTN_NUB_LEFT; - if (pad.Lx > 128 + ANALOG_DEADZONE) buttons |= BTN_NUB_RIGHT; - if (pad.Ly < 128 - ANALOG_DEADZONE) buttons |= BTN_NUB_UP; - if (pad.Ly > 128 + ANALOG_DEADZONE) buttons |= BTN_NUB_DOWN; + buttons &= ~(PBTN_NUB_UP|PBTN_NUB_DOWN|PBTN_NUB_LEFT|PBTN_NUB_RIGHT); + if (pad.Lx < 128 - ANALOG_DEADZONE) buttons |= PBTN_NUB_LEFT; + if (pad.Lx > 128 + ANALOG_DEADZONE) buttons |= PBTN_NUB_RIGHT; + if (pad.Ly < 128 - ANALOG_DEADZONE) buttons |= PBTN_NUB_UP; + if (pad.Ly > 128 + ANALOG_DEADZONE) buttons |= PBTN_NUB_DOWN; return buttons; } @@ -181,36 +263,110 @@ char *psp_get_status_line(void) return buff; } +void psp_wait_suspend(void) +{ + // probably should do something smarter here? + sceDisplayWaitVblankStart(); +} + +void psp_resume_suspend(void) +{ + // for some reason file IO doesn't seem to work + // after resume for some period of time, at least on 1.5 + SceUID fd; + int i; + for (i = 0; i < 30; i++) { + fd = sceIoOpen("EBOOT.PBP", PSP_O_RDONLY, 0777); + if (fd >= 0) break; + sceKernelDelayThread(100 * 1024); + } + if (fd >= 0) sceIoClose(fd); + sceDisplayWaitVblankStart(); + if (i < 30) + lprintf("io resumed after %i tries\n", i); + else { + lprintf("io resume failed with %08x\n", fd); + sceKernelDelayThread(500 * 1024); + } +} + /* alt logging */ -#define LOG_FILE "log.log" +#define LOG_FILE "log.txt" + +#ifndef LPRINTF_STDIO +typedef struct _log_entry +{ + char buff[256]; + struct _log_entry *next; +} log_entry; -static SceUID logfd = -1; +static log_entry *le_root = NULL; +#endif -void lprintf_f(const char *fmt, ...) +/* strange: if this function leaks memory (before psp_init() call?), + * resume after suspend breaks on 3.90 */ +void lprintf(const char *fmt, ...) { va_list vl; + +#ifdef LPRINTF_STDIO + va_start(vl, fmt); + vprintf(fmt, vl); + va_end(vl); +#else + static SceUID logfd = -1; + static int msg_count = 0; char buff[256]; + log_entry *le, *le1; if (logfd == -2) return; // disabled - if (logfd < 0) + va_start(vl, fmt); + vsnprintf(buff, sizeof(buff), fmt, vl); + va_end(vl); + + // note: this is still unsafe code + if (main_thread_id != sceKernelGetThreadId()) { - logfd = sceIoOpen(LOG_FILE, PSP_O_WRONLY|PSP_O_APPEND, 0777); - if (logfd < 0) { - logfd = -2; - return; + le = malloc(sizeof(*le)); + if (le == NULL) return; + le->next = NULL; + strcpy(le->buff, buff); + if (le_root == NULL) le_root = le; + else { + for (le1 = le_root; le1->next != NULL; le1 = le1->next); + le1->next = le; } + return; } - va_start(vl, fmt); - vsnprintf(buff, sizeof(buff), fmt, vl); - va_end(vl); + logfd = sceIoOpen(LOG_FILE, PSP_O_WRONLY|PSP_O_APPEND, 0777); + if (logfd < 0) { + if (msg_count == 0) logfd = -2; + return; + } + + if (le_root != NULL) + { + le1 = le_root; + le_root = NULL; + sceKernelDelayThread(1000); + while (le1 != NULL) { + le = le1; + le1 = le->next; + sceIoWrite(logfd, le->buff, strlen(le->buff)); + free(le); + msg_count++; + } + } sceIoWrite(logfd, buff, strlen(buff)); + msg_count++; // make sure it gets flushed sceIoClose(logfd); logfd = -1; +#endif }