From e3279bfee3bf6b8f057b51b824b191985b3899ea Mon Sep 17 00:00:00 2001 From: Sam Hegarty Date: Mon, 24 Oct 2011 20:51:41 +1300 Subject: [PATCH] sync with devkit psp --- src/atrac3/pspatrac3.h | 75 +++ src/display/pspdisplay.h | 35 +- src/fpu/Makefile.am | 2 +- src/fpu/double.S | 196 ++++++ src/fpu/pspfpu.c | 900 +++++++++++++++++++++++-- src/fpu/pspfpu.h | 330 +++++++-- src/ge/pspge.h | 37 +- src/kernel/Makefile.am | 2 +- src/kernel/SysMemForKernel.S | 6 + src/kernel/psploadcore.h | 2 +- src/kernel/pspsysmem_kernel.h | 15 + src/libc/stdio.h | 4 + src/libc/terminate.c | 2 - src/net/psphttp.h | 67 ++ src/rtc/psprtc.h | 31 +- src/samples/Makefile.am | 245 +++---- src/samples/exceptions/Makefile.sample | 18 + src/samples/exceptions/main.cpp | 51 ++ src/user/Makefile.am | 18 +- src/user/SysMemUserForUser.S | 6 + src/user/UtilsForUser.S | 6 + src/user/pspsysmem.h | 15 + src/user/psputils.h | 28 +- 23 files changed, 1821 insertions(+), 270 deletions(-) create mode 100644 src/fpu/double.S create mode 100644 src/samples/exceptions/Makefile.sample create mode 100644 src/samples/exceptions/main.cpp diff --git a/src/atrac3/pspatrac3.h b/src/atrac3/pspatrac3.h index dd381cee..6221aba1 100644 --- a/src/atrac3/pspatrac3.h +++ b/src/atrac3/pspatrac3.h @@ -18,6 +18,57 @@ extern "C" { #endif +/* Error code definition */ +#define PSP_ATRAC_SUCCESS SCE_OK + +#define PSP_ATRAC_ERROR_PARAM_FAIL (0x80630001) +#define PSP_ATRAC_ERROR_API_FAIL (0x80630002) +#define PSP_ATRAC_ERROR_NO_ATRACID (0x80630003) +#define PSP_ATRAC_ERROR_BAD_CODECTYPE (0x80630004) +#define PSP_ATRAC_ERROR_BAD_ATRACID (0x80630005) +#define PSP_ATRAC_ERROR_UNKNOWN_FORMAT (0x80630006) +#define PSP_ATRAC_ERROR_UNMATCH_FORMAT (0x80630007) +#define PSP_ATRAC_ERROR_BAD_DATA (0x80630008) +#define PSP_ATRAC_ERROR_ALLDATA_IS_ONMEMORY (0x80630009) +#define PSP_ATRAC_ERROR_UNSET_DATA (0x80630010) + +#define PSP_ATRAC_ERROR_READSIZE_IS_TOO_SMALL (0x80630011) +#define PSP_ATRAC_ERROR_NEED_SECOND_BUFFER (0x80630012) +#define PSP_ATRAC_ERROR_READSIZE_OVER_BUFFER (0x80630013) +#define PSP_ATRAC_ERROR_NOT_4BYTE_ALIGNMENT (0x80630014) +#define PSP_ATRAC_ERROR_BAD_SAMPLE (0x80630015) +#define PSP_ATRAC_ERROR_WRITEBYTE_FIRST_BUFFER (0x80630016) +#define PSP_ATRAC_ERROR_WRITEBYTE_SECOND_BUFFER (0x80630017) +#define PSP_ATRAC_ERROR_ADD_DATA_IS_TOO_BIG (0x80630018) + +#define PSP_ATRAC_ERROR_UNSET_PARAM (0x80630021) +#define PSP_ATRAC_ERROR_NONEED_SECOND_BUFFER (0x80630022) +#define PSP_ATRAC_ERROR_NODATA_IN_BUFFER (0x80630023) +#define PSP_ATRAC_ERROR_ALLDATA_WAS_DECODED (0x80630024) + +/* Audio Codec ID */ +#define PSP_ATRAC_AT3PLUS (0x00001000) +#define PSP_ATRAC_AT3 (0x00001001) + +/* Remain Frame typical Status */ +#define PSP_ATRAC_ALLDATA_IS_ON_MEMORY (-1) +#define PSP_ATRAC_NONLOOP_STREAM_DATA_IS_ON_MEMORY (-2) +#define PSP_ATRAC_LOOP_STREAM_DATA_IS_ON_MEMORY (-3) + +typedef struct { + u8 *pucWritePositionFirstBuf; + u32 uiWritableByteFirstBuf; + u32 uiMinWriteByteFirstBuf; + u32 uiReadPositionFirstBuf; + + u8 *pucWritePositionSecondBuf; + u32 uiWritableByteSecondBuf; + u32 uiMinWriteByteSecondBuf; + u32 uiReadPositionSecondBuf; +} PspBufferInfo; + +int sceAtracGetAtracID(uint uiCodecType); + /** * Creates a new Atrac ID from the specified data * @@ -132,6 +183,30 @@ int sceAtracGetNextSample(int atracID, int *outN); */ int sceAtracGetMaxSample(int atracID, int *outMax); +int sceAtracGetBufferInfoForReseting(int atracID, u32 uiSample, PspBufferInfo *pBufferInfo); + +int sceAtracGetChannel(int atracID, u32 *puiChannel); + +int sceAtracGetInternalErrorInfo(int atracID, int *piResult); + +int sceAtracGetLoopStatus(int atracID, int *piLoopNum, u32 *puiLoopStatus); + +int sceAtracGetNextDecodePosition(int atracID, u32 *puiSamplePosition); + +int sceAtracGetSecondBufferInfo(int atracID, u32 *puiPosition, u32 *puiDataByte); + +int sceAtracGetSoundSample(int atracID, int *piEndSample, int *piLoopStartSample, int *piLoopEndSample); + +int sceAtracResetPlayPosition(int atracID, u32 uiSample, u32 uiWriteByteFirstBuf, u32 uiWriteByteSecondBuf); + +int sceAtracSetData(int atracID, u8 *pucBufferAddr, u32 uiBufferByte); + +int sceAtracSetHalfwayBuffer(int atracID, u8 *pucBufferAddr, u32 uiReadByte, u32 uiBufferByte); + +int sceAtracSetHalfwayBufferAndGetID(u8 *pucBufferAddr, u32 uiReadByte, u32 uiBufferByte); + +int sceAtracSetSecondBuffer(int atracID, u8 *pucSecondBufferAddr, u32 uiSecondBufferByte); + #ifdef __cplusplus } #endif diff --git a/src/display/pspdisplay.h b/src/display/pspdisplay.h index cb2e2dd3..b21a833e 100644 --- a/src/display/pspdisplay.h +++ b/src/display/pspdisplay.h @@ -33,7 +33,7 @@ enum PspDisplayPixelFormats { enum PspDisplaySetBufSync { /** Buffer change effective immediately */ - PSP_DISPLAY_SETBUF_IMMEDIATE = 0, + PSP_DISPLAY_SETBUF_IMMEDIATE = 0, /** Buffer change effective next frame */ PSP_DISPLAY_SETBUF_NEXTFRAME = 1 }; @@ -41,9 +41,9 @@ enum PspDisplaySetBufSync { enum PspDisplayErrorCodes { - SCE_DISPLAY_ERROR_OK = 0, - SCE_DISPLAY_ERROR_POINTER = 0x80000103, - SCE_DISPLAY_ERROR_ARGUMENT = 0x80000107 + SCE_DISPLAY_ERROR_OK = 0, + SCE_DISPLAY_ERROR_POINTER = 0x80000103, + SCE_DISPLAY_ERROR_ARGUMENT = 0x80000107 }; @@ -68,7 +68,7 @@ int sceDisplaySetMode(int mode, int width, int height); * @param pmode - Pointer to an integer to receive the current mode. * @param pwidth - Pointer to an integer to receive the current width. * @param pheight - Pointer to an integer to receive the current height, - * + * * @return 0 on success */ int sceDisplayGetMode(int *pmode, int *pwidth, int *pheight); @@ -122,6 +122,31 @@ int sceDisplayWaitVblank(void); */ int sceDisplayWaitVblankCB(void); +/** + * Get accumlated HSYNC count + */ +int sceDisplayGetAccumulatedHcount(void); + +/** + * Get current HSYNC count + */ +int sceDisplayGetCurrentHcount(void); + +/** + * Get number of frames per second + */ +float sceDisplayGetFramePerSec(void); + +/** + * Get whether or not frame buffer is being displayed + */ +int sceDisplayIsForeground(void); + +/** + * Test whether VBLANK is active + */ +int sceDisplayIsVblank(void); + #ifdef __cplusplus } #endif diff --git a/src/fpu/Makefile.am b/src/fpu/Makefile.am index a44fbc68..de1c5d12 100644 --- a/src/fpu/Makefile.am +++ b/src/fpu/Makefile.am @@ -14,5 +14,5 @@ libpspfpuincludedir = @PSPSDK_INCLUDEDIR@ libpspfpuinclude_HEADERS = pspfpu.h lib_LIBRARIES = libpspfpu.a -libpspfpu_a_SOURCES = pspfpu.c +libpspfpu_a_SOURCES = pspfpu.c double.S libpspfpu_a_LIBADD = diff --git a/src/fpu/double.S b/src/fpu/double.S new file mode 100644 index 00000000..61399319 --- /dev/null +++ b/src/fpu/double.S @@ -0,0 +1,196 @@ +#define zero $0 /* wired zero */ +#define at $1 /* assembler temp */ +#define v0 $2 /* return value */ +#define v1 $3 +#define a0 $4 /* argument registers */ +#define a1 $5 +#define a2 $6 +#define a3 $7 +#define t0 $8 /* caller saved */ +#define t1 $9 +#define t2 $10 +#define t3 $11 +#define t4 $12 +#define t5 $13 +#define t6 $14 +#define t7 $15 +#define s0 $16 /* callee saved */ +#define s1 $17 +#define s2 $18 +#define s3 $19 +#define s4 $20 +#define s5 $21 +#define s6 $22 +#define s7 $23 +#define t8 $24 /* code generator */ +#define t9 $25 +#define k0 $26 /* kernel temporary */ +#define k1 $27 +#define gp $28 /* global pointer */ +#define sp $29 /* stack pointer */ +#define fp $30 /* frame pointer */ +#define ra $31 /* return address */ + +#define fv0 $f0 +#define fv1 $f1 +#define ft0 $f2 +#define ft1 $f3 +#define ft2 $f4 +#define ft3 $f5 +#define ft4 $f6 +#define ft5 $f7 +#define ft6 $f8 +#define ft7 $f9 +#define ft8 $f10 +#define ft9 $f11 +#define fa0 $f12 +#define fa1 $f13 +#define fa2 $f14 +#define fa3 $f15 +#define fa4 $f16 +#define fa5 $f17 +#define fa6 $f18 +#define fa7 $f19 +#define fs0 $f20 +#define fs1 $f21 +#define fs2 $f22 +#define fs3 $f23 +#define fs4 $f24 +#define fs5 $f25 +#define fs6 $f26 +#define fs7 $f27 +#define fs8 $f28 +#define fs9 $f29 +#define fs10 $f30 +#define fs11 $f31 + +.set noreorder +.set noat + +.text +.align 4 + +.global pspFpuFloatToDouble +.global pspFpuDoubleToFloat + +/** + * convert float to double + * double pspFpuFloatToDouble(float a); + * + * input: fa0 + * output: v0,v1 + * clobber: t0,t1 + */ +.ent pspFpuFloatToDouble +pspFpuFloatToDouble: + mfc1 t0, fa0 /* t0 = fa0 */ + ext t1, t0, 23, 8 /* t1 = (t0 >> 23) & 0xFF */ + beq t1, zero, ftod_denormal /* if (t1==0) goto ftod_denormal */ + addiu v0, t1, (-0x7F+0x3FF) /* v0 = t1 - 0x7F + 0x3FF */ + xori t1, t1, 0xFF /* t1 = t1 ^ 0xFF */ + li v1, 0x7FF /* v1 = 0x7FF */ + movz v0, v1, t1 /* v0 = (t1==0) ? v1 : v0 */ + ext v1, t0, 3, 20 /* v1 = (t0 >> 3 ) & 0x00FFFFF */ + ins v1, v0, 20, 11 /* v1 = (v1 & 0x800FFFFF) | ((v0<<20) & 0x7FF00000) */ + sll v0, t0, 29 /* v0 = (t0 << 29) */ + srl t0, t0, 31 /* t0 = (t0 >> 31) & 1 */ + jr ra /* return */ + ins v1, t0, 31, 1 /* v1 = (v1 & 0x7FFFFFFF) | ((t0<<31) & 0x80000000) */ + +ftod_denormal: + sll v0, t0, 9 /* v0 = t0 << 9 */ + beql v0, zero, ftod_zero /* if (v0==0) goto ftod_zero */ + move v1, zero /* v1 = 0 */ + li v1, 0x380 /* v1 = 0x380 */ + clz t1, v0 /* t1 = clz(v0) */ + subu v0, v1, t1 /* v0 = v1 - v0 = 0x380 - clz(t1) */ + sllv t1, t0, t1 /* t1 = t0 << t1 */ + ext v1, t1, 2, 20 /* v1 = (t1 >> 2 ) & 0x00FFFFF */ + ins v1, v0, 20, 11 /* v1 = (v1 & 0x800FFFFF) | ((v0<<20) & 0x7FF00000) */ + sll v0, t1, 30 /* v0 = (t1 << 30) */ +ftod_zero: + srl t0, t0, 31 /* t0 = (t0 >> 31) & 1 */ + jr ra /* return */ + ins v1, t0, 31, 1 /* v1 = (v1 & 0x7FFFFFFF) | ((t0<<31) & 0x80000000) */ +.end pspFpuFloatToDouble + +/** + * convert double to float + * float pspFpuDoubleToFloat(double a); + * input: a0,a1 + * output: fv0 + * clobber: t0,t1,t2,v0 + */ +.ent pspFpuDoubleToFloat +pspFpuDoubleToFloat: + ext t0, a1, 20, 11 /* t0 = (a1>>20) & 0x000007FF */ + beq t0, zero, dtof_zero /* if (t0==0) goto dtof_zero */ + xori t1, t0, 0x7FF /* t1 = t0 ^ 0x7FF */ + beq t1, zero, dtof_naninf /* if (t1==0) goto dtof_naninf */ + addiu t1, t0, (+0x7F-0x3FF) /* t1 = t0 + 0x7F - 0x3FF */ + blez t1, dtof_denormal /* if (t1<=0) goto dtof_denormal */ + addiu t2, t1, -0xFE /* t2 = t1 - 0xFE */ + bgtz t2, dtof_inf /* if (t2 > 0) goto dtof_inf */ + move v0, zero /* v0 = 0 */ + + srl v0, a0, 29 /* v0 = (a0>>29) & 0x00000007 */ + ins v0, a1, 3, 20 /* v0 = (v0 & 0xFF800007) | ((a1 & 0FFFFF)<<3) */ + beq t2, zero, dtof_inf_normal /* if (t2==0) goto dtof_inf_normal */ +dtof_normal: + srl t2, a1, 31 /* t2 = (a1>>31) & 1 */ + ins v0, t2, 31, 1 /* v0 = (v0 & 0x7FFFFFFF) | (t2 << 31) */ + ins v0, t1, 23, 8 /* v0 = (v0 & 0x8007FFFF) | (t1 << 23) */ + jr ra /* return */ + mtc1 v0, fv0 /* fv0 = v0 */ +dtof_denormal: + sll t0, a1, 12 /* t0 = a1 << 12 */ + srl v0, t0, 10 /* v0 = t0 >> 10 */ + srl t0, a0, 30 /* t0 = t0 >> 30 */ + or v0, v0, t0 /* v0 = v0 | t0 */ + li t0, 0x00400000 /* t0 = 0x00400000 */ + or v0, v0, t0 /* v0 = v0 | t0 */ + subu t0, zero, t1 /* t0 = zero - t1 */ + sltiu t1, t0, 22 /* t1 = (t0 < 22) */ + beq t1, zero, dtof_min /* if (t1==0) goto dtof_min */ + srlv v0, v0, t0 /* v0 = v0 >> t0 */ + srl t2, a1, 31 /* t2 = (a1>>31) & 1 */ + ins v0, t2, 31, 1 /* v0 = (v0 & 0x7FFFFFFF) | (t2 << 31) */ + jr ra /* return */ + mtc1 v0, fv0 /* fv0 = v0 */ +dtof_zero: + sll t0, a1, 12 /* t0 = a1 << 12 */ + or t0, t0, a0 /* t0 = t0 | a0 */ +dtof_min: + li v0, 0x00000001 /* v0 = 0x00000001 */ + movz v0, zero, t0 /* v0 = (t0==0) ? zero : v0 */ + srl t0, a1, 31 /* t0 = (a1 >> 31) & 1 */ + ins v0, t0, 31, 1 /* v0 = (v0 & 0x7FFFFFFF) | ((t0<<31) & 0x80000000) */ + jr ra /* return */ + mtc1 v0, fv0 /* fv0 = v0 */ +dtof_inf_normal: + nor t0, zero, a1 /* t0 = ~a1 */ + sll t0, t0, 12 /* t0 = t0 << 12 */ + bne t0, zero, dtof_normal /* if (t0!=0) goto dtof_normal */ + srl t0, a0, 28 /* t0 = a0 >> 28 */ + sltiu t0, t0, 0xF /* t0 = (t0 < 0xF) */ + bne t0, zero, dtof_normal /* if (t0!=0) goto dtof_normal */ + nop /* waste delay slot */ + j dtof_inf /* goto dtof_inf */ + move v0, zero /* v0 = 0 */ +dtof_naninf: + sll t0, a1, 12 /* t0 = a1 << 12 */ + or t1, t0, a0 /* t1 = t0 | a0 */ + srl v0, t0, 9 /* v0 = t0 >> 9 */ + srl t0, a0, 29 /* t0 = t0 >> 29 */ + or v0, v0, t0 /* v0 = v0 | t0 */ + sltiu t0, v0, 1 /* t0 = (v0 < 1) */ + or v0, v0, t0 /* v0 = v0 | t0 */ + movz v0, zero, t1 /* v0 = (t1==0) ? zero : v0 */ +dtof_inf: + li t0, 0x7F800000 /* t0 = 0x7F800000 */ + or v0, v0, t0 /* v0 = v0 | t0 */ + srl t0, a1, 31 /* t0 = (a1 >> 31) & 1 */ + ins v0, t0, 31, 1 /* v0 = (v0 & 0x7FFFFFFF) | ((t0<<31) & 0x80000000) */ + jr ra /* return */ + mtc1 v0, fv0 /* fv0 = v0 */ +.end pspFpuDoubleToFloat diff --git a/src/fpu/pspfpu.c b/src/fpu/pspfpu.c index d5dcff4f..0bcab53d 100644 --- a/src/fpu/pspfpu.c +++ b/src/fpu/pspfpu.c @@ -5,13 +5,42 @@ * * pspfpu.h - PSP FPU library * - * Copyright (c) 2006 TyRaNiD (James F.) + * Copyright (c) 2009 JetCube + * Copyright (c) 2006 TyRaNiD (James F.) * - * $Id: pspfpu.c 1781 2006-02-04 12:53:40Z tyranid $ */ #include "pspfpu.h" -uint32_t pspfpu_get_fcr31(void) +#define PSP_MATH_PI 3.14159265358979323846 +#define PSP_MATH_TWOPI (PSP_MATH_PI * 2.0) +#define PSP_MATH_SQRT2 1.41421356237309504880 +#define PSP_MATH_LN2 0.69314718055994530942 +#define PSP_MATH_LOG2E 1.4426950408889634074 +#define COS_SIN_DIV 0.208 + +static const float logPoly[] = { + 4194305.0 / (1024.0 * 1024.0 * 2.0), /* arround 2.0 */ + 5590817.0 / (1024.0 * 1024.0 * 8.0), /* arround 2.0/3.0 */ + 13890687.0 / (1024.0 * 1024.0 * 32.0), /* arround 2.0/5.0 */ +}; + +static const float triPoly[] = { + (float)(2.0*PSP_MATH_PI), + (float)(1.0), + (float)(-0xAAAA98/(1024.0*1024*64)), + (float)( 0x88801C/(1024.0*1024*1024)), + (float)(-0xCB9F27/(1024.0*1024*1024*64)), + + (float)(-0xFFFFF9/(1024.0*1024*32)), + (float)( 0xAAA6FB/(1024.0*1024*256)), + (float)(-0xB3D431/(1024.0*1024*1024*8)), + + (float)(-0xAAAAAA/(1024.0*1024*32)), + (float)( 0xCCCCCD/(1024.0*1024*64)), + (float)(-0x8F5C29/(1024.0*1024*64)), +}; + +uint32_t pspFpuGetFCR31(void) { uint32_t ret; @@ -23,129 +52,892 @@ uint32_t pspfpu_get_fcr31(void) return ret; } -void pspfpu_set_fcr31(uint32_t var) +void pspFpuSetFCR31(uint32_t var) { asm ( "ctc1 %0, $31\n" - : + : : "r"(var) ); } -void pspfpu_set_roundmode(enum FpuRoundMode mode) +void pspFpuSetRoundmode(enum PspFpuRoundMode mode) { uint32_t fcr; - fcr = pspfpu_get_fcr31(); - fcr &= ~FPU_RM_MASK; - fcr |= (mode & FPU_RM_MASK); - pspfpu_set_fcr31(fcr); + fcr = pspFpuGetFCR31(); + fcr &= ~PSP_FPU_RM_MASK; + fcr |= (mode & PSP_FPU_RM_MASK); + pspFpuSetFCR31(fcr); } -enum FpuRoundMode pspfpu_get_roundmode(void) +enum PspFpuRoundMode pspFpuGetRoundmode(void) { - return pspfpu_get_fcr31() & FPU_RM_MASK; + return pspFpuGetFCR31() & PSP_FPU_RM_MASK; } -uint32_t pspfpu_get_flags(void) +uint32_t pspFpuGetFlags(void) { uint32_t fcr; - fcr = pspfpu_get_fcr31(); - - return (fcr & FPU_FLAGS_MASK) >> FPU_FLAGS_POS; + fcr = pspFpuGetFCR31(); + + return (fcr & PSP_FPU_FLAGS_MASK) >> PSP_FPU_FLAGS_POS; } -void pspfpu_clear_flags(uint32_t clear) +void pspFpuClearFlags(uint32_t clear) { uint32_t fcr; clear &= 0x1F; - fcr = pspfpu_get_fcr31(); - fcr &= ~(clear << FPU_FLAGS_POS); - pspfpu_set_fcr31(fcr); + fcr = pspFpuGetFCR31(); + fcr &= ~(clear << PSP_FPU_FLAGS_POS); + pspFpuSetFCR31(fcr); } -uint32_t pspfpu_get_enable(void) +uint32_t pspFpuGetEnable(void) { uint32_t fcr; - fcr = pspfpu_get_fcr31(); - - return (fcr & FPU_ENABLE_MASK) >> FPU_ENABLE_POS; + fcr = pspFpuGetFCR31(); + + return (fcr & PSP_FPU_ENABLE_MASK) >> PSP_FPU_ENABLE_POS; } -void pspfpu_set_enable(uint32_t enable) +void pspFpuSetEnable(uint32_t enable) { uint32_t fcr; enable &= 0x1F; - fcr = pspfpu_get_fcr31() & ~FPU_ENABLE_MASK; - fcr |= enable << FPU_ENABLE_POS; - pspfpu_set_fcr31(fcr); + fcr = pspFpuGetFCR31() & ~PSP_FPU_ENABLE_MASK; + fcr |= enable << PSP_FPU_ENABLE_POS; + pspFpuSetFCR31(fcr); } -uint32_t pspfpu_get_cause(void) +uint32_t pspFpuGetCause(void) { uint32_t fcr; - fcr = pspfpu_get_fcr31(); - - return (fcr & FPU_CAUSE_MASK) >> FPU_CAUSE_POS; + fcr = pspFpuGetFCR31(); + + return (fcr & PSP_FPU_CAUSE_MASK) >> PSP_FPU_CAUSE_POS; } -void pspfpu_clear_cause(uint32_t clear) +void pspFpuClearCause(uint32_t clear) { uint32_t fcr; clear &= 0x3F; - fcr = pspfpu_get_fcr31(); - fcr &= ~(clear << FPU_CAUSE_POS); - pspfpu_set_fcr31(fcr); + fcr = pspFpuGetFCR31(); + fcr &= ~(clear << PSP_FPU_CAUSE_POS); + pspFpuSetFCR31(fcr); } -uint32_t pspfpu_get_fs(void) +uint32_t pspFpuGetFS(void) { uint32_t fcr; - fcr = pspfpu_get_fcr31(); - - return (fcr & FPU_FS_MASK) >> FPU_FS_POS; + fcr = pspFpuGetFCR31(); + + return (fcr & PSP_FPU_FS_MASK) >> PSP_FPU_FS_POS; } -void pspfpu_set_fs(uint32_t fs) +void pspFpuSetFS(uint32_t fs) { uint32_t fcr; - fcr = pspfpu_get_fcr31(); - fcr &= ~FPU_FS_MASK; + fcr = pspFpuGetFCR31(); + fcr &= ~PSP_FPU_FS_MASK; - fcr |= ((fs & 1) << FPU_FS_POS); + fcr |= ((fs & 1) << PSP_FPU_FS_POS); - pspfpu_set_fcr31(fcr); + pspFpuSetFCR31(fcr); } -uint32_t pspfpu_get_condbits(void) +uint32_t pspFpuGetCondbits(void) { uint32_t fcr; uint32_t cond; - fcr = pspfpu_get_fcr31(); - cond = (fcr & FPU_CC0_MASK) >> FPU_CC0_POS; - cond |= (fcr & FPU_CC17_MASK) >> (FPU_CC17_POS-1); + fcr = pspFpuGetFCR31(); + cond = (fcr & PSP_FPU_CC0_MASK) >> PSP_FPU_CC0_POS; + cond |= (fcr & PSP_FPU_CC17_MASK) >> (PSP_FPU_CC17_POS-1); return cond; } -void pspfpu_clear_condbits(uint32_t clear) +void pspFpuClearCondbits(uint32_t clear) { uint32_t fcr; clear &= 0xFF; - fcr = pspfpu_get_fcr31(); - fcr &= ~((clear & 1) << FPU_CC0_POS); - fcr &= ~((clear & 0xFE) << (FPU_CC17_POS-1)); + fcr = pspFpuGetFCR31(); + fcr &= ~((clear & 1) << PSP_FPU_CC0_POS); + fcr &= ~((clear & 0xFE) << (PSP_FPU_CC17_POS-1)); - pspfpu_set_fcr31(fcr); + pspFpuSetFCR31(fcr); +} + +float pspFpuAbs(float fs) +{ + register float fd; + asm ( + "abs.s %0, %1\n" + : "=f"(fd) + : "f"(fs) + ); + return (fd); +} + +int pspFpuCeil(float fs) +{ + return (__builtin_allegrex_ceil_w_s(fs)); +} + +int pspFpuFloor(float fs) +{ + return (__builtin_allegrex_floor_w_s(fs)); +} + +float pspFpuMax(float fs1, float fs2) +{ + register float fd; + fd = (fs1 > fs2) ? fs1 : fs2; + return (fd); +} + +float pspFpuMin(float fs1, float fs2) +{ + register float fd; + fd = (fs1 < fs2) ? fs1 : fs2; + return (fd); +} + +float pspFpuNeg(float fs) +{ + register float fd; + asm ( + "neg.s %0, %1\n" + : "=f"(fd) + : "f"(fs) + ); + return (fd); +} + +int pspFpuRound(float fs) +{ + return (__builtin_allegrex_round_w_s(fs)); +} + +float pspFpuRsqrt(float fs) +{ + return (1.0f / __builtin_allegrex_sqrt_s(fs)); +} + +float pspFpuSqrt(float fs) +{ + return (__builtin_allegrex_sqrt_s(fs)); +} + +int pspFpuTrunc(float fs) +{ + return (__builtin_allegrex_trunc_w_s(fs)); +} + +float pspFpuFmod(float fs, float fd) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "div.s %0, %1, %2\n" // v = fs / fd + "trunc.w.s %0, %0\n" // v = trunc(v) + "cvt.s.w %0, %0\n" // v = (float)v = (float)trunc(v) + "mul.s %0, %0, %2\n" // v = v * fd + "sub.s %0, %1, %0\n" // v = fs - v*fd = fs - trunc(fs / fd)*fd + ".set pop\n" + : "=&f"(v) + : "f"(fs), "f"(fd) + ); + return (v); +} + +float pspFpuFrac(float fs) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "trunc.w.s %0, %1\n" // v = trunc(fs) + "cvt.s.w %0, %0\n" // v = (float)v = (float)trunc(fs) + "sub.s %0, %1, %0\n" // v = fs - v + ".set pop\n" + : "=&f"(v) + : "f"(fs) + ); + return (v); +} + +float pspFpuReinterpretFloat(uint32_t ui) +{ + float v; + asm ( + "mtc1 %1, %0\n" + : "=f"(v) + : "r"(ui) + ); + return (v); +} + +uint32_t pspFpuReinterpretUint(float fs) +{ + unsigned int v; + asm ( + "mfc1 %0, %1\n" + : "=r"(v) + : "f"(fs) + ); + return (v); +} + +int pspFpuIsEqual(float fs1, float fs2) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "c.eq.s %2, %1\n" // compare fs1 to fs2 + "move %0, $0\n" // v = 0 + "bc1tl 0f\n" // if (fs1==fs2) goto 0f + "addiu %0, $0, 1\n" // if (fs1==fs2) v = 1 + "0:\n" + ".set pop\n" + : "=r"(v) + : "f"(fs1), "f"(fs2) + ); + return (v); +} + +float pspFpuSignFloat(float fs) +{ + float fv; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 $8, %1\n" // t0 = fs + "lui $10, 0x3F80\n" // t2 = 0x3F800000(1.0f) + "srl $9, $8, 23\n" // t1 = t0>>23 + "srl $8, $8, 31\n" // t0 = t0>>31 + "andi $9, $9, 0x00FF\n" // t1 = t1 & 0x00FF + "sll $8, $8, 31\n" // t0 = t0<<31 = (fs>=0) ? 0 : 0x80000000 + "movz $10, $0, $9\n" // t2 = (t1==0) ? 0 : t2 + "or $10, $10, $8\n" // t2 = t2 | t0 + "mtc1 $10, %0\n" // fv = t2 + ".set pop\n" + : "=f"(fv) + : "f"(fs) + : "$8", "$9", "$10" + ); + return (fv); +} + +int pspFpuSignInt(float fs) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 %0, %1\n" // v = fs + "lui $8, 0x7F80\n" // t0 = 0x7F800000(binary representaion 1.0 * 2^(255-127)) + "and $8, $8, %0\n" // t0 = at & v + "sra %0, %0, 30\n" // v = fs>>30 = (fs>=0) ? 0or1 : -1or-2 + "or %0, %0, 1\n" // v = v | 1 = (fs>=0) ? 1 : -1 + "movz %0, $0, $8\n" // v = (t0==0) ? 0 : v + ".set pop\n" + : "=r"(v) + : "f"(fs) + : "$8" + ); + return (v); +} + +float pspFpuPositiveZero(void) +{ + float v; + asm ( + "mtc1 $0, %0\n" // v = 0.0f + : "=f"(v) + ); + return (v); +} + +float pspFpuNegativeZero(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0x8000\n" // t0 = 0x80000000 + "mtc1 $8, %0\n" // v = -0.0f + ".set pop\n" + : "=f"(v) + : + : "$8" + ); + return (v); +} + +int pspFpuIsZero(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 $8, %1\n" // t0 = f + "sra %0, $8, 30\n" // v = t0>>30 + "sll $8, $8, 1\n" // t0 = t0<<1 + "ori %0, %0, 0x0001\n" // v = v | 1 = (f>=0) ? +1 : -1 + "movn %0, $0, $8\n" // v = (t0!=0) ? 0 : v + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8" + ); + return (v); +} + +int pspFpuIsPositiveZero(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 %0, %1\n" // v = f + "sltiu %0, %0, 1\n" // v = (v < 1) + ".set pop\n" + : "=r"(v) + : "f"(f) + ); + return (v); +} + +int pspFpuIsNegativeZero(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 %0, %1\n" // v = f + "lui $8, 0x8000\n" // t0 = 0x80000000 + "xor %0, %0, $8\n" // v = v ^ t0 + "sltiu %0, %0, 1\n" // v = (v < 1) + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8" + ); + return (v); +} + +int pspFpuIsDenormal(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 $8, %1\n" // t0 = f + "lui $9, 0x7F80\n" // t1 = 0x7F800000 + "or %0, $8, $9\n" // v = t0 | t1 = t0 | 0x7F800000 + "and $9, $8, $9\n" // t1 = t0 & t1 = t0 & 0x7F800000 + "sra %0, %0, 30\n" // v = v>>30 = (t0>=0) ? +1 : -1 + "sll $8, $8, 9\n" // t0 = t0<<9 + "movn %0, $0, $9\n" // v = (t1!=0) ? 0 : v if (exp!=0) is not denormal number + "movz %0, $0, $8\n" // v = (t0==0) ? 0 : v if (frac==0) is not decnormal number + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8", "$9" + ); + return (v); +} + +int pspFpuIsZeroOrDenormal(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 $8, %1\n" // t0 = f + "lui $9, 0x7F80\n" // t1 = 0x7F800000 + "or %0, $8, $9\n" // v = t0 | t1 = t0 | 0x7F800000 + "and $9, $8, $9\n" // t1 = t0 & t1 = t0 & 0x7F800000 + "sra %0, %0, 30\n" // v = v>>30 = (t0>=0) ? +1 : -1 + "movn %0, $0, $9\n" // v = (t1!=0) ? 0 : v if (exp!=0) is not denormal number + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8", "$9" + ); + return (v); +} + +float pspFpuPositiveInf(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0x7F80\n" // t0 = 0x7F800000 + "mtc1 $8, %0\n" // v = t0 = +Infinity + ".set pop\n" + : "=f"(v) + : + : "$8" + ); + return (v); +} + +float pspFpuNegativeInf(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0xFF80\n" // t0 = 0xFF800000 + "mtc1 $8, %0\n" // v = t0 = -Infinity + ".set pop\n" + : "=f"(v) + ); + return (v); +} + +int pspFpuIsInf(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 $8, %1\n" // t0 = f + "sll $9, $8, 1\n" // t1 = t0<<1 + "sra %0, $8, 30\n" // v = t0>>30 + "srl $9, $9, 24\n" // t1 = t1>>24 + "sll $8, $8, 9\n" // t0 = t0<<9 + "ori %0, %0, 0x0001\n" // v = v | 0x00000001 = (f>=0) ? +1 : -1 + "sltiu $9, $9, 0x00FF\n" // t1 = (t1<0xFF) + "movn %0, $0, $8\n" // v = (t0!=0) ? 0 : v if (frac!=0) is not Infinity + "movn %0, $0, $9\n" // v = (t1!=0) ? 0 : v if (exp!=0xFF) is not Infinity + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8", "$9" + ); + return (v); +} + +float pspFpuPositiveNaN(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0x7F80\n" + "ori $8, $8, 0x0001\n" // t0 = 0x7F800001 + "mtc1 $8, %0\n" // v = t0 = +SNaN(0x000001) + ".set pop\n" + : "=f"(v) + : + : "$8" + ); + return (v); +} + +float pspFpuNegativeNaN(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0xFF80\n" + "ori $8, $8, 0x0001\n" // t0 = 0xFF800001 + "mtc1 $8, %0\n" // v = t0 = -SNaN(0x000001) + ".set pop\n" + : "=f"(v) + : + : "$8" + ); + return (v); +} + +float pspFpuPositiveQNaN(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0x7FC0\n" // t0 = 0x7FC00000 + "mtc1 $8, %0\n" // v = t0 = +QNaN + ".set pop\n" + : "=f"(v) + : + : "$8" + ); + return (v); +} + +float pspFpuNegativeQNaN(void) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui $8, 0xFFC0\n" // t0 = 0xFFC00000 + "mtc1 $8, %0\n" // v = t0 = -QNaN + ".set pop\n" + : "=f"(v) + : + : "$8" + ); + return (v); +} + +float pspFpuPositiveSNaN(unsigned int uiSignal) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "addiu $9, $0, 1\n" // t1 = 0x00000001 + "ext $8, %1, 0, 22\n" // t0 = uiSignal & 0x003FFFFF + "movn $9, $8, $8\n" // t1 = (t0!=0) ? t0 : t1 + "lui $8, 0x7F80\n" // t0 = 0x7F800000 + "or $9, $9, $8\n" // t1 = t1 | t0 + "mtc1 $9, %0\n" // v = t1 + ".set pop\n" + : "=f"(v) + : "r"(uiSignal) + : "$8", "$9" + ); + return (v); +} + +float pspFpuNegativeSNaN(unsigned int uiSignal) +{ + float v; + asm ( + ".set push\n" + ".set noreorder\n" + "addiu $9, $0, 1\n" // t1 = 0x00000001 + "ext $8, %1, 0, 22\n" // t0 = uiSignal & 0x003FFFFF + "movn $9, $8, $8\n" // t1 = (t0!=0) ? t0 : t1 + "lui $8, 0xFF80\n" // t0 = 0xFF800000 + "or $9, $9, $8\n" // t1 = t1 | t0 + "mtc1 $9, %0\n" // v = t1 + ".set pop\n" + : "=f"(v) + : "r"(uiSignal) + : "$8", "$9" + ); + return (v); +} + +int pspFpuIsNaN(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "lui %0, 0x807F\n" // + "mfc1 $8, %1\n" // t0 = f + "ori %0, %0, 0xFFFF\n" // v = 0x807FFFFF + "sll $9, $8, 1\n" // t1 = t0<<1 + "and %0, %0, $8\n" // v = v & t0 + "srl $9, $9, 24\n" // t1 = t1>>24 + "sll $8, $8, 9\n" // t0 = t0<<9 + "sltiu $9, $9, 0x00FF\n" // t1 = (t1<0xFF) + "movz %0, $0, $8\n" // v = (t0==0) ? 0 : v if (frac==0) is not NaN + "movn %0, $0, $9\n" // v = (t1!=0) ? 0 : v if (exp!=0xFF) is not NAN + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8", "$9" + ); + return (v); +} + +int pspFpuIsInfOrNaN(float f) +{ + int v; + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 %0, %1\n" // v = f + "sll $8, %0, 1\n" // t0 = v<<1 + "sra %0, %0, 30\n" // v = v>>30 + "srl $8, $8, 24\n" // t0 = t0>>24 + "ori %0, %0, 0x0001\n" // v = v | 0x00000001 = (f>=0) ? +1 : -1 + "sltiu $8, $8, 0x00FF\n" // t0 = (t0<0xFF) + "movn %0, $0, $8\n" // v = (t0!=0) ? 0 : v if (exp!=0xFF) is neither NAN nor Infinity + ".set pop\n" + : "=r"(v) + : "f"(f) + : "$8" + ); + return (v); +} + +float pspFpuNormalizePhase(float fs) +{ + const float f2pi = PSP_MATH_TWOPI; + float fd; + + asm ( + ".set push\n" + ".set noreorder\n" + "mfc1 $9, %1\n" // t1 = f0 + "div.s $f0, $f0, %2\n" // f0 = f0 / f2pi = fs / 2PI + "round.w.s $f0, $f0\n" // f0 = (int)(f0+0.5) + "cvt.s.w $f0, $f0\n" // f0 = float(f0) + "mul.s $f0, $f0, %2\n" // f0 = f0 * f2pi = fd * 2PI + "sub.s %0, %1, $f0\n" // fd = fs - f0 = fs - (fd * 2PI) + ".set pop\n" + : "=f"(fd) + : "f"(fs), "f"(f2pi) + : "$f0", "$8", "$9" + ); + return (fd); +} + +float pspFpuLog(float x) +{ + union { + float f; + int i; + } fi; + int a, b, exponent; + float y, z; + fi.f = x; + if (fi.i <= 0) { + if ((fi.i & 0x7fffffff) == 0) { + fi.i = 0xff800000; /* -INF */ + return fi.f; + } + fi.i = 0xff80ffff; /* Quiet NaN */ + return fi.f; + } + + b = (fi.i & 0x007fffff); + a = b - (1<<23); + exponent = fi.i; + if (b <= 0x3504F3) { + a = b; + b = b - (1 << 23); + exponent -= (1<<23); + } + b = b - (1 << 23) + (1<<25); + + x = (float)(a) / (float)(b); + z = (((exponent>>23)-126) * 0xB17218) * (float)(1.0/(1<<24)); + y = x * x; + return z + x * (((logPoly[2] * y + logPoly[1]) * y) + logPoly[0]); +} + +float pspFpuExp(float x) +{ + /* + * exp(x)=e^x=e^(y * log2)=2^Y + * =2^z * 2^y + * =2^z * (2^(y/2))^2 + * =2^z * (e^(f/2))^2 + * =2^z * (e^(f/4))^4 + * where y=x/log 2 + * z=nearest(y) , -0.5 <= f=y-z < 0.5 + */ + union { + float f; + int i; + } fi; + float z, f; + + fi.f = x; + fi.i &= 0x7fffffff; + if (fi.i >= 0x42b00f34) {/* arround 88.03 */ + /* overflow */ + if (x != x) { + return x; /* NaN */ + } + if (fi.i < 0) { + return 0.0; /* underflow */ + } + fi.i = 0x7f800000; + return fi.f; /* +INF */ + } + + f = fi.f * (float)PSP_MATH_LOG2E; + + z = __builtin_allegrex_round_w_s(f); + f = f-z; + fi.i = z; + if (x < 0) + fi.i = -fi.i; + fi.i = (fi.i+127) << 23; + + /* use Pade aprox. */ + f = (6.0f + (float)(4.0*PSP_MATH_LN2 * 0.25)*f + + (float)(0.9996*PSP_MATH_LN2*0.25*PSP_MATH_LN2*0.25)*f*f) + / (6.0f - (float)(2.0*PSP_MATH_LN2 * 0.25)*f); + f *= f; + fi.f *= f*f; + return fi.f; +} + +static float _pspFpuSinMain(float x) +{ + float y = x*x; + return x * (((triPoly[4] * y + + triPoly[3]) * y + + triPoly[2]) * y + + triPoly[1]); +} + +static float _pspFpuCosMain(float x) +{ + float y = x*x; + return ((triPoly[7] * y + + triPoly[6]) * y + + triPoly[5]) * y + + triPoly[1]; +} + +static float _pspFpuAtanMain(float x) +{ + float y = x*x; + return x * (((triPoly[10] * y + + triPoly[9]) * y + + triPoly[8]) * y + + triPoly[1]); +} + + +float pspFpuSin(float x) +{ + float pi2; + int sign = 1; + + /* NaN */ + if (x != x) { + return x; + } + + pi2 = triPoly[0]; + if (x < 0.0f) { + sign = -1; + x = -x; + } + + if (x > pi2) { + float y = x / pi2; + x -= (float)((int)y) * pi2; + } + + pi2 *= 0.5f; + if (x > pi2) { + x -= pi2; + sign = -sign; + } + + if (x > pi2*0.5f) { + x = pi2 - x; + } + if (x > (float)(PSP_MATH_PI * (0.5 - COS_SIN_DIV))) { + return _pspFpuCosMain(pi2*0.5f - x) * sign; + } + + return _pspFpuSinMain(x) * sign; +} + + +float pspFpuCos(float x) +{ + float pi2; + int sign = 1; + + /* NaN */ + if (x != x) { + return x; + } + + pi2 = triPoly[0]; + if (x < 0.0f) { + x = -x; + } + + if (x > pi2) { + float y = x / pi2; + x -= (float)((int)y) * pi2; + } + + pi2 *= 0.5f; // pi2 = PI + if (x > pi2) { + x -= pi2; + sign = -1; + } + + if (x > pi2*0.5f) { + sign = -sign; + x = pi2 - x; + } + if (x > (float) (PSP_MATH_PI * COS_SIN_DIV)) { + return _pspFpuSinMain(pi2*0.5f - x) * sign; + } + + return _pspFpuCosMain(x) * sign; +} + +static float _atanf(float x) +{ + if (x < 0.19890f) { + return _pspFpuAtanMain(x); + } + if (x < 0.668106f) { + return (float)(PSP_MATH_PI / 8) + + _pspFpuAtanMain((x - (float)(PSP_MATH_SQRT2 - 1)) / (1.0f + ((float)(PSP_MATH_SQRT2 - 1)*x))); + } + return ((float)PSP_MATH_PI / 4) + _pspFpuAtanMain((x - 1.0f) / (x + 1.0f)); +} + + +float pspFpuAtan(float x) +{ + int sign = 1; + + /* NaN */ + if (x != x) { + return x; + } + + if (x < 0.0f) { + x = -x; + sign = -1; + } + if (x >= 1.0f) { + /*J atan(x) = pi/2 - atan(1/x) */ + x = 1.0f / x; + x = ((float)(PSP_MATH_PI / 2)) - _atanf(x); + } else { + x = _atanf(x); + } + return x * (float)sign; +} + +float pspFpuAsin(float x) +{ + x = x*x; + return pspFpuAtan(__builtin_allegrex_sqrt_s(x/(1.0f-x))); +} + +float pspFpuAcos(float x) +{ + x = x*x; + return pspFpuAtan(__builtin_allegrex_sqrt_s((1.0f-x)/x)); } diff --git a/src/fpu/pspfpu.h b/src/fpu/pspfpu.h index 8bc0c888..110be7b0 100644 --- a/src/fpu/pspfpu.h +++ b/src/fpu/pspfpu.h @@ -5,7 +5,8 @@ * * pspfpu.h - Prototypes for the FPU library * - * Copyright (c) 2006 TyRaNiD (James F.) + * Copyright (c) 2009 JetCube + * Copyright (c) 2006 TyRaNiD (James F.) * * $Id: pspfpu.h 1782 2006-02-04 12:57:05Z tyranid $ */ @@ -23,131 +24,131 @@ extern "C" { #endif /** Enumeration for FPU rounding modes */ -enum FpuRoundMode +enum PspFpuRoundMode { /** Round to nearest representable value */ - FPU_RN = 0, + PSP_FPU_RN = 0, /** Round towards zero */ - FPU_RZ = 1, + PSP_FPU_RZ = 1, /** Round towards plus infinity */ - FPU_RP = 2, - /** Round towards minus infinity */ - FPU_RM = 3, + PSP_FPU_RP = 2, + /** Round towards minus infinity */ + PSP_FPU_RM = 3, }; /** Mask value for rounding mode */ -#define FPU_RM_MASK 0x03 +#define PSP_FPU_RM_MASK 0x03 /** Enumeration for FPU exceptions */ -enum FpuExceptions +enum PspFpuExceptions { /** Inexact operation exception */ - FPU_EXCEPTION_INEXACT = 0x01, + PSP_FPU_EXCEPTION_INEXACT = 0x01, /** Underflow exception */ - FPU_EXCEPTION_UNDERFLOW = 0x02, + PSP_FPU_EXCEPTION_UNDERFLOW = 0x02, /** Overflow exception */ - FPU_EXCEPTION_OVERFLOW = 0x04, + PSP_FPU_EXCEPTION_OVERFLOW = 0x04, /** Division by zero exception */ - FPU_EXCEPTION_DIVBYZERO = 0x08, + PSP_FPU_EXCEPTION_DIVBYZERO = 0x08, /** Invalid operation exception */ - FPU_EXCEPTION_INVALIDOP = 0x10, + PSP_FPU_EXCEPTION_INVALIDOP = 0x10, /** Unimplemented operation exception (only supported in the cause bits) */ - FPU_EXCEPTION_UNIMPOP = 0x20, + PSP_FPU_EXCEPTION_UNIMPOP = 0x20, /** All exceptions */ - FPU_EXCEPTION_ALL = 0x3F + PSP_FPU_EXCEPTION_ALL = 0x3F }; /** Bit position of the flag bits */ -#define FPU_FLAGS_POS 2 +#define PSP_FPU_FLAGS_POS 2 /** Bit position of the enable bits */ -#define FPU_ENABLE_POS 7 +#define PSP_FPU_ENABLE_POS 7 /** Bit position of the cause bits */ -#define FPU_CAUSE_POS 12 +#define PSP_FPU_CAUSE_POS 12 /** Bit position of the cc0 bit */ -#define FPU_CC0_POS 23 +#define PSP_FPU_CC0_POS 23 /** Bit position of the fs bit */ -#define FPU_FS_POS 24 +#define PSP_FPU_FS_POS 24 /** Bit position of the cc1->7 bits */ -#define FPU_CC17_POS 25 +#define PSP_FPU_CC17_POS 25 -#define FPU_FLAGS_MASK (0x1F << FPU_FLAGS_POS) -#define FPU_ENABLE_MASK (0x1F << FPU_ENABLE_POS) -#define FPU_CAUSE_MASK (0x3F << FPU_CAUSE_POS) -#define FPU_CC0_MASK (1 << FPU_CC0_POS) -#define FPU_FS_MASK (1 << FPU_FS_POS) -#define FPU_CC17_MASK (0x7F << FPU_CC17_POS) +#define PSP_FPU_FLAGS_MASK (0x1F << PSP_FPU_FLAGS_POS) +#define PSP_FPU_ENABLE_MASK (0x1F << PSP_FPU_ENABLE_POS) +#define PSP_FPU_CAUSE_MASK (0x3F << PSP_FPU_CAUSE_POS) +#define PSP_FPU_CC0_MASK (1 << PSP_FPU_CC0_POS) +#define PSP_FPU_FS_MASK (1 << PSP_FPU_FS_POS) +#define PSP_FPU_CC17_MASK (0x7F << PSP_FPU_CC17_POS) /** * Get the current value of the control/status register * * @return The value of the control/status register */ -uint32_t pspfpu_get_fcr31(void); +uint32_t pspFpuGetFCR31(void); /** * Set the current value of the control/status register * * @param var - The value to set. */ -void pspfpu_set_fcr31(uint32_t var); +void pspFpuSetFCR31(uint32_t var); /** * Set the current round mode * - * @param mode - The rounding mode to set, one of ::FpuRoundMode + * @param mode - The rounding mode to set, one of ::PspFpuRoundMode */ -void pspfpu_set_roundmode(enum FpuRoundMode mode); +void pspFpuSetRoundmode(enum PspFpuRoundMode mode); /** * Get the current round mode * - * @return The round mode, one of ::FpuRoundMode + * @return The round mode, one of ::PspFpuRoundMode */ -enum FpuRoundMode pspfpu_get_roundmode(void); +enum PspFpuRoundMode pspFpuGetRoundmode(void); /** * Get the exception flags (set when an exception occurs but * the actual exception bit is not enabled) * - * @return Bitmask of the flags, zero or more of ::FpuExceptions + * @return Bitmask of the flags, zero or more of ::PspFpuExceptions */ -uint32_t pspfpu_get_flags(void); +uint32_t pspFpuGetFlags(void); -/** +/** * Clear the flags bits * - * @param clear - Bitmask of the bits to clear, one or more of ::FpuExceptions + * @param clear - Bitmask of the bits to clear, one or more of ::PspFpuExceptions */ -void pspfpu_clear_flags(uint32_t clear); +void pspFpuClearFlags(uint32_t clear); /** * Get the exception enable flags * - * @return Bitmask of the flags, zero or more of ::FpuExceptions + * @return Bitmask of the flags, zero or more of ::PspFpuExceptions */ -uint32_t pspfpu_get_enable(void); +uint32_t pspFpuGetEnable(void); -/** +/** * Set the enable flags bits * - * @param enable - Bitmask of exceptions to enable, zero or more of ::FpuExceptions + * @param enable - Bitmask of exceptions to enable, zero or more of ::PspFpuExceptions */ -void pspfpu_set_enable(uint32_t enable); +void pspFpuSetEnable(uint32_t enable); /** * Get the cause bits (only useful if you installed your own exception handler) * - * @return Bitmask of flags, zero or more of ::FpuExceptions + * @return Bitmask of flags, zero or more of ::PspFpuExceptions */ -uint32_t pspfpu_get_cause(void); +uint32_t pspFpuGetCause(void); /** * Clear the cause bits * - * @param clear - Bitmask of the bits to clear, one or more of ::FpuExceptions + * @param clear - Bitmask of the bits to clear, one or more of ::PspFpuExceptions * */ -void pspfpu_clear_cause(uint32_t clear); +void pspFpuClearCause(uint32_t clear); /** * Get the current value of the FS bit (if FS is 0 then an exception occurs with @@ -155,28 +156,253 @@ void pspfpu_clear_cause(uint32_t clear); * * @return The current state of the FS bit (0 or 1) */ -uint32_t pspfpu_get_fs(void); +uint32_t pspFpuGetFS(void); /** * Set the FS bit * * @param fs - 0 or 1 to unset or set fs */ -void pspfpu_set_fs(uint32_t fs); +void pspFpuSetFS(uint32_t fs); /** * Get the condition flags (8 bits) * * @return The current condition flags */ -uint32_t pspfpu_get_condbits(void); +uint32_t pspFpuGetCondbits(void); /** * Clear the condition bits * * @param clear - Bitmask of the bits to clear */ -void pspfpu_clear_condbits(uint32_t clear); +void pspFpuClearCondbits(uint32_t clear); + +/** + * returns absolute value + */ +float pspFpuAbs(float f); + +/** + * Round up + */ +int pspFpuCeil(float f); + +/** + * Truncate + */ +int pspFpuFloor(float f); + +/** + * select maximum value + */ +float pspFpuMax(float f1, float f2); + +/** + * select minimum value + */ +float pspFpuMin(float f1, float f2); + +/** + * Sign reversal + */ +float pspFpuNeg(float f); + +/** + * Round to nearest + */ +int pspFpuRound(float f); + +/* + * Reciprocal of square root + */ +float pspFpuRsqrt(float f); + +/** + * Square root + */ +float pspFpuSqrt(float f); + +/** + * Round towards zero + */ +int pspFpuTrunc(float f); + +/** + * + */ +float pspFpuFmod(float fs, float fd); + +/** + * + */ +float pspFpuFrac(float f); + +/** + * + */ +float pspFpuReinterpretFloat(uint32_t ui); + +/** + * + */ +uint32_t pspFpuReinterpretUint(float f); + +/** + * + */ +int pspFpuIsEqual(float f1, float f2); + +/** + * + */ +float pspFpuSignFloat(float f); + +/** + * + */ +int pspFpuSignInt(float f); + +/** + * Positive zero + */ +float pspFpuPositiveZero(void); + +/** + * Negative zero + */ +float pspFpuNegativeZero(void); + +/** + * Test for zero value + */ +int pspFpuIsZero(float f); + +/** + * Test for positive zero + */ +int pspFpuIsPositiveZero(float f); + +/** + * Test for negative zero + */ +int pspFpuIsNegativeZero(float f); + +/** + * Test for denormalized number + */ +int pspFpuIsDenormal(float f); + +/** + * Test for zero or denormalized number + */ +int pspFpuIsZeroOrDenormal(float f); + +/** + * Positive infinity + */ +float pspFpuPositiveInf(void); + +/** + * Negative infinity + */ +float pspFpuNegativeInf(void); + +/** + * Test for infinity + */ +int pspFpuIsInf(float f); + +/** + * NaN (positive SNaN) + */ +float pspFpuPositiveNaN(void); + +/** + * NaN (negative SNaN) + */ +float pspFpuNegativeNaN(void); + +/** + * Quiet NaN (positive QNaN) + */ +float pspFpuPositiveQNaN(void); + +/** + * Quiet NaN (positive QNaN) + */ +float pspFpuNegativeQNaN(void); + +/** + * Signaling NaN (positive SNaN) + */ +float pspFpuPositiveSNaN(unsigned int uiSignal); + +/** + * Signaling NaN (negative SNaN) + */ +float pspFpuNegativeSNaN(unsigned int uiSignal); + +/** + * Test for NaN + */ +int pspFpuIsNaN(float f); + +/** + * Test for infinity or NaN + */ +int pspFpuIsInfOrNaN(float f); + +/** + * + */ +float pspFpuNormalizePhase(float f); + +/** + * Sine + */ +float pspFpuSin(float x); + +/** + * Cosine + */ +float pspFpuCos(float x); + +/** + * Arc tangent + */ +float pspFpuAtan(float x); + +/** + * Natural Logarithm + */ +float pspFpuLog(float x); + +/** + * Exponential + */ +float pspFpuExp(float x); + +/** + * ArcSin + */ +float pspFpuAsin(float x); + +/** + * ArcCos + */ +float pspFpuAcos(float x); + +/** + * convert float to double + */ +double pspFpuFloatToDouble(float a); + +/** + * convert double to float + */ +float pspFpuDoubleToFloat(double a); #ifdef __cplusplus } diff --git a/src/ge/pspge.h b/src/ge/pspge.h index ce0101a0..a9cb69be 100644 --- a/src/ge/pspge.h +++ b/src/ge/pspge.h @@ -45,6 +45,13 @@ typedef struct PspGeListArgs PspGeContext* context; } PspGeListArgs; +/** + * Drawing queue interruption parameter + */ +typedef struct PspGeBreakParam { + unsigned int buf[4]; +} PspGeBreakParam; + /** * Get the size of VRAM. * @@ -116,7 +123,7 @@ int sceGeSaveContext(PspGeContext *context); */ int sceGeRestoreContext(const PspGeContext *context); -/** +/** * Enqueue a display list at the tail of the GE display list queue. * * @param list - The head of the list to queue. @@ -131,7 +138,7 @@ int sceGeListEnQueue(const void *list, void *stall, int cbid, PspGeListArgs *arg /** * Enqueue a display list at the head of the GE display list queue. - * + * * @param list - The head of the list to queue. * @param stall - The stall address. * If NULL then no stall address set and the list is transferred immediately. @@ -153,7 +160,7 @@ int sceGeListDeQueue(int qid); /** * Update the stall address for the specified queue. - * + * * @param qid - The ID of the queue. * @param stall - The stall address to update * @@ -176,22 +183,22 @@ typedef enum PspGeSyncType { * * @param qid - The queue ID of the list to sync. * @param syncType - Specifies the condition to wait on. One of ::PspGeSyncType. - * + * * @return ??? */ int sceGeListSync(int qid, int syncType); /** * Wait for drawing to complete. - * + * * @param syncType - Specifies the condition to wait on. One of ::PspGeSyncType. - * + * * @return ??? */ int sceGeDrawSync(int syncType); /** - * Register callback handlers for the the Ge + * Register callback handlers for the the Ge * * @param cb - Configured callback data structure * @return The callback ID, < 0 on error @@ -206,6 +213,22 @@ int sceGeSetCallback(PspGeCallbackData *cb); */ int sceGeUnsetCallback(int cbid); +/** + * Interrupt drawing queue + */ +int sceGeBreak(int mode, PspGeBreakParam *pParam); + +/** + * Restart drawing queue + */ +int sceGeContinue(void); + +/** + * Set Graphics Engine eDRAM address translation mode + */ +int sceGeEdramSetAddrTranslation(int width); + + #ifdef __cplusplus } #endif diff --git a/src/kernel/Makefile.am b/src/kernel/Makefile.am index 5d2baf78..e423782c 100644 --- a/src/kernel/Makefile.am +++ b/src/kernel/Makefile.am @@ -34,7 +34,7 @@ SYSCLIB_OBJS = SysclibForKernel_0000.o SysclibForKernel_0001.o SysclibForKernel_ LOADEXEC_OBJS = LoadExecForKernel_0000.o LoadExecForKernel_0001.o LoadExecForKernel_0002.o LoadExecForKernel_0003.o LoadExecForKernel_0004.o LoadExecForKernel_0005.o LoadExecForKernel_0006.o LoadExecForKernel_0007.o LoadExecForKernel_0008.o LoadExecForKernel_0009.o LoadExecForKernel_0010.o LoadExecForKernel_0011.o LoadExecForKernel_0012.o LoadExecForKernel_0013.o LoadExecForKernel_0014.o LoadExecForKernel_0015.o LoadExecForKernel_0016.o LoadExecForKernel_0017.o LoadExecForKernel_0018.o LoadExecForKernel_0019.o LoadExecForKernel_0020.o LoadExecForKernel_0021.o LoadExecForKernel_0022.o LoadExecForKernel_0023.o LoadExecForKernel_0024.o LoadExecForKernel_0025.o LoadExecForKernel_0026.o -SYSMEM_OBJS = SysMemForKernel_0000.o SysMemForKernel_0001.o SysMemForKernel_0002.o SysMemForKernel_0003.o SysMemForKernel_0004.o SysMemForKernel_0005.o SysMemForKernel_0006.o SysMemForKernel_0007.o SysMemForKernel_0008.o SysMemForKernel_0009.o SysMemForKernel_0010.o SysMemForKernel_0011.o SysMemForKernel_0012.o SysMemForKernel_0013.o SysMemForKernel_0014.o SysMemForKernel_0015.o SysMemForKernel_0016.o SysMemForKernel_0017.o SysMemForKernel_0018.o SysMemForKernel_0019.o SysMemForKernel_0020.o SysMemForKernel_0021.o SysMemForKernel_0022.o SysMemForKernel_0023.o SysMemForKernel_0024.o SysMemForKernel_0025.o SysMemForKernel_0026.o SysMemForKernel_0027.o SysMemForKernel_0028.o SysMemForKernel_0029.o SysMemForKernel_0030.o SysMemForKernel_0031.o SysMemForKernel_0032.o SysMemForKernel_0033.o SysMemForKernel_0034.o SysMemForKernel_0035.o SysMemForKernel_0036.o SysMemForKernel_0037.o SysMemForKernel_0038.o SysMemForKernel_0039.o SysMemForKernel_0040.o SysMemForKernel_0041.o SysMemForKernel_0042.o SysMemForKernel_0043.o SysMemForKernel_0044.o SysMemForKernel_0045.o SysMemForKernel_0046.o SysMemForKernel_0047.o SysMemForKernel_0048.o SysMemForKernel_0049.o SysMemForKernel_0050.o SysMemForKernel_0051.o SysMemForKernel_0052.o SysMemForKernel_0053.o SysMemForKernel_0054.o SysMemForKernel_0055.o SysMemForKernel_0056.o SysMemForKernel_0057.o SysMemForKernel_0058.o SysMemForKernel_0059.o SysMemForKernel_0060.o SysMemForKernel_0061.o SysMemForKernel_0062.o SysMemForKernel_0063.o SysMemForKernel_0064.o SysMemForKernel_0065.o SysMemForKernel_0066.o SysMemForKernel_0067.o SysMemForKernel_0068.o +SYSMEM_OBJS = SysMemForKernel_0000.o SysMemForKernel_0001.o SysMemForKernel_0002.o SysMemForKernel_0003.o SysMemForKernel_0004.o SysMemForKernel_0005.o SysMemForKernel_0006.o SysMemForKernel_0007.o SysMemForKernel_0008.o SysMemForKernel_0009.o SysMemForKernel_0010.o SysMemForKernel_0011.o SysMemForKernel_0012.o SysMemForKernel_0013.o SysMemForKernel_0014.o SysMemForKernel_0015.o SysMemForKernel_0016.o SysMemForKernel_0017.o SysMemForKernel_0018.o SysMemForKernel_0019.o SysMemForKernel_0020.o SysMemForKernel_0021.o SysMemForKernel_0022.o SysMemForKernel_0023.o SysMemForKernel_0024.o SysMemForKernel_0025.o SysMemForKernel_0026.o SysMemForKernel_0027.o SysMemForKernel_0028.o SysMemForKernel_0029.o SysMemForKernel_0030.o SysMemForKernel_0031.o SysMemForKernel_0032.o SysMemForKernel_0033.o SysMemForKernel_0034.o SysMemForKernel_0035.o SysMemForKernel_0036.o SysMemForKernel_0037.o SysMemForKernel_0038.o SysMemForKernel_0039.o SysMemForKernel_0040.o SysMemForKernel_0041.o SysMemForKernel_0042.o SysMemForKernel_0043.o SysMemForKernel_0044.o SysMemForKernel_0045.o SysMemForKernel_0046.o SysMemForKernel_0047.o SysMemForKernel_0048.o SysMemForKernel_0049.o SysMemForKernel_0050.o SysMemForKernel_0051.o SysMemForKernel_0052.o SysMemForKernel_0053.o SysMemForKernel_0054.o SysMemForKernel_0055.o SysMemForKernel_0056.o SysMemForKernel_0057.o SysMemForKernel_0058.o SysMemForKernel_0059.o SysMemForKernel_0060.o SysMemForKernel_0061.o SysMemForKernel_0062.o SysMemForKernel_0063.o SysMemForKernel_0064.o SysMemForKernel_0065.o SysMemForKernel_0066.o SysMemForKernel_0067.o SysMemForKernel_0068.o SysMemForKernel_0069.o SysMemForKernel_0070.o MODULE_OBJS = ModuleMgrForKernel_0000.o ModuleMgrForKernel_0001.o ModuleMgrForKernel_0002.o ModuleMgrForKernel_0003.o ModuleMgrForKernel_0004.o ModuleMgrForKernel_0005.o ModuleMgrForKernel_0006.o ModuleMgrForKernel_0007.o ModuleMgrForKernel_0008.o ModuleMgrForKernel_0009.o ModuleMgrForKernel_0010.o ModuleMgrForKernel_0011.o ModuleMgrForKernel_0012.o ModuleMgrForKernel_0013.o ModuleMgrForKernel_0014.o ModuleMgrForKernel_0015.o ModuleMgrForKernel_0016.o ModuleMgrForKernel_0017.o ModuleMgrForKernel_0018.o ModuleMgrForKernel_0019.o ModuleMgrForKernel_0020.o ModuleMgrForKernel_0021.o ModuleMgrForKernel_0022.o diff --git a/src/kernel/SysMemForKernel.S b/src/kernel/SysMemForKernel.S index bd61768d..e28a2cb1 100644 --- a/src/kernel/SysMemForKernel.S +++ b/src/kernel/SysMemForKernel.S @@ -211,3 +211,9 @@ #ifdef F_SysMemForKernel_0068 IMPORT_FUNC "SysMemForKernel",0x6373995D,sceKernelGetModel #endif +#ifdef F_SysMemForKernel_0069 + IMPORT_FUNC "SysMemForKernel",0x7591C7DB,sceKernelSetCompiledSdkVersion +#endif +#ifdef F_SysMemForKernel_0070 + IMPORT_FUNC "SysMemForKernel",0xFC114573,sceKernelGetCompiledSdkVersion +#endif diff --git a/src/kernel/psploadcore.h b/src/kernel/psploadcore.h index 1c106972..a8c0bed1 100644 --- a/src/kernel/psploadcore.h +++ b/src/kernel/psploadcore.h @@ -52,7 +52,7 @@ typedef struct SceModule { unsigned int nsegment; unsigned int segmentaddr[4]; unsigned int segmentsize[4]; -} SceModule; +} __attribute__((packed)) SceModule; /** Defines a library and its exported functions and variables. Use the len member to determine the real size of the table (size = len * 4). */ diff --git a/src/kernel/pspsysmem_kernel.h b/src/kernel/pspsysmem_kernel.h index 3654bb3f..e33a89d9 100644 --- a/src/kernel/pspsysmem_kernel.h +++ b/src/kernel/pspsysmem_kernel.h @@ -201,6 +201,21 @@ int sceKernelDeleteUID(SceUID uid); */ int sceKernelGetModel(void); +/** + * Set the version of the SDK with which the caller was compiled. + * Version numbers are as for sceKernelDevkitVersion(). + * + * @return 0 on success, < 0 on error. + */ +int sceKernelSetCompiledSdkVersion(int version); + +/** + * Get the SDK version set with sceKernelSetCompiledSdkVersion(). + * + * @return Version number, or 0 if unset. + */ +int sceKernelGetCompiledSdkVersion(void); + #ifdef __cplusplus } #endif diff --git a/src/libc/stdio.h b/src/libc/stdio.h index f8feb62b..9f9b5084 100644 --- a/src/libc/stdio.h +++ b/src/libc/stdio.h @@ -18,6 +18,10 @@ #include #include +#include +#define STDIN_FILENO 0 +#define STDOUT_FILENO 1 +#define STDERR_FILENO 2 #ifdef __cplusplus extern "C" { diff --git a/src/libc/terminate.c b/src/libc/terminate.c index a1a1ff8c..7be725a4 100644 --- a/src/libc/terminate.c +++ b/src/libc/terminate.c @@ -20,8 +20,6 @@ extern void _exit(int code); __attribute__((weak)) void abort() { - printf("Program aborted.\n"); - while (1) _exit(1); } diff --git a/src/net/psphttp.h b/src/net/psphttp.h index 5c550172..e4651067 100644 --- a/src/net/psphttp.h +++ b/src/net/psphttp.h @@ -17,6 +17,12 @@ extern "C" { #endif +typedef enum +{ + PSP_HTTP_VERSION_1_0, + PSP_HTTP_VERSION_1_1 +} PspHttpHttpVersion; + typedef enum { PSP_HTTP_METHOD_GET, @@ -25,6 +31,41 @@ typedef enum } PspHttpMethod; +typedef enum +{ + PSP_HTTP_AUTH_BASIC, + PSP_HTTP_AUTH_DIGEST +} PspHttpAuthType; + + +typedef enum +{ + PSP_HTTP_PROXY_AUTO, + PSP_HTTP_PROXY_MANUAL +} PspHttpProxyMode; + +typedef enum +{ + PSP_HTTP_HEADER_OVERWRITE, + PSP_HTTP_HEADER_ADD +} PspHttpAddHeaderMode; + +/* Memory function types */ +typedef void *(*PspHttpMallocFunction)(SceSize size); +typedef void *(*PspHttpReallocFunction)(void *p, SceSize size); +typedef void (*PspHttpFreeFunction)(void *p); + +typedef int (*PspHttpPasswordCB)( + int request, + PspHttpAuthType auth_type, + const unsigned char *realm, + unsigned char *username, + unsigned char *password, + SceBool need_entity, + unsigned char **entity_body, + SceSize *entity_size, + SceBool *save); + /** * Init the http library. * @@ -319,6 +360,32 @@ int sceHttpsEnd(void); */ int sceHttpsLoadDefaultCert(int unknown1, int unknown2); +int sceHttpDisableAuth(int id); + +int sceHttpDisableCache(int id); + +int sceHttpEnableAuth(int id); + +int sceHttpEnableCache(int id); + +int sceHttpEndCache(void); + +int sceHttpGetAllHeader(int request, unsigned char **header, unsigned int *header_size); + +int sceHttpGetNetworkErrno(int request, int *err_num); + +int sceHttpGetProxy(int id, int *activate_flag, int *mode, unsigned char *proxy_host, SceSize len, unsigned short *proxy_port); + +int sceHttpInitCache(SceSize max_size); + +int sceHttpSetAuthInfoCB(int id, PspHttpPasswordCB cbfunc); + +int sceHttpSetProxy(int id, int activate_flag, int mode, const unsigned char *new_proxy_host, unsigned short new_proxy_port); + +int sceHttpSetResHeaderMaxSize(int id, unsigned int header_size); + +int sceHttpSetMallocFunction(PspHttpMallocFunction malloc_func, PspHttpFreeFunction free_func, PspHttpReallocFunction realloc_func); + #if defined(__cplusplus) }; #endif diff --git a/src/rtc/psprtc.h b/src/rtc/psprtc.h index e36a5cd9..d1a26c9c 100644 --- a/src/rtc/psprtc.h +++ b/src/rtc/psprtc.h @@ -249,14 +249,31 @@ int sceRtcSetWin32FileTime(pspTime* date, u64* win32Time); int sceRtcGetWin32FileTime(pspTime* date, u64* win32Time); int sceRtcParseDateTime(u64 *destTick, const char *dateString); -/* -sceRtcFormatRFC2822 -sceRtcFormatRFC2822LocalTime -sceRtcFormatRFC3339 -sceRtcFormatRFC3339LocalTime -sceRtcParseRFC3339 -*/ +/** + * Format Tick-representation UTC time in RFC2822 format + */ +int sceRtcFormatRFC2822(char *pszDateTime, const u64 *pUtc, int iTimeZoneMinutes); + +/** + * Format Tick-representation UTC time in RFC2822 format + */ +int sceRtcFormatRFC2822LocalTime(char *pszDateTime, const u64 *pUtc); + +/** + * Format Tick-representation UTC time in RFC3339(ISO8601) format + */ +int sceRtcFormatRFC3339(char *pszDateTime, const u64 *pUtc, int iTimeZoneMinutes); + +/** + * Format Tick-representation UTC time in RFC3339(ISO8601) format + */ +int sceRtcFormatRFC3339LocalTime(char *pszDateTime, const u64 *pUtc); + +/** + * Parse time information represented in RFC3339 format + */ +int sceRtcParseRFC3339(u64 *pUtc, const char *pszDateTime); #ifdef __cplusplus } diff --git a/src/samples/Makefile.am b/src/samples/Makefile.am index 9b64793f..2d0fcc3f 100644 --- a/src/samples/Makefile.am +++ b/src/samples/Makefile.am @@ -1,122 +1,123 @@ - -samplesdir = @PSPSDK@/samples - -SAMPLES = \ - audio/polyphonic \ - audio/wavegen \ - controller/basic \ - debug/exception \ - debug/kprintf \ - debug/prxdecrypt \ - debug/profiler \ - debug/debugkb \ - debug/sio \ - debug/gdb \ - gu/beginobject \ - gu/blend \ - gu/blit \ - gu/celshading \ - gu/clut \ - gu/common \ - gu/copy \ - gu/cube \ - gu/envmap \ - gu/integerdrawing \ - gu/lights \ - gu/lines \ - gu/logic \ - gu/morph \ - gu/morphskin \ - gu/ortho \ - gu/reflection \ - gu/rendertarget \ - gu/shadowprojection \ - gu/signals \ - gu/skinning \ - gu/speed \ - gu/spharm \ - gu/splinesurface \ - gu/sprite \ - gu/text \ - gu/timing \ - gu/vertex \ - gu/zbufferfog \ - ir/sircs \ - ir/irda \ - kernel/kdumper \ - kernel/loadmodule \ - kernel/threadstatus \ - kernel/cwd \ - kernel/fileio \ - kernel/idstorage \ - kernel/messagebox \ - kernel/registry \ - kernel/regenum \ - kernel/systimer \ - kernel/sysevent \ - mp3 \ - ms/callback \ - nand/dumpipl \ - net/simple \ - net/simple_prx \ - net/resolver \ - net/wlanscan \ - net/wlanscan_elf \ - power \ - prx/prx_loader \ - prx/testprx \ - savedata/utility \ - savedata/decrypt \ - savedata/encrypt \ - template/elf_template \ - template/prx_template \ - template/lib_template \ - template/kprx_template \ - usb/storage \ - utility/gamesharing \ - utility/htmlviewer \ - utility/netconf \ - utility/netdialog \ - utility/msgdialog \ - utility/systemparam \ - utility/osk \ - me/basic \ - wlan - -all: - -dist-hook: - rm -rf `find $(distdir) -name .svn -o -name CVS` - -# Install all of the samples. Rename any files that end in a .sample extension. -SAMPLES_INSTALL = $(INSTALL_DATA) -install-data-hook: - $(mkinstalldirs) $(DESTDIR)$(samplesdir) - @list='$(SAMPLES)'; for s in $$list; do \ - $(mkinstalldirs) $(DESTDIR)$(samplesdir)/$$s; \ - for p in $(srcdir)/$$s/*; do \ - if test -f $$p; then \ - f="`echo $$p | sed -e 's|^.*/||'`"; \ - echo " $(SAMPLES_INSTALL) $$p $(DESTDIR)$(samplesdir)/$$s/$$f"; \ - $(SAMPLES_INSTALL) $$p $(DESTDIR)$(samplesdir)/$$s/$$f; \ - else :; fi; \ - done; \ - done - @for p in `find $(DESTDIR)$(samplesdir) -name *.sample -print `; do \ - f="`echo $$p | sed -e 's/\.sample$$//'`"; \ - echo " mv $$p $$f"; \ - mv $$p $$f; \ - done - -uninstall-hook: - @list='$(SAMPLES)'; for s in $$list; do \ - for p in $(DESTDIR)$(samplesdir)/$$s/*; do \ - if test -f $$p; then \ - p="`echo $$p | sed -e 's|^.*/||'`"; \ - echo " rm -f $(DESTDIR)$(samplesdir)/$$s/$$p"; \ - rm -f $(DESTDIR)$(samplesdir)/$$s/$$p; \ - else :; fi; \ - done; \ - done - -EXTRA_DIST = $(SAMPLES) + +samplesdir = @PSPSDK@/samples + +SAMPLES = \ + audio/polyphonic \ + audio/wavegen \ + controller/basic \ + debug/exception \ + debug/kprintf \ + debug/prxdecrypt \ + debug/profiler \ + debug/debugkb \ + debug/sio \ + debug/gdb \ + gu/beginobject \ + gu/blend \ + gu/blit \ + gu/celshading \ + gu/clut \ + gu/common \ + gu/copy \ + gu/cube \ + gu/envmap \ + gu/integerdrawing \ + gu/lights \ + gu/lines \ + gu/logic \ + gu/morph \ + gu/morphskin \ + gu/ortho \ + gu/reflection \ + gu/rendertarget \ + gu/shadowprojection \ + gu/signals \ + gu/skinning \ + gu/speed \ + gu/spharm \ + gu/splinesurface \ + gu/sprite \ + gu/text \ + gu/timing \ + gu/vertex \ + gu/zbufferfog \ + ir/sircs \ + ir/irda \ + kernel/kdumper \ + kernel/loadmodule \ + kernel/threadstatus \ + kernel/cwd \ + kernel/fileio \ + kernel/idstorage \ + kernel/messagebox \ + kernel/registry \ + kernel/regenum \ + kernel/systimer \ + kernel/sysevent \ + mp3 \ + ms/callback \ + nand/dumpipl \ + net/simple \ + net/simple_prx \ + net/resolver \ + net/wlanscan \ + net/wlanscan_elf \ + power \ + prx/prx_loader \ + prx/testprx \ + savedata/utility \ + savedata/decrypt \ + savedata/encrypt \ + template/elf_template \ + template/prx_template \ + template/lib_template \ + template/kprx_template \ + usb/storage \ + utility/gamesharing \ + utility/htmlviewer \ + utility/netconf \ + utility/netdialog \ + utility/msgdialog \ + utility/systemparam \ + utility/osk \ + me/basic \ + wlan \ + exceptions + +all: + +dist-hook: + rm -rf `find $(distdir) -name .svn -o -name CVS` + +# Install all of the samples. Rename any files that end in a .sample extension. +SAMPLES_INSTALL = $(INSTALL_DATA) +install-data-hook: + $(mkinstalldirs) $(DESTDIR)$(samplesdir) + @list='$(SAMPLES)'; for s in $$list; do \ + $(mkinstalldirs) $(DESTDIR)$(samplesdir)/$$s; \ + for p in $(srcdir)/$$s/*; do \ + if test -f $$p; then \ + f="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " $(SAMPLES_INSTALL) $$p $(DESTDIR)$(samplesdir)/$$s/$$f"; \ + $(SAMPLES_INSTALL) $$p $(DESTDIR)$(samplesdir)/$$s/$$f; \ + else :; fi; \ + done; \ + done + @for p in `find $(DESTDIR)$(samplesdir) -name *.sample -print `; do \ + f="`echo $$p | sed -e 's/\.sample$$//'`"; \ + echo " mv $$p $$f"; \ + mv $$p $$f; \ + done + +uninstall-hook: + @list='$(SAMPLES)'; for s in $$list; do \ + for p in $(DESTDIR)$(samplesdir)/$$s/*; do \ + if test -f $$p; then \ + p="`echo $$p | sed -e 's|^.*/||'`"; \ + echo " rm -f $(DESTDIR)$(samplesdir)/$$s/$$p"; \ + rm -f $(DESTDIR)$(samplesdir)/$$s/$$p; \ + else :; fi; \ + done; \ + done + +EXTRA_DIST = $(SAMPLES) diff --git a/src/samples/exceptions/Makefile.sample b/src/samples/exceptions/Makefile.sample new file mode 100644 index 00000000..508cd52c --- /dev/null +++ b/src/samples/exceptions/Makefile.sample @@ -0,0 +1,18 @@ +TARGET = CppException +OBJS = main.o +LIBS = -lstdc++ + +INCDIR = +CFLAGS = -G0 -Wall -O2 +CXXFLAGS = $(CFLAGS) -fno-rtti -fexceptions +ASFLAGS = $(CFLAGS) + +LIBDIR = +LDFLAGS = + +EXTRA_TARGETS = EBOOT.PBP +PSP_EBOOT_TITLE = C++ Exception Sample + +PSPSDK=$(shell psp-config --pspsdk-path) +include $(PSPSDK)/lib/build.mak + diff --git a/src/samples/exceptions/main.cpp b/src/samples/exceptions/main.cpp new file mode 100644 index 00000000..5a3b9882 --- /dev/null +++ b/src/samples/exceptions/main.cpp @@ -0,0 +1,51 @@ +#include +#include +#include + +/* Define printf, just to make typing easier */ +#define printf pspDebugScreenPrintf + +/* Define the module info section */ +PSP_MODULE_INFO("cppException", 0, 1, 1); + +/* Define the main thread's attribute value (optional) */ +PSP_MAIN_THREAD_ATTR(THREAD_ATTR_USER | THREAD_ATTR_VFPU); + +#include +using namespace std; + +class myexception: public exception +{ + virtual const char* what() const throw() + { + return "My exception happened"; + } +} myex; + +int main (void) +{ + pspDebugScreenInit(); + SceCtrlData pad; + + try + { + throw myex; + } + catch (exception& e) + { + printf("%s\n", e.what()); + } + + printf("\nPress X to quit.\n"); + + for (;;) + { + sceCtrlReadBufferPositive(&pad, 1); + if (pad.Buttons & PSP_CTRL_CROSS) + break; + } + sceKernelExitGame(); + + return 0; +} + diff --git a/src/user/Makefile.am b/src/user/Makefile.am index 9372f371..b9b40172 100644 --- a/src/user/Makefile.am +++ b/src/user/Makefile.am @@ -10,27 +10,27 @@ INCLUDES = -I$(top_srcdir)/src/base CFLAGS = @PSPSDK_CFLAGS@ CCASFLAGS = $(CFLAGS) $(INCLUDES) -IO_OBJS = IoFileMgrForUser_0000.o IoFileMgrForUser_0001.o IoFileMgrForUser_0002.o IoFileMgrForUser_0003.o IoFileMgrForUser_0004.o IoFileMgrForUser_0005.o IoFileMgrForUser_0006.o IoFileMgrForUser_0007.o IoFileMgrForUser_0008.o IoFileMgrForUser_0009.o IoFileMgrForUser_0010.o IoFileMgrForUser_0011.o IoFileMgrForUser_0012.o IoFileMgrForUser_0013.o IoFileMgrForUser_0014.o IoFileMgrForUser_0015.o IoFileMgrForUser_0016.o IoFileMgrForUser_0017.o IoFileMgrForUser_0018.o IoFileMgrForUser_0019.o IoFileMgrForUser_0020.o IoFileMgrForUser_0021.o IoFileMgrForUser_0022.o IoFileMgrForUser_0023.o IoFileMgrForUser_0024.o IoFileMgrForUser_0025.o IoFileMgrForUser_0026.o IoFileMgrForUser_0027.o IoFileMgrForUser_0028.o IoFileMgrForUser_0029.o IoFileMgrForUser_0030.o IoFileMgrForUser_0031.o IoFileMgrForUser_0032.o IoFileMgrForUser_0033.o IoFileMgrForUser_0034.o IoFileMgrForUser_0035.o IoFileMgrForUser_0036.o +IO_OBJS = IoFileMgrForUser_0000.o IoFileMgrForUser_0001.o IoFileMgrForUser_0002.o IoFileMgrForUser_0003.o IoFileMgrForUser_0004.o IoFileMgrForUser_0005.o IoFileMgrForUser_0006.o IoFileMgrForUser_0007.o IoFileMgrForUser_0008.o IoFileMgrForUser_0009.o IoFileMgrForUser_0010.o IoFileMgrForUser_0011.o IoFileMgrForUser_0012.o IoFileMgrForUser_0013.o IoFileMgrForUser_0014.o IoFileMgrForUser_0015.o IoFileMgrForUser_0016.o IoFileMgrForUser_0017.o IoFileMgrForUser_0018.o IoFileMgrForUser_0019.o IoFileMgrForUser_0020.o IoFileMgrForUser_0021.o IoFileMgrForUser_0022.o IoFileMgrForUser_0023.o IoFileMgrForUser_0024.o IoFileMgrForUser_0025.o IoFileMgrForUser_0026.o IoFileMgrForUser_0027.o IoFileMgrForUser_0028.o IoFileMgrForUser_0029.o IoFileMgrForUser_0030.o IoFileMgrForUser_0031.o IoFileMgrForUser_0032.o IoFileMgrForUser_0033.o IoFileMgrForUser_0034.o IoFileMgrForUser_0035.o IoFileMgrForUser_0036.o -KERNEL_OBJS = Kernel_Library_0000.o Kernel_Library_0001.o Kernel_Library_0002.o Kernel_Library_0003.o Kernel_Library_0004.o Kernel_Library_0005.o +KERNEL_OBJS = Kernel_Library_0000.o Kernel_Library_0001.o Kernel_Library_0002.o Kernel_Library_0003.o Kernel_Library_0004.o Kernel_Library_0005.o MODMGR_OBJS = ModuleMgrForUser_0000.o ModuleMgrForUser_0001.o ModuleMgrForUser_0002.o ModuleMgrForUser_0003.o ModuleMgrForUser_0004.o ModuleMgrForUser_0005.o ModuleMgrForUser_0006.o ModuleMgrForUser_0007.o ModuleMgrForUser_0008.o ModuleMgrForUser_0009.o ModuleMgrForUser_0010.o ModuleMgrForUser_0011.o -STDIO_OBJS = StdioForUser_0000.o StdioForUser_0001.o StdioForUser_0002.o StdioForUser_0003.o StdioForUser_0004.o StdioForUser_0005.o StdioForUser_0006.o StdioForUser_0007.o StdioForUser_0008.o StdioForUser_0009.o +STDIO_OBJS = StdioForUser_0000.o StdioForUser_0001.o StdioForUser_0002.o StdioForUser_0003.o StdioForUser_0004.o StdioForUser_0005.o StdioForUser_0006.o StdioForUser_0007.o StdioForUser_0008.o StdioForUser_0009.o SUSPEND_OBJS = sceSuspendForUser_0000.o sceSuspendForUser_0001.o sceSuspendForUser_0002.o sceSuspendForUser_0003.o sceSuspendForUser_0004.o sceSuspendForUser_005.o sceSuspendForUser_0006.o -SYSMEM_OBJS = SysMemUserForUser_0000.o SysMemUserForUser_0001.o SysMemUserForUser_0002.o SysMemUserForUser_0003.o SysMemUserForUser_0004.o SysMemUserForUser_0005.o SysMemUserForUser_0006.o SysMemUserForUser_0007.o +SYSMEM_OBJS = SysMemUserForUser_0000.o SysMemUserForUser_0001.o SysMemUserForUser_0002.o SysMemUserForUser_0003.o SysMemUserForUser_0004.o SysMemUserForUser_0005.o SysMemUserForUser_0006.o SysMemUserForUser_0007.o SysMemUserForUser_0008.o SysMemUserForUser_0009.o -THREADMAN_OBJS = ThreadManForUser_0000.o ThreadManForUser_0001.o ThreadManForUser_0002.o ThreadManForUser_0003.o ThreadManForUser_0004.o ThreadManForUser_0005.o ThreadManForUser_0006.o ThreadManForUser_0007.o ThreadManForUser_0008.o ThreadManForUser_0009.o ThreadManForUser_0010.o ThreadManForUser_0011.o ThreadManForUser_0012.o ThreadManForUser_0013.o ThreadManForUser_0014.o ThreadManForUser_0015.o ThreadManForUser_0016.o ThreadManForUser_0017.o ThreadManForUser_0018.o ThreadManForUser_0019.o ThreadManForUser_0020.o ThreadManForUser_0021.o ThreadManForUser_0022.o ThreadManForUser_0023.o ThreadManForUser_0024.o ThreadManForUser_0025.o ThreadManForUser_0026.o ThreadManForUser_0027.o ThreadManForUser_0028.o ThreadManForUser_0029.o ThreadManForUser_0030.o ThreadManForUser_0031.o ThreadManForUser_0032.o ThreadManForUser_0033.o ThreadManForUser_0034.o ThreadManForUser_0035.o ThreadManForUser_0036.o ThreadManForUser_0037.o ThreadManForUser_0038.o ThreadManForUser_0039.o ThreadManForUser_0040.o ThreadManForUser_0041.o ThreadManForUser_0042.o ThreadManForUser_0043.o ThreadManForUser_0044.o ThreadManForUser_0045.o ThreadManForUser_0046.o ThreadManForUser_0047.o ThreadManForUser_0048.o ThreadManForUser_0049.o ThreadManForUser_0050.o ThreadManForUser_0051.o ThreadManForUser_0052.o ThreadManForUser_0053.o ThreadManForUser_0054.o ThreadManForUser_0055.o ThreadManForUser_0056.o ThreadManForUser_0057.o ThreadManForUser_0058.o ThreadManForUser_0059.o ThreadManForUser_0060.o ThreadManForUser_0061.o ThreadManForUser_0062.o ThreadManForUser_0063.o ThreadManForUser_0064.o ThreadManForUser_0065.o ThreadManForUser_0066.o ThreadManForUser_0067.o ThreadManForUser_0068.o ThreadManForUser_0069.o ThreadManForUser_0070.o ThreadManForUser_0071.o ThreadManForUser_0072.o ThreadManForUser_0073.o ThreadManForUser_0074.o ThreadManForUser_0075.o ThreadManForUser_0076.o ThreadManForUser_0077.o ThreadManForUser_0078.o ThreadManForUser_0079.o ThreadManForUser_0080.o ThreadManForUser_0081.o ThreadManForUser_0082.o ThreadManForUser_0083.o ThreadManForUser_0084.o ThreadManForUser_0085.o ThreadManForUser_0086.o ThreadManForUser_0087.o ThreadManForUser_0088.o ThreadManForUser_0089.o ThreadManForUser_0090.o ThreadManForUser_0091.o ThreadManForUser_0092.o ThreadManForUser_0093.o ThreadManForUser_0094.o ThreadManForUser_0095.o ThreadManForUser_0096.o ThreadManForUser_0097.o ThreadManForUser_0098.o ThreadManForUser_0099.o ThreadManForUser_0100.o ThreadManForUser_0101.o ThreadManForUser_0102.o ThreadManForUser_0103.o ThreadManForUser_0104.o ThreadManForUser_0105.o ThreadManForUser_0106.o ThreadManForUser_0107.o ThreadManForUser_0108.o ThreadManForUser_0109.o ThreadManForUser_0110.o ThreadManForUser_0111.o ThreadManForUser_0112.o ThreadManForUser_0113.o ThreadManForUser_0114.o ThreadManForUser_0115.o ThreadManForUser_0116.o ThreadManForUser_0117.o ThreadManForUser_0118.o ThreadManForUser_0119.o ThreadManForUser_0120.o ThreadManForUser_0121.o ThreadManForUser_0122.o ThreadManForUser_0123.o ThreadManForUser_0124.o ThreadManForUser_0125.o ThreadManForUser_0126.o +THREADMAN_OBJS = ThreadManForUser_0000.o ThreadManForUser_0001.o ThreadManForUser_0002.o ThreadManForUser_0003.o ThreadManForUser_0004.o ThreadManForUser_0005.o ThreadManForUser_0006.o ThreadManForUser_0007.o ThreadManForUser_0008.o ThreadManForUser_0009.o ThreadManForUser_0010.o ThreadManForUser_0011.o ThreadManForUser_0012.o ThreadManForUser_0013.o ThreadManForUser_0014.o ThreadManForUser_0015.o ThreadManForUser_0016.o ThreadManForUser_0017.o ThreadManForUser_0018.o ThreadManForUser_0019.o ThreadManForUser_0020.o ThreadManForUser_0021.o ThreadManForUser_0022.o ThreadManForUser_0023.o ThreadManForUser_0024.o ThreadManForUser_0025.o ThreadManForUser_0026.o ThreadManForUser_0027.o ThreadManForUser_0028.o ThreadManForUser_0029.o ThreadManForUser_0030.o ThreadManForUser_0031.o ThreadManForUser_0032.o ThreadManForUser_0033.o ThreadManForUser_0034.o ThreadManForUser_0035.o ThreadManForUser_0036.o ThreadManForUser_0037.o ThreadManForUser_0038.o ThreadManForUser_0039.o ThreadManForUser_0040.o ThreadManForUser_0041.o ThreadManForUser_0042.o ThreadManForUser_0043.o ThreadManForUser_0044.o ThreadManForUser_0045.o ThreadManForUser_0046.o ThreadManForUser_0047.o ThreadManForUser_0048.o ThreadManForUser_0049.o ThreadManForUser_0050.o ThreadManForUser_0051.o ThreadManForUser_0052.o ThreadManForUser_0053.o ThreadManForUser_0054.o ThreadManForUser_0055.o ThreadManForUser_0056.o ThreadManForUser_0057.o ThreadManForUser_0058.o ThreadManForUser_0059.o ThreadManForUser_0060.o ThreadManForUser_0061.o ThreadManForUser_0062.o ThreadManForUser_0063.o ThreadManForUser_0064.o ThreadManForUser_0065.o ThreadManForUser_0066.o ThreadManForUser_0067.o ThreadManForUser_0068.o ThreadManForUser_0069.o ThreadManForUser_0070.o ThreadManForUser_0071.o ThreadManForUser_0072.o ThreadManForUser_0073.o ThreadManForUser_0074.o ThreadManForUser_0075.o ThreadManForUser_0076.o ThreadManForUser_0077.o ThreadManForUser_0078.o ThreadManForUser_0079.o ThreadManForUser_0080.o ThreadManForUser_0081.o ThreadManForUser_0082.o ThreadManForUser_0083.o ThreadManForUser_0084.o ThreadManForUser_0085.o ThreadManForUser_0086.o ThreadManForUser_0087.o ThreadManForUser_0088.o ThreadManForUser_0089.o ThreadManForUser_0090.o ThreadManForUser_0091.o ThreadManForUser_0092.o ThreadManForUser_0093.o ThreadManForUser_0094.o ThreadManForUser_0095.o ThreadManForUser_0096.o ThreadManForUser_0097.o ThreadManForUser_0098.o ThreadManForUser_0099.o ThreadManForUser_0100.o ThreadManForUser_0101.o ThreadManForUser_0102.o ThreadManForUser_0103.o ThreadManForUser_0104.o ThreadManForUser_0105.o ThreadManForUser_0106.o ThreadManForUser_0107.o ThreadManForUser_0108.o ThreadManForUser_0109.o ThreadManForUser_0110.o ThreadManForUser_0111.o ThreadManForUser_0112.o ThreadManForUser_0113.o ThreadManForUser_0114.o ThreadManForUser_0115.o ThreadManForUser_0116.o ThreadManForUser_0117.o ThreadManForUser_0118.o ThreadManForUser_0119.o ThreadManForUser_0120.o ThreadManForUser_0121.o ThreadManForUser_0122.o ThreadManForUser_0123.o ThreadManForUser_0124.o ThreadManForUser_0125.o ThreadManForUser_0126.o -UTILS_OBJS = UtilsForUser_0000.o UtilsForUser_0001.o UtilsForUser_0002.o UtilsForUser_0003.o UtilsForUser_0004.o UtilsForUser_0005.o UtilsForUser_0006.o UtilsForUser_0007.o UtilsForUser_0008.o UtilsForUser_0009.o UtilsForUser_0010.o UtilsForUser_0011.o UtilsForUser_0012.o UtilsForUser_0013.o UtilsForUser_0014.o UtilsForUser_0015.o UtilsForUser_0016.o UtilsForUser_0017.o UtilsForUser_0018.o UtilsForUser_0019.o UtilsForUser_0020.o UtilsForUser_0021.o UtilsForUser_0022.o UtilsForUser_0023.o UtilsForUser_0024.o +UTILS_OBJS = UtilsForUser_0000.o UtilsForUser_0001.o UtilsForUser_0002.o UtilsForUser_0003.o UtilsForUser_0004.o UtilsForUser_0005.o UtilsForUser_0006.o UtilsForUser_0007.o UtilsForUser_0008.o UtilsForUser_0009.o UtilsForUser_0010.o UtilsForUser_0011.o UtilsForUser_0012.o UtilsForUser_0013.o UtilsForUser_0014.o UtilsForUser_0015.o UtilsForUser_0016.o UtilsForUser_0017.o UtilsForUser_0018.o UtilsForUser_0019.o UtilsForUser_0020.o UtilsForUser_0021.o UtilsForUser_0022.o UtilsForUser_0023.o UtilsForUser_0024.o UtilsForUser_0025.o UtilsForUser_0026.o -INTERRUPT_OBJS = InterruptManager_0000.o InterruptManager_0001.o InterruptManager_0002.o InterruptManager_0003.o InterruptManager_0004.o InterruptManager_0005.o InterruptManager_0006.o InterruptManager_0007.o InterruptManager_0008.o InterruptManager_0009.o +INTERRUPT_OBJS = InterruptManager_0000.o InterruptManager_0001.o InterruptManager_0002.o InterruptManager_0003.o InterruptManager_0004.o InterruptManager_0005.o InterruptManager_0006.o InterruptManager_0007.o InterruptManager_0008.o InterruptManager_0009.o -LOADEXEC_OBJS = LoadExecForUser_0000.o LoadExecForUser_0001.o LoadExecForUser_0002.o LoadExecForUser_0003.o LoadExecForUser_0004.o +LOADEXEC_OBJS = LoadExecForUser_0000.o LoadExecForUser_0001.o LoadExecForUser_0002.o LoadExecForUser_0003.o LoadExecForUser_0004.o -IMPOSE_OBJS = sceImpose_0000.o sceImpose_0001.o sceImpose_0002.o sceImpose_0003.o sceImpose_0004.o sceImpose_0005.o sceImpose_0006.o sceImpose_0007.o sceImpose_0008.o sceImpose_0009.o sceImpose_0010.o sceImpose_0011.o sceImpose_0012.o sceImpose_0013.o sceImpose_0014.o sceImpose_0015.o +IMPOSE_OBJS = sceImpose_0000.o sceImpose_0001.o sceImpose_0002.o sceImpose_0003.o sceImpose_0004.o sceImpose_0005.o sceImpose_0006.o sceImpose_0007.o sceImpose_0008.o sceImpose_0009.o sceImpose_0010.o sceImpose_0011.o sceImpose_0012.o sceImpose_0013.o sceImpose_0014.o sceImpose_0015.o libpspuserincludedir = @PSPSDK_INCLUDEDIR@ libpspuserinclude_HEADERS = \ diff --git a/src/user/SysMemUserForUser.S b/src/user/SysMemUserForUser.S index dd197730..1f656cc9 100644 --- a/src/user/SysMemUserForUser.S +++ b/src/user/SysMemUserForUser.S @@ -26,3 +26,9 @@ #ifdef F_SysMemUserForUser_0007 IMPORT_FUNC "SysMemUserForUser",0x13A5ABEF,sceKernelPrintf #endif +#ifdef F_SysMemUserForUser_0008 + IMPORT_FUNC "SysMemUserForUser",0x7591C7DB,sceKernelSetCompiledSdkVersion +#endif +#ifdef F_SysMemUserForUser_0009 + IMPORT_FUNC "SysMemUserForUser",0xFC114573,sceKernelGetCompiledSdkVersion +#endif diff --git a/src/user/UtilsForUser.S b/src/user/UtilsForUser.S index 85c88419..ceceac39 100644 --- a/src/user/UtilsForUser.S +++ b/src/user/UtilsForUser.S @@ -77,3 +77,9 @@ #ifdef F_UtilsForUser_0024 IMPORT_FUNC "UtilsForUser",0xFB05FAD0,sceKernelIcacheReadTag #endif +#ifdef F_UtilsForUser_0025 + IMPORT_FUNC "UtilsForUser",0x920F104A,sceKernelIcacheInvalidateAll +#endif +#ifdef F_UtilsForUser_0026 + IMPORT_FUNC "UtilsForUser",0xC2DF770E,sceKernelIcacheInvalidateRange +#endif diff --git a/src/user/pspsysmem.h b/src/user/pspsysmem.h index 1dfc986e..308d71f0 100644 --- a/src/user/pspsysmem.h +++ b/src/user/pspsysmem.h @@ -115,6 +115,21 @@ void sceKernelPrintf(const char *format, ...) __attribute__((format(printf, 1, 2 #endif +/** + * Set the version of the SDK with which the caller was compiled. + * Version numbers are as for sceKernelDevkitVersion(). + * + * @return 0 on success, < 0 on error. + */ +int sceKernelSetCompiledSdkVersion(int version); + +/** + * Get the SDK version set with sceKernelSetCompiledSdkVersion(). + * + * @return Version number, or 0 if unset. + */ +int sceKernelGetCompiledSdkVersion(void); + #ifdef __cplusplus } #endif diff --git a/src/user/psputils.h b/src/user/psputils.h index 935d84ab..c59b8cea 100644 --- a/src/user/psputils.h +++ b/src/user/psputils.h @@ -20,7 +20,7 @@ extern "C" { #endif -/* Some of the structures and definitions in this file were extracted from the japanese +/* Some of the structures and definitions in this file were extracted from the japanese puzzle bobble main executable */ /** @defgroup Utils Utils Library */ @@ -37,17 +37,17 @@ extern "C" { */ time_t sceKernelLibcTime(time_t *t); -/** +/** * Get the processor clock used since the start of the process */ clock_t sceKernelLibcClock(void); -/** +/** * Get the current time of time and time zone information */ int sceKernelLibcGettimeofday(struct timeval *tp, struct timezone *tzp); -/** +/** * Write back the data cache to memory */ void sceKernelDcacheWritebackAll(void); @@ -58,12 +58,12 @@ void sceKernelDcacheWritebackAll(void); void sceKernelDcacheWritebackInvalidateAll(void); /** - * Write back a range of addresses from data cache to memory + * Write back a range of addresses from the data cache to memory */ void sceKernelDcacheWritebackRange(const void *p, unsigned int size); /** - * Write back and invalidate a range of addresses in data cache + * Write back and invalidate a range of addresses in the data cache */ void sceKernelDcacheWritebackInvalidateRange(const void *p, unsigned int size); @@ -72,13 +72,23 @@ void sceKernelDcacheWritebackInvalidateRange(const void *p, unsigned int size); */ void sceKernelDcacheInvalidateRange(const void *p, unsigned int size); +/** + * Invalidate the instruction cache + */ +void sceKernelIcacheInvalidateAll(void); + +/** + * Invalidate a range of addresses in the instruction cache + */ +void sceKernelIcacheInvalidateRange(const void *p, unsigned int size); + /** Structure for holding a mersenne twister context */ typedef struct _SceKernelUtilsMt19937Context { unsigned int count; unsigned int state[624]; } SceKernelUtilsMt19937Context; -/** +/** * Function to initialise a mersenne twister context. * * @param ctx - Pointer to a context @@ -173,7 +183,7 @@ typedef struct _SceKernelUtilsSha1Context { /** * Function to SHA1 hash a data block. - * + * * @param data - The data to hash. * @param size - The size of the data. * @param digest - Pointer to a 20 byte array for storing the digest @@ -213,7 +223,7 @@ int sceKernelUtilsSha1BlockUpdate(SceKernelUtilsSha1Context *ctx, u8 *data, u32 /** * Function to get the result of the SHA1 hash. - * + * * @param ctx - Pointer to a prefilled context. * @param digest - A pointer to a 20 byte array to contain the digest. *