update for recent /gp2x changes
[picodrive.git] / platform / psp / psp.c
CommitLineData
8b99ab90 1// (c) Copyright 2007 notaz, All rights reserved.
2// Free for non-commercial use.
3
4// For commercial use, separate licencing terms must be obtained.
5
7d4906bf 6#include <stdio.h>
110df09c 7#include <stdlib.h>
7d4906bf 8#include <stdarg.h>
9#include <string.h>
ea08c296 10#include <unistd.h>
7d4906bf 11
1820b5a7 12#include <pspkernel.h>
7d4906bf 13#include <pspiofilemgr.h>
1820b5a7 14#include <pspdisplay.h>
70357ce5 15#include <psppower.h>
9caf44b5 16#include <psprtc.h>
1820b5a7 17#include <pspgu.h>
2445b7cb 18#include <pspsdk.h>
1820b5a7 19
20#include "psp.h"
b542be46 21#include "emu.h"
1820b5a7 22#include "../common/lprintf.h"
052c0f86 23#include "version.h"
1820b5a7 24
2445b7cb 25extern int pico_main(void);
26
27#ifndef FW15
28
2b02d6e5 29PSP_MODULE_INFO("PicoDrive", 0, 1, 51);
110df09c 30PSP_HEAP_SIZE_MAX();
1820b5a7 31
2445b7cb 32int main() { return pico_main(); } /* just a wrapper */
33
34#else
35
2b02d6e5 36PSP_MODULE_INFO("PicoDrive", 0x1000, 1, 51);
2445b7cb 37PSP_MAIN_THREAD_ATTR(0);
38
39int main()
40{
41 SceUID thid;
42
43 /* this is the thing we need the kernel mode for */
44 pspSdkInstallNoDeviceCheckPatch();
45
46 thid = sceKernelCreateThread("pico_main", (SceKernelThreadEntry) pico_main, 32, 0x2000, PSP_THREAD_ATTR_USER, NULL);
47 if (thid >= 0)
48 sceKernelStartThread(thid, 0, 0);
ff6b7429 49#ifndef GCOV
2445b7cb 50 sceKernelExitDeleteThread(0);
ff6b7429 51#else
52 while (engineState != PGS_Quit)
53 sceKernelDelayThread(1024 * 1024);
54#endif
2445b7cb 55
56 return 0;
57}
58
59#endif
60
2b02d6e5 61int psp_unhandled_suspend = 0;
62
9112b6ce 63unsigned int __attribute__((aligned(16))) guCmdList[GU_CMDLIST_SIZE];
64
65void *psp_screen = VRAM_FB0;
ea08c296 66
1820b5a7 67static int current_screen = 0; /* front bufer */
68
110df09c 69static SceUID main_thread_id = -1;
70
9caf44b5 71#define ANALOG_DEADZONE 80
1820b5a7 72
73/* Exit callback */
74static int exit_callback(int arg1, int arg2, void *common)
75{
76 sceKernelExitGame();
77 return 0;
78}
79
b542be46 80/* Power Callback */
81static int power_callback(int unknown, int pwrflags, void *common)
82{
7d0143a2 83 lprintf("power_callback: flags: 0x%08X\n", pwrflags);
84
b542be46 85 /* check for power switch and suspending as one is manual and the other automatic */
7d0143a2 86 if (pwrflags & PSP_POWER_CB_POWER_SWITCH || pwrflags & PSP_POWER_CB_SUSPENDING || pwrflags & PSP_POWER_CB_STANDBY)
b542be46 87 {
2b02d6e5 88 psp_unhandled_suspend = 1;
89 if (engineState != PGS_Suspending)
90 engineStateSuspend = engineState;
91 sceKernelDelayThread(100000); // ??
b542be46 92 }
7d0143a2 93 else if (pwrflags & PSP_POWER_CB_RESUME_COMPLETE)
ea08c296 94 {
2b02d6e5 95 engineState = PGS_SuspendWake;
ea08c296 96 }
7d0143a2 97
2445b7cb 98 //sceDisplayWaitVblankStart();
b542be46 99 return 0;
100}
101
1820b5a7 102/* Callback thread */
103static int callback_thread(SceSize args, void *argp)
104{
105 int cbid;
106
4b167c12 107 lprintf("callback_thread started with id %08x, priority %i\n",
a4221917 108 sceKernelGetThreadId(), sceKernelGetThreadCurrentPriority());
1820b5a7 109
110 cbid = sceKernelCreateCallback("Exit Callback", exit_callback, NULL);
111 sceKernelRegisterExitCallback(cbid);
b542be46 112 cbid = sceKernelCreateCallback("Power Callback", power_callback, NULL);
113 scePowerRegisterCallback(0, cbid);
1820b5a7 114
115 sceKernelSleepThreadCB();
116
117 return 0;
118}
119
120void psp_init(void)
121{
a4221917 122 SceUID thid;
ea08c296 123 char buff[128], *r;
124
125 /* fw 1.5 sometimes returns 8002032c, although getcwd works */
126 r = getcwd(buff, sizeof(buff));
127 if (r) sceIoChdir(buff);
1820b5a7 128
110df09c 129 main_thread_id = sceKernelGetThreadId();
130
052c0f86 131 lprintf("\n%s\n", "PicoDrive v" VERSION " " __DATE__ " " __TIME__);
110df09c 132 lprintf("running on %08x kernel\n", sceKernelDevkitVersion()),
133 lprintf("entered psp_init, threadId %08x, priority %i\n", main_thread_id,
a4221917 134 sceKernelGetThreadCurrentPriority());
1820b5a7 135
2445b7cb 136 thid = sceKernelCreateThread("update_thread", callback_thread, 0x11, 0xFA0, 0, NULL);
1820b5a7 137 if (thid >= 0)
138 {
139 sceKernelStartThread(thid, 0, 0);
140 }
141
142 /* video */
143 sceDisplaySetMode(0, 480, 272);
9112b6ce 144 sceDisplaySetFrameBuf(VRAM_FB1, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
1820b5a7 145 current_screen = 1;
9112b6ce 146 psp_screen = VRAM_FB0;
1820b5a7 147
148 /* gu */
149 sceGuInit();
150
9112b6ce 151 sceGuStart(GU_DIRECT, guCmdList);
8ab3e3c1 152 sceGuDrawBuffer(GU_PSM_5650, (void *)VRAMOFFS_FB0, 512);
153 sceGuDispBuffer(480, 272, (void *)VRAMOFFS_FB1, 512); // don't care
9112b6ce 154 sceGuClear(GU_COLOR_BUFFER_BIT | GU_DEPTH_BUFFER_BIT);
8ab3e3c1 155 sceGuDepthBuffer((void *)VRAMOFFS_DEPTH, 512);
9112b6ce 156 sceGuOffset(2048 - (480 / 2), 2048 - (272 / 2));
157 sceGuViewport(2048, 2048, 480, 272);
158 sceGuDepthRange(0xc350, 0x2710);
159 sceGuScissor(0, 0, 480, 272);
160 sceGuEnable(GU_SCISSOR_TEST);
9112b6ce 161
162 sceGuDepthMask(0xffff);
163 sceGuDisable(GU_DEPTH_TEST);
164
165 sceGuFrontFace(GU_CW);
9112b6ce 166 sceGuEnable(GU_TEXTURE_2D);
9112b6ce 167 sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB);
8ab3e3c1 168 sceGuAmbientColor(0xffffffff);
169 sceGuColor(0xffffffff);
9112b6ce 170 sceGuFinish();
171 sceGuSync(0, 0);
172
173 sceDisplayWaitVblankStart();
174 sceGuDisplay(GU_TRUE);
175
176
1820b5a7 177 /* input */
178 sceCtrlSetSamplingCycle(0);
9caf44b5 179 sceCtrlSetSamplingMode(PSP_CTRL_MODE_ANALOG);
1820b5a7 180}
181
182void psp_finish(void)
183{
aefb65bc 184 lprintf("psp_finish..\n");
1820b5a7 185 sceGuTerm();
186
187 //sceKernelSleepThread();
188 sceKernelExitGame();
189}
190
7d4906bf 191void psp_video_flip(int wait_vsync)
1820b5a7 192{
7d4906bf 193 if (wait_vsync) sceDisplayWaitVblankStart();
70357ce5 194 sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565,
195 wait_vsync ? PSP_DISPLAY_SETBUF_IMMEDIATE : PSP_DISPLAY_SETBUF_NEXTFRAME);
1820b5a7 196 current_screen ^= 1;
9112b6ce 197 psp_screen = current_screen ? VRAM_FB0 : VRAM_FB1;
7d4906bf 198}
199
200void *psp_video_get_active_fb(void)
201{
9112b6ce 202 return current_screen ? VRAM_FB1 : VRAM_FB0;
1820b5a7 203}
204
205void psp_video_switch_to_single(void)
206{
9112b6ce 207 psp_screen = VRAM_FB0;
1820b5a7 208 sceDisplaySetFrameBuf(psp_screen, 512, PSP_DISPLAY_PIXEL_FORMAT_565, PSP_DISPLAY_SETBUF_NEXTFRAME);
209 current_screen = 0;
210}
211
212void psp_msleep(int ms)
213{
214 sceKernelDelayThread(ms * 1000);
215}
216
7d4906bf 217unsigned int psp_pad_read(int blocking)
1820b5a7 218{
9caf44b5 219 unsigned int buttons;
1820b5a7 220 SceCtrlData pad;
7d4906bf 221 if (blocking)
222 sceCtrlReadBufferPositive(&pad, 1);
223 else sceCtrlPeekBufferPositive(&pad, 1);
9caf44b5 224 buttons = pad.Buttons;
225
226 // analog..
e5ab6faf 227 buttons &= ~(PBTN_NUB_UP|PBTN_NUB_DOWN|PBTN_NUB_LEFT|PBTN_NUB_RIGHT);
228 if (pad.Lx < 128 - ANALOG_DEADZONE) buttons |= PBTN_NUB_LEFT;
229 if (pad.Lx > 128 + ANALOG_DEADZONE) buttons |= PBTN_NUB_RIGHT;
230 if (pad.Ly < 128 - ANALOG_DEADZONE) buttons |= PBTN_NUB_UP;
231 if (pad.Ly > 128 + ANALOG_DEADZONE) buttons |= PBTN_NUB_DOWN;
1820b5a7 232
9caf44b5 233 return buttons;
1820b5a7 234}
235
70357ce5 236int psp_get_cpu_clock(void)
237{
238 return scePowerGetCpuClockFrequencyInt();
239}
240
241int psp_set_cpu_clock(int clock)
242{
243 int ret = scePowerSetClockFrequency(clock, clock, clock/2);
244 if (ret != 0) lprintf("failed to set clock: %i\n", ret);
245
246 return ret;
247}
248
9caf44b5 249char *psp_get_status_line(void)
250{
251 static char buff[64];
252 int ret, bat_percent, bat_time;
253 pspTime time;
254
255 ret = sceRtcGetCurrentClockLocalTime(&time);
256 bat_percent = scePowerGetBatteryLifePercent();
257 bat_time = scePowerGetBatteryLifeTime();
258 if (ret < 0 || bat_percent < 0 || bat_time < 0) return NULL;
259
260 snprintf(buff, sizeof(buff), "%02i:%02i bat: %3i%%", time.hour, time.minutes, bat_percent);
261 if (!scePowerIsPowerOnline())
262 snprintf(buff+strlen(buff), sizeof(buff)-strlen(buff), " (%i:%02i)", bat_time/60, bat_time%60);
263 return buff;
264}
265
7d0143a2 266void psp_wait_suspend(void)
267{
268 // probably should do something smarter here?
269 sceDisplayWaitVblankStart();
270}
271
ea08c296 272void psp_resume_suspend(void)
273{
274 // for some reason file IO doesn't seem to work
275 // after resume for some period of time, at least on 1.5
276 SceUID fd;
277 int i;
278 for (i = 0; i < 30; i++) {
2b1f0e25 279 fd = sceIoOpen("EBOOT.PBP", PSP_O_RDONLY, 0777);
280 if (fd >= 0) break;
281 sceKernelDelayThread(100 * 1024);
ea08c296 282 }
283 if (fd >= 0) sceIoClose(fd);
284 sceDisplayWaitVblankStart();
ea08c296 285 if (i < 30)
2b1f0e25 286 lprintf("io resumed after %i tries\n", i);
287 else {
288 lprintf("io resume failed with %08x\n", fd);
289 sceKernelDelayThread(500 * 1024);
290 }
ea08c296 291}
292
7d4906bf 293/* alt logging */
110df09c 294#define LOG_FILE "log.txt"
295
c6196c0f 296#ifndef LPRINTF_STDIO
110df09c 297typedef struct _log_entry
298{
299 char buff[256];
300 struct _log_entry *next;
301} log_entry;
7d4906bf 302
110df09c 303static log_entry *le_root = NULL;
c6196c0f 304#endif
9caf44b5 305
052c0f86 306/* strange: if this function leaks memory (before psp_init() call?),
307 * resume after suspend breaks on 3.90 */
7d0143a2 308void lprintf(const char *fmt, ...)
7d4906bf 309{
310 va_list vl;
110df09c 311
312#ifdef LPRINTF_STDIO
313 va_start(vl, fmt);
314 vprintf(fmt, vl);
315 va_end(vl);
316#else
317 static SceUID logfd = -1;
ea08c296 318 static int msg_count = 0;
7d4906bf 319 char buff[256];
110df09c 320 log_entry *le, *le1;
7d4906bf 321
9caf44b5 322 if (logfd == -2) return; // disabled
323
110df09c 324 va_start(vl, fmt);
325 vsnprintf(buff, sizeof(buff), fmt, vl);
326 va_end(vl);
327
328 // note: this is still unsafe code
329 if (main_thread_id != sceKernelGetThreadId())
7d4906bf 330 {
110df09c 331 le = malloc(sizeof(*le));
332 if (le == NULL) return;
333 le->next = NULL;
334 strcpy(le->buff, buff);
335 if (le_root == NULL) le_root = le;
336 else {
337 for (le1 = le_root; le1->next != NULL; le1 = le1->next);
338 le1->next = le;
9caf44b5 339 }
110df09c 340 return;
7d4906bf 341 }
342
110df09c 343 logfd = sceIoOpen(LOG_FILE, PSP_O_WRONLY|PSP_O_APPEND, 0777);
344 if (logfd < 0) {
ea08c296 345 if (msg_count == 0) logfd = -2;
110df09c 346 return;
347 }
348
349 if (le_root != NULL)
350 {
351 le1 = le_root;
352 le_root = NULL;
353 sceKernelDelayThread(1000);
354 while (le1 != NULL) {
355 le = le1;
356 le1 = le->next;
357 sceIoWrite(logfd, le->buff, strlen(le->buff));
358 free(le);
ea08c296 359 msg_count++;
110df09c 360 }
361 }
7d4906bf 362
363 sceIoWrite(logfd, buff, strlen(buff));
ea08c296 364 msg_count++;
9caf44b5 365
366 // make sure it gets flushed
367 sceIoClose(logfd);
368 logfd = -1;
110df09c 369#endif
7d4906bf 370}
371
372