X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=platform%2Fpsp%2Fpsp.c;h=99b9084c5fa585bbbfdeea3a82751a695ff8c5d6;hb=8b99ab90aa519639a87c302c9a26fef526febde9;hp=4bc1020b96e769dbabbd9af0e616068c567b9be8;hpb=1820b5a7a18fc8c37dddb2ab88159e513ceb3b16;p=picodrive.git diff --git a/platform/psp/psp.c b/platform/psp/psp.c index 4bc1020..99b9084 100644 --- a/platform/psp/psp.c +++ b/platform/psp/psp.c @@ -1,15 +1,35 @@ +// (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 +#include +#include #include #include "psp.h" +#include "emu.h" #include "../common/lprintf.h" PSP_MODULE_INFO("PicoDrive", 0, 1, 34); +PSP_HEAP_SIZE_MAX(); + +unsigned int __attribute__((aligned(16))) guCmdList[GU_CMDLIST_SIZE]; -void *psp_screen = PSP_VRAM_BASE0; +void *psp_screen = VRAM_FB0; static int current_screen = 0; /* front bufer */ +static SceUID main_thread_id = -1; + +#define ANALOG_DEADZONE 80 /* Exit callback */ static int exit_callback(int arg1, int arg2, void *common) @@ -18,15 +38,31 @@ static int exit_callback(int arg1, int arg2, void *common) return 0; } +/* Power Callback */ +static int power_callback(int unknown, int pwrflags, void *common) +{ + /* 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) + { + lprintf("power_callback: flags: 0x%08X: suspending\n", pwrflags); + engineState = PGS_Menu; + } + sceDisplayWaitVblankStart(); + return 0; +} + /* Callback thread */ static int callback_thread(SceSize args, void *argp) { int cbid; - lprintf("callback_thread started with id %i\n", sceKernelGetThreadId()); + 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(); @@ -35,9 +71,13 @@ static int callback_thread(SceSize args, void *argp) void psp_init(void) { - int thid; + SceUID thid; - lprintf("entered psp_init, threadId %i\n", sceKernelGetThreadId()); + main_thread_id = sceKernelGetThreadId(); + + 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); if (thid >= 0) @@ -47,16 +87,42 @@ void psp_init(void) /* video */ sceDisplaySetMode(0, 480, 272); - sceDisplaySetFrameBuf(PSP_VRAM_BASE1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME); + sceDisplaySetFrameBuf(VRAM_FB1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME); current_screen = 1; - psp_screen = PSP_VRAM_BASE0; + psp_screen = VRAM_FB0; /* gu */ sceGuInit(); + sceGuStart(GU_DIRECT, guCmdList); + sceGuDrawBuffer(GU_PSM_5650, (void *)VRAMOFFS_FB0, 512); + sceGuDispBuffer(480, 272, (void *)VRAMOFFS_FB1, 512); // don't care + sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT); + sceGuDepthBuffer((void *)VRAMOFFS_DEPTH, 512); + sceGuOffset(2048 - (480 / 2), 2048 - (272 / 2)); + sceGuViewport(2048, 2048, 480, 272); + sceGuDepthRange(0xc350, 0x2710); + sceGuScissor(0, 0, 480, 272); + sceGuEnable(GU_SCISSOR_TEST); + + sceGuDepthMask(0xffff); + sceGuDisable(GU_DEPTH_TEST); + + sceGuFrontFace(GU_CW); + sceGuEnable(GU_TEXTURE_2D); + sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); + sceGuAmbientColor(0xffffffff); + sceGuColor(0xffffffff); + sceGuFinish(); + sceGuSync(0, 0); + + sceDisplayWaitVblankStart(); + sceGuDisplay(GU_TRUE); + + /* input */ sceCtrlSetSamplingCycle(0); - sceCtrlSetSamplingMode(0); + sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG); } void psp_finish(void) @@ -67,16 +133,23 @@ void psp_finish(void) sceKernelExitGame(); } -void psp_video_flip(void) +void psp_video_flip(int wait_vsync) { - sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME); + if (wait_vsync) sceDisplayWaitVblankStart(); + sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565, + wait_vsync ? PSP_DISPLAY_SETBUF_IMMEDIATE : PSP_DISPLAY_SETBUF_NEXTFRAME); current_screen ^= 1; - psp_screen = current_screen ? PSP_VRAM_BASE1 : PSP_VRAM_BASE0; + psp_screen = current_screen ? VRAM_FB0 : VRAM_FB1; +} + +void *psp_video_get_active_fb(void) +{ + return current_screen ? VRAM_FB1 : VRAM_FB0; } void psp_video_switch_to_single(void) { - psp_screen = PSP_VRAM_BASE0; + psp_screen = VRAM_FB0; sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME); current_screen = 0; } @@ -86,11 +159,125 @@ void psp_msleep(int ms) sceKernelDelayThread(ms * 1000); } -unsigned int psp_pad_read(void) +unsigned int psp_pad_read(int blocking) { + unsigned int buttons; SceCtrlData pad; - sceCtrlReadBufferPositive(&pad, 1); + if (blocking) + sceCtrlReadBufferPositive(&pad, 1); + else sceCtrlPeekBufferPositive(&pad, 1); + buttons = pad.Buttons; - return 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; + + return buttons; +} + +int psp_get_cpu_clock(void) +{ + return scePowerGetCpuClockFrequencyInt(); } +int psp_set_cpu_clock(int clock) +{ + int ret = scePowerSetClockFrequency(clock, clock, clock/2); + if (ret != 0) lprintf("failed to set clock: %i\n", ret); + + return ret; +} + +char *psp_get_status_line(void) +{ + static char buff[64]; + int ret, bat_percent, bat_time; + pspTime time; + + ret = sceRtcGetCurrentClockLocalTime(&time); + bat_percent = scePowerGetBatteryLifePercent(); + bat_time = scePowerGetBatteryLifeTime(); + if (ret < 0 || bat_percent < 0 || bat_time < 0) return NULL; + + snprintf(buff, sizeof(buff), "%02i:%02i bat: %3i%%", time.hour, time.minutes, bat_percent); + if (!scePowerIsPowerOnline()) + snprintf(buff+strlen(buff), sizeof(buff)-strlen(buff), " (%i:%02i)", bat_time/60, bat_time%60); + return buff; +} + +/* alt logging */ +#define LOG_FILE "log.txt" + +typedef struct _log_entry +{ + char buff[256]; + struct _log_entry *next; +} log_entry; + +static log_entry *le_root = NULL; + +void lprintf_f(const char *fmt, ...) +{ + va_list vl; + +#ifdef LPRINTF_STDIO + va_start(vl, fmt); + vprintf(fmt, vl); + va_end(vl); +#else + static SceUID logfd = -1; + char buff[256]; + log_entry *le, *le1; + + if (logfd == -2) return; // disabled + + va_start(vl, fmt); + vsnprintf(buff, sizeof(buff), fmt, vl); + va_end(vl); + + // note: this is still unsafe code + if (main_thread_id != sceKernelGetThreadId()) + { + 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; + } + + logfd = sceIoOpen(LOG_FILE, PSP_O_WRONLY|PSP_O_APPEND, 0777); + if (logfd < 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); + } + } + + sceIoWrite(logfd, buff, strlen(buff)); + + // make sure it gets flushed + sceIoClose(logfd); + logfd = -1; +#endif +} + +