diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json index a185c7e4b..70f8d862b 100644 --- a/.vscode/c_cpp_properties.json +++ b/.vscode/c_cpp_properties.json @@ -7,8 +7,15 @@ "GAMECUBE" ], "includePath": [ - "${workspaceFolder}/include/**", - "${workspaceFolder}/src/**" + "${workspaceFolder}/include", + "${workspaceFolder}/include/bink", + "${workspaceFolder}/include/PowerPC_EABI_Support/MSL/MSL_C/MSL_Common/Include", + "${workspaceFolder}/include/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include", + "${workspaceFolder}/include/inline", + "${workspaceFolder}/include/rwsdk", + "${workspaceFolder}/src/SB/Core/gc", + "${workspaceFolder}/src/SB/Core/x", + "${workspaceFolder}/src/SB/Game" ], "cStandard": "c99", "cppStandard": "c++98", diff --git a/configure.py b/configure.py index bbf728d9a..5b439f35b 100644 --- a/configure.py +++ b/configure.py @@ -242,7 +242,6 @@ "-i include/bink", "-i include/PowerPC_EABI_Support/MSL/MSL_C/MSL_Common/Include", "-i include/PowerPC_EABI_Support/MSL/MSL_C++/MSL_Common/Include", - "-i include/dolphin", "-i include/inline", "-i include/rwsdk", "-i src/SB/Core/gc", diff --git a/include/dolphin.h b/include/dolphin.h new file mode 100644 index 000000000..ac1ebcf7b --- /dev/null +++ b/include/dolphin.h @@ -0,0 +1,24 @@ +#ifndef _DOLPHIN_H_ +#define _DOLPHIN_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/include/dolphin/G2D.h b/include/dolphin/G2D.h new file mode 100644 index 000000000..18772ed00 --- /dev/null +++ b/include/dolphin/G2D.h @@ -0,0 +1,88 @@ +#ifndef _DOLPHIN_G2D_H_ +#define _DOLPHIN_G2D_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum G2DMatCtg { + G2D_CTG_TEXTURE, + G2D_CTG_RGB_DIRECT, + G2D_CTG_RGBA_INDEX8, + G2D_CTG_EMPTY, +} G2DMatCtg; + +typedef struct G2DSprite { + u16 nTlcS; // "Top Left Corner" + u16 nTlcT; + u16 nWidth; + u16 nHeight; + GXTexObj* to; + f32 rS0; + f32 rT0; + f32 rS1; + f32 rT1; +} G2DSprite; + +typedef struct G2DPosOri { + f32 rPosX; + f32 rPosY; + f32 rOriX; + f32 rOriY; +} G2DPosOri; + +typedef struct G2DGlob { + u16 nViewportTlcX; + u16 nViewportTlcY; + u16 nViewportWidth; + u16 nViewportHeight; + G2DPosOri poCam; + f32 rWorldX; + f32 rWorldY; + f32 rHalfX; + f32 rHalfY; +} G2DGlob; + +typedef struct G2DMatDesc { + s32 nReserved; + G2DMatCtg nCategory; + GXColor* color; + GXTexObj* to; + u8* clut; // Color Look-Up Table +} G2DMatDesc; + +typedef struct G2DTileDesc { + u8 nMaterial; + u8 nS; + u8 nT; + u8 nCI; // Color Index + u8 aUser[4]; +} G2DTileDesc; + +typedef struct G2DLayer { + void* map; + s8 nHS; + s8 nVS; + s8 nBPI; + s16 nTileWidth; + s16 nTileHeight; + s8 bWrap; + u8 nNumMaterials; + G2DTileDesc* tileDesc; + G2DMatDesc* matDesc; +} G2DLayer; + +void G2DInitSprite(G2DSprite* sprite); +void G2DDrawSprite(G2DSprite* sprite, G2DPosOri* po); +void G2DDrawLayer(G2DLayer* layer, s8* aSortBuffer); +void G2DSetCamera(G2DPosOri* po); +void G2DInitWorld(u32 nWorldX, u32 nWorldY); +void G2DSetViewport(u16 nLeft, u16 nTop, u16 nWidth, u16 nHeight); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_G2D_H_ diff --git a/include/dolphin/ai.h b/include/dolphin/ai.h new file mode 100644 index 000000000..84db3343b --- /dev/null +++ b/include/dolphin/ai.h @@ -0,0 +1,50 @@ +#ifndef _DOLPHIN_AI_H_ +#define _DOLPHIN_AI_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*AISCallback)(u32 count); +typedef void (*AIDCallback)(); + +#define AI_STREAM_START 1 +#define AI_STREAM_STOP 0 + +#define AI_SAMPLERATE_32KHZ 0 +#define AI_SAMPLERATE_48KHZ 1 + +AIDCallback AIRegisterDMACallback(AIDCallback callback); +void AIInitDMA(u32 start_addr, u32 length); +BOOL AIGetDMAEnableFlag(void); +void AIStartDMA(void); +void AIStopDMA(void); +u32 AIGetDMABytesLeft(void); +u32 AIGetDMAStartAddr(void); +u32 AIGetDMALength(void); +BOOL AICheckInit(void); +AISCallback AIRegisterStreamCallback(AISCallback callback); +u32 AIGetStreamSampleCount(void); +void AIResetStreamSampleCount(void); +void AISetStreamTrigger(u32 trigger); +u32 AIGetStreamTrigger(void); +void AISetStreamPlayState(u32 state); +u32 AIGetStreamPlayState(void); +void AISetDSPSampleRate(u32 rate); +u32 AIGetDSPSampleRate(void); +void AISetStreamSampleRate(u32 rate); +u32 AIGetStreamSampleRate(void); +void AISetStreamVolLeft(u8 vol); +u8 AIGetStreamVolLeft(void); +void AISetStreamVolRight(u8 vol); +u8 AIGetStreamVolRight(void); +void AIInit(u8* stack); +void AIReset(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/am.h b/include/dolphin/am.h new file mode 100644 index 000000000..153553b11 --- /dev/null +++ b/include/dolphin/am.h @@ -0,0 +1,26 @@ +#ifndef _DOLPHIN_AM_H_ +#define _DOLPHIN_AM_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*AMCallback)(char* path); + +void* AMLoadFile(char* path, u32* length); +u32 AMPush(char* path); +u32 AMPushData(void* buffer, u32 length); +void AMPop(void); +u32 AMGetZeroBuffer(void); +u32 AMGetReadStatus(void); +u32 AMGetFreeSize(void); +u32 AMGetStackPointer(void); +void AMInit(u32 aramBase, u32 aramBytes); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/amc/AmcExi2Comm.h b/include/dolphin/amc/AmcExi2Comm.h new file mode 100644 index 000000000..c38c8a6a1 --- /dev/null +++ b/include/dolphin/amc/AmcExi2Comm.h @@ -0,0 +1,123 @@ +#ifndef _DOLPHIN_AMC_AMCEXI2COMM_H_ +#define _DOLPHIN_AMC_AMCEXI2COMM_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum +{ + AMC_EXI_NO_ERROR = 0, + AMC_EXI_UNSELECTED, +} AmcExiError; + +// --------------------------------------------------------------------------- +// +// void EXI2_Init( volatile unsigned char **inputPendingPtrRef, +// EXICallback monitorCallback ); +// +// Description: Initialize the EXI2 driver (without interrupts). The +// parameter 'inputPendingPtrref' is a flag showing whether input +// is waiting in the EXI2 buffer and 'monitorCallback' is a +// pointer to a callback function that is invoked at the end of +// the EXI2 ISR. +// +// --------------------------------------------------------------------------- +void EXI2_Init(volatile unsigned char **inputPendingPtrRef, EXICallback monitorCallback); + +// --------------------------------------------------------------------------- +// +// void EXI2_EnableInterrupts( void ); +// +// Description: Enable EXI2 interrupts. This function must be called to use +// interrupts on the EXI2 interface. Call this function only +// after EXI2_Init() has been invoked. +// +// --------------------------------------------------------------------------- +void EXI2_EnableInterrupts( void ); + + + +// --------------------------------------------------------------------------- +// +// int EXI2_Poll( void ); +// +// Description: Returns the number of bytes waiting to be read in the EXI2 +// buffer. +// +// --------------------------------------------------------------------------- +int EXI2_Poll( void ); + + + +// --------------------------------------------------------------------------- +// +// AmcExiError EXI2_ReadN( void *bytes, unsigned long length ); +// +// Description: Read length bytes and return in bytes[] array. +// +// Returns: One of AMC_EXI_*. +// +// --------------------------------------------------------------------------- +AmcExiError EXI2_ReadN( void *bytes, unsigned long length); + + + +// --------------------------------------------------------------------------- +// +// AmcExiError EXI2_WriteN( const void *bytes, unsigned long length ); +// +// Description: Write length bytes stored in bytes[] array. +// +// Returns: One of AMC_EXI_*. +// +// --------------------------------------------------------------------------- +AmcExiError EXI2_WriteN( const void *bytes, unsigned long length); + + + +// --------------------------------------------------------------------------- +// +// void EXI2_Reserve( void ); +// +// Description: Disable non-monitor communications over the EXI2 port. +// This function must be called before the monitor takes +// control of the processor. +// +// --------------------------------------------------------------------------- +void EXI2_Reserve( void ); + + + +// --------------------------------------------------------------------------- +// +// void EXI2_Unreserve( void ); +// +// Description: Re-enable non-monitor communications over the EXI2 port. +// This function must be called just before the monitor +// gives control of the processor back to the application. +// +// --------------------------------------------------------------------------- +void EXI2_Unreserve( void ); + + + +// --------------------------------------------------------------------------- +// +// AmcExiError EXI2_GetStatusReg( u16* pu16StatusReg ); +// +// Description: Read and store the value of the status register into +// *pu16StatusReg. +// +// Returns: One of AMC_EXI_*. +// --------------------------------------------------------------------------- +AmcExiError EXI2_GetStatusReg( u16* pu16StatusReg ); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/amc/AmcTypes.h b/include/dolphin/amc/AmcTypes.h new file mode 100644 index 000000000..c11d8c49a --- /dev/null +++ b/include/dolphin/amc/AmcTypes.h @@ -0,0 +1,9 @@ +#ifndef _INCLUDE_DOLPHIN_AMCTYPES_H_ +#define _INCLUDE_DOLPHIN_AMCTYPES_H_ + +#include + +// EXI callback function pointer type +typedef void (*EXICallback)(s32 chan, OSContext* context); + +#endif diff --git a/include/dolphin/ar.h b/include/dolphin/ar.h new file mode 100644 index 000000000..d65a28281 --- /dev/null +++ b/include/dolphin/ar.h @@ -0,0 +1,71 @@ +#ifndef _DOLPHIN_AR_H_ +#define _DOLPHIN_AR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*ARQCallback)(u32 pointerToARQRequest); + +struct ARQRequest { + /* 0x00 */ struct ARQRequest *next; + /* 0x04 */ u32 owner; + /* 0x08 */ u32 type; + /* 0x0C */ u32 priority; + /* 0x10 */ u32 source; + /* 0x14 */ u32 dest; + /* 0x18 */ u32 length; + /* 0x1C */ ARQCallback callback; +}; + +#define ARQ_DMA_ALIGNMENT 32 + +#define ARAM_DIR_MRAM_TO_ARAM 0x00 +#define ARAM_DIR_ARAM_TO_MRAM 0x01 + +#define ARStartDMARead(mmem, aram, len) \ + ARStartDMA(ARAM_DIR_ARAM_TO_MRAM, mmem, aram, len) +#define ARStartDMAWrite(mmem, aram, len) \ + ARStartDMA(ARAM_DIR_MRAM_TO_ARAM, mmem, aram, len) + +typedef struct ARQRequest ARQRequest; + +#define ARQ_TYPE_MRAM_TO_ARAM ARAM_DIR_MRAM_TO_ARAM +#define ARQ_TYPE_ARAM_TO_MRAM ARAM_DIR_ARAM_TO_MRAM + +#define ARQ_PRIORITY_LOW 0 +#define ARQ_PRIORITY_HIGH 1 + +// AR +ARQCallback ARRegisterDMACallback(ARQCallback callback); +u32 ARGetDMAStatus(void); +void ARStartDMA(u32 type, u32 mainmem_addr, u32 aram_addr, u32 length); +u32 ARAlloc(u32 length); +u32 ARFree(u32* length); +BOOL ARCheckInit(void); +u32 ARInit(u32* stack_index_addr, u32 num_entries); +void ARReset(void); +void ARSetSize(void); +u32 ARGetBaseAddress(void); +u32 ARGetSize(void); +u32 ARGetInternalSize(void); +void ARClear(u32 flag); + +// ARQ +void ARQInit(void); +void ARQReset(void); +void ARQPostRequest(ARQRequest* request, u32 owner, u32 type, u32 priority, u32 source, u32 dest, u32 length, ARQCallback callback); +void ARQRemoveRequest(ARQRequest* request); +void ARQRemoveOwnerRequest(u32 owner); +void ARQFlushQueue(void); +void ARQSetChunkSize(u32 size); +u32 ARQGetChunkSize(void); +BOOL ARQCheckInit(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/ax.h b/include/dolphin/ax.h new file mode 100644 index 000000000..0148446ee --- /dev/null +++ b/include/dolphin/ax.h @@ -0,0 +1,325 @@ +#ifndef _DOLPHIN_AX_H_ +#define _DOLPHIN_AX_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _AXPBMIX { + /* 0x00 */ u16 vL; + /* 0x02 */ u16 vDeltaL; + /* 0x04 */ u16 vR; + /* 0x06 */ u16 vDeltaR; + /* 0x08 */ u16 vAuxAL; + /* 0x0A */ u16 vDeltaAuxAL; + /* 0x0C */ u16 vAuxAR; + /* 0x0E */ u16 vDeltaAuxAR; + /* 0x10 */ u16 vAuxBL; + /* 0x12 */ u16 vDeltaAuxBL; + /* 0x14 */ u16 vAuxBR; + /* 0x16 */ u16 vDeltaAuxBR; + /* 0x18 */ u16 vAuxBS; + /* 0x1A */ u16 vDeltaAuxBS; + /* 0x1C */ u16 vS; + /* 0x1E */ u16 vDeltaS; + /* 0x20 */ u16 vAuxAS; + /* 0x22 */ u16 vDeltaAuxAS; +} AXPBMIX; + +typedef struct _AXPBITD { + /* 0x00 */ u16 flag; + /* 0x02 */ u16 bufferHi; + /* 0x04 */ u16 bufferLo; + /* 0x06 */ u16 shiftL; + /* 0x08 */ u16 shiftR; + /* 0x0A */ u16 targetShiftL; + /* 0x0C */ u16 targetShiftR; +} AXPBITD; + +typedef struct _AXPBUPDATE { + /* 0x00 */ u16 updNum[5]; + /* 0x0A */ u16 dataHi; + /* 0x0C */ u16 dataLo; +} AXPBUPDATE; + +typedef struct _AXPBDPOP { + /* 0x00 */ s16 aL; + /* 0x02 */ s16 aAuxAL; + /* 0x04 */ s16 aAuxBL; + /* 0x06 */ s16 aR; + /* 0x08 */ s16 aAuxAR; + /* 0x0A */ s16 aAuxBR; + /* 0x0C */ s16 aS; + /* 0x0E */ s16 aAuxAS; + /* 0x10 */ s16 aAuxBS; +} AXPBDPOP; + +typedef struct _AXPBVE { + /* 0x00 */ u16 currentVolume; + /* 0x02 */ s16 currentDelta; +} AXPBVE; + +typedef struct _AXPBFIR { + /* 0x00 */ u16 numCoefs; + /* 0x02 */ u16 coefsHi; + /* 0x04 */ u16 coefsLo; +} AXPBFIR; + +typedef struct _AXPBADDR { + /* 0x00 */ u16 loopFlag; + /* 0x02 */ u16 format; + /* 0x04 */ u16 loopAddressHi; + /* 0x06 */ u16 loopAddressLo; + /* 0x08 */ u16 endAddressHi; + /* 0x0A */ u16 endAddressLo; + /* 0x0C */ u16 currentAddressHi; + /* 0x0E */ u16 currentAddressLo; +} AXPBADDR; + +typedef struct _AXPBADPCM { + /* 0x00 */ u16 a[8][2]; + /* 0x20 */ u16 gain; + /* 0x22 */ u16 pred_scale; + /* 0x24 */ u16 yn1; + /* 0x26 */ u16 yn2; +} AXPBADPCM; + +typedef struct _AXPBSRC { + /* 0x00 */ u16 ratioHi; + /* 0x02 */ u16 ratioLo; + /* 0x04 */ u16 currentAddressFrac; + /* 0x06 */ u16 last_samples[4]; +} AXPBSRC; + +typedef struct _AXPBADPCMLOOP { + /* 0x00 */ u16 loop_pred_scale; + /* 0x02 */ u16 loop_yn1; + /* 0x04 */ u16 loop_yn2; +} AXPBADPCMLOOP; + +typedef struct _AXPBLPF { + u16 on; + u16 yn1; + u16 a0; + u16 b0; +} AXPBLPF; + +typedef struct _AXPB { + /* 0x00 */ u16 nextHi; + /* 0x02 */ u16 nextLo; + /* 0x04 */ u16 currHi; + /* 0x06 */ u16 currLo; + /* 0x08 */ u16 srcSelect; + /* 0x0A */ u16 coefSelect; + /* 0x0C */ u16 mixerCtrl; + /* 0x0E */ u16 state; + /* 0x10 */ u16 type; + /* 0x12 */ AXPBMIX mix; + /* 0x36 */ AXPBITD itd; + /* 0x44 */ AXPBUPDATE update; + /* 0x52 */ AXPBDPOP dpop; + /* 0x64 */ AXPBVE ve; + /* 0x68 */ AXPBFIR fir; + /* 0x6E */ AXPBADDR addr; + /* 0x7E */ AXPBADPCM adpcm; + /* 0xA6 */ AXPBSRC src; + /* 0xB4 */ AXPBADPCMLOOP adpcmLoop; + /* 0xBA */ AXPBLPF lpf; + /* 0xC2 */ u16 pad[25]; +} AXPB; + +typedef struct _AXVPB { + /* 0x000 */ void* next; + /* 0x004 */ void* prev; + /* 0x008 */ void* next1; + /* 0x00C */ u32 priority; + /* 0x010 */ void (*callback)(void*); + /* 0x014 */ u32 userContext; + /* 0x018 */ u32 index; + /* 0x01C */ u32 sync; + /* 0x020 */ u32 depop; + /* 0x024 */ u32 updateMS; + /* 0x028 */ u32 updateCounter; + /* 0x02C */ u32 updateTotal; + /* 0x030 */ u16* updateWrite; + /* 0x034 */ u16 updateData[128]; + /* 0x134 */ void* itdBuffer; + /* 0x138 */ AXPB pb; +} AXVPB; + +typedef struct _AXPBITDBUFFER { + /* 0x00 */ s16 data[32]; +} AXPBITDBUFFER; + +typedef struct _AXPBU { + /* 0x00 */ u16 data[128]; +} AXPBU; + +typedef struct _AXSPB { + /* 0x00 */ u16 dpopLHi; + /* 0x02 */ u16 dpopLLo; + /* 0x04 */ s16 dpopLDelta; + /* 0x06 */ u16 dpopRHi; + /* 0x08 */ u16 dpopRLo; + /* 0x0A */ s16 dpopRDelta; + /* 0x0C */ u16 dpopSHi; + /* 0x0E */ u16 dpopSLo; + /* 0x10 */ s16 dpopSDelta; + /* 0x12 */ u16 dpopALHi; + /* 0x14 */ u16 dpopALLo; + /* 0x16 */ s16 dpopALDelta; + /* 0x18 */ u16 dpopARHi; + /* 0x1A */ u16 dpopARLo; + /* 0x1C */ s16 dpopARDelta; + /* 0x1E */ u16 dpopASHi; + /* 0x20 */ u16 dpopASLo; + /* 0x22 */ s16 dpopASDelta; + /* 0x24 */ u16 dpopBLHi; + /* 0x26 */ u16 dpopBLLo; + /* 0x28 */ s16 dpopBLDelta; + /* 0x2A */ u16 dpopBRHi; + /* 0x2C */ u16 dpopBRLo; + /* 0x2E */ s16 dpopBRDelta; + /* 0x30 */ u16 dpopBSHi; + /* 0x32 */ u16 dpopBSLo; + /* 0x34 */ s16 dpopBSDelta; +} AXSPB; + +typedef struct _AXPROFILE { + /* 0x00 */ u64 axFrameStart; + /* 0x08 */ u64 auxProcessingStart; + /* 0x10 */ u64 auxProcessingEnd; + /* 0x18 */ u64 userCallbackStart; + /* 0x20 */ u64 userCallbackEnd; + /* 0x28 */ u64 axFrameEnd; + /* 0x30 */ u32 axNumVoices; +} AXPROFILE; + +typedef struct AX_AUX_DATA { + /* 0x00 */ s32* l; + /* 0x00 */ s32* r; + /* 0x00 */ s32* s; +} AX_AUX_DATA; + +typedef struct AX_AUX_DATA_DPL2 { + /* 0x00 */ s32* l; + /* 0x00 */ s32* r; + /* 0x00 */ s32* ls; + /* 0x00 */ s32* rs; +} AX_AUX_DATA_DPL2; + +typedef void (*AXCallback)(); + +#define AX_DSP_SLAVE_LENGTH 0xF80 +#define AX_MAX_VOICES 64 + +#define AX_SRC_TYPE_NONE 0 +#define AX_SRC_TYPE_LINEAR 1 +#define AX_SRC_TYPE_4TAP_8K 2 +#define AX_SRC_TYPE_4TAP_12K 3 +#define AX_SRC_TYPE_4TAP_16K 4 + +// sync flags +#define AX_SYNC_FLAG_COPYALL (1 << 31) +#define AX_SYNC_FLAG_UNK1 (1 << 30) // reserved, unused? +#define AX_SYNC_FLAG_UNK2 (1 << 29) // reserved, unused? +#define AX_SYNC_FLAG_UNK3 (1 << 28) // reserved, unused? +#define AX_SYNC_FLAG_UNK4 (1 << 27) // reserved, unused? +#define AX_SYNC_FLAG_UNK5 (1 << 26) // reserved, unused? +#define AX_SYNC_FLAG_UNK6 (1 << 25) // reserved, unused? +#define AX_SYNC_FLAG_UNK7 (1 << 24) // reserved, unused? +#define AX_SYNC_FLAG_UNK8 (1 << 23) // reserved, unused? +#define AX_SYNC_FLAG_UNK9 (1 << 22) // reserved, unused? +#define AX_SYNC_FLAG_UNK10 (1 << 21) // reserved, unused? +#define AX_SYNC_FLAG_COPYADPCMLOOP (1 << 20) +#define AX_SYNC_FLAG_COPYRATIO (1 << 19) +#define AX_SYNC_FLAG_COPYSRC (1 << 18) +#define AX_SYNC_FLAG_COPYADPCM (1 << 17) +#define AX_SYNC_FLAG_COPYCURADDR (1 << 16) +#define AX_SYNC_FLAG_COPYENDADDR (1 << 15) +#define AX_SYNC_FLAG_COPYLOOPADDR (1 << 14) +#define AX_SYNC_FLAG_COPYLOOP (1 << 13) +#define AX_SYNC_FLAG_COPYADDR (1 << 12) +#define AX_SYNC_FLAG_COPYFIR (1 << 11) +#define AX_SYNC_FLAG_SWAPVOL (1 << 10) +#define AX_SYNC_FLAG_COPYVOL (1 << 9) +#define AX_SYNC_FLAG_COPYDPOP (1 << 8) +#define AX_SYNC_FLAG_COPYUPDATE (1 << 7) +#define AX_SYNC_FLAG_COPYTSHIFT (1 << 6) +#define AX_SYNC_FLAG_COPYITD (1 << 5) +#define AX_SYNC_FLAG_COPYAXPBMIX (1 << 4) +#define AX_SYNC_FLAG_COPYTYPE (1 << 3) +#define AX_SYNC_FLAG_COPYSTATE (1 << 2) +#define AX_SYNC_FLAG_COPYMXRCTRL (1 << 1) +#define AX_SYNC_FLAG_COPYSELECT (1 << 0) + +#define AX_PRIORITY_STACKS 32 + +// AX +void AXInit(void); +void AXInitEx(u32 outputBufferMode); +void AXQuit(void); + +// AXAlloc +void AXFreeVoice(AXVPB* p); +AXVPB* AXAcquireVoice(u32 priority, void (*callback)(void *), u32 userContext); +void AXSetVoicePriority(AXVPB* p, u32 priority); + +// AXAux +void AXRegisterAuxACallback(void (*callback)(void*, void*), void* context); +void AXRegisterAuxBCallback(void (*callback)(void*, void*), void* context); + +// AXCL +void AXSetMode(u32 mode); +u32 AXGetMode(void); + +// AXOut +extern AXPROFILE __AXLocalProfile; + +void AXSetStepMode(u32 i); +AXCallback AXRegisterCallback(AXCallback callback); + +// AXProf +void AXInitProfile(AXPROFILE* profile, u32 maxProfiles); +u32 AXGetProfile(void); + +// AXVPB +void AXSetVoiceSrcType(AXVPB* p, u32 type); +void AXSetVoiceState(AXVPB* p, u16 state); +void AXSetVoiceType(AXVPB* p, u16 type); +void AXSetVoiceMix(AXVPB* p, AXPBMIX* mix); +void AXSetVoiceItdOn(AXVPB* p); +void AXSetVoiceItdTarget(AXVPB* p, u16 lShift, u16 rShift); +void AXSetVoiceUpdateIncrement(AXVPB* p); +void AXSetVoiceUpdateWrite(AXVPB* p, u16 param, u16 data); +void AXSetVoiceDpop(AXVPB* p, AXPBDPOP* dpop); +void AXSetVoiceVe(AXVPB* p, AXPBVE* ve); +void AXSetVoiceVeDelta(AXVPB* p, s16 delta); +void AXSetVoiceFir(AXVPB* p, AXPBFIR* fir); +void AXSetVoiceAddr(AXVPB* p, AXPBADDR* addr); +void AXSetVoiceLoop(AXVPB* p, u16 loop); +void AXSetVoiceLoopAddr(AXVPB* p, u32 addr); +void AXSetVoiceEndAddr(AXVPB* p, u32 addr); +void AXSetVoiceCurrentAddr(AXVPB* p, u32 addr); +void AXSetVoiceAdpcm(AXVPB* p, AXPBADPCM* adpcm); +void AXSetVoiceSrc(AXVPB* p, AXPBSRC* src_); +void AXSetVoiceSrcRatio(AXVPB* p, f32 ratio); +void AXSetVoiceAdpcmLoop(AXVPB* p, AXPBADPCMLOOP* adpcmloop); +void AXSetMaxDspCycles(u32 cycles); +u32 AXGetMaxDspCycles(void); +u32 AXGetDspCycles(void); +void AXSetVoiceLpf(AXVPB* p, AXPBLPF* lpf); +void AXSetVoiceLpfCoefs(AXVPB* p, u16 a0, u16 b0); +void AXGetLpfCoefs(u16 freq, u16* a0, u16* b0); + +// DSPCode +extern u16 axDspSlaveLength; +extern u16 axDspSlave[AX_DSP_SLAVE_LENGTH]; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_AX_H_ diff --git a/include/dolphin/axart.h b/include/dolphin/axart.h new file mode 100644 index 000000000..46c375f71 --- /dev/null +++ b/include/dolphin/axart.h @@ -0,0 +1,224 @@ +#ifndef _DOLPHIN_AXART_H_ +#define _DOLPHIN_AXART_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +enum __axart_type { + AXART_TYPE_NONE, + AXART_TYPE_3D, + AXART_TYPE_PANNING, + AXART_TYPE_ITD, + AXART_TYPE_SRC, + AXART_TYPE_PITCH, + AXART_TYPE_PITCH_ENV, + AXART_TYPE_PITCH_MOD, + AXART_TYPE_VOLUME, + AXART_TYPE_AUX_A_VOLUME, + AXART_TYPE_AUX_B_VOLUME, + AXART_TYPE_VOLUME_ENV, + AXART_TYPE_AUX_A_VOLUME_ENV, + AXART_TYPE_AUX_B_VOLUME_ENV, + AXART_TYPE_VOLUME_MOD, + AXART_TYPE_AUX_A_VOLUME_MOD, + AXART_TYPE_AUX_B_VOLUME_MOD, + AXART_TYPE_LPF, + + AXART_TYPE_NUM +}; + +typedef struct { + void* next; + u32 type; +} AXART_ART; + +typedef struct { + f32* lfo; + u32 length; + f32 delta; + u32 sampleIndex; + f32 counter; + f32 sample1; + f32 sample; + f32 output; +} AXART_LFO; + +typedef struct { + AXART_ART art; + f32 hAngle; + f32 vAngle; + f32 dist; + f32 closingSpeed; + u32 update; + u8 pan; + u8 span; + u8 src; + u16 itdL; + u16 itdR; + f32 pitch; + s32 attenuation; +} AXART_3D; + +typedef struct { + AXART_ART art; + u8 pan; + u8 span; +} AXART_PANNING; + +typedef struct { + AXART_ART art; + u16 itdL; + u16 itdR; +} AXART_ITD; + +typedef struct { + AXART_ART art; + u8 src; +} AXART_SRC; + +typedef struct { + AXART_ART art; + s32 cents; +} AXART_PITCH; + +typedef struct { + AXART_ART art; + s32 delta; + s32 target; + s32 cents; +} AXART_PITCH_ENV; + +typedef struct { + AXART_ART art; + AXART_LFO lfo; + s32 cents; +} AXART_PITCH_MOD; + +typedef struct { + AXART_ART art; + s32 attenuation; +} AXART_VOLUME; + +typedef struct { + AXART_ART art; + s32 attenuation; +} AXART_AUXA_VOLUME; + +typedef struct { + AXART_ART art; + s32 attenuation; +} AXART_AUXB_VOLUME; + +typedef struct { + AXART_ART art; + s32 delta; + s32 target; + s32 attenuation; +} AXART_VOLUME_ENV; + +typedef struct { + AXART_ART art; + s32 delta; + s32 target; + s32 attenuation; +} AXART_AUXA_VOLUME_ENV; + +typedef struct { + AXART_ART art; + s32 delta; + s32 target; + s32 attenuation; +} AXART_AUXB_VOLUME_ENV; + +typedef struct { + AXART_ART art; + AXART_LFO lfo; + s32 attenuation; +} AXART_VOLUME_MOD; + +typedef struct { + AXART_ART art; + AXART_LFO lfo; + s32 attenuation; +} AXART_AUXA_VOLUME_MOD; + +typedef struct { + AXART_ART art; + AXART_LFO lfo; + s32 attenuation; +} AXART_AUXB_VOLUME_MOD; + +typedef struct { + AXART_ART art; + u32 initLPF; + u32 frequency; + u32 update; +} AXART_LPF; + +typedef struct { + void* next; + void* prev; + AXVPB* axvpb; + f32 sampleRate; + AXART_ART* articulators; +} AXART_SOUND; + +#define AXART_SINE_CNT 64 +extern f32 AXARTSine[AXART_SINE_CNT]; + +// axart +void AXARTInit(void); +void AXARTQuit(void); +void AXARTServiceSounds(void); +void AXARTAddSound(AXART_SOUND* sound); +void AXARTRemoveSound(AXART_SOUND* sound); +void AXARTInitLfo(AXART_LFO* lfo, f32* samples, u32 length, f32 delta); +void AXARTInitArt3D(AXART_3D* articulator); +void AXARTInitArtPanning(AXART_PANNING* articulator); +void AXARTInitArtItd(AXART_ITD* articulator); +void AXARTInitArtSrctype(AXART_SRC* articulator); +void AXARTInitArtPitch(AXART_PITCH* articulator); +void AXARTInitArtPitchEnv(AXART_PITCH_ENV* articulator); +void AXARTInitArtPitchMod(AXART_PITCH_MOD* articulator); +void AXARTInitArtVolume(AXART_VOLUME* articulator); +void AXARTInitArtAuxAVolume(AXART_AUXA_VOLUME* articulator); +void AXARTInitArtAuxBVolume(AXART_AUXB_VOLUME* articulator); +void AXARTInitArtVolumeEnv(AXART_VOLUME_ENV* articulator); +void AXARTInitArtAuxAVolumeEnv(AXART_AUXA_VOLUME_ENV* articulator); +void AXARTInitArtAuxBVolumeEnv(AXART_AUXB_VOLUME_ENV* articulator); +void AXARTInitArtVolumeMod(AXART_VOLUME_MOD* articulator); +void AXARTInitArtAuxAVolumeMod(AXART_AUXA_VOLUME_MOD* articulator); +void AXARTInitArtAuxBVolumeMod(AXART_AUXB_VOLUME_MOD* articulator); +void AXARTInitArtLpf(AXART_LPF* articulator); + +// axart3d +void AXARTSet3DDistanceScale(f32 scale); +void AXARTSet3DDopplerScale(f32 scale); +void AXART3DSound(AXART_3D* articulator); + +// axartcents +f32 AXARTCents(s32 cents); + +// axartenv +void AXARTPitchEnv(AXART_PITCH_ENV* articulator); +void AXARTVolumeEnv(AXART_VOLUME_ENV* articulator); + +// axartlfo +void AXARTLfo(AXART_LFO* lfo); + +// axartsound +void AXARTServiceSound(AXART_SOUND* sound); +void AXARTAddArticulator(AXART_SOUND* sound, AXART_ART* articulator); + +// axartlpf +void AXARTLpf(AXART_LPF*, AXVPB*); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_AXART_H_ diff --git a/include/dolphin/axfx.h b/include/dolphin/axfx.h new file mode 100644 index 000000000..53933c858 --- /dev/null +++ b/include/dolphin/axfx.h @@ -0,0 +1,196 @@ +#ifndef _DOLPHIN_AXFX_H_ +#define _DOLPHIN_AXFX_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct AXFX_REVSTD_DELAYLINE { + /* 0x00 */ s32 inPoint; + /* 0x04 */ s32 outPoint; + /* 0x08 */ s32 length; + /* 0x0C */ f32* inputs; + /* 0x10 */ f32 lastOutput; +} AXFX_REVSTD_DELAYLINE; + +typedef struct AXFX_REVSTD_WORK { + /* 0x000 */ AXFX_REVSTD_DELAYLINE AP[6]; + /* 0x078 */ AXFX_REVSTD_DELAYLINE C[6]; + /* 0x0F0 */ f32 allPassCoeff; + /* 0x0F4 */ f32 combCoef[6]; + /* 0x10C */ f32 lpLastout[3]; + /* 0x118 */ f32 level; + /* 0x11C */ f32 damping; + /* 0x120 */ s32 preDelayTime; + /* 0x124 */ f32* preDelayLine[3]; + /* 0x130 */ f32* preDelayPtr[3]; +} AXFX_REVSTD_WORK; + +typedef struct AXFX_REVERBSTD { + /* 0x000 */ AXFX_REVSTD_WORK rv; + /* 0x13C */ u8 tempDisableFX; + /* 0x140 */ f32 coloration; + /* 0x144 */ f32 mix; + /* 0x148 */ f32 time; + /* 0x14C */ f32 damping; + /* 0x150 */ f32 preDelay; +} AXFX_REVERBSTD; + +typedef struct AXFX_BUFFERUPDATE { + /* 0x00 */ s32* left; + /* 0x04 */ s32* right; + /* 0x08 */ s32* surround; +} AXFX_BUFFERUPDATE; + +typedef struct AXFX_BUFFERUPDATE_DPL2 { + /* 0x00 */ s32* L; + /* 0x04 */ s32* R; + /* 0x08 */ s32* Ls; + /* 0x0C */ s32* Rs; +} AXFX_BUFFERUPDATE_DPL2; + +// REVHI Structs + +typedef struct AXFX_REVHI_DELAYLINE { + /* 0x00 */ s32 inPoint; + /* 0x04 */ s32 outPoint; + /* 0x08 */ s32 length; + /* 0x0C */ f32* inputs; + /* 0x10 */ f32 lastOutput; +} AXFX_REVHI_DELAYLINE; + +typedef struct AXFX_REVHI_WORK { + /* 0x000 */ AXFX_REVHI_DELAYLINE AP[9]; + /* 0x0B4 */ AXFX_REVHI_DELAYLINE C[9]; + /* 0x168 */ f32 allPassCoeff; + /* 0x16C */ f32 combCoef[9]; + /* 0x190 */ f32 lpLastout[3]; + /* 0x19C */ f32 level; + /* 0x1A0 */ f32 damping; + /* 0x1A4 */ s32 preDelayTime; + /* 0x1A8 */ f32 crosstalk; + /* 0x1AC */ f32* preDelayLine[3]; + /* 0x1B8 */ f32* preDelayPtr[3]; +} AXFX_REVHI_WORK; + +typedef struct AXFX_REVHI_WORK_DPL2 { + /* 0x000 */ AXFX_REVHI_DELAYLINE AP[12]; + /* 0x0F0 */ AXFX_REVHI_DELAYLINE C[12]; + /* 0x1E0 */ f32 allPassCoeff; + /* 0x1E4 */ f32 combCoef[12]; + /* 0x214 */ f32 lpLastout[4]; + /* 0x224 */ f32 level; + /* 0x228 */ f32 damping; + /* 0x22C */ s32 preDelayTime; + /* 0x230 */ f32 crosstalk; + /* 0x234 */ f32* preDelayLine[4]; + /* 0x244 */ f32* preDelayPtr[4]; +} AXFX_REVHI_WORK_DPL2; + +typedef struct AXFX_REVERBHI { + /* 0x000 */ AXFX_REVHI_WORK rv; + /* 0x1C4 */ u8 tempDisableFX; + /* 0x1C8 */ f32 coloration; + /* 0x1CC */ f32 mix; + /* 0x1D0 */ f32 time; + /* 0x1D4 */ f32 damping; + /* 0x1D8 */ f32 preDelay; + /* 0x1DC */ f32 crosstalk; +} AXFX_REVERBHI; + +typedef struct AXFX_REVERBHI_DPL2 { + /* 0x000 */ AXFX_REVHI_WORK_DPL2 rv; + /* 0x254 */ u8 tempDisableFX; + /* 0x258 */ f32 coloration; + /* 0x25C */ f32 mix; + /* 0x260 */ f32 time; + /* 0x264 */ f32 damping; + /* 0x268 */ f32 preDelay; +} AXFX_REVERBHI_DPL2; + +typedef struct AXFX_DELAY { + /* 0x00 */ u32 currentSize[3]; + /* 0x0C */ u32 currentPos[3]; + /* 0x18 */ u32 currentFeedback[3]; + /* 0x24 */ u32 currentOutput[3]; + /* 0x30 */ s32* left; + /* 0x34 */ s32* right; + /* 0x38 */ s32* sur; + /* 0x3C */ u32 delay[3]; + /* 0x48 */ u32 feedback[3]; + /* 0x54 */ u32 output[3]; +} AXFX_DELAY; + +typedef struct AXFX_CHORUS_SRCINFO { + /* 0x00 */ s32* dest; + /* 0x04 */ s32* smpBase; + /* 0x08 */ s32* old; + /* 0x0C */ u32 posLo; + /* 0x10 */ u32 posHi; + /* 0x14 */ u32 pitchLo; + /* 0x18 */ u32 pitchHi; + /* 0x1C */ u32 trigger; + /* 0x20 */ u32 target; +} AXFX_CHORUS_SRCINFO; + +typedef struct AXFX_CHORUS_WORK { + /* 0x00 */ s32* lastLeft[3]; + /* 0x0C */ s32* lastRight[3]; + /* 0x18 */ s32* lastSur[3]; + /* 0x24 */ u8 currentLast; + /* 0x28 */ s32 oldLeft[4]; + /* 0x38 */ s32 oldRight[4]; + /* 0x48 */ s32 oldSur[4]; + /* 0x58 */ u32 currentPosLo; + /* 0x5C */ u32 currentPosHi; + /* 0x60 */ s32 pitchOffset; + /* 0x64 */ u32 pitchOffsetPeriodCount; + /* 0x68 */ u32 pitchOffsetPeriod; + /* 0x6C */ AXFX_CHORUS_SRCINFO src; +} AXFX_CHORUS_WORK; + +typedef struct AXFX_CHORUS { + /* 0x00 */ AXFX_CHORUS_WORK work; + /* 0x90 */ u32 baseDelay; + /* 0x94 */ u32 variation; + /* 0x98 */ u32 period; +} AXFX_CHORUS; + +// chorus +int AXFXChorusInit(AXFX_CHORUS* c); +int AXFXChorusShutdown(AXFX_CHORUS* c); +int AXFXChorusSettings(AXFX_CHORUS* c); +void AXFXChorusCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_CHORUS* chorus); + +// delay +void AXFXDelayCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_DELAY* delay); +int AXFXDelaySettings(AXFX_DELAY* delay); +int AXFXDelayInit(AXFX_DELAY* delay); +int AXFXDelayShutdown(AXFX_DELAY* delay); + +// reverb_hi +void DoCrossTalk(s32* l, s32* r, f32 cross, f32 invcross); +int AXFXReverbHiInit(AXFX_REVERBHI* rev); +int AXFXReverbHiShutdown(AXFX_REVERBHI* rev); +int AXFXReverbHiSettings(AXFX_REVERBHI* rev); +void AXFXReverbHiCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_REVERBHI* reverb); + +// reverb_hi_4ch +int AXFXReverbHiInitDpl2(AXFX_REVERBHI_DPL2* reverb); +int AXFXReverbHiShutdownDpl2(AXFX_REVERBHI_DPL2* reverb); +int AXFXReverbHiSettingsDpl2(AXFX_REVERBHI_DPL2* rev); +void AXFXReverbHiCallbackDpl2(AXFX_BUFFERUPDATE_DPL2* bufferUpdate, AXFX_REVERBHI_DPL2* reverb); + +// reverb_std +int AXFXReverbStdInit(AXFX_REVERBSTD* rev); +int AXFXReverbStdShutdown(AXFX_REVERBSTD* rev); +int AXFXReverbStdSettings(AXFX_REVERBSTD* rev); +void AXFXReverbStdCallback(AXFX_BUFFERUPDATE* bufferUpdate, AXFX_REVERBSTD* reverb); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_AXFX_H_ diff --git a/include/dolphin/base/PPCArch.h b/include/dolphin/base/PPCArch.h new file mode 100644 index 000000000..35f5da9c7 --- /dev/null +++ b/include/dolphin/base/PPCArch.h @@ -0,0 +1,542 @@ +#ifndef _DOLPHIN_PPCARCH +#define _DOLPHIN_PPCARCH + +#include "dolphin/types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define CTR 9 +#define XER 1 +#define LR 8 + +#define UPMC1 937 +#define UPMC2 938 +#define UPMC3 941 +#define UPMC4 942 + +#define USIA 939 + +#define UMMCR0 936 +#define UMMCR1 940 + +#define HID0 1008 +#define HID1 1009 + +#define PVR 287 + +#define IBAT0U 528 +#define IBAT0L 529 +#define IBAT1U 530 +#define IBAT1L 531 +#define IBAT2U 532 +#define IBAT2L 533 +#define IBAT3U 534 +#define IBAT3L 535 + +#define DBAT0U 536 +#define DBAT0L 537 +#define DBAT1U 538 +#define DBAT1L 539 +#define DBAT2U 540 +#define DBAT2L 541 +#define DBAT3U 542 +#define DBAT3L 543 + +#define SDR1 25 + +#define SPRG0 272 +#define SPRG1 273 +#define SPRG2 274 +#define SPRG3 275 + +#define DAR 19 +#define DSISR 18 + +#define SRR0 26 +#define SRR1 27 + +#define EAR 282 + +#define DABR 1013 + +#define TBL 284 +#define TBU 285 + +#define L2CR 1017 + +#define DEC 22 + +#define IABR 1010 + +#define PMC1 953 +#define PMC2 954 +#define PMC3 957 +#define PMC4 958 + +#define SIA 955 + +#define MMCR0 952 +#define MMCR1 956 + +#define THRM1 1020 +#define THRM2 1021 +#define THRM3 1022 + +#define ICTC 1019 + +#define GQR0 912 +#define GQR1 913 +#define GQR2 914 +#define GQR3 915 +#define GQR4 916 +#define GQR5 917 +#define GQR6 918 +#define GQR7 919 + +#define HID2 920 + +#define WPAR 921 + +#define DMA_U 922 +#define DMA_L 923 + +#define MSR_POW 0x00040000 // Power Management +#define MSR_ILE 0x00010000 // Interrupt Little Endian +#define MSR_EE 0x00008000 // external interrupt +#define MSR_PR 0x00004000 // privilege level(should be 0) +#define MSR_FP 0x00002000 // floating point available +#define MSR_ME 0x00001000 // machine check enable +#define MSR_FE0 0x00000800 // floating point exception enable +#define MSR_SE 0x00000400 // single step trace enable +#define MSR_BE 0x00000200 // branch trace enable +#define MSR_FE1 0x00000100 // floating point exception enable +#define MSR_IP 0x00000040 // Exception prefix +#define MSR_IR 0x00000020 // instruction relocate +#define MSR_DR 0x00000010 // data relocate +#define MSR_PM 0x00000004 // Performance monitor marked mode +#define MSR_RI 0x00000002 // Recoverable interrupt +#define MSR_LE 0x00000001 // Little Endian + +#define MSR_POW_BIT 13 // Power Management +#define MSR_ILE_BIT 15 // Interrupt Little Endian +#define MSR_EE_BIT 16 // external interrupt +#define MSR_PR_BIT 17 // privilege level (should be 0) +#define MSR_FP_BIT 18 // floating point available +#define MSR_ME_BIT 19 // machine check enable +#define MSR_FE0_BIT 20 // floating point exception enable +#define MSR_SE_BIT 21 // single step trace enable +#define MSR_BE_BIT 22 // branch trace enable +#define MSR_FE1_BIT 23 // floating point exception enable +#define MSR_IP_BIT 25 // Exception prefix +#define MSR_IR_BIT 26 // instruction relocate +#define MSR_DR_BIT 27 // data relocate +#define MSR_PM_BIT 29 // Performance monitor marked mode +#define MSR_RI_BIT 30 // Recoverable interrupt +#define MSR_LE_BIT 31 // Little Endian + +/*---------------------------------------------------------------------------* + HID0 bits + *---------------------------------------------------------------------------*/ +#define HID0_EMCP 0x80000000u // Enable MCP +#define HID0_DBP 0x40000000u // Enable 60x bus address and data parity chk +#define HID0_EBA 0x20000000u // Enable 60x address parity checking +#define HID0_EBD 0x10000000u // Enable 60x data parity checking +#define HID0_BCLK 0x08000000u // CLK_OUT output enable and clk selection +#define HID0_ECLK 0x02000000u // CLK_OUT output enable and clk selection +#define HID0_PAR 0x01000000u // Disable !ARTRY precharge +#define HID0_DOZE 0x00800000u // Doze mode enable +#define HID0_NAP 0x00400000u // Nap mode enable +#define HID0_SLEEP 0x00200000u // Sleep mode enable +#define HID0_DPM 0x00100000u // Dynamic power management enable +#define HID0_NHR 0x00010000u // Not hard reset (0 hard reset if s/w set it) +#define HID0_ICE 0x00008000u // Instruction cache enable +#define HID0_DCE 0x00004000u // Data cache enable +#define HID0_ILOCK 0x00002000u // ICache lock +#define HID0_DLOCK 0x00001000u // DCache lock +#define HID0_ICFI 0x00000800u // ICache flash invalidate +#define HID0_DCFI 0x00000400u // DCache flash invalidate +#define HID0_SPD 0x00000200u // Speculative cache access enable (0 enable) +#define HID0_IFEM 0x00000100u // Enable M bit on bus for Ifetch +#define HID0_SGE 0x00000080u // Store gathering enable +#define HID0_DCFA 0x00000040u // DCache flush assist - set before a flush +#define HID0_BTIC 0x00000020u // Branch target icache enable +#define HID0_ABE 0x00000008u // Address bcast enable +#define HID0_BHT 0x00000004u // Branch history table enable +#define HID0_NOOPTI 0x00000001u // No-op Dcache touch instructions + +#define HID0_ICE_BIT 16 // Instruction cache enable +#define HID0_DCE_BIT 17 // Data cache enable +#define HID0_ILOCK_BIT 18 // ICache lock +#define HID0_DLOCK_BIT 19 // DCache lock + +#define HID2_LSQE 0x80000000 // L/S quantize enable +#define HID2_WPE 0x40000000 // Write pipe enable +#define HID2_PSE 0x20000000 // Paired single enable +#define HID2_LCE 0x10000000 // Locked cache enable + +#define HID2_DCHERR 0x00800000 // ERROR: dcbz_l cache hit +#define HID2_DNCERR 0x00400000 // ERROR: DMA access to normal cache +#define HID2_DCMERR 0x00200000 // ERROR: DMA cache miss error +#define HID2_DQOERR 0x00100000 // ERROR: DMA queue overflow +#define HID2_DCHEE 0x00080000 // dcbz_l cache hit error enable +#define HID2_DNCEE 0x00040000 // DMA access to normal cache error enable +#define HID2_DCMEE 0x00020000 // DMA cache miss error error enable +#define HID2_DQOEE 0x00010000 // DMA queue overflow error enable + +#define HID2_DMAQL_MASK 0x0F000000 // DMA queue length mask +#define HID2_DMAQL_SHIFT 24 // DMA queue shift + +#define HID2_LSQE_BIT 0 +#define HID2_WPE_BIT 1 +#define HID2_PSE_BIT 2 +#define HID2_LCE_BIT 3 + +#define HID2_DCHERR_BIT 8 +#define HID2_DNCERR_BIT 9 +#define HID2_DCMERR_BIT 10 +#define HID2_DQOERR_BIT 11 +#define HID2_DCHEE_BIT 12 +#define HID2_DNCEE_BIT 13 +#define HID2_DCMEE_BIT 14 +#define HID2_DQOEE_BIT 15 + +#define GQR_LOAD_SCALE_MASK 0x3F000000 // load scale field +#define GQR_LOAD_TYPE_MASK 0x00070000 // load type field +#define GQR_STORE_SCALE_MASK 0x00003F00 // store scale field +#define GQR_STORE_TYPE_MASK 0x00000007 // store type field + +typedef struct +{ + u32 _pad0 :2; + u32 loadScale :6; + u32 _pad1 :5; + u32 loadType :3; + u32 _pad2 :2; + u32 storeScale :6; + u32 _pad3 :5; + u32 storeType :3; +} PPC_GQR_t; + +typedef union +{ + u32 val; + PPC_GQR_t f; +} PPC_GQR_u; + + +#define DMA_U_ADDR_MASK 0xFFFFFFE0 // Start addr in memory +#define DMA_U_LEN_U_MASK 0x0000001F // lines to transfer (U) + +#define DMA_L_LC_ADDR_MASK 0xFFFFFFE0 // Start addr in LC +#define DMA_L_LOAD 0x00000010 // 0 - store, 1 - load +#define DMA_L_STORE 0x00000000 // 0 - store, 1 - load +#define DMA_L_LEN_MASK 0x0000000C // lines to transfer (L) +#define DMA_L_TRIGGER 0x00000002 // 0 - cmd inactive, 1 - cmd rdy +#define DMA_L_FLUSH 0x00000001 // 1 - Flush DMA queue + +typedef struct +{ + u32 memAddr :27; + u32 dmaLenU :5; +} PPC_DMA_U_t; + +typedef union +{ + u32 val; + PPC_DMA_U_t f; +} PPC_DMA_U_u; + + +typedef struct +{ + u32 lcAddr :27; + u32 dmaLd :1; + u32 dmaLenL :2; + u32 dmaTrigger :1; + u32 dmaFlush :1; +} PPC_DMA_L_t; + + +typedef union +{ + u32 val; + PPC_DMA_L_t f; +} PPC_DMA_L_u; + + +#define WPAR_ADDR 0xFFFFFFE0 // 32byte gather address +#define WPAR_BNE 0x00000001 // Buffer not empty (R) + +#define SRR1_DMA_BIT 0x00200000 +#define SRR1_L2DP_BIT 0x00100000 + +#define L2CR_L2E 0x80000000 // L2 Enable +#define L2CR_L2PE 0x40000000 // L2 data parity generation and checking enable + +#define L2CR_L2SIZ_256K 0x10000000 // L2 size 256K +#define L2CR_L2SIZ_512K 0x20000000 // L2 size 512 +#define L2CR_L2SIZ_1M 0x30000000 // L2 size 1M + +#define L2CR_L2CLK_1_0 0x02000000 // L2 clock ratio 1 +#define L2CR_L2CLK_1_5 0x04000000 // L2 clock ratio 1.5 +#define L2CR_L2CLK_2_0 0x08000000 // L2 clock ratio 2 +#define L2CR_L2CLK_2_5 0x0A000000 // L2 clock ratio 2.5 +#define L2CR_L2CLK_3_0 0x0C000000 // L2 clock ratio 3 + +#define L2CR_RAM_FLOW_THRU_BURST 0x00000000 // L2 RAM type flow-through sync. burst SRAM +#define L2CR_RAM_PIPELINE_BURST 0x01000000 // L2 RAM type pipelined sync. burst SRAM +#define L2CR_RAM_PIPELINE_LATE 0x01800000 // L2 RAM type pipelined sync. late-write SRAM + +#define L2CR_L2DO 0x00400000 // Data only +#define L2CR_L2I 0x00200000 // Global invalidate +#define L2CR_L2CTL 0x00100000 // ZZ enable +#define L2CR_L2WT 0x00080000 // L2 write through +#define L2CR_L2TS 0x00040000 // L2 test support + +#define L2CR_L2OH_0_5 0x00000000 // L2 output hold 0.5 ns +#define L2CR_L2OH_1_0 0x00010000 // L2 output hold 1.0 ns + +#define L2CR_L2SL 0x00008000 // L2 DLL slow +#define L2CR_L2DF 0x00004000 // L2 differential clock +#define L2CR_L2BYP 0x00002000 // L2 DLL bypass +#define L2CR_L2CS 0x00000200 // L2 clock stop +#define L2CR_L2DRO 0x00000100 // L2 DLL rollover checkstop enable +#define L2CR_L2CTR_MASK 0x000000FE // L2 counter value mask +#define L2CR_L2IP 0x00000001 // L2 global invalidate in progress + +#define MMCR0_DIS 0x80000000 // Disables counting unconditionally +#define MMCR0_DP 0x40000000 // Disables counting while in supervisor mode +#define MMCR0_DU 0x20000000 // Disables counting while in user mode +#define MMCR0_DMS 0x10000000 // Disables counting while MSR[PM] is set +#define MMCR0_DMR 0x08000000 // Disables counting while MSR[PM] is zero +#define MMCR0_ENINT 0x04000000 // Enables performance monitor interrupt signaling +#define MMCR0_DISCOUNT 0x02000000 // Disables counting of PMCn when a performance monitor interrupt is signaled or... +#define MMCR0_RTCSELECT_MASK 0x01800000 // 64-bit time base, bit selection enable +#define MMCR0_RTCSELECT_63 0x00000000 // Pick bit 63 to count +#define MMCR0_RTCSELECT_55 0x00800000 // Pick bit 55 to count +#define MMCR0_RTCSELECT_51 0x01000000 // Pick bit 51 to count +#define MMCR0_RTCSELECT_47 0x01800000 // Pick bit 47 to count +#define MMCR0_INTONBITTRANS 0x00400000 // Causes interrupt signaling on bit transition from off to on +#define MMCR0_THRESHOLD_MASK 0x003F0000 // Threshold value +#define MMCR0_THRESHOLD(n) ((n) << 16) // Threshold value (0 - 63) +#define MMCR0_PMC1INTCONTROL 0x00008000 // Enables interrupt signaling due to PMC1 counter overflow +#define MMCR0_PMC2INTCONTROL 0x00004000 // Enables interrupt signaling due to PMC2-PMC4 counter overflow +#define MMCR0_PMCTRIGGER 0x00002000 // Can be used to trigger counting of PMC2-PMC4 after PMC1 has overflowed or... +#define MMCR0_PMC1SELECT_MASK 0x00001FC0 // PMC1 input selector +#define MMCR0_PMC2SELECT_MASK 0x0000003F // PMC2 input selector + +#define MMCR1_PMC3SELECT_MASK 0xF8000000 // PMC3 input selector +#define MMCR1_PMC4SELECT_MASK 0x07C00000 // PMC4 input selector + +#define PMC1_OV 0x80000000 // Overflow +#define PMC1_COUNTER 0x7FFFFFFF // Counter value +#define PMC2_OV 0x80000000 // Overflow +#define PMC2_COUNTER 0x7FFFFFFF // Counter value +#define PMC3_OV 0x80000000 // Overflow +#define PMC3_COUNTER 0x7FFFFFFF // Counter value +#define PMC4_OV 0x80000000 // Overflow +#define PMC4_COUNTER 0x7FFFFFFF // Counter value + +/*---------------------------------------------------------------------------* + PMC1 Events + *---------------------------------------------------------------------------*/ +#define MMCR0_PMC1_HOLD 0x00000000 // Register holds current value +#define MMCR0_PMC1_CYCLE 0x00000040 // Processor cycles +#define MMCR0_PMC1_INSTRUCTION 0x00000080 // # of instructions completed. +#define MMCR0_PMC1_TRANSITION 0x000000C0 // # of transitions for 0 to 1 +#define MMCR0_PMC1_DISPATCHED 0x00000100 // # of instructions dispatched +#define MMCR0_PMC1_EIEIO 0x00000140 // # of eieio instructions completed +#define MMCR0_PMC1_ITLB_CYCLE 0x00000180 // # of cycles spent performing table search op. for the ITLB +#define MMCR0_PMC1_L2_HIT 0x000001C0 // # of access that hit the L2. +#define MMCR0_PMC1_EA 0x00000200 // # of valid instruction EAs delivered to the memory subsystem +#define MMCR0_PMC1_IABR 0x00000240 // # of time the address of an instruction matches the IABR +#define MMCR0_PMC1_L1_MISS 0x00000280 // # of loads that miss the L1 +#define MMCR0_PMC1_Bx_UNRESOLVED 0x000002C0 // # of branches that are unresolved when processed +#define MMCR0_PMC1_Bx_STALL_CYCLE 0x00000300 // # of cycles that dispatcher stalls due to a second + // unresolved branch in the instruction stream +#define MMCR0_PMC1_IC_FETCH_MISS 0x00000340 // # of times an instruction fetch missed the L1 Icache +#define MMCR0_PMC2_HOLD 0x00000000 // Register holds current value +#define MMCR0_PMC2_CYCLE 0x00000001 // Processor cycles +#define MMCR0_PMC2_INSTRUCTION 0x00000002 // # of instructions completed +#define MMCR0_PMC2_TRANSITION 0x00000003 // # of time-base (lower) bit transitions +#define MMCR0_PMC2_DISPATCHED 0x00000004 // # of instructions dispatched +#define MMCR0_PMC2_IC_MISS 0x00000005 // # of L1 instruction cache misses +#define MMCR0_PMC2_ITLB_MISS 0x00000006 // # of ITLB misses +#define MMCR0_PMC2_L2_I_MISS 0x00000007 // # of L2 instruction misses +#define MMCR0_PMC2_Bx_FALL_TROUGH 0x00000008 // # of fall-through branches +#define MMCR0_PMC2_PR_SWITCH 0x00000009 // # of MSR[PR] bit toggles +#define MMCR0_PMC2_RESERVED_LOAD 0x0000000A // # of reserved loads completed +#define MMCR0_PMC2_LOAD_STORE 0x0000000B // # of completed loads and stores +#define MMCR0_PMC2_SNOOP 0x0000000C // # of snoops +#define MMCR0_PMC2_L1_CASTOUT 0x0000000D // # of L1 castouts to L2 +#define MMCR0_PMC2_SYSTEM 0x0000000E // # of completed system unit instructions +#define MMCR0_PMC2_IC_FETCH_MISS 0x0000000F // # of instruction fetch misses in the L1 +#define MMCR0_PMC2_Bx_OUT_OF_ORDER 0x00000010 // # of branches allowing out-of-order execution + +/*---------------------------------------------------------------------------* + PMC3 Events + *---------------------------------------------------------------------------*/ +#define MMCR1_PMC3_HOLD 0x00000000 // Register holds current value +#define MMCR1_PMC3_CYCLE 0x08000000 // Processor cycles +#define MMCR1_PMC3_INSTRUCTION 0x10000000 // # of instructions completed +#define MMCR1_PMC3_TRANSITION 0x18000000 // # of time-base (lower) bit transitions +#define MMCR1_PMC3_DISPATCHED 0x20000000 // # of instructions dispatched +#define MMCR1_PMC3_DC_MISS 0x28000000 // # of L1 data cache misses +#define MMCR1_PMC3_DTLB_MISS 0x30000000 // # of DTLB misses +#define MMCR1_PMC3_L2_D_MISS 0x38000000 // # of L2 data misses +#define MMCR1_PMC3_Bx_TAKEN 0x40000000 // # predicted branches that were taken +#define MMCR1_PMC3_PM_SWITCH 0x48000000 // # of transitions between marked and unmarked processes +#define MMCR1_PMC3_COND_STORE 0x50000000 // # of store conditional instructions completed +#define MMCR1_PMC3_FPU 0x58000000 // # of instructions completed from the FPU +#define MMCR1_PMC3_L2_SNOOP_CASTOUT 0x60000000 // # of L2 castout caused by snoops to modified lines +#define MMCR1_PMC3_L2_HIT 0x68000000 // # of cache operations that hit in the L2 cache +#define MMCR1_PMC3_L1_MISS_CYCLE 0x78000000 // # of cycles generated by L1 load misses +#define MMCR1_PMC3_Bx_SECOND 0x80000000 // # of branches in the second speculative branch + // resolved correctly +#define MMCR1_PMC3_BPU_LR_CR 0x88000000 // # of cycles the BPU stalls due to LR or CR unresolved + // dependencies + +#define MMCR1_PMC4_HOLD 0x00000000 // Register holds current value +#define MMCR1_PMC4_CYCLE 0x00400000 // Processor cycles +#define MMCR1_PMC4_INSTRUCTION 0x00800000 // # of instructions completed +#define MMCR1_PMC4_TRANSITION 0x00C00000 // # of time-base (lower) bit transitions +#define MMCR1_PMC4_DISPATCHED 0x01000000 // # of instructions dispatched +#define MMCR1_PMC4_L2_CASTOUT 0x01400000 // # of L2 castouts +#define MMCR1_PMC4_DTLB_CYCLE 0x01800000 // # of cycles spent performing table searches for DTLB accesses +#define MMCR1_PMC4_Bx_MISSED 0x02000000 // # of mispredicted branches +#define MMCR1_PMC4_COND_STORE_INT 0x02800000 // # of store conditional instructions completed + // with reservation intact +#define MMCR1_PMC4_SYNC 0x02C00000 // # of completed sync instructions +#define MMCR1_PMC4_SNOOP_RETRY 0x03000000 // # of snoop request retries +#define MMCR1_PMC4_INTEGER 0x03400000 // # of completed integer operations +#define MMCR1_PMC4_BPU_THIRD 0x03800000 // # of cycles the BPU cannot process new branches + // due to having two unresolved branches +#define MMCR1_PMC4_DC_MISS 0x07C00000 // # of L1 data cache misses + +/*---------------------------------------------------------------------------* + FPSCR bits + *---------------------------------------------------------------------------*/ +#ifndef FPSCR_FX +#define FPSCR_FX 0x80000000 // Exception summary +#define FPSCR_FEX 0x40000000 // Enabled exception summary +#define FPSCR_VX 0x20000000 // Invalid operation +#define FPSCR_OX 0x10000000 // Overflow exception +#define FPSCR_UX 0x08000000 // Underflow exception +#define FPSCR_ZX 0x04000000 // Zero divide exception +#define FPSCR_XX 0x02000000 // Inexact exception +#define FPSCR_VXSNAN 0x01000000 // SNaN +#define FPSCR_VXISI 0x00800000 // Infinity - Infinity +#define FPSCR_VXIDI 0x00400000 // Infinity / Infinity +#define FPSCR_VXZDZ 0x00200000 // 0 / 0 +#define FPSCR_VXIMZ 0x00100000 // Infinity * 0 +#define FPSCR_VXVC 0x00080000 // Invalid compare +#define FPSCR_FR 0x00040000 // Fraction rounded +#define FPSCR_FI 0x00020000 // Fraction inexact +#define FPSCR_VXSOFT 0x00000400 // Software request +#define FPSCR_VXSQRT 0x00000200 // Invalid square root +#define FPSCR_VXCVI 0x00000100 // Invalid integer convert +#define FPSCR_VE 0x00000080 // Invalid operation exception enable +#define FPSCR_OE 0x00000040 // Overflow exception enable +#define FPSCR_UE 0x00000020 // Underflow exception enable +#define FPSCR_ZE 0x00000010 // Zero divide exception enable +#define FPSCR_XE 0x00000008 // Inexact exception enable +#define FPSCR_NI 0x00000004 // Non-IEEE mode +#endif + +#ifndef FPSCR_FX_BIT +#define FPSCR_FX_BIT 0 // Exception summary +#define FPSCR_FEX_BIT 1 // Enabled exception summary +#define FPSCR_VX_BIT 2 // Invalid operation +#define FPSCR_OX_BIT 3 // Overflow exception +#define FPSCR_UX_BIT 4 // Underflow exception +#define FPSCR_ZX_BIT 5 // Zero divide exception +#define FPSCR_XX_BIT 6 // Inexact exception +#define FPSCR_VXSNAN_BIT 7 // SNaN +#define FPSCR_VXISI_BIT 8 // Infinity - Infinity +#define FPSCR_VXIDI_BIT 9 // Infinity / Infinity +#define FPSCR_VXZDZ_BIT 10 // 0 / 0 +#define FPSCR_VXIMZ_BIT 11 // Infinity * 0 +#define FPSCR_VXVC_BIT 12 // Invalid compare +#define FPSCR_FR_BIT 13 // Fraction rounded +#define FPSCR_FI_BIT 14 // Fraction inexact +#define FPSCR_VXSOFT_BIT 21 // Software request +#define FPSCR_VXSQRT_BIT 22 // Invalid square root +#define FPSCR_VXCVI_BIT 23 // Invalid integer convert +#define FPSCR_VE_BIT 24 // Invalid operation exception enable +#define FPSCR_OE_BIT 25 // Overflow exception enable +#define FPSCR_UE_BIT 26 // Underflow exception enable +#define FPSCR_ZE_BIT 27 // Zero divide exception enable +#define FPSCR_XE_BIT 28 // Inexact exception enable +#define FPSCR_NI_BIT 29 // Non-IEEE mode +#endif + +union FpscrUnion { + f64 f; + struct { + u32 fpscr_pad; + u32 fpscr; + } u; +}; + +// PPCArch +u32 PPCMfmsr(); +void PPCMtmsr(u32 newMSR); +u32 PPCOrMsr(u32 value); +u32 PPCMfhid0(); +void PPCMthid0(u32 newHID0); +u32 PPCMfl2cr(); +void PPCMtl2cr(u32 newL2cr); +void PPCMtdec(u32 newDec); +void PPCSync(); +void PPCHalt(); +u32 PPCMffpscr(); +void PPCMtfpscr(u32 newFPSCR); +u32 PPCMfhid2(); +void PPCMthid2(u32 newhid2); +u32 PPCMfwpar(); +void PPCMtwpar(u32 newwpar); +void PPCEnableSpeculation(); +void PPCDisableSpeculation(); +void PPCSetFpIEEEMode(); +void PPCSetFpNonIEEEMode(); +u32 PPCMfpmc4(); +u32 PPCMfpmc3(); +u32 PPCMfpmc1(); +void PPCMtpmc1(u32 newPmc1); +void PPCMtpmc2(u32 newPmc1); +void PPCMtpmc3(u32 newPmc1); +void PPCMtpmc4(u32 newPmc1); +void PPCMtmmcr0(u32 newMmcr0); +void PPCMtmmcr1(u32 newMmcr0); +void PPCMtdmaU(u32 newdmau); +void PPCMtdmaL(u32 newdmal); +u32 PPCMfdec(void); +u32 PPCMfpmc2(void); +u32 PPCAndMsr(u32 value); +u32 PPCAndCMsr(u32 value); +u32 PPCMfhid1(); +void PPCEieio(); +u32 PPCMfmmcr0(); +u32 PPCMfmmcr1(); +u32 PPCMfpmc2(); +u32 PPCMfsia(); +void PPCMtsia(u32 newSia); +u32 PPCMfdmaL(); +u32 PPCMfpvr(); +u32 PPCMfdmaU(); + +// PPCPm +void PMBegin(void); +void PMEnd(void); +void PMCycles(void); +void PML1FetchMisses(void); +void PML1MissCycles(void); +void PMInstructions(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_PPCARCH diff --git a/include/dolphin/card.h b/include/dolphin/card.h new file mode 100644 index 000000000..f335a2a8d --- /dev/null +++ b/include/dolphin/card.h @@ -0,0 +1,334 @@ +#ifndef _DOLPHIN_CARD_H_ +#define _DOLPHIN_CARD_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define CARD_FILENAME_MAX 32 +#define CARD_MAX_FILE 127 +#define CARD_ICON_MAX 8 + +typedef void (*CARDCallback)(s32 chan, s32 result); + +typedef struct CARDFileInfo +{ + s32 chan; + s32 fileNo; + s32 offset; + s32 length; + u16 iBlock; +} CARDFileInfo; + +typedef struct CARDDir +{ + u8 gameName[4]; + u8 company[2]; + u8 _padding0; + u8 bannerFormat; + u8 fileName[CARD_FILENAME_MAX]; + u32 time; // seconds since 01/01/2000 midnight + u32 iconAddr; // 0xffffffff if not used + u16 iconFormat; + u16 iconSpeed; + u8 permission; + u8 copyTimes; + u16 startBlock; + u16 length; + u8 _padding1[2]; + u32 commentAddr; // 0xffffffff if not used +} CARDDir; + +typedef struct CARDControl +{ + /* 0x000 */ BOOL attached; + /* 0x004 */ s32 result; + /* 0x008 */ u16 size; + /* 0x00A */ u16 pageSize; + /* 0x00C */ s32 sectorSize; + /* 0x010 */ u16 cBlock; + /* 0x012 */ u16 vendorID; + /* 0x014 */ s32 latency; + /* 0x018 */ u8 id[12]; + /* 0x024 */ int mountStep; + /* 0x028 */ int formatStep; + /* 0x028 */ u32 scramble; + /* 0x02C */ DSPTaskInfo task; + /* 0x080 */ void* workArea; + /* 0x084 */ CARDDir* currentDir; + /* 0x088 */ u16* currentFat; + /* 0x08C */ OSThreadQueue threadQueue; + /* 0x094 */ u8 cmd[9]; + /* 0x0A0 */ s32 cmdlen; + /* 0x0A4 */ volatile u32 mode; + /* 0x0A8 */ int retry; + /* 0x0AC */ int repeat; + /* 0x0B0 */ u32 addr; + /* 0x0B4 */ void* buffer; + /* 0x0B8 */ s32 xferred; + /* 0x0BC */ u16 freeNo; + /* 0x0BE */ u16 startBlock; + /* 0x0C0 */ CARDFileInfo* fileInfo; + /* 0x0C4 */ CARDCallback extCallback; + /* 0x0C8 */ CARDCallback txCallback; + /* 0x0CC */ CARDCallback exiCallback; + /* 0x0D0 */ CARDCallback apiCallback; + /* 0x0D4 */ CARDCallback xferCallback; + /* 0x0D8 */ CARDCallback eraseCallback; + /* 0x0DC */ CARDCallback unlockCallback; + /* 0x0E0 */ OSAlarm alarm; + /* 0x108 */ u32 cid; + /* 0x10C */ const DVDDiskID* diskID; +} CARDControl; + +typedef struct CARDDecParam +{ + /* 0x00 */ u8* inputAddr; + /* 0x04 */ u32 inputLength; + /* 0x08 */ u32 aramAddr; + /* 0x0C */ u8* outputAddr; +} CARDDecParam; + +typedef struct CARDID +{ + /* 0x000 */ u8 serial[32]; + /* 0x020 */ u16 deviceID; + /* 0x022 */ u16 size; + /* 0x024 */ u16 encode; + /* 0x026 */ u8 padding[470]; + /* 0x1FC */ u16 checkSum; + /* 0x1FE */ u16 checkSumInv; +} CARDID; + +typedef struct CARDDirCheck +{ + /* 0x00 */ u8 padding0[56]; + /* 0x38 */ u16 padding1; + /* 0x3A */ s16 checkCode; + /* 0x3C */ u16 checkSum; + /* 0x3E */ u16 checkSumInv; +} CARDDirCheck; + +typedef struct CARDStat +{ + /* 0x00 */ char fileName[CARD_FILENAME_MAX]; + /* 0x20 */ u32 length; + /* 0x24 */ u32 time; + /* 0x28 */ u8 gameName[4]; + /* 0x2C */ u8 company[2]; + /* 0x2E */ u8 bannerFormat; + /* 0x30 */ u32 iconAddr; + /* 0x34 */ u16 iconFormat; + /* 0x36 */ u16 iconSpeed; + /* 0x38 */ u32 commentAddr; + /* 0x3C */ u32 offsetBanner; + /* 0x40 */ u32 offsetBannerTlut; + /* 0x44 */ u32 offsetIcon[CARD_ICON_MAX]; + /* 0x64 */ u32 offsetIconTlut; + /* 0x68 */ u32 offsetData; +} CARDStat; + +#define CARD_ATTR_PUBLIC 0x04u +#define CARD_ATTR_NO_COPY 0x08u +#define CARD_ATTR_NO_MOVE 0x10u +#define CARD_ATTR_GLOBAL 0x20u +#define CARD_ATTR_COMPANY 0x40u + +#define CARD_FAT_AVAIL 0x0000u +#define CARD_FAT_CHECKSUM 0x0000u +#define CARD_FAT_CHECKSUMINV 0x0001u +#define CARD_FAT_CHECKCODE 0x0002u +#define CARD_FAT_FREEBLOCKS 0x0003u +#define CARD_FAT_LASTSLOT 0x0004u + +#define CARD_WORKAREA_SIZE (5 * 8 * 1024) + +#define CARD_SEG_SIZE 0x200u +#define CARD_PAGE_SIZE 0x80u +#define CARD_MAX_SIZE 0x01000000U + +#define CARD_NUM_SYSTEM_BLOCK 5 +#define CARD_SYSTEM_BLOCK_SIZE (8 * 1024u) + +#define CARD_MAX_MOUNT_STEP (CARD_NUM_SYSTEM_BLOCK + 2) + +#define CARD_STAT_SPEED_END 0 +#define CARD_STAT_SPEED_FAST 1 +#define CARD_STAT_SPEED_MIDDLE 2 +#define CARD_STAT_SPEED_SLOW 3 +#define CARD_STAT_SPEED_MASK 3 + +#define CARD_RESULT_UNLOCKED 1 +#define CARD_RESULT_READY 0 +#define CARD_RESULT_BUSY -1 +#define CARD_RESULT_WRONGDEVICE -2 +#define CARD_RESULT_NOCARD -3 +#define CARD_RESULT_NOFILE -4 +#define CARD_RESULT_IOERROR -5 +#define CARD_RESULT_BROKEN -6 +#define CARD_RESULT_EXIST -7 +#define CARD_RESULT_NOENT -8 +#define CARD_RESULT_INSSPACE -9 +#define CARD_RESULT_NOPERM -10 +#define CARD_RESULT_LIMIT -11 +#define CARD_RESULT_NAMETOOLONG -12 +#define CARD_RESULT_ENCODING -13 +#define CARD_RESULT_CANCELED -14 +#define CARD_RESULT_FATAL_ERROR -128 + +#define CARDIsValidBlockNo(card, blockNo) \ + ((blockNo) >= CARD_NUM_SYSTEM_BLOCK && (blockNo) < (card)->cBlock) + +#define CARD_READ_SIZE 512 +#define CARD_COMMENT_SIZE 64 + +#define CARD_ICON_WIDTH 32 +#define CARD_ICON_HEIGHT 32 + +#define CARD_BANNER_WIDTH 96 +#define CARD_BANNER_HEIGHT 32 + +#define CARD_STAT_ICON_NONE 0 +#define CARD_STAT_ICON_C8 1 +#define CARD_STAT_ICON_RGB5A3 2 +#define CARD_STAT_ICON_MASK 3 + +#define CARD_STAT_BANNER_NONE 0 +#define CARD_STAT_BANNER_C8 1 +#define CARD_STAT_BANNER_RGB5A3 2 +#define CARD_STAT_BANNER_MASK 3 + +#define CARD_ENCODE_ANSI 0 +#define CARD_ENCODE_SJIS 1 + +#define CARD_STAT_ANIM_LOOP 0x00 +#define CARD_STAT_ANIM_BOUNCE 0x04 +#define CARD_STAT_ANIM_MASK 0x04 + +#define CARDGetDirCheck(dir) ((CARDDirCheck*)&(dir)[CARD_MAX_FILE]) +#define CARDGetBannerFormat(stat) (((stat)->bannerFormat) & CARD_STAT_BANNER_MASK) +#define CARDGetIconAnim(stat) (((stat)->bannerFormat) & CARD_STAT_ANIM_MASK) +#define CARDGetIconFormat(stat, n) (((stat)->iconFormat >> (2 * (n))) & CARD_STAT_ICON_MASK) +#define CARDGetIconSpeed(stat, n) (((stat)->iconSpeed >> (2 * (n))) & CARD_STAT_SPEED_MASK) +#define CARDSetBannerFormat(stat, f) \ + ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_BANNER_MASK) | (f))) +#define CARDSetIconAnim(stat, f) \ + ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_ANIM_MASK) | (f))) +#define CARDSetIconFormat(stat, n, f) \ + ((stat)->iconFormat = \ + (u16)(((stat)->iconFormat & ~(CARD_STAT_ICON_MASK << (2 * (n)))) | ((f) << (2 * (n))))) +#define CARDSetIconSpeed(stat, n, f) \ + ((stat)->iconSpeed = \ + (u16)(((stat)->iconSpeed & ~(CARD_STAT_SPEED_MASK << (2 * (n)))) | ((f) << (2 * (n))))) +#define CARDSetIconAddress(stat, addr) ((stat)->iconAddr = (u32)(addr)) +#define CARDSetCommentAddress(stat, addr) ((stat)->commentAddr = (u32)(addr)) +#define CARDGetFileNo(fileInfo) ((fileInfo)->fileNo) + +extern u32 __CARDFreq; + +#if DEBUG +#define CARDFreq __CARDFreq +#else +#define CARDFreq EXI_FREQ_16M +#endif + +void CARDInit(void); +s32 CARDGetResultCode(s32 chan); +s32 CARDCheckAsync(s32 chan, CARDCallback callback); +s32 CARDFreeBlocks(s32 chan, s32* byteNotUsed, s32* filesNotUsed); +s32 CARDRenameAsync(s32 chan, const char* old, const char* _new, CARDCallback callback); + +// CARDBios +void CARDInit(void); +s32 CARDGetResultCode(s32 chan); +s32 CARDFreeBlocks(s32 chan, s32* byteNotUsed, s32* filesNotUsed); +s32 CARDGetEncoding(s32 chan, u16* encode); +s32 CARDGetMemSize(s32 chan, u16* size); +s32 CARDGetSectorSize(s32 chan, u32* size); +const DVDDiskID* CARDGetDiskID(s32 chan); +s32 CARDSetDiskID(s32 chan, const DVDDiskID* diskID); +BOOL CARDSetFastMode(BOOL enable); +BOOL CARDGetFastMode(void); +s32 CARDGetCurrentMode(s32 chan, u32* mode); + +// CARDCheck +s32 CARDCheckExAsync(s32 chan, s32* xferBytes, CARDCallback callback); +s32 CARDCheckAsync(s32 chan, CARDCallback callback); +s32 CARDCheckEx(s32 chan, s32* xferBytes); +s32 CARDCheck(s32 chan); + +// CARDCreate +s32 CARDCreateAsync(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo, + CARDCallback callback); +s32 CARDCreate(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo); + +// CARDDelete +s32 CARDFastDeleteAsync(s32 chan, s32 fileNo, CARDCallback callback); +s32 CARDFastDelete(s32 chan, s32 fileNo); +s32 CARDDeleteAsync(s32 chan, const char* fileName, CARDCallback callback); +s32 CARDDelete(s32 chan, const char* fileName); + +// CARDErase +s32 CARDEraseAsync(CARDFileInfo* fileInfo, s32 length, s32 offset, CARDCallback callback); +s32 CARDErase(CARDFileInfo* fileInfo, s32 length, s32 offset); + +// CARDFormat +s32 CARDFormat(s32 chan); + +// CARDMount +int CARDProbe(s32 chan); +s32 CARDProbeEx(s32 chan, s32* memSize, s32* sectorSize); +s32 CARDMountAsync(s32 chan, void* workArea, CARDCallback detachCallback, + CARDCallback attachCallback); +s32 CARDMount(s32 chan, void* workArea, CARDCallback detachCallback); +s32 CARDUnmount(s32 chan); + +// CARDNet +u16 CARDSetVendorID(u16 vendorID); +u16 CARDGetVendorID(); +s32 CARDGetSerialNo(s32 chan, u64* serialNo); +s32 CARDGetUniqueCode(s32 chan, u64* uniqueCode); +s32 CARDGetAttributes(s32 chan, s32 fileNo, u8* attr); +s32 CARDSetAttributesAsync(s32 chan, s32 fileNo, u8 attr, CARDCallback callback); +s32 CARDSetAttributes(s32 chan, s32 fileNo, u8 attr); + +// CARDOpen +s32 CARDFastOpen(s32 chan, s32 fileNo, CARDFileInfo* fileInfo); +s32 CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo); +s32 CARDClose(CARDFileInfo* fileInfo); + +// CARDProgram +s32 CARDProgramAsync(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset, + CARDCallback callback); +s32 CARDProgram(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset); + +// CARDRdwr +s32 CARDGetXferredBytes(s32 chan); + +// CARDRead +s32 CARDReadAsync(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset, CARDCallback callback); +s32 CARDRead(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset); +s32 CARDCancel(CARDFileInfo* fileInfo); + +// CARDRename +s32 CARDRename(s32 chan, const char* old, const char* _new); + +// CARDStat +s32 CARDGetStatus(s32 chan, s32 fileNo, CARDStat* stat); +s32 CARDSetStatusAsync(s32 chan, s32 fileNo, CARDStat* stat, CARDCallback callback); +s32 CARDSetStatus(s32 chan, s32 fileNo, CARDStat* stat); + +// CARDWrite +s32 CARDWriteAsync(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset, + CARDCallback callback); +s32 CARDWrite(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/db.h b/include/dolphin/db.h new file mode 100644 index 000000000..a126bbe39 --- /dev/null +++ b/include/dolphin/db.h @@ -0,0 +1,20 @@ +#ifndef _DOLPHIN_DB_H_ +#define _DOLPHIN_DB_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_DBINTERFACE_ADDR 0x00000040 + +BOOL DBIsDebuggerPresent(void); +void DBPrintf(char* str, ...); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DB_H_ diff --git a/include/dolphin/db/DBInterface.h b/include/dolphin/db/DBInterface.h new file mode 100644 index 000000000..7bfa35427 --- /dev/null +++ b/include/dolphin/db/DBInterface.h @@ -0,0 +1,31 @@ +#ifndef _DOLPHIN_DBINTERFACE_H_ +#define _DOLPHIN_DBINTERFACE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct DBInterface { + u32 bPresent; + u32 exceptionMask; + void (*ExceptionDestination)(void); + void* exceptionReturn; +} DBInterface; + +extern DBInterface* __DBInterface; + +void DBInit(void); +void DBInitComm(int* inputFlagPtr, int* mtrCallback); +void __DBExceptionDestination(void); +void __DBExceptionDestinationAux(void); +BOOL __DBIsExceptionMarked(__OSException exception); +void __DBMarkException(u8 exception, int value); +void __DBSetPresent(u32 value); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/demo.h b/include/dolphin/demo.h new file mode 100644 index 000000000..43a7efbf7 --- /dev/null +++ b/include/dolphin/demo.h @@ -0,0 +1,21 @@ +#ifndef _DOLPHIN_DEMO_H_ +#define _DOLPHIN_DEMO_H_ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern u32 DEMOFontBitmap[768]; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DEMO_H_ diff --git a/include/dolphin/demo/DEMOAVX.h b/include/dolphin/demo/DEMOAVX.h new file mode 100644 index 000000000..2f5e77960 --- /dev/null +++ b/include/dolphin/demo/DEMOAVX.h @@ -0,0 +1,20 @@ +#ifndef _DOLPHIN_DEMOAVX_H_ +#define _DOLPHIN_DEMOAVX_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void DEMOAVXAttach(void* buffer, u32 num_frames); +u32 DEMOAVXGetNumFilled(void); +u32 DEMOAVXGetFrameCounter(void); +u32 DEMOAVXRefreshBuffer(u32* start_index, u32* end_index); +void DEMOAVXInit(s16* left, s16* right, u32 size); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DEMOAVX_H_ diff --git a/include/dolphin/demo/DEMOInit.h b/include/dolphin/demo/DEMOInit.h new file mode 100644 index 000000000..a555cb215 --- /dev/null +++ b/include/dolphin/demo/DEMOInit.h @@ -0,0 +1,30 @@ +#ifndef _DOLPHIN_DEMOINIT_H_ +#define _DOLPHIN_DEMOINIT_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +extern void* DemoFrameBuffer1; +extern void* DemoFrameBuffer2; +extern void* DemoCurrentBuffer; + +void DEMOInit(GXRenderModeObj* mode); +void DEMOBeforeRender(void); +void DEMODoneRender(void); +void DEMOSwapBuffers(void); +void DEMOSetTevColorIn(GXTevStageID stage, GXTevColorArg a, GXTevColorArg b, GXTevColorArg c, GXTevColorArg d); +void DEMOSetTevOp(GXTevStageID id, GXTevMode mode); +GXRenderModeObj* DEMOGetRenderModeObj(void); +u32 DEMOGetCurrentBuffer(void); +void DEMOSetGPHangMetric(u8 enable); +void DEMOEnableGPHangWorkaround(u32 timeoutFrames); +void DEMOReInit(GXRenderModeObj* mode); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DEMOINIT_H_ diff --git a/include/dolphin/demo/DEMOPad.h b/include/dolphin/demo/DEMOPad.h new file mode 100644 index 000000000..ed690cbbf --- /dev/null +++ b/include/dolphin/demo/DEMOPad.h @@ -0,0 +1,33 @@ +#ifndef _DOLPHIN_DEMOPAD_H_ +#define _DOLPHIN_DEMOPAD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + /* 0x00 */ PADStatus pst; + /* 0x0C */ u16 buttonDown; + /* 0x0E */ u16 buttonUp; + /* 0x10 */ u16 dirs; + /* 0x12 */ u16 dirsNew; + /* 0x14 */ u16 dirsReleased; + /* 0x16 */ s16 stickDeltaX; + /* 0x18 */ s16 stickDeltaY; + /* 0x1A */ s16 substickDeltaX; + /* 0x1C */ s16 substickDeltaY; +} DEMODMPad; + +extern DEMODMPad DemoPad[4]; +extern u32 DemoNumValidPads; + +void DEMOPadRead(void); +void DEMOPadInit(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DEMOPAD_H_ diff --git a/include/dolphin/demo/DEMOPuts.h b/include/dolphin/demo/DEMOPuts.h new file mode 100644 index 000000000..07017b4c1 --- /dev/null +++ b/include/dolphin/demo/DEMOPuts.h @@ -0,0 +1,40 @@ +#ifndef _DOLPHIN_DEMOPUTS_H_ +#define _DOLPHIN_DEMOPUTS_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + DMTF_POINTSAMPLE, + DMTF_BILERP, +} DMTexFlt; + +typedef enum { + DM_FT_OPQ, + DM_FT_RVS, + DM_FT_XLU +} DMFontType; + +void DEMOSetFontType(s32 attr); +void DEMOLoadFont(GXTexMapID texMap, GXTexMtx texMtx, DMTexFlt texFlt); +void DEMOSetupScrnSpc(s32 width, s32 height, f32 depth); +void DEMOInitCaption(s32 font_type, s32 width, s32 height); +void DEMOPuts(s16 x, s16 y, s16 z, char* string); +void DEMOPrintf(s16 x, s16 y, s16 z, char* fmt, ...); +OSFontHeader* DEMOInitROMFont(void); +void DEMOSetROMFontSize(s16 size, s16 space); +int DEMORFPuts(s16 x, s16 y, s16 z, char* string); +int DEMORFPutsEx(s16 x, s16 y, s16 z, char* string, s16 maxWidth, int length); +int DEMORFPrintf(s16 x, s16 y, s16 z, char* fmt, ...); +char* DEMODumpROMFont(char* string); +int DEMOGetRFTextWidth(char* string); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/demo/DEMOStats.h b/include/dolphin/demo/DEMOStats.h new file mode 100644 index 000000000..346fb65a7 --- /dev/null +++ b/include/dolphin/demo/DEMOStats.h @@ -0,0 +1,48 @@ +#ifndef _DOLPHIN_DEMOSTATS_H_ +#define _DOLPHIN_DEMOSTATS_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum DEMO_STAT_TYPE { + DEMO_STAT_GP0 = 0, + DEMO_STAT_GP1 = 1, + DEMO_STAT_MEM = 2, + DEMO_STAT_PIX = 3, + DEMO_STAT_VC = 4, + DEMO_STAT_FR = 5, + DEMO_STAT_TBW = 6, + DEMO_STAT_TBP = 7, + DEMO_STAT_MYC = 8, + DEMO_STAT_MYR = 9, +} DEMO_STAT_TYPE; + +typedef struct DemoStatData { + char text[50]; + DEMO_STAT_TYPE stat_type; + u32 stat; + u32 count; +} DemoStatData; + +typedef enum { + DEMO_STAT_TL = 0, + DEMO_STAT_BL = 1, + DEMO_STAT_TLD = 2, + DEMO_STAT_BLD = 3, + DEMO_STAT_IO = 4, +} DEMO_STAT_DISP; + +extern u8 DemoStatEnable; + +void DEMOSetStats(DemoStatData* stat, u32 nstats, DEMO_STAT_DISP disp); +void DEMOUpdateStats(u8 inc); +void DEMOPrintStats(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DEMOSTATS_H_ diff --git a/include/dolphin/demo/DEMOWin.h b/include/dolphin/demo/DEMOWin.h new file mode 100644 index 000000000..cf1710fe3 --- /dev/null +++ b/include/dolphin/demo/DEMOWin.h @@ -0,0 +1,137 @@ +#ifndef _DOLPHIN_DEMOWIN_H_ +#define _DOLPHIN_DEMOWIN_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define DEMOWIN_ITEM_CAP 0 +#define DEMOWIN_ITEM_BKGND 1 +#define DEMOWIN_ITEM_BORDER 2 +#define DEMOWIN_ITEM_DEFAULT 3 + +// flags +#define DEMOWIN_FLAGS_INIT (1 << 0) +#define DEMOWIN_FLAGS_OPENED (1 << 1) + +typedef struct { + /* 0x00 */ PADStatus pads[4]; + /* 0x30 */ u32 button[4]; + /* 0x40 */ u32 old_button[4]; + /* 0x50 */ u32 changed_button[4]; + /* 0x60 */ u32 repeat_button[4]; + /* 0x70 */ u32 repeat_ctr[4]; +} DEMOWinPadInfo; + +typedef struct STRUCT_DEMOWIN DEMOWindow; +typedef struct STRUCT_DEMOWIN { + /* 0x00 */ s32 x1; + /* 0x04 */ s32 y1; + /* 0x08 */ s32 x2; + /* 0x0C */ s32 y2; + /* 0x10 */ u32 priority; + /* 0x14 */ u32 flags; + /* 0x18 */ u16 x_cal; + /* 0x1A */ u16 y_cal; + /* 0x1C */ u16 pixel_width; + /* 0x1E */ u16 pixel_height; + /* 0x20 */ u16 char_width; + /* 0x22 */ u16 char_height; + /* 0x24 */ u16 num_scroll_lines; + /* 0x26 */ u16 total_lines; + /* 0x28 */ u16 curr_output_line; + /* 0x2A */ u16 curr_output_col; + /* 0x2C */ u16 curr_view_line; + /* 0x2E */ s16 cursor_line; + /* 0x30 */ char* caption; + /* 0x34 */ u8* buffer; + /* 0x38 */ GXColor bkgnd; + /* 0x3C */ GXColor cap; + /* 0x40 */ GXColor border; + /* 0x44 */ void (*refresh)(DEMOWindow *); + /* 0x48 */ DEMOWindow* next; + /* 0x4C */ DEMOWindow* prev; + /* 0x50 */ void* parent; + /* 0x54 */ DEMOWinPadInfo pad; +} DEMOWindow; + +typedef struct STRUCT_MENU DEMOWinMenu; +typedef struct STRUCT_MENU_ITEM { + /* 0x00 */ char* name; + /* 0x04 */ u32 flags; + /* 0x08 */ void (*function)(DEMOWinMenu*, u32, u32*); + /* 0x0C */ DEMOWinMenu* link; +} DEMOWinMenuItem; + +typedef struct STRUCT_MENU { + /* 0x00 */ char* title; + /* 0x04 */ DEMOWindow* handle; + /* 0x08 */ DEMOWinMenuItem* items; + /* 0x0C */ s32 max_display_items; + /* 0x10 */ u32 flags; + /* 0x14 */ void (*cb_open)(DEMOWinMenu*, u32); + /* 0x18 */ void (*cb_move)(DEMOWinMenu*, u32); + /* 0x1C */ void (*cb_select)(DEMOWinMenu*, u32); + /* 0x20 */ void (*cb_cancel)(DEMOWinMenu*, u32); + /* 0x24 */ s32 num_display_items; + /* 0x28 */ s32 num_items; + /* 0x2C */ u32 max_str_len; + /* 0x30 */ s32 curr_pos; + /* 0x34 */ s32 display_pos; +} DEMOWinMenu; + +typedef struct STRUCT_LISTBOX_ITEM { + /* 0x00 */ char* name; // offset 0x0, size 0x4 + /* 0x04 */ u32 flags; // offset 0x4, size 0x4 +} DEMOWinListboxItem; + +typedef struct STRUCT_LISTBOX { + /* 0x00 */ char* title; // offset 0x0, size 0x4 + /* 0x04 */ DEMOWindow* handle; // offset 0x4, size 0x4 + /* 0x08 */ DEMOWinListboxItem* items; // offset 0x8, size 0x4 + /* 0x0C */ s32 max_display_items; // offset 0xC, size 0x4 + /* 0x10 */ u32 flags; // offset 0x10, size 0x4 + /* 0x14 */ s32 num_display_items; // offset 0x14, size 0x4 + /* 0x18 */ s32 num_items; // offset 0x18, size 0x4 + /* 0x1C */ u32 max_str_len; // offset 0x1C, size 0x4 + /* 0x20 */ s32 curr_pos; // offset 0x20, size 0x4 + /* 0x24 */ s32 display_pos; // offset 0x24, size 0x4 + /* 0x28 */ int cursor_state; // offset 0x28, size 0x4 +} DEMOWinListbox; + +void DEMOWinInit(void); +DEMOWindow* DEMOWinCreateWindow(s32 x1, s32 y1, s32 x2, s32 y2, char* caption, u16 scroll, void* func); +void DEMOWinDestroyWindow(DEMOWindow* handle); +void DEMOWinOpenWindow(DEMOWindow* handle); +void DEMOWinCloseWindow(DEMOWindow* handle); +void DEMOWinSetWindowColor(DEMOWindow* handle, u32 item, u8 r, u8 g, u8 b, u8 a); +void DEMOWinLogPrintf(DEMOWindow* handle, char* fmt, ...); +void DEMOWinPrintfXY(DEMOWindow* handle, u16 col, u16 row, char* fmt, ...); +void DEMOWinScrollWindow(DEMOWindow* handle, u32 dir); +void DEMOWinBringToFront(DEMOWindow* handle); +void DEMOWinSendToBack(DEMOWindow* handle); +void DEMOWinClearRow(DEMOWindow* handle, u16 row); +void DEMOWinClearWindow(DEMOWindow* handle); +void DEMOWinClearBuffer(DEMOWindow* handle); +void DEMOWinRefresh(void); +DEMOWinMenu* DEMOWinCreateMenuWindow(DEMOWinMenu* menu, u16 x, u16 y); +void DEMOWinDestroyMenuWindow(DEMOWinMenu* menu); +u32 DEMOWinMenuChild(DEMOWinMenu* menu, int child_flag); +void DEMOWinPadInit(DEMOWinPadInfo* p); +void DEMOWinPadRead(DEMOWinPadInfo* p); +void DEMOWinSetRepeat(u32 threshold, u32 rate); +void DEMOWinResetRepeat(void); +DEMOWinListbox* DEMOWinCreateListWindow(DEMOWinListbox* list, u16 x, u16 y); +void DEMOWinDestroyListWindow(DEMOWinListbox* list); +void DEMOWinListSetCursor(DEMOWinListbox* list, int x); +s32 DEMOWinListScrollList(DEMOWinListbox* list, u32 dir); +s32 DEMOWinListMoveCursor(DEMOWinListbox* list, u32 dir); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DEMOWIN_H_ diff --git a/include/dolphin/dolphin.h b/include/dolphin/dolphin.h deleted file mode 100644 index fc959563c..000000000 --- a/include/dolphin/dolphin.h +++ /dev/null @@ -1,412 +0,0 @@ -#ifndef __DOLPHIN_H__ -#define __DOLPHIN_H__ - -typedef signed char s8; -typedef signed short s16; -typedef signed long s32; -typedef signed long long s64; -typedef unsigned char u8; -typedef unsigned short u16; -typedef unsigned long u32; -typedef unsigned long long u64; - -typedef volatile u8 vu8; -typedef volatile u16 vu16; -typedef volatile u32 vu32; -typedef volatile u64 vu64; -typedef volatile s8 vs8; -typedef volatile s16 vs16; -typedef volatile s32 vs32; -typedef volatile s64 vs64; - -typedef float f32; -typedef double f64; -typedef volatile f32 vf32; -typedef volatile f64 vf64; - -typedef char* Ptr; - -#ifndef BOOL -typedef int BOOL; -#endif - -#ifndef TRUE -#define TRUE 1 -#endif - -#ifndef FALSE -#define FALSE 0 -#endif - -#ifndef NULL -#define NULL 0 -#endif - -#define OS_CACHED_REGION_PREFIX 0x8000 -#define OS_UNCACHED_REGION_PREFIX 0xC000 -#define OS_PHYSICAL_MASK 0x3FFF - -#define OS_BASE_CACHED (OS_CACHED_REGION_PREFIX << 16) -#define OS_BASE_UNCACHED (OS_UNCACHED_REGION_PREFIX << 16) - -#ifdef __MWERKS__ -u32 __OSSimulatedMemSize : (OS_BASE_CACHED | 0x00F0); -u32 __OSBusClock : (OS_BASE_CACHED | 0x00F8); -u32 __OSCoreClock : (OS_BASE_CACHED | 0x00FC); -s32 __gUnknown800030C0[2] : (OS_BASE_CACHED | 0x30C0); -u8 __gUnknown800030E3 : (OS_BASE_CACHED | 0x30E3); -#else -#define __OSBusClock (*(u32*)(OS_BASE_CACHED | 0x00F8)) -#define __OSCoreClock (*(u32*)(OS_BASE_CACHED | 0x00FC)) -#endif -#define OS_BUS_CLOCK __OSBusClock -#define OS_CORE_CLOCK __OSCoreClock -#define OS_TIMER_CLOCK (OS_BUS_CLOCK / 4) - -#define OSTicksToSeconds(ticks) ((ticks) / (OS_TIMER_CLOCK)) -#define OSTicksToMilliseconds(ticks) ((ticks) / (OS_TIMER_CLOCK / 1000)) -#define OSTicksToMicroseconds(ticks) ((ticks) * 8 / (OS_TIMER_CLOCK / 125000)) -#define OSSecondsToTicks(sec) ((sec) * (OS_TIMER_CLOCK)) -#define OSMillisecondsToTicks(msec) ((msec) * (OS_TIMER_CLOCK / 1000)) -#define OSNanosecondsToTicks(nsec) (((nsec) * (OS_TIMER_CLOCK / 125000)) / 8000) -#define OSMicrosecondsToTicks(usec) (((usec) * (OS_TIMER_CLOCK / 125000)) / 8) - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct DVDDiskID DVDDiskID; - -struct DVDDiskID -{ - char gameName[4]; - char company[2]; - u8 diskNumber; - u8 gameVersion; - u8 streaming; - u8 streamingBufSize; - u8 padding[22]; -}; - -typedef struct DVDCommandBlock DVDCommandBlock; - -typedef void (*DVDCBCallback)(s32 result, DVDCommandBlock* block); - -struct DVDCommandBlock -{ - DVDCommandBlock* next; - DVDCommandBlock* prev; - u32 command; - s32 state; - u32 offset; - u32 length; - void* addr; - u32 currTransferSize; - u32 transferredSize; - DVDDiskID* id; - DVDCBCallback callback; - void* userData; -}; - -typedef struct DVDFileInfo DVDFileInfo; - -typedef void (*DVDCallback)(s32 result, DVDFileInfo* fileInfo); - -struct DVDFileInfo -{ - DVDCommandBlock cb; - u32 startAddr; - u32 length; - DVDCallback callback; -}; - -// idk what this is -struct _AXVPB -{ - s32 i; -}; - -#define DVD_STATE_FATAL_ERROR -1 -#define DVD_STATE_END 0 -#define DVD_STATE_BUSY 1 -#define DVD_STATE_WAITING 2 -#define DVD_STATE_COVER_CLOSED 3 -#define DVD_STATE_NO_DISK 4 -#define DVD_STATE_COVER_OPEN 5 -#define DVD_STATE_WRONG_DISK 6 -#define DVD_STATE_MOTOR_STOPPED 7 -#define DVD_STATE_PAUSING 8 -#define DVD_STATE_IGNORED 9 -#define DVD_STATE_CANCELED 10 -#define DVD_STATE_RETRY 11 - -#define DVD_RESULT_GOOD 0 -#define DVD_RESULT_FATAL_ERROR -1 -#define DVD_RESULT_IGNORED -2 -#define DVD_RESULT_CANCELED -3 - -#define DVDReadAsync(fileInfo, addr, length, offset, callback) \ - DVDReadAsyncPrio((fileInfo), (addr), (length), (offset), (callback), 2) - -typedef int OSHeapHandle; - -#define OSRoundUp32B(x) (((u32)(x) + 32 - 1) & ~(32 - 1)) -#define OSRoundDown32B(x) (((u32)(x)) & ~(32 - 1)) - -typedef s64 OSTime; -typedef u32 OSTick; - -typedef struct OSCalendarTime -{ - int sec; // seconds after the minute [0, 61] - int min; // minutes after the hour [0, 59] - int hour; // hours since midnight [0, 23] - int mday; // day of the month [1, 31] - int mon; // month since January [0, 11] - int year; // years since 0000 - int wday; // days since Sunday [0, 6] - int yday; // days since January 1 [0, 365] - int msec; // milliseconds after the second [0,999] - int usec; // microseconds after the millisecond [0,999] -} OSCalendarTime; - -typedef struct OSContext -{ - u32 gpr[32]; - u32 cr; - u32 lr; - u32 ctr; - u32 xer; - f64 fpr[32]; - u32 fpscr_pad; - u32 fpscr; - u32 srr0; - u32 srr1; - u16 mode; - u16 state; - u32 gqr[8]; - u32 psf_pad; - f64 psf[32]; -} OSContext; - -#define PAD_MAX_CONTROLLERS 4 - -#define PAD_BUTTON_LEFT 0x0001 -#define PAD_BUTTON_RIGHT 0x0002 -#define PAD_BUTTON_DOWN 0x0004 -#define PAD_BUTTON_UP 0x0008 -#define PAD_TRIGGER_Z 0x0010 -#define PAD_TRIGGER_R 0x0020 -#define PAD_TRIGGER_L 0x0040 -#define PAD_BUTTON_A 0x0100 -#define PAD_BUTTON_B 0x0200 -#define PAD_BUTTON_X 0x0400 -#define PAD_BUTTON_Y 0x0800 -#define PAD_BUTTON_START 0x1000 - -#define PAD_ERR_NONE 0 -#define PAD_ERR_NO_CONTROLLER -1 -#define PAD_ERR_NOT_READY -2 -#define PAD_ERR_TRANSFER -3 - -typedef struct PADStatus -{ - u16 button; - s8 stickX; - s8 stickY; - s8 substickX; - s8 substickY; - u8 triggerLeft; - u8 triggerRight; - u8 analogA; - u8 analogB; - s8 err; -} PADStatus; - -extern volatile OSHeapHandle __OSCurrHeap; - -#define OSAlloc(size) OSAllocFromHeap(__OSCurrHeap, (size)) -#define OSFree(ptr) OSFreeToHeap(__OSCurrHeap, (ptr)) - -BOOL DVDFastOpen(s32 entrynum, DVDFileInfo* fileInfo); -BOOL DVDReadAsyncPrio(DVDFileInfo* fileInfo, void* addr, s32 length, s32 offset, - DVDCallback callback, s32 prio); -s32 DVDCancel(volatile DVDCommandBlock* block); -BOOL DVDClose(DVDFileInfo* fileInfo); -int DVDSeekAsyncPrio(DVDFileInfo* fileInfo, s32 offset, void (*callback)(s32, DVDFileInfo*), - s32 prio); -s32 DVDGetCommandBlockStatus(const DVDCommandBlock* block); -s32 DVDConvertPathToEntrynum(const char* pathPtr); -BOOL DVDCancelAllAsync(DVDCBCallback callback); -void OSPanic(const char* file, int line, const char* msg, ...); -void* OSAllocFromHeap(OSHeapHandle heap, u32 size); -void OSFreeToHeap(OSHeapHandle heap, void* ptr); -OSHeapHandle OSCreateHeap(void* start, void* end); -OSHeapHandle OSSetCurrentHeap(OSHeapHandle heap); -void* OSInitAlloc(void* arenaStart, void* arenaEnd, int maxHeaps); -void* OSGetArenaHi(); -void* OSGetArenaLo(); -OSTime OSGetTime(); -void OSTicksToCalendarTime(OSTime ticks, OSCalendarTime* td); -BOOL PADInit(); -void PADControlMotor(int chan, u32 command); -void PADRead(PADStatus* status); -void PADClamp(PADStatus* status); -void PADReset(u32 mask); -void AXQuit(); -void AXFreeVoice(_AXVPB*); -void OSSetSoundMode(u32 mode); -void VIWaitForRetrace(); - -#define CARD_FILENAME_MAX 32 -#define CARD_MAX_FILE 127 -#define CARD_ICON_MAX 8 - -typedef void (*CARDCallback)(s32 chan, s32 result); - -typedef struct CARDFileInfo -{ - /*0x00*/ s32 chan; - /*0x04*/ s32 fileNo; - /*0x08*/ s32 offset; - /*0x0C*/ s32 length; - /*0x10*/ u16 iBlock; -} CARDFileInfo; - -#define CARD_ATTR_PUBLIC 0x04u -#define CARD_ATTR_NO_COPY 0x08u -#define CARD_ATTR_NO_MOVE 0x10u -#define CARD_ATTR_GLOBAL 0x20u -#define CARD_ATTR_COMPANY 0x40u - -#define CARD_STAT_SPEED_END 0 -#define CARD_STAT_SPEED_FAST 1 -#define CARD_STAT_SPEED_MIDDLE 2 -#define CARD_STAT_SPEED_SLOW 3 -#define CARD_STAT_SPEED_MASK 3 - -#define CARD_RESULT_UNLOCKED 1 -#define CARD_RESULT_READY 0 -#define CARD_RESULT_BUSY -1 -#define CARD_RESULT_WRONGDEVICE -2 -#define CARD_RESULT_NOCARD -3 -#define CARD_RESULT_NOFILE -4 -#define CARD_RESULT_IOERROR -5 -#define CARD_RESULT_BROKEN -6 -#define CARD_RESULT_EXIST -7 -#define CARD_RESULT_NOENT -8 -#define CARD_RESULT_INSSPACE -9 -#define CARD_RESULT_NOPERM -10 -#define CARD_RESULT_LIMIT -11 -#define CARD_RESULT_NAMETOOLONG -12 -#define CARD_RESULT_ENCODING -13 -#define CARD_RESULT_CANCELED -14 -#define CARD_RESULT_FATAL_ERROR -128 - -#define CARD_ICON_WIDTH 32 -#define CARD_ICON_HEIGHT 32 - -#define CARD_BANNER_WIDTH 96 -#define CARD_BANNER_HEIGHT 32 - -#define CARD_STAT_ICON_NONE 0 -#define CARD_STAT_ICON_C8 1 -#define CARD_STAT_ICON_RGB5A3 2 -#define CARD_STAT_ICON_MASK 3 - -#define CARD_STAT_BANNER_NONE 0 -#define CARD_STAT_BANNER_C8 1 -#define CARD_STAT_BANNER_RGB5A3 2 -#define CARD_STAT_BANNER_MASK 3 - -#define CARD_ENCODE_ANSI 0 -#define CARD_ENCODE_SJIS 1 - -#define CARD_STAT_ANIM_LOOP 0x00 -#define CARD_STAT_ANIM_BOUNCE 0x04 -#define CARD_STAT_ANIM_MASK 0x04 - -#define CARDGetDirCheck(dir) ((CARDDirCheck*)&(dir)[CARD_MAX_FILE]) -#define CARDGetBannerFormat(stat) (((stat)->bannerFormat) & CARD_STAT_BANNER_MASK) -#define CARDGetIconAnim(stat) (((stat)->bannerFormat) & CARD_STAT_ANIM_MASK) -#define CARDGetIconFormat(stat, n) (((stat)->iconFormat >> (2 * (n))) & CARD_STAT_ICON_MASK) -#define CARDGetIconSpeed(stat, n) (((stat)->iconSpeed >> (2 * (n))) & CARD_STAT_SPEED_MASK) -#define CARDSetBannerFormat(stat, f) \ - ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_BANNER_MASK) | (f))) -#define CARDSetIconAnim(stat, f) \ - ((stat)->bannerFormat = (u8)(((stat)->bannerFormat & ~CARD_STAT_ANIM_MASK) | (f))) -#define CARDSetIconFormat(stat, n, f) \ - ((stat)->iconFormat = \ - (u16)(((stat)->iconFormat & ~(CARD_STAT_ICON_MASK << (2 * (n)))) | ((f) << (2 * (n))))) -#define CARDSetIconSpeed(stat, n, f) \ - ((stat)->iconSpeed = \ - (u16)(((stat)->iconSpeed & ~(CARD_STAT_SPEED_MASK << (2 * (n)))) | ((f) << (2 * (n))))) -#define CARDSetIconAddress(stat, addr) ((stat)->iconAddr = (u32)(addr)) -#define CARDSetCommentAddress(stat, addr) ((stat)->commentAddr = (u32)(addr)) -#define CARDGetFileNo(fileInfo) ((fileInfo)->fileNo) - -// CARDBios.h -void CARDInit(void); -s32 CARDGetResultCode(s32 chan); -s32 CARDFreeBlocks(s32 chan, s32* byteNotUsed, s32* filesNotUsed); -s32 CARDGetEncoding(s32 chan, u16* encode); -s32 CARDGetSectorSize(s32 chan, u32* size); -// CARDCreate -s32 CARDCreate(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo); -// CARDDelete -s32 CARDDelete(s32 chan, const char* fileName); -// CARDMount.h -s32 CARDProbeEx(s32 chan, s32* memSize, s32* sectorSize); -s32 CARDMount(s32 chan, void* workArea, CARDCallback detachCallback); -s32 CARDUnmount(s32 chan); -// CARDCheck.h -s32 CARDCheckEx(s32 chan, s32* xferBytes); -// CARDStat.h -typedef struct CARDStat -{ - /*0x00*/ char fileName[CARD_FILENAME_MAX]; - /*0x20*/ u32 length; - /*0x24*/ u32 time; - /*0x28*/ u8 gameName[4]; - /*0x2C*/ u8 company[2]; - /*0x2E*/ u8 bannerFormat; - /*0x30*/ u32 iconAddr; - /*0x34*/ u16 iconFormat; - /*0x36*/ u16 iconSpeed; - /*0x38*/ u32 commentAddr; - /*0x3C*/ u32 offsetBanner; - /*0x40*/ u32 offsetBannerTlut; - /*0x44*/ u32 offsetIcon[CARD_ICON_MAX]; - /*0x64*/ u32 offsetIconTlut; - /*0x68*/ u32 offsetData; -} CARDStat; -s32 CARDGetStatus(s32 chan, s32 fileNo, CARDStat* stat); -s32 CARDSetStatus(s32 chan, s32 fileNo, struct CARDStat* stat); -// CARDRead.h -s32 CARDReadAsync(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset, CARDCallback callback); -s32 CARDRead(struct CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset); -// CARDWrite -s32 CARDWriteAsync(CARDFileInfo* fileInfo, void* buf, s32 length, s32 offset, - CARDCallback callback); -// CARDOpen.h -s32 CARDFastOpen(s32 chan, s32 fileNo, CARDFileInfo* fileInfo); -s32 CARDOpen(s32 chan, char* fileName, CARDFileInfo* fileInfo); -s32 CARDClose(CARDFileInfo* fileInfo); -// CARDNet -s32 CARDSetAttributes(s32 chan, s32 fileNo, u8 attr); -// CARDFormat -s32 CARDFormat(s32 chan); -// CARDRdwr -s32 CARDGetXferredBytes(s32 chan); - -// GX -#include -#include -#include -#include - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/dolphin/dsp.h b/include/dolphin/dsp.h new file mode 100644 index 000000000..db2975948 --- /dev/null +++ b/include/dolphin/dsp.h @@ -0,0 +1,57 @@ +#ifndef _DOLPHIN_DSP_H_ +#define _DOLPHIN_DSP_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*DSPCallback)(void* task); +typedef struct STRUCT_DSP_TASK DSPTaskInfo; + +typedef struct STRUCT_DSP_TASK { + /* 0x00 */ volatile u32 state; + /* 0x04 */ volatile u32 priority; + /* 0x08 */ volatile u32 flags; + /* 0x0C */ u16* iram_mmem_addr; + /* 0x10 */ u32 iram_length; + /* 0x14 */ u32 iram_addr; + /* 0x18 */ u16* dram_mmem_addr; + /* 0x1C */ u32 dram_length; + /* 0x20 */ u32 dram_addr; + /* 0x24 */ u16 dsp_init_vector; + /* 0x26 */ u16 dsp_resume_vector; + /* 0x28 */ DSPCallback init_cb; + /* 0x2C */ DSPCallback res_cb; + /* 0x30 */ DSPCallback done_cb; + /* 0x34 */ DSPCallback req_cb; + /* 0x38 */ DSPTaskInfo* next; + /* 0x3C */ DSPTaskInfo* prev; + /* 0x40 */ OSTime t_context; + /* 0x48 */ OSTime t_task; +} DSPTaskInfo; + +u32 DSPCheckMailToDSP(void); +u32 DSPCheckMailFromDSP(void); +u32 DSPReadCPUToDSPMbox(void); +u32 DSPReadMailFromDSP(void); +void DSPSendMailToDSP(u32 mail); +void DSPAssertInt(void); +void DSPInit(void); +BOOL DSPCheckInit(void); +void DSPReset(void); +void DSPHalt(void); +void DSPUnhalt(void); +u32 DSPGetDMAStatus(void); +DSPTaskInfo* DSPAddTask(DSPTaskInfo* task); +DSPTaskInfo* DSPCancelTask(DSPTaskInfo* task); +DSPTaskInfo* DSPAssertTask(DSPTaskInfo* task); + +DSPTaskInfo* __DSPGetCurrentTask(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/dtk.h b/include/dolphin/dtk.h new file mode 100644 index 000000000..3a76a0ff7 --- /dev/null +++ b/include/dolphin/dtk.h @@ -0,0 +1,56 @@ +#ifndef _DOLPHIN_DTK_H_ +#define _DOLPHIN_DTK_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*DTKCallback)(u32 eventMask); +typedef void (*DTKFlushCallback)(void); + +typedef struct DTKTrack { + /* 0x00 */ struct DTKTrack* prev; + /* 0x04 */ struct DTKTrack* next; + /* 0x08 */ char* fileName; + /* 0x0C */ u32 eventMask; + /* 0x10 */ DTKCallback callback; + /* 0x14 */ DVDFileInfo dvdFileInfo; +} DTKTrack; + +#define DTK_STATE_STOP 0 +#define DTK_STATE_RUN 1 +#define DTK_STATE_PAUSE 2 +#define DTK_STATE_BUSY 3 +#define DTK_STATE_PREPARE 4 + +#define DTK_MODE_NOREPEAT 0 +#define DTK_MODE_ALLREPEAT 1 +#define DTK_MODE_REPEAT1 2 + +void DTKInit(void); +void DTKShutdown(void); +u32 DTKQueueTrack(char* fileName, DTKTrack* track, u32 eventMask, DTKCallback callback); +u32 DTKRemoveTrack(DTKTrack* track); +int DTKFlushTracks(DTKFlushCallback callback); +void DTKSetSampleRate(u32 samplerate); +void DTKSetInterruptFrequency(u32 samples); +void DTKSetRepeatMode(u32 repeat); +int DTKSetState(u32 state); +int DTKNextTrack(void); +int DTKPrevTrack(void); +u32 DTKGetSampleRate(void); +u32 DTKGetRepeatMode(void); +u32 DTKGetState(void); +u32 DTKGetPosition(void); +u32 DTKGetInterruptFrequency(void); +DTKTrack* DTKGetCurrentTrack(void); +void DTKSetVolume(u8 left, u8 right); +u16 DTKGetVolume(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/dvd.h b/include/dolphin/dvd.h new file mode 100644 index 000000000..4bbe3190e --- /dev/null +++ b/include/dolphin/dvd.h @@ -0,0 +1,237 @@ +#ifndef _DOLPHIN_DVD_H_ +#define _DOLPHIN_DVD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// needed for matching release +#define DVD_ASSERTMSGLINE(line, cond, msg) \ + if (!(cond)) \ + OSPanic(__FILE__, line, msg) + +#define DVD_ASSERTMSG1LINE(line, cond, msg, arg1) \ + if (!(cond)) \ + OSPanic(__FILE__, line, msg, arg1) + +#define DVD_ASSERTMSG2LINE(line, cond, msg, arg1, arg2) \ + if (!(cond)) \ + OSPanic(__FILE__, line, msg, arg1, arg2) + +#define DVD_RESULT_GOOD 0 +#define DVD_RESULT_FATAL_ERROR -1 +#define DVD_RESULT_IGNORED -2 +#define DVD_RESULT_CANCELED -6 + +#define DVD_STATE_FATAL_ERROR -1 +#define DVD_STATE_END 0 +#define DVD_STATE_BUSY 1 +#define DVD_STATE_WAITING 2 +#define DVD_STATE_COVER_CLOSED 3 +#define DVD_STATE_NO_DISK 4 +#define DVD_STATE_COVER_OPEN 5 +#define DVD_STATE_WRONG_DISK 6 +#define DVD_STATE_MOTOR_STOPPED 7 +#define DVD_STATE_PAUSING 8 +#define DVD_STATE_IGNORED 9 +#define DVD_STATE_CANCELED 10 +#define DVD_STATE_RETRY 11 + +#define DVD_MIN_TRANSFER_SIZE 32 + +// could be bitfields +#define DVD_INTTYPE_TC 1 +#define DVD_INTTYPE_DE 2 +// unk type 3 +#define DVD_INTTYPE_CVR 4 + +// DVD Commands +#define DVD_COMMAND_NONE 0 +#define DVD_COMMAND_READ 1 +#define DVD_COMMAND_SEEK 2 +#define DVD_COMMAND_CHANGE_DISK 3 +#define DVD_COMMAND_BSREAD 4 +#define DVD_COMMAND_READID 5 +#define DVD_COMMAND_INITSTREAM 6 +#define DVD_COMMAND_CANCELSTREAM 7 +#define DVD_COMMAND_STOP_STREAM_AT_END 8 +#define DVD_COMMAND_REQUEST_AUDIO_ERROR 9 +#define DVD_COMMAND_REQUEST_PLAY_ADDR 10 +#define DVD_COMMAND_REQUEST_START_ADDR 11 +#define DVD_COMMAND_REQUEST_LENGTH 12 +#define DVD_COMMAND_AUDIO_BUFFER_CONFIG 13 +#define DVD_COMMAND_INQUIRY 14 +#define DVD_COMMAND_BS_CHANGE_DISK 15 +#define DVD_COMMAND_UNK_16 16 + +typedef struct DVDDiskID { + char gameName[4]; + char company[2]; + u8 diskNumber; + u8 gameVersion; + u8 streaming; + u8 streamingBufSize; + u8 padding[22]; +} DVDDiskID; + +typedef struct DVDCommandBlock DVDCommandBlock; +typedef void (*DVDCBCallback)(s32 result, DVDCommandBlock* block); +typedef void (*DVDLowCallback)(u32); + +typedef void (*DVDCommandCheckerCallback)(u32); +typedef void (*DVDCommandChecker)(DVDCommandBlock*, DVDCommandCheckerCallback); + +struct DVDCommandBlock { + /* 0x00 */ DVDCommandBlock* next; + /* 0x04 */ DVDCommandBlock* prev; + /* 0x08 */ u32 command; + /* 0x0C */ s32 state; + /* 0x10 */ u32 offset; + /* 0x14 */ u32 length; + /* 0x18 */ void* addr; + /* 0x1C */ u32 currTransferSize; + /* 0x20 */ u32 transferredSize; + /* 0x24 */ DVDDiskID* id; + /* 0x28 */ DVDCBCallback callback; + /* 0x2C */ void* userData; +}; + +typedef struct DVDFileInfo DVDFileInfo; +typedef void (*DVDCallback)(s32 result, DVDFileInfo *fileInfo); +struct DVDFileInfo { + /* 0x00 */ DVDCommandBlock cb; + /* 0x30 */ u32 startAddr; + /* 0x34 */ u32 length; + /* 0x38 */ DVDCallback callback; +}; + +typedef struct { + u32 entryNum; + u32 location; + u32 next; +} DVDDir; + +typedef struct { + u32 entryNum; + BOOL isDir; + char* name; +} DVDDirEntry; + +typedef struct DVDBB2 { + /* 0x00 */ u32 bootFilePosition; + /* 0x04 */ u32 FSTPosition; + /* 0x08 */ u32 FSTLength; + /* 0x0C */ u32 FSTMaxLength; + /* 0x10 */ void* FSTAddress; + /* 0x14 */ u32 userPosition; + /* 0x18 */ u32 userLength; + /* 0x1C */ u32 padding0; +} DVDBB2; + +typedef struct DVDDriveInfo { + /* 0x00 */ u16 revisionLevel; + /* 0x02 */ u16 deviceCode; + /* 0x04 */ u32 releaseDate; + /* 0x08 */ u8 padding[24]; +} DVDDriveInfo; + +// DVD +void DVDInit(void); +int DVDReadAbsAsyncPrio(DVDCommandBlock* block, void* addr, s32 length, s32 offset, DVDCBCallback callback, s32 prio); +int DVDSeekAbsAsyncPrio(DVDCommandBlock* block, s32 offset, DVDCBCallback callback, s32 prio); +int DVDReadAbsAsyncForBS(DVDCommandBlock* block, void* addr, s32 length, s32 offset, DVDCBCallback callback); +int DVDReadDiskID(DVDCommandBlock* block, DVDDiskID* diskID, DVDCBCallback callback); +int DVDPrepareStreamAbsAsync(DVDCommandBlock* block, u32 length, u32 offset, DVDCBCallback callback); +int DVDCancelStreamAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDCancelStream(DVDCommandBlock* block); +int DVDStopStreamAtEndAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDStopStreamAtEnd(DVDCommandBlock* block); +int DVDGetStreamErrorStatusAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDGetStreamErrorStatus(DVDCommandBlock* block); +int DVDGetStreamPlayAddrAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDGetStreamPlayAddr(DVDCommandBlock* block); +int DVDGetStreamStartAddrAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDGetStreamStartAddr(DVDCommandBlock* block); +int DVDGetStreamLengthAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDGetStreamLength(DVDCommandBlock* block); +int DVDChangeDiskAsyncForBS(DVDCommandBlock* block, DVDCBCallback callback); +int DVDChangeDiskAsync(DVDCommandBlock* block, DVDDiskID* id, DVDCBCallback callback); +s32 DVDChangeDisk(DVDCommandBlock* block, DVDDiskID* id); +int DVDStopMotorAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDStopMotor(DVDCommandBlock* block); +int DVDInquiryAsync(DVDCommandBlock* block, DVDDriveInfo* info, DVDCBCallback callback); +s32 DVDInquiry(DVDCommandBlock* block, DVDDriveInfo* info); +void DVDReset(void); +int DVDResetRequired(void); +s32 DVDGetCommandBlockStatus(const DVDCommandBlock* block); +s32 DVDGetDriveStatus(void); +BOOL DVDSetAutoInvalidation(BOOL autoInval); +void DVDPause(void); +void DVDResume(void); +int DVDCancelAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDCancel(volatile DVDCommandBlock* block); +int DVDCancelAllAsync(DVDCBCallback callback); +s32 DVDCancelAll(void); +DVDDiskID* DVDGetCurrentDiskID(void); +BOOL DVDCheckDisk(void); + +// DVD FATAL +int DVDSetAutoFatalMessaging(BOOL enable); + +// DVD FS +s32 DVDConvertPathToEntrynum(const char* pathPtr); +BOOL DVDFastOpen(s32 entrynum, DVDFileInfo* fileInfo); +BOOL DVDOpen(const char* fileName, DVDFileInfo* fileInfo); +BOOL DVDClose(DVDFileInfo* fileInfo); +BOOL DVDGetCurrentDir(char* path, u32 maxlen); +BOOL DVDChangeDir(const char* dirName); +BOOL DVDReadAsyncPrio(DVDFileInfo* fileInfo, void* addr, s32 length, s32 offset, + DVDCallback callback, s32 prio); +s32 DVDReadPrio(DVDFileInfo* fileInfo, void* addr, s32 length, s32 offset, s32 prio); +int DVDSeekAsyncPrio(DVDFileInfo* fileInfo, s32 offset, void (* callback)(s32, DVDFileInfo *), s32 prio); +s32 DVDSeekPrio(DVDFileInfo* fileInfo, s32 offset, s32 prio); +s32 DVDGetFileInfoStatus(const DVDFileInfo* fileInfo); +BOOL DVDFastOpenDir(s32 entrynum, DVDDir* dir); +int DVDOpenDir(const char* dirName, DVDDir* dir); +int DVDReadDir(DVDDir* dir, DVDDirEntry* dirent); +int DVDCloseDir(DVDDir* dir); +void DVDRewindDir(DVDDir* dir); +void* DVDGetFSTLocation(void); +BOOL DVDPrepareStreamAsync(DVDFileInfo* fileInfo, u32 length, u32 offset, DVDCallback callback); +s32 DVDPrepareStream(DVDFileInfo* fileInfo, u32 length, u32 offset); +s32 DVDGetTransferredSize(DVDFileInfo* fileinfo); + +#define DVDReadAsync(fileInfo, addr, length, offset, callback) \ + DVDReadAsyncPrio((fileInfo), (addr), (length), (offset), (callback), 2) + +// DVD ID UTILS +int DVDCompareDiskID(const DVDDiskID* id1, const DVDDiskID* id2); +DVDDiskID* DVDGenerateDiskID(DVDDiskID* id, const char* game, const char* company, u8 diskNum, u8 version); + +// DVD LOW +BOOL DVDLowRead(void* addr, u32 length, u32 offset, DVDLowCallback callback); +BOOL DVDLowSeek(u32 offset, DVDLowCallback callback); +BOOL DVDLowWaitCoverClose(DVDLowCallback callback); +BOOL DVDLowReadDiskID(DVDDiskID* diskID, DVDLowCallback callback); +BOOL DVDLowStopMotor(DVDLowCallback callback); +BOOL DVDLowRequestError(DVDLowCallback callback); +BOOL DVDLowInquiry(DVDDriveInfo* info, DVDLowCallback callback); +BOOL DVDLowAudioStream(u32 subcmd, u32 length, u32 offset, DVDLowCallback callback); +BOOL DVDLowRequestAudioStatus(u32 subcmd, DVDLowCallback callback); +BOOL DVDLowAudioBufferConfig(BOOL enable, u32 size, DVDLowCallback callback); +void DVDLowReset(void); +DVDLowCallback DVDLowSetResetCoverCallback(DVDLowCallback callback); +BOOL DVDLowBreak(void); +DVDLowCallback DVDLowClearCallback(void); +u32 DVDLowGetCoverStatus(void); + +// DVD QUEUE +void DVDDumpWaitingQueue(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/exi.h b/include/dolphin/exi.h new file mode 100644 index 000000000..f094c3613 --- /dev/null +++ b/include/dolphin/exi.h @@ -0,0 +1,103 @@ +#ifndef _DOLPHIN_EXI_H_ +#define _DOLPHIN_EXI_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define EXI_MEMORY_CARD_59 0x00000004 +#define EXI_MEMORY_CARD_123 0x00000008 +#define EXI_MEMORY_CARD_251 0x00000010 +#define EXI_MEMORY_CARD_507 0x00000020 + +#define EXI_MEMORY_CARD_1019 0x00000040 +#define EXI_MEMORY_CARD_2043 0x00000080 + +#define EXI_MEMORY_CARD_1019A 0x00000140 +#define EXI_MEMORY_CARD_1019B 0x00000240 +#define EXI_MEMORY_CARD_1019C 0x00000340 +#define EXI_MEMORY_CARD_1019D 0x00000440 +#define EXI_MEMORY_CARD_1019E 0x00000540 +#define EXI_MEMORY_CARD_1019F 0x00000640 +#define EXI_MEMORY_CARD_1019G 0x00000740 + +#define EXI_MEMORY_CARD_2043A 0x00000180 +#define EXI_MEMORY_CARD_2043B 0x00000280 +#define EXI_MEMORY_CARD_2043C 0x00000380 +#define EXI_MEMORY_CARD_2043D 0x00000480 +#define EXI_MEMORY_CARD_2043E 0x00000580 +#define EXI_MEMORY_CARD_2043F 0x00000680 +#define EXI_MEMORY_CARD_2043G 0x00000780 + +#define EXI_USB_ADAPTER 0x01010000 +#define EXI_NPDP_GDEV 0x01020000 + +#define EXI_MODEM 0x02020000 +#define EXI_ETHER 0x04020200 +#define EXI_MIC 0x04060000 +#define EXI_AD16 0x04120000 +#define EXI_RS232C 0x04040404 +#define EXI_ETHER_VIEWER 0x04220001 +#define EXI_STREAM_HANGER 0x04130000 + +#define EXI_MARLIN 0x03010000 + +#define EXI_IS_VIEWER 0x05070000 + +#define EXI_READ 0 +#define EXI_WRITE 1 + +#define EXI_FREQ_1M 0 +#define EXI_FREQ_2M 1 +#define EXI_FREQ_4M 2 +#define EXI_FREQ_8M 3 +#define EXI_FREQ_16M 4 +#define EXI_FREQ_32M 5 + +typedef void (*EXICallback)(s32 chan, OSContext* context); +typedef struct EXIControl { + EXICallback exiCallback; + EXICallback tcCallback; + EXICallback extCallback; + volatile u32 state; + int immLen; + u8* immBuf; + u32 dev; + u32 id; + s32 idTime; + int items; + struct { + u32 dev; + EXICallback callback; + } queue[3]; +} EXIControl; + +EXICallback EXISetExiCallback(s32 channel, EXICallback callback); + +void EXIInit(void); +BOOL EXILock(s32 channel, u32 device, EXICallback callback); +BOOL EXIUnlock(s32 channel); +BOOL EXISelect(s32 channel, u32 device, u32 frequency); +BOOL EXIDeselect(s32 channel); +BOOL EXIImm(s32 channel, void* buffer, s32 length, u32 type, EXICallback callback); +BOOL EXIImmEx(s32 channel, void* buffer, s32 length, u32 type); +BOOL EXIDma(s32 channel, void* buffer, s32 length, u32 type, EXICallback callback); +BOOL EXISync(s32 channel); +BOOL EXIProbe(s32 channel); +s32 EXIProbeEx(s32 channel); +BOOL EXIAttach(s32 channel, EXICallback callback); +BOOL EXIDetach(s32 channel); +u32 EXIGetState(s32 channel); +s32 EXIGetID(s32 channel, u32 device, u32* id); +void EXIProbeReset(void); +int EXISelectSD(s32 chan, u32 dev, u32 freq); +s32 EXIGetType(s32 chan, u32 dev, u32* type); +char* EXIGetTypeString(u32 type); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd.h b/include/dolphin/gd.h new file mode 100644 index 000000000..57c929dad --- /dev/null +++ b/include/dolphin/gd.h @@ -0,0 +1,14 @@ +#ifndef _DOLPHIN_GD_H_ +#define _DOLPHIN_GD_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif diff --git a/include/dolphin/gd/GDBase.h b/include/dolphin/gd/GDBase.h new file mode 100644 index 000000000..a1b69ed7f --- /dev/null +++ b/include/dolphin/gd/GDBase.h @@ -0,0 +1,127 @@ +#ifndef _DOLPHIN_GD_BASE_H +#define _DOLPHIN_GD_BASE_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*GDOverflowCb)(void); + +typedef struct _GDLObj { + u8* start; + u32 length; + u8* ptr; + u8* top; +} GDLObj; + +extern GDLObj* __GDCurrentDL; + +void GDInitGDLObj(GDLObj* dl, void* start, u32 length); +void GDFlushCurrToMem(void); +void GDPadCurr32(void); +void GDOverflowed(void); +void GDSetOverflowCallback(GDOverflowCb callback); +GDOverflowCb GDGetOverflowCallback(void); + +inline static void GDOverflowCheck(u32 size) { + if (__GDCurrentDL->ptr + size > __GDCurrentDL->top) { + GDOverflowed(); + } +} + +inline static void __GDWrite(u8 data) { + *__GDCurrentDL->ptr++ = data; +} + +inline static void GDWrite_u8(u8 data) { + GDOverflowCheck(sizeof(u8)); + __GDWrite(data); +} + +inline static void GDWrite_u16(u16 data) { + GDOverflowCheck(sizeof(u16)); + __GDWrite((u8)((data >> 8))); + __GDWrite((u8)((data >> 0) & 0xFF)); +} + +inline static void GDWrite_u24(u32 data) { + GDOverflowCheck(3); + __GDWrite((u8)((data >> 16) & 0xFF)); + __GDWrite((u8)((data >> 8) & 0xFF)); + __GDWrite((u8)((data >> 0) & 0xFF)); +} + +inline static void GDWrite_u32(u32 data) { + GDOverflowCheck(sizeof(u32)); + __GDWrite((u8)((data >> 24) & 0xFF)); + __GDWrite((u8)((data >> 16) & 0xFF)); + __GDWrite((u8)((data >> 8) & 0xFF)); + __GDWrite((u8)((data >> 0) & 0xFF)); +} + +inline static void GDWrite_f32(f32 data) { + union { + f32 f; + u32 u; + } fid; + fid.f = data; + GDWrite_u32(fid.u); +} + +inline static void GDWriteXFCmdHdr(u16 addr, u8 len) { + GDWrite_u8(GX_LOAD_XF_REG); + GDWrite_u16(len - 1); + GDWrite_u16(addr); +} + +inline static void GDWriteXFCmd(u16 addr, u32 val) { + GDWrite_u8(GX_LOAD_XF_REG); + GDWrite_u16(0); + GDWrite_u16(addr); + GDWrite_u32(val); +} + +inline static void GDWriteXFIndxDCmd(u16 addr, u8 len, u16 index) { + GDWrite_u8(GX_LOAD_INDX_D); + GDWrite_u16(index); + GDWrite_u16((len - 1) << 12 | addr); +} + +inline static void GDWriteXFIndxACmd(u16 addr, u8 len, u16 index) { + GDWrite_u8(GX_LOAD_INDX_A); + GDWrite_u16(index); + GDWrite_u16(((len - 1) << 12) | addr); +} + +inline static void GDWriteXFIndxBCmd(u16 addr, u8 len, u16 index) { + GDWrite_u8(GX_LOAD_INDX_B); + GDWrite_u16(index); + GDWrite_u16(((len - 1) << 12) | addr); +} + +inline static void GDWriteXFIndxCCmd(u16 addr, u8 len, u16 index) { + GDWrite_u8(GX_LOAD_INDX_C); + GDWrite_u16(index); + GDWrite_u16(((len - 1) << 12) | addr); +} + +inline static void GDWriteCPCmd(u8 addr, u32 val) { + GDWrite_u8(GX_LOAD_CP_REG); + GDWrite_u8(addr); + GDWrite_u32(val); +} + +inline static void GDWriteBPCmd(u32 regval) { + GDWrite_u8(GX_LOAD_BP_REG); + GDWrite_u32(regval); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDFile.h b/include/dolphin/gd/GDFile.h new file mode 100644 index 000000000..3589fbb7e --- /dev/null +++ b/include/dolphin/gd/GDFile.h @@ -0,0 +1,31 @@ +#ifndef _DOLPHIN_GD_FILE_H +#define _DOLPHIN_GD_FILE_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GD_FILE_VERSION_NUMBER 0x11223344 + +typedef struct _GDGList { + void* ptr; + u32 byteLength; +} GDGList; + +typedef struct _GDFileHeader { + u32 versionNumber; + u32 numDLs; + u32 numPLs; + GDGList* DLDescArray; + GDGList* PLDescArray; +} GDFileHeader; + +s32 GDReadDLFile(const char* fName, u32* numDLs, u32* numPLs, GDGList** DLDescArray, GDGList** PLDescArray); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDGeometry.h b/include/dolphin/gd/GDGeometry.h new file mode 100644 index 000000000..2a5c44d02 --- /dev/null +++ b/include/dolphin/gd/GDGeometry.h @@ -0,0 +1,185 @@ +#ifndef _DOLPHIN_GD_GEOMETRY_H_ +#define _DOLPHIN_GD_GEOMETRY_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Command processor register IDs +#define CP_REG_MTXIDXA_ID 0x30 // Matrix index A +#define CP_REG_MTXIDXB_ID 0x40 // Matrix index B +#define CP_REG_VCD_LO_ID 0x50 // Vertex descriptor (lo) +#define CP_REG_VCD_HI_ID 0x60 // Vertex descriptor (hi) +#define CP_REG_VAT_GRP0_ID 0x70 // Vertex attribute table (group 0) +#define CP_REG_VAT_GRP1_ID 0x80 // Vertex attribute table (group 1) +#define CP_REG_VAT_GRP2_ID 0x90 // Vertex attribute table (group 2) +#define CP_REG_ARRAYBASE_ID 0xA0 // Vertex array start/base +#define CP_REG_ARRAYSTRIDE_ID 0xB0 // Vertex array stride + +#define CP_REG_VCD_LO(pnMtxIdx, txMtxIdxMask, posn, norm, col0, col1) \ + ( \ + (pnMtxIdx) << 0 | \ + (txMtxIdxMask) << 1 | \ + (posn) << 9 | \ + (norm) << 11 | \ + (col0) << 13 | \ + (col1) << 15 \ + ) + +#define CP_REG_VCD_HI(tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7) \ + ( \ + (tex0) << 0 | \ + (tex1) << 2 | \ + (tex2) << 4 | \ + (tex3) << 6 | \ + (tex4) << 8 | \ + (tex5) << 10 | \ + (tex6) << 12 | \ + (tex7) << 14 \ + ) + +#define CP_REG_VAT_GRP0(posCnt, posType, posFrac, nrmCnt, nrmType, c0Cnt, c0Type, c1Cnt, c1Type, tx0Cnt, tx0Type, tx0Frac, p12, nrmIdx3) \ + ( \ + (posCnt) << 0 | \ + (posType) << 1 | \ + (posFrac) << 4 | \ + (nrmCnt) << 9 | \ + (nrmType) << 10 | \ + (c0Cnt) << 13 | \ + (c0Type) << 14 | \ + (c1Cnt) << 17 | \ + (c1Type) << 18 | \ + (tx0Cnt) << 21 | \ + (tx0Type) << 22 | \ + (tx0Frac) << 25 | \ + (p12) << 30 | \ + (nrmIdx3) << 31 \ + ) + +#define CP_REG_VAT_GRP1(tx1Cnt, tx1Type, tx1Frac, tx2Cnt, tx2Type, tx2Frac, tx3Cnt, tx3Type, tx3Frac, tx4Cnt, tx4Type, p11) \ + ( \ + (tx1Cnt) << 0 | \ + (tx1Type) << 1 | \ + (tx1Frac) << 4 | \ + (tx2Cnt) << 9 | \ + (tx2Type) << 10 | \ + (tx2Frac) << 13 | \ + (tx3Cnt) << 18 | \ + (tx3Type) << 19 | \ + (tx3Frac) << 22 | \ + (tx4Cnt) << 27 | \ + (tx4Type) << 28 | \ + p11 << 31 \ + ) + +#define CP_REG_VAT_GRP2(tx4Frac, tx5Cnt, tx5Type, tx5Frac, tx6Cnt, tx6Type, tx6Frac, tx7Cnt, tx7Type, tx7Frac) \ + ( \ + (tx4Frac) << 0 | \ + (tx5Cnt) << 5 | \ + (tx5Type) << 6 | \ + (tx5Frac) << 9 | \ + (tx6Cnt) << 14 | \ + (tx6Type) << 15 | \ + (tx6Frac) << 18 | \ + (tx7Cnt) << 23 | \ + (tx7Type) << 24 | \ + (tx7Frac) << 27 \ + ) + +// Transform unit register IDs +#define XF_REG_ERROR_ID 0x1000 +#define XF_REG_DIAGNOSTICS_ID 0x1001 +#define XF_REG_STATE0_ID 0x1002 +#define XF_REG_STATE1_ID 0x1003 +#define XF_REG_CLOCK_ID 0x1004 +#define XF_REG_CLIPDISABLE_ID 0x1005 +#define XF_REG_PERF0_ID 0x1006 +#define XF_REG_PERF1_ID 0x1007 +#define XF_REG_INVERTEXSPEC_ID 0x1008 +#define XF_REG_NUMCOLORS_ID 0x1009 +#define XF_REG_DUALTEXTRAN_ID 0x1012 +#define XF_REG_SCALEX_ID 0x101A +#define XF_REG_SCALEY_ID 0x101B +#define XF_REG_SCALEZ_ID 0x101C +#define XF_REG_OFFSETX_ID 0x101D +#define XF_REG_OFFSETY_ID 0x101E +#define XF_REG_OFFSETZ_ID 0x101F +#define XF_REG_NUMTEX_ID 0x103F +#define XF_REG_TEX0_ID 0x1040 +#define XF_REG_TEX1_ID 0x1041 +#define XF_REG_TEX2_ID 0x1042 +#define XF_REG_TEX3_ID 0x1043 +#define XF_REG_TEX4_ID 0x1044 +#define XF_REG_TEX5_ID 0x1045 +#define XF_REG_TEX6_ID 0x1046 +#define XF_REG_TEX7_ID 0x1047 +#define XF_REG_DUALTEX0_ID 0x1050 +#define XF_REG_DUALTEX1_ID 0x1051 +#define XF_REG_DUALTEX2_ID 0x1052 +#define XF_REG_DUALTEX3_ID 0x1053 +#define XF_REG_DUALTEX4_ID 0x1054 +#define XF_REG_DUALTEX5_ID 0x1055 +#define XF_REG_DUALTEX6_ID 0x1056 +#define XF_REG_DUALTEX7_ID 0x1057 + +#define XF_REG_INVTXSPEC(ncols, nnorms, ntexs) \ + ( \ + (ncols) << 0 | \ + (nnorms) << 2 | \ + (ntexs) << 4 \ + ) + +#define XF_REG_TEX(proj, form, tgType, row, embossRow, embossLit) \ + ( \ + (proj) << 1 | \ + (form) << 2 | \ + (tgType) << 4 | \ + (row) << 7 | \ + (embossRow) << 12 | \ + (embossLit) << 15 \ + ) + +#define XF_REG_DUALTEX(mtx, normalize) \ + ( \ + (mtx) << 0 | \ + (normalize) << 8 \ + ) + +#define BP_GEN_MODE(nTexGens, nChans, nTevs, p4, nInds) \ + ( \ + (u32)(nTexGens) << 0 | \ + (u32)(nChans) << 4 | \ + (u32)(nTevs) << 10 | \ + (u32)(p4) << 14 | \ + (u32)(nInds) << 16 \ + ) + +#define BP_LP_SIZE(lineWidth, pointSize, lineOffset, pointOffset, lineHalfAspect, p5) \ + ( \ + (u32)(lineWidth) << 0 | \ + (u32)(pointSize) << 8 | \ + (u32)(lineOffset) << 16 | \ + (u32)(pointOffset) << 19 | \ + (u32)(lineHalfAspect) << 22 | \ + (u32)(p5) << 24 \ + ) + +void GDSetVtxDescv(const GXVtxDescList* attrPtr); +void GDSetVtxAttrFmtv(GXVtxFmt vtxfmt, const GXVtxAttrFmtList* list); +void GDSetArray(GXAttr attr, void* base_ptr, u8 stride); +void GDSetArrayRaw(GXAttr attr, u32 base_ptr_raw, u8 stride); +void GDPatchArrayPtr(void* base_ptr); +void GDSetTexCoordGen(GXTexCoordID dst_coord, GXTexGenType func, GXTexGenSrc src_param, u8 normalize, u32 postmtx); +void GDSetCullMode(GXCullMode mode); +void GDSetGenMode(u8 nTexGens, u8 nChans, u8 nTevs); +void GDSetGenMode2(u8 nTexGens, u8 nChans, u8 nTevs, u8 nInds, GXCullMode cm); +void GDSetLPSize(u8 lineWidth, u8 pointSize, GXTexOffset lineOffset, GXTexOffset pointOffset, u8 lineHalfAspect); +void GDSetCoPlanar(u8 enable); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDIndirect.h b/include/dolphin/gd/GDIndirect.h new file mode 100644 index 000000000..4ca854c31 --- /dev/null +++ b/include/dolphin/gd/GDIndirect.h @@ -0,0 +1,91 @@ +#ifndef _DOLPHIN_GD_INDIRECT_H_ +#define _DOLPHIN_GD_INDIRECT_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define BP_TEV_INDIRECT(ind_stage, format, bias_sel, alpha_sel, mtx_sel, wrap_s, wrap_t, utc_lod, add_prev, id) \ + ( \ + (u32)(ind_stage) << 0 | \ + (u32)(format) << 2 | \ + (u32)(bias_sel) << 4 | \ + (u32)(alpha_sel) << 7 | \ + (u32)(mtx_sel) << 9 | \ + (u32)(wrap_s) << 13 | \ + (u32)(wrap_t) << 16 | \ + (u32)(utc_lod) << 19 | \ + (u32)(add_prev) << 20 | \ + (u32)(id) << 24 \ + ) + +#define BP_IND_MTX(m0, m1, scale_exp, id) \ + ( \ + (u32)(m0) << 0 | \ + (u32)(m1) << 11 | \ + (u32)(scale_exp) << 22 | \ + (u32)(id) << 24 \ + ) + +#define BP_IND_TEXCOORD_SCALE(scaleS0, scaleT0, scaleS1, scaleT1, id) \ + ( \ + (u32)(scaleS0) << 0 | \ + (u32)(scaleT0) << 4 | \ + (u32)(scaleS1) << 8 | \ + (u32)(scaleT1) << 12 | \ + (u32)(id) << 24 \ + ) + +#define BP_IND_TEX_ORDER(map0, coord0, map1, coord1, map2, coord2, map3, coord3, id) \ + ( \ + (u32)(map0) << 0 | \ + (u32)(coord0) << 3 | \ + (u32)(map1) << 6 | \ + (u32)(coord1) << 9 | \ + (u32)(map2) << 12 | \ + (u32)(coord2) << 15 | \ + (u32)(map3) << 18 | \ + (u32)(coord3) << 21 | \ + (u32)(id) << 24 \ + ) + +#define BP_IND_MASK(mask, id) \ + ( \ + (u32)(mask) << 0 | \ + (u32)(id) << 24 \ + ) + +void GDSetTevIndirect(GXTevStageID tev_stage, GXIndTexStageID ind_stage, + GXIndTexFormat format, GXIndTexBiasSel bias_sel, + GXIndTexMtxID matrix_sel, GXIndTexWrap wrap_s, + GXIndTexWrap wrap_t, u8 add_prev, u8 utc_lod, + GXIndTexAlphaSel alpha_sel); +void GDSetIndTexMtx(GXIndTexMtxID mtx_id, const f32 offset[2][3], s8 scale_exp); +void GDSetIndTexCoordScale(GXIndTexStageID indStageEven, GXIndTexScale scaleS0, + GXIndTexScale scaleT0, GXIndTexScale scaleS1, + GXIndTexScale scaleT1); +void GDSetIndTexOrder(GXTexCoordID texCoord0, GXTexMapID texMap0, + GXTexCoordID texCoord1, GXTexMapID texMap1, + GXTexCoordID texCoord2, GXTexMapID texMap2, + GXTexCoordID texCoord3, GXTexMapID texMap3); +void GDSetTevDirect(GXTevStageID tev_stage); +void GDSetTevIndWarp(GXTevStageID tev_stage, GXIndTexStageID ind_stage, u8 signed_offset, u8 replace_mode, GXIndTexMtxID matrix_sel); +void GDSetTevIndTile(GXTevStageID tev_stage, GXIndTexStageID ind_stage, + u16 tilesize_s, u16 tilesize_t, u16 tilespacing_s, + u16 tilespacing_t, GXIndTexFormat format, + GXIndTexMtxID matrix_sel, GXIndTexBiasSel bias_sel, + GXIndTexAlphaSel alpha_sel); +void GDSetTevIndBumpST(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXIndTexMtxID matrix_sel); +void GDSetTevIndBumpXYZ(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXIndTexMtxID matrix_sel); +void GDSetTevIndRepeat(GXTevStageID tev_stage); +void __GDSetIndTexMask(u32 mask); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDLight.h b/include/dolphin/gd/GDLight.h new file mode 100644 index 000000000..b67d385c6 --- /dev/null +++ b/include/dolphin/gd/GDLight.h @@ -0,0 +1,73 @@ +#ifndef _DOLPHIN_GD_LIGHT_H_ +#define _DOLPHIN_GD_LIGHT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define XF_LIGHT_ID 0x0600 +#define XF_LIGHT_COLOR_ID 0x0603 +#define XF_LIGHT_ATTN_ID 0x0604 +#define XF_LIGHT_DISTATTN_ID 0x0607 +#define XF_LIGHT_POS_ID 0x060A +#define XF_LIGHT_SPEC_DIR_ID 0x060A +#define XF_LIGHT_DIR_ID 0x060D + +#define XF_REG_AMBIENT0_ID 0x100A +#define XF_REG_AMBIENT1_ID 0x100B +#define XF_REG_MATERIAL0_ID 0x100C +#define XF_REG_MATERIAL1_ID 0x100D +#define XF_REG_COLOR0CNTRL_ID 0x100E +#define XF_REG_COLOR1CNTRL_ID 0x100F +#define XF_REG_ALPHA0CNTRL_ID 0x1010 +#define XF_REG_ALPHA1CNTRL_ID 0x1011 + +#define XF_REG_CHAN_CTRL(matsrc, enable, lightmask0, ambsrc, diff_fn, p5, p6, lightmask4) \ + ( \ + (u32)(matsrc) << 0 | \ + (u32)(enable) << 1 | \ + (u32)(lightmask0) << 2 | \ + (u32)(ambsrc) << 6 | \ + (u32)(diff_fn) << 7 | \ + (u32)(p5) << 9 | \ + (u32)(p6) << 10 | \ + (u32)(lightmask4) << 11 \ + ) + +void GDSetLightAttn(GXLightID light, f32 a0, f32 a1, f32 a2, f32 k0, f32 k1, f32 k2); +void GDSetLightSpot(GXLightID light, f32 cutoff, GXSpotFn spot_func); +void GDSetLightDistAttn(GXLightID light, f32 ref_dist, f32 ref_br, GXDistAttnFn dist_func); +void GDSetLightColor(GXLightID light, GXColor color); +void GDSetLightPos(GXLightID light, f32 x, f32 y, f32 z); +void GDSetLightDir(GXLightID light, f32 nx, f32 ny, f32 nz); +void GDSetSpecularDirHA(GXLightID light, f32 nx, f32 ny, f32 nz, f32 hx, f32 hy, f32 hz); +void GDSetSpecularDir(GXLightID light, f32 nx, f32 ny, f32 nz); +void GDLoadLightObjIndx(u32 lt_obj_indx, GXLightID light); +void GDSetChanAmbColor(GXChannelID chan, GXColor color); +void GDSetChanMatColor(GXChannelID chan, GXColor color); +void GDSetChanCtrl(GXChannelID chan, u8 enable, GXColorSrc amb_src, + GXColorSrc mat_src, u32 light_mask, GXDiffuseFn diff_fn, + GXAttnFn attn_fn); + +inline static u16 __GDLightID2Index(GXLightID id) { + u16 idx; + + idx = 0x1F - __cntlzw(id); + if (idx > 7) { + idx = 0; + } + return idx; +} + +inline static u16 __GDLightID2Offset(GXLightID id) { + return __GDLightID2Index(id) * 16; +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDPixel.h b/include/dolphin/gd/GDPixel.h new file mode 100644 index 000000000..158b04ec1 --- /dev/null +++ b/include/dolphin/gd/GDPixel.h @@ -0,0 +1,95 @@ +#ifndef _DOLPHIN_GD_PIXEL_H +#define _DOLPHIN_GD_PIXEL_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define BP_FOG_UNK0(a, id) \ + ( \ + (u32)(a) << 0 | \ + (u32)(id) << 24 \ + ) + +#define BP_FOG_UNK1(b_m, id) \ + ( \ + (u32)(b_m) << 0 | \ + (u32)(id) << 24 \ + ) + +#define BP_FOG_UNK2(b_expn, id) \ + ( \ + (u32)(b_expn) << 0 | \ + (u32)(id) << 24 \ + ) + +#define BP_FOG_UNK3(c, proj, fsel, id) \ + ( \ + (u32)(c) << 0 | \ + (u32)(proj) << 20 | \ + (u32)(fsel) << 21 | \ + (u32)(id) << 24 \ + ) + +#define BP_FOG_COLOR(r, g, b, id) \ + ( \ + (u32)(b) << 0 | \ + (u32)(g) << 8 | \ + (u32)(r) << 16 | \ + (u32)(id) << 24 \ + ) + +#define BP_BLEND_MODE(enable, enable_logic, enable_dither, enable_color_update, enable_alpha_update, dst_factor, src_factor, blend_sub, logic_op, id) \ + ( \ + (u32)(enable) << 0 | \ + (u32)(enable_logic) << 1 | \ + (u32)(enable_dither) << 2 | \ + (u32)(enable_color_update) << 3 | \ + (u32)(enable_alpha_update) << 4 | \ + (u32)(dst_factor) << 5 | \ + (u32)(src_factor) << 8 | \ + (u32)(blend_sub) << 11 | \ + (u32)(logic_op) << 12 | \ + (u32)(id) << 24 \ + ) + +#define BP_Z_MODE(enable_compare, compare_fn, enable_update, id) \ + ( \ + (u32)(enable_compare) << 0 | \ + (u32)(compare_fn) << 1 | \ + (u32)(enable_update) << 4 | \ + (u32)(id) << 24 \ + ) + +#define BP_DST_ALPHA(alpha, enable, id) \ + ( \ + (u32)(alpha) << 0 | \ + (u32)(enable) << 8 | \ + (u32)(id) << 24 \ + ) + +#define BP_TOKEN(token, id) \ + ( \ + (u32)(token) << 0 | \ + (u32)(id) << 24 \ + ) + +void GDSetFog(GXFogType type, f32 startz, f32 endz, f32 nearz, f32 farz, GXColor color); +void GDSetBlendMode(GXBlendMode type, GXBlendFactor src_factor, GXBlendFactor dst_factor, GXLogicOp logic_op); +void GDSetBlendModeEtc(GXBlendMode type, GXBlendFactor src_factor, + GXBlendFactor dst_factor, GXLogicOp logic_op, + u8 color_update_enable, + u8 alpha_update_enable, + u8 dither_enable); +void GDSetZMode(u8 compare_enable, GXCompare func, u8 update_enable); +void GDSetDstAlpha(u8 enable, u8 alpha); +void GDSetDrawSync(u16 token); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDTev.h b/include/dolphin/gd/GDTev.h new file mode 100644 index 000000000..baec8b5e2 --- /dev/null +++ b/include/dolphin/gd/GDTev.h @@ -0,0 +1,133 @@ +#ifndef _DOLPHIN_GD_TEV_H +#define _DOLPHIN_GD_TEV_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define BP_TEV_COLOR(d, c, b, a, bias, op, clamp, scale, out, id) \ + ( \ + (u32)(d) << 0 | \ + (u32)(c) << 4 | \ + (u32)(b) << 8 | \ + (u32)(a) << 12 | \ + (u32)(bias) << 16 | \ + (u32)(op) << 18 | \ + (u32)(clamp) << 19 | \ + (u32)(scale) << 20 | \ + (u32)(out) << 22 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEV_ALPHA(ras_sel, tex_sel, d, c, b, a, bias, op, clamp, scale, out, id) \ + ( \ + (u32)(ras_sel) << 0 | \ + (u32)(tex_sel) << 2 | \ + (u32)(d) << 4 | \ + (u32)(c) << 7 | \ + (u32)(b) << 10 | \ + (u32)(a) << 13 | \ + (u32)(bias) << 16 | \ + (u32)(op) << 18 | \ + (u32)(clamp) << 19 | \ + (u32)(scale) << 20 | \ + (u32)(out) << 22 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEV_COLOR_REG_RA(r, a, reg, id) \ + ( \ + (u32)(r) << 0 | \ + (u32)(a) << 12 | \ + (u32)(reg) << 23 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEV_COLOR_REG_BG(b, g, reg, id) \ + ( \ + (u32)(b) << 0 | \ + (u32)(g) << 12 | \ + (u32)(reg) << 23 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEV_KSEL(rb, ga, kcsel0, kasel0, kcsel1, kasel1, id) \ + ( \ + (u32)(rb) << 0 | \ + (u32)(ga) << 2 | \ + (u32)(kcsel0) << 4 | \ + (u32)(kasel0) << 9 | \ + (u32)(kcsel1) << 14 | \ + (u32)(kasel1) << 19 | \ + (u32)(id) << 24 \ + ) + +#define BP_ALPHA_COMPARE(ref0, ref1, comp0, comp1, op, id) \ + ( \ + (u32)(ref0) << 0 | \ + (u32)(ref1) << 8 | \ + (u32)(comp0) << 16 | \ + (u32)(comp1) << 19 | \ + (u32)(op) << 22 | \ + (u32)(id) << 24 \ + ) + +#define BP_ZTEX_PARAMS_0(bias, id) \ + ( \ + (u32)(bias) << 0 | \ + (u32)(id) << 24 \ + ) + +#define BP_ZTEX_PARAMS_1(zfmt, op, id) \ + ( \ + (u32)(zfmt) << 0 | \ + (u32)(op) << 2 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEV_ORDER(map0, coord0, enable0, color0, map1, coord1, enable1, color1, id) \ + ( \ + (u32)(map0) << 0 | \ + (u32)(coord0) << 3 | \ + (u32)(enable0) << 6 | \ + (u32)(color0) << 7 | \ + (u32)(map1) << 12 | \ + (u32)(coord1) << 15 | \ + (u32)(enable1) << 18 | \ + (u32)(color1) << 19 | \ + (u32)(id) << 24 \ + ) + +void GDSetTevOp(GXTevStageID stage, GXTevMode mode); +void GDSetTevColorCalc(GXTevStageID stage, GXTevColorArg a, GXTevColorArg b, + GXTevColorArg c, GXTevColorArg d, GXTevOp op, + GXTevBias bias, GXTevScale scale, u8 clamp, + GXTevRegID out_reg); +void GDSetTevAlphaCalcAndSwap(GXTevStageID stage, GXTevAlphaArg a, + GXTevAlphaArg b, GXTevAlphaArg c, GXTevAlphaArg d, + GXTevOp op, GXTevBias bias, GXTevScale scale, + u8 clamp, GXTevRegID out_reg, + GXTevSwapSel ras_sel, GXTevSwapSel tex_sel); +void GDSetTevColor(GXTevRegID reg, GXColor color); +void GDSetTevColorS10(GXTevRegID reg, GXColorS10 color); +void GDSetTevKColor(GXTevKColorID reg, GXColor color); +void GDSetTevKonstantSel(GXTevStageID evenStage, GXTevKColorSel kcsel0, + GXTevKAlphaSel kasel0, GXTevKColorSel kcsel1, + GXTevKAlphaSel kasel1); +void GDSetTevSwapModeTable(GXTevSwapSel table, GXTevColorChan red, + GXTevColorChan green, GXTevColorChan blue, + GXTevColorChan alpha); +void GDSetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp1, u8 ref1); +void GDSetZTexture(GXZTexOp op, GXTexFmt fmt, u32 bias); +void GDSetTevOrder(GXTevStageID evenStage, GXTexCoordID coord0, GXTexMapID map0, + GXChannelID color0, GXTexCoordID coord1, GXTexMapID map1, + GXChannelID color1); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDTexture.h b/include/dolphin/gd/GDTexture.h new file mode 100644 index 000000000..2370cbb52 --- /dev/null +++ b/include/dolphin/gd/GDTexture.h @@ -0,0 +1,127 @@ +#ifndef _DOLPHIN_GD_TEXTURE_H +#define _DOLPHIN_GD_TEXTURE_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define BP_TEX_MODE0(wrap_s, wrap_t, mag_filt, min_filt, edge_lod, lod_bias, max_aniso, bias_clamp, id) \ + ( \ + (u32)(wrap_s) << 0 | \ + (u32)(wrap_t) << 2 | \ + (u32)(mag_filt) << 4 | \ + (u32)(min_filt) << 5 | \ + (u32)(edge_lod) << 8 | \ + (u32)(lod_bias) << 9 | \ + (u32)(max_aniso) << 19 | \ + (u32)(bias_clamp) << 21 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEX_MODE1(min_lod, max_lod, id) \ + ( \ + (u32)(min_lod) << 0 | \ + (u32)(max_lod) << 8 | \ + (u32)(id) << 24 \ + ) + +#define BP_IMAGE_ATTR(width, height, format, id) \ + ( \ + (u32)(width) << 0 | \ + (u32)(height) << 10 | \ + (u32)(format) << 20 | \ + (u32)(id) << 24 \ + ) + +#define BP_IMAGE_PTR(ptr, id) \ + ( \ + (u32)(ptr) << 0 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEX_CACHE_EVEN(tmem, size0, size1, type, id) \ + ( \ + (u32)(tmem) << 0 | \ + (u32)(size0) << 15 | \ + (u32)(size1) << 18 | \ + (u32)(type) << 21 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEX_CACHE_ODD(tmem, size0, size1, id) \ + ( \ + (u32)(tmem) << 0 | \ + (u32)(size0) << 15 | \ + (u32)(size1) << 18 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEX_TLUT(tmem, format, id) \ + ( \ + (u32)(tmem) << 0 | \ + (u32)(format) << 10 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEXCOORD_S_SCALE(s_scale, s_bias, s_wrap, line_offset, point_offset, id) \ + ( \ + (u32)(s_scale) << 0 | \ + (u32)(s_bias) << 16 | \ + (u32)(s_wrap) << 17 | \ + (u32)(line_offset) << 18 | \ + (u32)(point_offset) << 19 | \ + (u32)(id) << 24 \ + ) + +#define BP_TEXCOORD_T_SCALE(t_scale, t_bias, t_wrap, id) \ + ( \ + (u32)(t_scale) << 0 | \ + (u32)(t_bias) << 16 | \ + (u32)(t_wrap) << 17 | \ + (u32)(id) << 24 \ + ) + +#define BP_LOAD_TLUT0(ptr, id) \ + ( \ + (u32)(ptr) << 0 | \ + (u32)(id) << 24 \ + ) + +#define BP_LOAD_TLUT1(ptr, size, id) \ + ( \ + (u32)(ptr) << 0 | \ + (u32)(size) << 10 | \ + (u32)(id) << 24 \ + ) + +void GDSetTexLookupMode(GXTexMapID id, GXTexWrapMode wrap_s, + GXTexWrapMode wrap_t, GXTexFilter min_filt, + GXTexFilter mag_filt, f32 min_lod, f32 max_lod, + f32 lod_bias, u8 bias_clamp, u8 do_edge_lod, + GXAnisotropy max_aniso); + +void GDSetTexImgAttr(GXTexMapID id, u16 width, u16 height, GXTexFmt format); +void GDSetTexImgPtr(GXTexMapID id, void* image_ptr); +void GDSetTexImgPtrRaw(GXTexMapID id, u32 image_ptr_raw); +void GDPatchTexImgPtr(void* image_ptr); +void GDSetTexCached(GXTexMapID id, u32 tmem_even, GXTexCacheSize size_even, + u32 tmem_odd, GXTexCacheSize size_odd); +void GDSetTexPreLoaded(GXTexMapID id, u32 tmem_even, u32 tmem_odd); +void GDSetTexTlut(GXTexMapID id, u32 tmem_addr, GXTlutFmt format); +void GDSetTexCoordScale(GXTexCoordID coord, u16 s_scale, u16 t_scale); +void GDSetTexCoordScale2(GXTexCoordID coord, u16 s_scale, u8 s_bias, + u8 s_wrap, u16 t_scale, u8 t_bias, u8 t_wrap); +void GDSetTexCoordScaleAndTOEs(GXTexCoordID coord, u16 s_scale, u8 s_bias, + u8 s_wrap, u16 t_scale, u8 t_bias, u8 t_wrap, + u8 line_offset, u8 point_offset); +void GDLoadTlut(void* tlut_ptr, u32 tmem_addr, GXTlutSize size); +void GDLoadTlutRaw(u32 tlut_ptr_raw, u32 tmem_addr, GXTlutSize size); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gd/GDTransform.h b/include/dolphin/gd/GDTransform.h new file mode 100644 index 000000000..8d0159fdb --- /dev/null +++ b/include/dolphin/gd/GDTransform.h @@ -0,0 +1,56 @@ +#ifndef _DOLPHIN_GD_TRANSFORM_H_ +#define _DOLPHIN_GD_TRANSFORM_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define CP_MTX_REG_A_ID 0x30 +#define CP_MTX_REG_B_ID 0x40 + +#define XF_REG_MATRIXINDEX0_ID 0x1018 +#define XF_REG_MATRIXINDEX1_ID 0x1019 +#define XF_REG_PROJECTIONA_ID 0x1020 +#define XF_REG_PROJECTIONB_ID 0x1021 +#define XF_REG_PROJECTIONC_ID 0x1022 +#define XF_REG_PROJECTIOND_ID 0x1023 +#define XF_REG_PROJECTIONE_ID 0x1024 +#define XF_REG_PROJECTIONF_ID 0x1025 +#define XF_REG_PROJECTORTHO_ID 0x1026 + +#define CP_MTX_REG_A(pn, t0, t1, t2, t3) \ + ( \ + (u32)(pn) << 0 | \ + (u32)(t0) << 6 | \ + (u32)(t1) << 12 | \ + (u32)(t2) << 18 | \ + (u32)(t3) << 24 \ + ) + +#define CP_MTX_REG_B(t4, t5, t6, t7) \ + ( \ + (u32)(t4) << 0 | \ + (u32)(t5) << 6 | \ + (u32)(t6) << 12 | \ + (u32)(t7) << 18 \ + ) + +void GDLoadPosMtxImm(const Mtx mtx, u32 id); +void GDLoadPosMtxIndx(u16 mtx_indx, u32 id); +void GDLoadNrmMtxImm(const Mtx mtx, u32 id); +void GDLoadNrmMtxImm3x3(const f32 mtx[3][3], u32 id); +void GDLoadNrmMtxIndx3x3(u16 mtx_indx, u32 id); +void GDLoadTexMtxImm(const Mtx mtx, u32 id, GXTexMtxType type); +void GDLoadTexMtxIndx(u16 mtx_indx, u32 id, GXTexMtxType type); +void GDSetCurrentMtx(u32 pn, u32 t0, u32 t1, u32 t2, u32 t3, u32 t4, u32 t5, u32 t6, u32 t7); +void GDSetProjection(const Mtx44 mtx, GXProjectionType type); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx.h b/include/dolphin/gx.h new file mode 100644 index 000000000..0e90e543e --- /dev/null +++ b/include/dolphin/gx.h @@ -0,0 +1,40 @@ +#ifndef _DOLPHIN_GX_H_ +#define _DOLPHIN_GX_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// unsorted GX externs + +#ifdef __cplusplus +extern "C" { +#endif + +// GXMisc +void (*GXSetDrawSyncCallback(void (*cb)(u16)))(u16); +void GXSetDrawSync(u16 token); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXBump.h b/include/dolphin/gx/GXBump.h new file mode 100644 index 000000000..2a24dc69f --- /dev/null +++ b/include/dolphin/gx/GXBump.h @@ -0,0 +1,29 @@ +#ifndef _DOLPHIN_GX_GXBUMP_H_ +#define _DOLPHIN_GX_GXBUMP_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetTevIndirect(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXIndTexFormat format, GXIndTexBiasSel bias_sel, GXIndTexMtxID matrix_sel, GXIndTexWrap wrap_s, GXIndTexWrap wrap_t, GXBool add_prev, GXBool utc_lod, GXIndTexAlphaSel alpha_sel); +void GXSetIndTexMtx(GXIndTexMtxID mtx_id, const f32 offset[2][3], s8 scale_exp); +void GXSetIndTexCoordScale(GXIndTexStageID ind_state, GXIndTexScale scale_s, GXIndTexScale scale_t); +void GXSetIndTexOrder(GXIndTexStageID ind_stage, GXTexCoordID tex_coord, GXTexMapID tex_map); +void GXSetNumIndStages(u8 nIndStages); +void GXSetTevDirect(GXTevStageID tev_stage); +void GXSetTevIndWarp(GXTevStageID tev_stage, GXIndTexStageID ind_stage, u8 signed_offset, u8 replace_mode, GXIndTexMtxID matrix_sel); +void GXSetTevIndTile(GXTevStageID tev_stage, GXIndTexStageID ind_stage, u16 tilesize_s, + u16 tilesize_t, u16 tilespacing_s, u16 tilespacing_t, GXIndTexFormat format, + GXIndTexMtxID matrix_sel, GXIndTexBiasSel bias_sel, GXIndTexAlphaSel alpha_sel); +void GXSetTevIndBumpST(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXIndTexMtxID matrix_sel); +void GXSetTevIndBumpXYZ(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXIndTexMtxID matrix_sel); +void GXSetTevIndRepeat(GXTevStageID tev_stage); +void __GXSetIndirectMask(u32 mask); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXCommandList.h b/include/dolphin/gx/GXCommandList.h new file mode 100644 index 000000000..9adae3cb7 --- /dev/null +++ b/include/dolphin/gx/GXCommandList.h @@ -0,0 +1,37 @@ +#ifndef _DOLPHIN_GX_GXCOMMANDLIST_H_ +#define _DOLPHIN_GX_GXCOMMANDLIST_H_ + +#include + +#define GX_NOP 0x00 +#define GX_LOAD_CP_REG 0x08 +#define GX_LOAD_XF_REG 0x10 +#define GX_LOAD_INDX_A 0x20 +#define GX_LOAD_INDX_B 0x28 +#define GX_LOAD_INDX_C 0x30 +#define GX_LOAD_INDX_D 0x38 +#define GX_LOAD_BP_REG 0x61 + +#define GX_DRAW_QUADS 0x80 +#define GX_DRAW_TRIANGLES 0x90 +#define GX_DRAW_TRIANGLE_STRIP 0x98 +#define GX_DRAW_TRIANGLE_FAN 0xA0 +#define GX_DRAW_LINES 0xA8 +#define GX_DRAW_LINE_STRIP 0xB0 +#define GX_DRAW_POINTS 0xB8 + +#define GX_CMD_CALL_DL 0x40 +#define GX_CMD_INVAL_VTX 0x48 + +#define GX_OPCODE_MASK 0xF8 +#define GX_VAT_MASK 0x07 + +extern u8 GXTexMode0Ids[8]; +extern u8 GXTexMode1Ids[8]; +extern u8 GXTexImage0Ids[8]; +extern u8 GXTexImage1Ids[8]; +extern u8 GXTexImage2Ids[8]; +extern u8 GXTexImage3Ids[8]; +extern u8 GXTexTlutIds[8]; + +#endif diff --git a/include/dolphin/gx/GXCpu2Efb.h b/include/dolphin/gx/GXCpu2Efb.h new file mode 100644 index 000000000..46aa3e336 --- /dev/null +++ b/include/dolphin/gx/GXCpu2Efb.h @@ -0,0 +1,29 @@ +#ifndef _DOLPHIN_GX_GXCPU2EFB_H_ +#define _DOLPHIN_GX_GXCPU2EFB_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXPokeAlphaMode(GXCompare func, u8 threshold); +void GXPokeAlphaRead(GXAlphaReadMode mode); +void GXPokeAlphaUpdate(GXBool update_enable); +void GXPokeBlendMode(GXBlendMode type, GXBlendFactor src_factor, GXBlendFactor dst_factor, GXLogicOp op); +void GXPokeColorUpdate(GXBool update_enable); +void GXPokeDstAlpha(GXBool enable, u8 alpha); +void GXPokeDither(GXBool dither); +void GXPokeZMode(GXBool compare_enable, GXCompare func, GXBool update_enable); +void GXPeekARGB(u16 x, u16 y, u32* color); +void GXPokeARGB(u16 x, u16 y, u32 color); +void GXPeekZ(u16 x, u16 y, u32* z); +void GXPokeZ(u16 x, u16 y, u32 z); +u32 GXCompressZ16(u32 z24, GXZFmt16 zfmt); +u32 GXDecompressZ16(u32 z16, GXZFmt16 zfmt); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXCull.h b/include/dolphin/gx/GXCull.h new file mode 100644 index 000000000..cac438181 --- /dev/null +++ b/include/dolphin/gx/GXCull.h @@ -0,0 +1,18 @@ +#ifndef _DOLPHIN_GX_GXCULL_H_ +#define _DOLPHIN_GX_GXCULL_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetScissor(u32 left, u32 top, u32 wd, u32 ht); +void GXSetCullMode(GXCullMode mode); +void GXSetCoPlanar(GXBool enable); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXDispList.h b/include/dolphin/gx/GXDispList.h new file mode 100644 index 000000000..357fb8f7e --- /dev/null +++ b/include/dolphin/gx/GXDispList.h @@ -0,0 +1,18 @@ +#ifndef _DOLPHIN_GX_GXDISPLIST_H_ +#define _DOLPHIN_GX_GXDISPLIST_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXBeginDisplayList(void* list, u32 size); +u32 GXEndDisplayList(void); +void GXCallDisplayList(void* list, u32 nbytes); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXDraw.h b/include/dolphin/gx/GXDraw.h new file mode 100644 index 000000000..c8e779345 --- /dev/null +++ b/include/dolphin/gx/GXDraw.h @@ -0,0 +1,24 @@ +#ifndef _DOLPHIN_GX_GXDRAW_H_ +#define _DOLPHIN_GX_GXDRAW_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXDrawCylinder(u8 numEdges); +void GXDrawTorus(f32 rc, u8 numc, u8 numt); +void GXDrawSphere(u8 numMajor, u8 numMinor); +void GXDrawCube(void); +void GXDrawDodeca(void); +void GXDrawOctahedron(void); +void GXDrawIcosahedron(void); +void GXDrawSphere1(u8 depth); +u32 GXGenNormalTable(u8 depth, f32* table); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXEnum.h b/include/dolphin/gx/GXEnum.h new file mode 100644 index 000000000..db4ea87d2 --- /dev/null +++ b/include/dolphin/gx/GXEnum.h @@ -0,0 +1,900 @@ +#ifndef _DOLPHIN_GX_GXENUM_H_ +#define _DOLPHIN_GX_GXENUM_H_ + +#include + +typedef u8 GXBool; + +#define GX_FALSE ((GXBool)0) +#define GX_TRUE ((GXBool)1) + +#define GX_ENABLE ((GXBool)1) +#define GX_DISABLE ((GXBool)0) + +typedef enum _GXProjectionType { + GX_PERSPECTIVE, + GX_ORTHOGRAPHIC, +} GXProjectionType; + +typedef enum _GXCompare { + GX_NEVER, + GX_LESS, + GX_EQUAL, + GX_LEQUAL, + GX_GREATER, + GX_NEQUAL, + GX_GEQUAL, + GX_ALWAYS, +} GXCompare; + +typedef enum _GXAlphaOp { + GX_AOP_AND, + GX_AOP_OR, + GX_AOP_XOR, + GX_AOP_XNOR, + GX_MAX_ALPHAOP, +} GXAlphaOp; + +typedef enum _GXZFmt16 { + GX_ZC_LINEAR, + GX_ZC_NEAR, + GX_ZC_MID, + GX_ZC_FAR, +} GXZFmt16; + +typedef enum _GXGamma { + GX_GM_1_0, + GX_GM_1_7, + GX_GM_2_2, +} GXGamma; + +typedef enum _GXPixelFmt { + GX_PF_RGB8_Z24, + GX_PF_RGBA6_Z24, + GX_PF_RGB565_Z16, + GX_PF_Z24, + GX_PF_Y8, + GX_PF_U8, + GX_PF_V8, + GX_PF_YUV420, +} GXPixelFmt; + +typedef enum _GXPrimitive { + GX_QUADS = 0x80, + GX_TRIANGLES = 0x90, + GX_TRIANGLESTRIP = 0x98, + GX_TRIANGLEFAN = 0xA0, + GX_LINES = 0xA8, + GX_LINESTRIP = 0xB0, + GX_POINTS = 0xB8, +} GXPrimitive; + +typedef enum _GXVtxFmt { + GX_VTXFMT0, + GX_VTXFMT1, + GX_VTXFMT2, + GX_VTXFMT3, + GX_VTXFMT4, + GX_VTXFMT5, + GX_VTXFMT6, + GX_VTXFMT7, + GX_MAX_VTXFMT, +} GXVtxFmt; + +typedef enum _GXAttr { + GX_VA_PNMTXIDX, + GX_VA_TEX0MTXIDX, + GX_VA_TEX1MTXIDX, + GX_VA_TEX2MTXIDX, + GX_VA_TEX3MTXIDX, + GX_VA_TEX4MTXIDX, + GX_VA_TEX5MTXIDX, + GX_VA_TEX6MTXIDX, + GX_VA_TEX7MTXIDX, + GX_VA_POS, + GX_VA_NRM, + GX_VA_CLR0, + GX_VA_CLR1, + GX_VA_TEX0, + GX_VA_TEX1, + GX_VA_TEX2, + GX_VA_TEX3, + GX_VA_TEX4, + GX_VA_TEX5, + GX_VA_TEX6, + GX_VA_TEX7, + GX_POS_MTX_ARRAY, + GX_NRM_MTX_ARRAY, + GX_TEX_MTX_ARRAY, + GX_LIGHT_ARRAY, + GX_VA_NBT, + GX_VA_MAX_ATTR, + GX_VA_NULL = 0xFF, +} GXAttr; + +typedef enum _GXAttrType { + GX_NONE, + GX_DIRECT, + GX_INDEX8, + GX_INDEX16, +} GXAttrType; + +#define _GX_TF_CTF 0x20 +#define _GX_TF_ZTF 0x10 + +typedef enum _GXTexFmt { + GX_TF_I4 = 0x0, + GX_TF_I8 = 0x1, + GX_TF_IA4 = 0x2, + GX_TF_IA8 = 0x3, + GX_TF_RGB565 = 0x4, + GX_TF_RGB5A3 = 0x5, + GX_TF_RGBA8 = 0x6, + GX_TF_CMPR = 0xE, + + GX_CTF_R4 = 0x0 | _GX_TF_CTF, + GX_CTF_RA4 = 0x2 | _GX_TF_CTF, + GX_CTF_RA8 = 0x3 | _GX_TF_CTF, + GX_CTF_YUVA8 = 0x6 | _GX_TF_CTF, + GX_CTF_A8 = 0x7 | _GX_TF_CTF, + GX_CTF_R8 = 0x8 | _GX_TF_CTF, + GX_CTF_G8 = 0x9 | _GX_TF_CTF, + GX_CTF_B8 = 0xA | _GX_TF_CTF, + GX_CTF_RG8 = 0xB | _GX_TF_CTF, + GX_CTF_GB8 = 0xC | _GX_TF_CTF, + + GX_TF_Z8 = 0x1 | _GX_TF_ZTF, + GX_TF_Z16 = 0x3 | _GX_TF_ZTF, + GX_TF_Z24X8 = 0x6 | _GX_TF_ZTF, + + GX_CTF_Z4 = 0x0 | _GX_TF_ZTF | _GX_TF_CTF, + GX_CTF_Z8M = 0x9 | _GX_TF_ZTF | _GX_TF_CTF, + GX_CTF_Z8L = 0xA | _GX_TF_ZTF | _GX_TF_CTF, + GX_CTF_Z16L = 0xC | _GX_TF_ZTF | _GX_TF_CTF, + + GX_TF_A8 = GX_CTF_A8, +} GXTexFmt; + +typedef enum _GXCITexFmt { + GX_TF_C4 = 0x8, + GX_TF_C8 = 0x9, + GX_TF_C14X2 = 0xA, +} GXCITexFmt; + +typedef enum _GXTexWrapMode { + GX_CLAMP, + GX_REPEAT, + GX_MIRROR, + GX_MAX_TEXWRAPMODE, +} GXTexWrapMode; + +typedef enum _GXTexFilter { + GX_NEAR, + GX_LINEAR, + GX_NEAR_MIP_NEAR, + GX_LIN_MIP_NEAR, + GX_NEAR_MIP_LIN, + GX_LIN_MIP_LIN, +} GXTexFilter; + +typedef enum _GXAnisotropy { + GX_ANISO_1, + GX_ANISO_2, + GX_ANISO_4, + GX_MAX_ANISOTROPY, +} GXAnisotropy; + +typedef enum _GXTexMapID { + GX_TEXMAP0, + GX_TEXMAP1, + GX_TEXMAP2, + GX_TEXMAP3, + GX_TEXMAP4, + GX_TEXMAP5, + GX_TEXMAP6, + GX_TEXMAP7, + GX_MAX_TEXMAP, + GX_TEXMAP_NULL = 0xFF, + GX_TEX_DISABLE = 0x100, +} GXTexMapID; + +typedef enum _GXTexCoordID { + GX_TEXCOORD0, + GX_TEXCOORD1, + GX_TEXCOORD2, + GX_TEXCOORD3, + GX_TEXCOORD4, + GX_TEXCOORD5, + GX_TEXCOORD6, + GX_TEXCOORD7, + GX_MAX_TEXCOORD, + GX_TEXCOORD_NULL = 0xFF, +} GXTexCoordID; + +typedef enum _GXTevStageID { + GX_TEVSTAGE0, + GX_TEVSTAGE1, + GX_TEVSTAGE2, + GX_TEVSTAGE3, + GX_TEVSTAGE4, + GX_TEVSTAGE5, + GX_TEVSTAGE6, + GX_TEVSTAGE7, + GX_TEVSTAGE8, + GX_TEVSTAGE9, + GX_TEVSTAGE10, + GX_TEVSTAGE11, + GX_TEVSTAGE12, + GX_TEVSTAGE13, + GX_TEVSTAGE14, + GX_TEVSTAGE15, + GX_MAX_TEVSTAGE, +} GXTevStageID; + +typedef enum _GXTevMode { + GX_MODULATE, + GX_DECAL, + GX_BLEND, + GX_REPLACE, + GX_PASSCLR, +} GXTevMode; + +typedef enum _GXTexMtxType { + GX_MTX3x4, + GX_MTX2x4, +} GXTexMtxType; + +typedef enum _GXTexGenType { + GX_TG_MTX3x4, + GX_TG_MTX2x4, + GX_TG_BUMP0, + GX_TG_BUMP1, + GX_TG_BUMP2, + GX_TG_BUMP3, + GX_TG_BUMP4, + GX_TG_BUMP5, + GX_TG_BUMP6, + GX_TG_BUMP7, + GX_TG_SRTG, +} GXTexGenType; + +typedef enum _GXPosNrmMtx { + GX_PNMTX0 = 0, + GX_PNMTX1 = 3, + GX_PNMTX2 = 6, + GX_PNMTX3 = 9, + GX_PNMTX4 = 12, + GX_PNMTX5 = 15, + GX_PNMTX6 = 18, + GX_PNMTX7 = 21, + GX_PNMTX8 = 24, + GX_PNMTX9 = 27, +} GXPosNrmMtx; + +typedef enum _GXTexMtx { + GX_TEXMTX0 = 30, + GX_TEXMTX1 = 33, + GX_TEXMTX2 = 36, + GX_TEXMTX3 = 39, + GX_TEXMTX4 = 42, + GX_TEXMTX5 = 45, + GX_TEXMTX6 = 48, + GX_TEXMTX7 = 51, + GX_TEXMTX8 = 54, + GX_TEXMTX9 = 57, + GX_IDENTITY = 60, +} GXTexMtx; + +typedef enum _GXChannelID { + GX_COLOR0, + GX_COLOR1, + GX_ALPHA0, + GX_ALPHA1, + GX_COLOR0A0, + GX_COLOR1A1, + GX_COLOR_ZERO, + GX_ALPHA_BUMP, + GX_ALPHA_BUMPN, + GX_COLOR_NULL = 0xFF, +} GXChannelID; + +typedef enum _GXTexGenSrc { + GX_TG_POS, + GX_TG_NRM, + GX_TG_BINRM, + GX_TG_TANGENT, + GX_TG_TEX0, + GX_TG_TEX1, + GX_TG_TEX2, + GX_TG_TEX3, + GX_TG_TEX4, + GX_TG_TEX5, + GX_TG_TEX6, + GX_TG_TEX7, + GX_TG_TEXCOORD0, + GX_TG_TEXCOORD1, + GX_TG_TEXCOORD2, + GX_TG_TEXCOORD3, + GX_TG_TEXCOORD4, + GX_TG_TEXCOORD5, + GX_TG_TEXCOORD6, + GX_TG_COLOR0, + GX_TG_COLOR1, +} GXTexGenSrc; + +typedef enum _GXBlendMode { + GX_BM_NONE, + GX_BM_BLEND, + GX_BM_LOGIC, + GX_BM_SUBTRACT, + GX_MAX_BLENDMODE, +} GXBlendMode; + +typedef enum _GXBlendFactor { + GX_BL_ZERO, + GX_BL_ONE, + GX_BL_SRCCLR, + GX_BL_INVSRCCLR, + GX_BL_SRCALPHA, + GX_BL_INVSRCALPHA, + GX_BL_DSTALPHA, + GX_BL_INVDSTALPHA, + GX_BL_DSTCLR = GX_BL_SRCCLR, + GX_BL_INVDSTCLR = GX_BL_INVSRCCLR, +} GXBlendFactor; + +typedef enum _GXLogicOp { + GX_LO_CLEAR, + GX_LO_AND, + GX_LO_REVAND, + GX_LO_COPY, + GX_LO_INVAND, + GX_LO_NOOP, + GX_LO_XOR, + GX_LO_OR, + GX_LO_NOR, + GX_LO_EQUIV, + GX_LO_INV, + GX_LO_REVOR, + GX_LO_INVCOPY, + GX_LO_INVOR, + GX_LO_NAND, + GX_LO_SET, +} GXLogicOp; + +typedef enum _GXCompCnt { + GX_POS_XY = 0, + GX_POS_XYZ = 1, + GX_NRM_XYZ = 0, + GX_NRM_NBT = 1, + GX_NRM_NBT3 = 2, + GX_CLR_RGB = 0, + GX_CLR_RGBA = 1, + GX_TEX_S = 0, + GX_TEX_ST = 1, +} GXCompCnt; + +typedef enum _GXCompType { + GX_U8 = 0, + GX_S8 = 1, + GX_U16 = 2, + GX_S16 = 3, + GX_F32 = 4, + GX_RGB565 = 0, + GX_RGB8 = 1, + GX_RGBX8 = 2, + GX_RGBA4 = 3, + GX_RGBA6 = 4, + GX_RGBA8 = 5, +} GXCompType; + +typedef enum _GXPTTexMtx { + GX_PTTEXMTX0 = 64, + GX_PTTEXMTX1 = 67, + GX_PTTEXMTX2 = 70, + GX_PTTEXMTX3 = 73, + GX_PTTEXMTX4 = 76, + GX_PTTEXMTX5 = 79, + GX_PTTEXMTX6 = 82, + GX_PTTEXMTX7 = 85, + GX_PTTEXMTX8 = 88, + GX_PTTEXMTX9 = 91, + GX_PTTEXMTX10 = 94, + GX_PTTEXMTX11 = 97, + GX_PTTEXMTX12 = 100, + GX_PTTEXMTX13 = 103, + GX_PTTEXMTX14 = 106, + GX_PTTEXMTX15 = 109, + GX_PTTEXMTX16 = 112, + GX_PTTEXMTX17 = 115, + GX_PTTEXMTX18 = 118, + GX_PTTEXMTX19 = 121, + GX_PTIDENTITY = 125, +} GXPTTexMtx; + +typedef enum _GXTevRegID { + GX_TEVPREV, + GX_TEVREG0, + GX_TEVREG1, + GX_TEVREG2, + GX_MAX_TEVREG, +} GXTevRegID; + +typedef enum _GXDiffuseFn { + GX_DF_NONE, + GX_DF_SIGN, + GX_DF_CLAMP, +} GXDiffuseFn; + +typedef enum _GXColorSrc { + GX_SRC_REG, + GX_SRC_VTX, +} GXColorSrc; + +typedef enum _GXAttnFn { + GX_AF_SPEC, + GX_AF_SPOT, + GX_AF_NONE, +} GXAttnFn; + +typedef enum _GXLightID { + GX_LIGHT0 = 0x001, + GX_LIGHT1 = 0x002, + GX_LIGHT2 = 0x004, + GX_LIGHT3 = 0x008, + GX_LIGHT4 = 0x010, + GX_LIGHT5 = 0x020, + GX_LIGHT6 = 0x040, + GX_LIGHT7 = 0x080, + GX_MAX_LIGHT = 0x100, + GX_LIGHT_NULL = 0, +} GXLightID; + +typedef enum _GXTexOffset { + GX_TO_ZERO, + GX_TO_SIXTEENTH, + GX_TO_EIGHTH, + GX_TO_FOURTH, + GX_TO_HALF, + GX_TO_ONE, + GX_MAX_TEXOFFSET, +} GXTexOffset; + +typedef enum _GXSpotFn { + GX_SP_OFF, + GX_SP_FLAT, + GX_SP_COS, + GX_SP_COS2, + GX_SP_SHARP, + GX_SP_RING1, + GX_SP_RING2, +} GXSpotFn; + +typedef enum _GXDistAttnFn { + GX_DA_OFF, + GX_DA_GENTLE, + GX_DA_MEDIUM, + GX_DA_STEEP, +} GXDistAttnFn; + +typedef enum _GXCullMode { + GX_CULL_NONE, + GX_CULL_FRONT, + GX_CULL_BACK, + GX_CULL_ALL +} GXCullMode; + +typedef enum _GXTevSwapSel { + GX_TEV_SWAP0 = 0, + GX_TEV_SWAP1, + GX_TEV_SWAP2, + GX_TEV_SWAP3, + GX_MAX_TEVSWAP +} GXTevSwapSel; + +typedef enum _GXTevColorChan { + GX_CH_RED = 0, + GX_CH_GREEN, + GX_CH_BLUE, + GX_CH_ALPHA +} GXTevColorChan; + +typedef enum _GXFogType { + GX_FOG_NONE = 0, + GX_FOG_PERSP_LIN = 2, + GX_FOG_PERSP_EXP = 4, + GX_FOG_PERSP_EXP2 = 5, + GX_FOG_PERSP_REVEXP = 6, + GX_FOG_PERSP_REVEXP2 = 7, + GX_FOG_ORTHO_LIN = 10, + GX_FOG_ORTHO_EXP = 12, + GX_FOG_ORTHO_EXP2 = 13, + GX_FOG_ORTHO_REVEXP = 14, + GX_FOG_ORTHO_REVEXP2 = 15, + GX_FOG_LIN = 2, + GX_FOG_EXP = 4, + GX_FOG_EXP2 = 5, + GX_FOG_REVEXP = 6, + GX_FOG_REVEXP2 = 7, +} GXFogType; + +typedef enum _GXTevColorArg { + GX_CC_CPREV = 0, + GX_CC_APREV = 1, + GX_CC_C0 = 2, + GX_CC_A0 = 3, + GX_CC_C1 = 4, + GX_CC_A1 = 5, + GX_CC_C2 = 6, + GX_CC_A2 = 7, + GX_CC_TEXC = 8, + GX_CC_TEXA = 9, + GX_CC_RASC = 10, + GX_CC_RASA = 11, + GX_CC_ONE = 12, + GX_CC_HALF = 13, + GX_CC_KONST = 14, + GX_CC_ZERO = 15, + GX_CC_TEXRRR = 16, + GX_CC_TEXGGG = 17, + GX_CC_TEXBBB = 18, + GX_CC_QUARTER = 14, +} GXTevColorArg; + +typedef enum _GXTevAlphaArg { + GX_CA_APREV = 0, + GX_CA_A0 = 1, + GX_CA_A1 = 2, + GX_CA_A2 = 3, + GX_CA_TEXA = 4, + GX_CA_RASA = 5, + GX_CA_KONST = 6, + GX_CA_ZERO = 7, + GX_CA_ONE = 6, +} GXTevAlphaArg; + +typedef enum _GXTevOp { + GX_TEV_ADD = 0, + GX_TEV_SUB = 1, + GX_TEV_COMP_R8_GT = 8, + GX_TEV_COMP_R8_EQ = 9, + GX_TEV_COMP_GR16_GT = 10, + GX_TEV_COMP_GR16_EQ = 11, + GX_TEV_COMP_BGR24_GT = 12, + GX_TEV_COMP_BGR24_EQ = 13, + GX_TEV_COMP_RGB8_GT = 14, + GX_TEV_COMP_RGB8_EQ = 15, + GX_TEV_COMP_A8_GT = GX_TEV_COMP_RGB8_GT, + GX_TEV_COMP_A8_EQ = GX_TEV_COMP_RGB8_EQ +} GXTevOp; + +typedef enum _GXTevBias { + GX_TB_ZERO, + GX_TB_ADDHALF, + GX_TB_SUBHALF, + GX_MAX_TEVBIAS +} GXTevBias; + +typedef enum _GXTevScale { + GX_CS_SCALE_1, + GX_CS_SCALE_2, + GX_CS_SCALE_4, + GX_CS_DIVIDE_2, + GX_MAX_TEVSCALE +} GXTevScale; + +typedef enum _GXTevKColorSel { + GX_TEV_KCSEL_1 = 0x00, + GX_TEV_KCSEL_7_8 = 0x01, + GX_TEV_KCSEL_3_4 = 0x02, + GX_TEV_KCSEL_5_8 = 0x03, + GX_TEV_KCSEL_1_2 = 0x04, + GX_TEV_KCSEL_3_8 = 0x05, + GX_TEV_KCSEL_1_4 = 0x06, + GX_TEV_KCSEL_1_8 = 0x07, + GX_TEV_KCSEL_K0 = 0x0C, + GX_TEV_KCSEL_K1 = 0x0D, + GX_TEV_KCSEL_K2 = 0x0E, + GX_TEV_KCSEL_K3 = 0x0F, + GX_TEV_KCSEL_K0_R = 0x10, + GX_TEV_KCSEL_K1_R = 0x11, + GX_TEV_KCSEL_K2_R = 0x12, + GX_TEV_KCSEL_K3_R = 0x13, + GX_TEV_KCSEL_K0_G = 0x14, + GX_TEV_KCSEL_K1_G = 0x15, + GX_TEV_KCSEL_K2_G = 0x16, + GX_TEV_KCSEL_K3_G = 0x17, + GX_TEV_KCSEL_K0_B = 0x18, + GX_TEV_KCSEL_K1_B = 0x19, + GX_TEV_KCSEL_K2_B = 0x1A, + GX_TEV_KCSEL_K3_B = 0x1B, + GX_TEV_KCSEL_K0_A = 0x1C, + GX_TEV_KCSEL_K1_A = 0x1D, + GX_TEV_KCSEL_K2_A = 0x1E, + GX_TEV_KCSEL_K3_A = 0x1F +} GXTevKColorSel; + +typedef enum _GXTevKAlphaSel { + GX_TEV_KASEL_1 = 0x00, + GX_TEV_KASEL_7_8 = 0x01, + GX_TEV_KASEL_3_4 = 0x02, + GX_TEV_KASEL_5_8 = 0x03, + GX_TEV_KASEL_1_2 = 0x04, + GX_TEV_KASEL_3_8 = 0x05, + GX_TEV_KASEL_1_4 = 0x06, + GX_TEV_KASEL_1_8 = 0x07, + GX_TEV_KASEL_K0_R = 0x10, + GX_TEV_KASEL_K1_R = 0x11, + GX_TEV_KASEL_K2_R = 0x12, + GX_TEV_KASEL_K3_R = 0x13, + GX_TEV_KASEL_K0_G = 0x14, + GX_TEV_KASEL_K1_G = 0x15, + GX_TEV_KASEL_K2_G = 0x16, + GX_TEV_KASEL_K3_G = 0x17, + GX_TEV_KASEL_K0_B = 0x18, + GX_TEV_KASEL_K1_B = 0x19, + GX_TEV_KASEL_K2_B = 0x1A, + GX_TEV_KASEL_K3_B = 0x1B, + GX_TEV_KASEL_K0_A = 0x1C, + GX_TEV_KASEL_K1_A = 0x1D, + GX_TEV_KASEL_K2_A = 0x1E, + GX_TEV_KASEL_K3_A = 0x1F +} GXTevKAlphaSel; + +typedef enum _GXTevKColorID { + GX_KCOLOR0 = 0, + GX_KCOLOR1, + GX_KCOLOR2, + GX_KCOLOR3, + GX_MAX_KCOLOR +} GXTevKColorID; + +typedef enum _GXZTexOp { + GX_ZT_DISABLE, + GX_ZT_ADD, + GX_ZT_REPLACE, + GX_MAX_ZTEXOP, +} GXZTexOp; + +typedef enum _GXIndTexFormat { + GX_ITF_8, + GX_ITF_5, + GX_ITF_4, + GX_ITF_3, + GX_MAX_ITFORMAT, +} GXIndTexFormat; + +typedef enum _GXIndTexBiasSel { + GX_ITB_NONE, + GX_ITB_S, + GX_ITB_T, + GX_ITB_ST, + GX_ITB_U, + GX_ITB_SU, + GX_ITB_TU, + GX_ITB_STU, + GX_MAX_ITBIAS, +} GXIndTexBiasSel; + +typedef enum _GXIndTexAlphaSel { + GX_ITBA_OFF, + GX_ITBA_S, + GX_ITBA_T, + GX_ITBA_U, + GX_MAX_ITBALPHA, +} GXIndTexAlphaSel; + +typedef enum _GXIndTexMtxID { + GX_ITM_OFF, + GX_ITM_0, + GX_ITM_1, + GX_ITM_2, + GX_ITM_S0 = 5, + GX_ITM_S1, + GX_ITM_S2, + GX_ITM_T0 = 9, + GX_ITM_T1, + GX_ITM_T2, +} GXIndTexMtxID; + +typedef enum _GXIndTexWrap { + GX_ITW_OFF, + GX_ITW_256, + GX_ITW_128, + GX_ITW_64, + GX_ITW_32, + GX_ITW_16, + GX_ITW_0, + GX_MAX_ITWRAP, +} GXIndTexWrap; + +typedef enum _GXIndTexStageID { + GX_INDTEXSTAGE0, + GX_INDTEXSTAGE1, + GX_INDTEXSTAGE2, + GX_INDTEXSTAGE3, + GX_MAX_INDTEXSTAGE, +} GXIndTexStageID; + +typedef enum _GXIndTexScale { + GX_ITS_1, + GX_ITS_2, + GX_ITS_4, + GX_ITS_8, + GX_ITS_16, + GX_ITS_32, + GX_ITS_64, + GX_ITS_128, + GX_ITS_256, + GX_MAX_ITSCALE, +} GXIndTexScale; + +typedef enum _GXPerf0 { + GX_PERF0_VERTICES, + GX_PERF0_CLIP_VTX, + GX_PERF0_CLIP_CLKS, + GX_PERF0_XF_WAIT_IN, + GX_PERF0_XF_WAIT_OUT, + GX_PERF0_XF_XFRM_CLKS, + GX_PERF0_XF_LIT_CLKS, + GX_PERF0_XF_BOT_CLKS, + GX_PERF0_XF_REGLD_CLKS, + GX_PERF0_XF_REGRD_CLKS, + GX_PERF0_CLIP_RATIO, + + GX_PERF0_TRIANGLES, + GX_PERF0_TRIANGLES_CULLED, + GX_PERF0_TRIANGLES_PASSED, + GX_PERF0_TRIANGLES_SCISSORED, + GX_PERF0_TRIANGLES_0TEX, + GX_PERF0_TRIANGLES_1TEX, + GX_PERF0_TRIANGLES_2TEX, + GX_PERF0_TRIANGLES_3TEX, + GX_PERF0_TRIANGLES_4TEX, + GX_PERF0_TRIANGLES_5TEX, + GX_PERF0_TRIANGLES_6TEX, + GX_PERF0_TRIANGLES_7TEX, + GX_PERF0_TRIANGLES_8TEX, + GX_PERF0_TRIANGLES_0CLR, + GX_PERF0_TRIANGLES_1CLR, + GX_PERF0_TRIANGLES_2CLR, + + GX_PERF0_QUAD_0CVG, + GX_PERF0_QUAD_NON0CVG, + GX_PERF0_QUAD_1CVG, + GX_PERF0_QUAD_2CVG, + GX_PERF0_QUAD_3CVG, + GX_PERF0_QUAD_4CVG, + GX_PERF0_AVG_QUAD_CNT, + + GX_PERF0_CLOCKS, + GX_PERF0_NONE, +} GXPerf0; + +typedef enum _GXPerf1 { + GX_PERF1_TEXELS, + GX_PERF1_TX_IDLE, + GX_PERF1_TX_REGS, + GX_PERF1_TX_MEMSTALL, + GX_PERF1_TC_CHECK1_2, + GX_PERF1_TC_CHECK3_4, + GX_PERF1_TC_CHECK5_6, + GX_PERF1_TC_CHECK7_8, + GX_PERF1_TC_MISS, + + GX_PERF1_VC_ELEMQ_FULL, + GX_PERF1_VC_MISSQ_FULL, + GX_PERF1_VC_MEMREQ_FULL, + GX_PERF1_VC_STATUS7, + GX_PERF1_VC_MISSREP_FULL, + GX_PERF1_VC_STREAMBUF_LOW, + GX_PERF1_VC_ALL_STALLS, + GX_PERF1_VERTICES, + + GX_PERF1_FIFO_REQ, + GX_PERF1_CALL_REQ, + GX_PERF1_VC_MISS_REQ, + GX_PERF1_CP_ALL_REQ, + + GX_PERF1_CLOCKS, + GX_PERF1_NONE, +} GXPerf1; + +typedef enum _GXVCachePerf { + GX_VC_POS = 0, + GX_VC_NRM = 1, + GX_VC_CLR0 = 2, + GX_VC_CLR1 = 3, + GX_VC_TEX0 = 4, + GX_VC_TEX1 = 5, + GX_VC_TEX2 = 6, + GX_VC_TEX3 = 7, + GX_VC_TEX4 = 8, + GX_VC_TEX5 = 9, + GX_VC_TEX6 = 10, + GX_VC_TEX7 = 11, + GX_VC_ALL = 15, +} GXVCachePerf; + +typedef enum _GXClipMode { + GX_CLIP_ENABLE = 0, + GX_CLIP_DISABLE = 1, +} GXClipMode; + +typedef enum _GXFBClamp { + GX_CLAMP_NONE = 0, + GX_CLAMP_TOP = 1, + GX_CLAMP_BOTTOM = 2, +} GXFBClamp; + +typedef enum _GXCopyMode { + GX_COPY_PROGRESSIVE = 0, + GX_COPY_INTLC_EVEN = 2, + GX_COPY_INTLC_ODD = 3, +} GXCopyMode; + +typedef enum _GXAlphaReadMode { + GX_READ_00, + GX_READ_FF, + GX_READ_NONE, +} GXAlphaReadMode; + +typedef enum _GXTexCacheSize { + GX_TEXCACHE_32K, + GX_TEXCACHE_128K, + GX_TEXCACHE_512K, + GX_TEXCACHE_NONE, +} GXTexCacheSize; + +typedef enum _GXTlut { + GX_TLUT0, + GX_TLUT1, + GX_TLUT2, + GX_TLUT3, + GX_TLUT4, + GX_TLUT5, + GX_TLUT6, + GX_TLUT7, + GX_TLUT8, + GX_TLUT9, + GX_TLUT10, + GX_TLUT11, + GX_TLUT12, + GX_TLUT13, + GX_TLUT14, + GX_TLUT15, + GX_BIGTLUT0, + GX_BIGTLUT1, + GX_BIGTLUT2, + GX_BIGTLUT3, +} GXTlut; + +typedef enum _GXTlutFmt { + GX_TL_IA8, + GX_TL_RGB565, + GX_TL_RGB5A3, + GX_MAX_TLUTFMT, +} GXTlutFmt; + +typedef enum _GXTlutSize { + GX_TLUT_16 = 1, + GX_TLUT_32 = 2, + GX_TLUT_64 = 4, + GX_TLUT_128 = 8, + GX_TLUT_256 = 16, + GX_TLUT_512 = 32, + GX_TLUT_1K = 64, + GX_TLUT_2K = 128, + GX_TLUT_4K = 256, + GX_TLUT_8K = 512, + GX_TLUT_16K = 1024, +} GXTlutSize; + +typedef enum _GXMiscToken { + GX_MT_XF_FLUSH = 1, + GX_MT_DL_SAVE_CONTEXT = 2, + GX_MT_ABORT_WAIT_COPYOUT = 3, + GX_MT_NULL = 0, +} GXMiscToken; + +#endif diff --git a/include/dolphin/gx/GXFifo.h b/include/dolphin/gx/GXFifo.h new file mode 100644 index 000000000..069f36a4e --- /dev/null +++ b/include/dolphin/gx/GXFifo.h @@ -0,0 +1,46 @@ +#ifndef _DOLPHIN_GX_GXFIFO_H_ +#define _DOLPHIN_GX_GXFIFO_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + u8 pad[128]; +} GXFifoObj; + +typedef void (*GXBreakPtCallback)(void); + +void GXInitFifoBase(GXFifoObj* fifo, void* base, u32 size); +void GXInitFifoPtrs(GXFifoObj* fifo, void* readPtr, void* writePtr); +void GXInitFifoLimits(GXFifoObj* fifo, u32 hiWatermark, u32 loWatermark); +void GXSetCPUFifo(GXFifoObj* fifo); +void GXSetGPFifo(GXFifoObj* fifo); +void GXSaveCPUFifo(GXFifoObj* fifo); +void GXSaveGPFifo(GXFifoObj* fifo); +void GXGetGPStatus(GXBool* overhi, GXBool* underlow, GXBool* readIdle, GXBool* cmdIdle, GXBool* brkpt); +void GXGetFifoStatus(GXFifoObj* fifo, GXBool* overhi, GXBool* underflow, u32* fifoCount, GXBool* cpuWrite, GXBool* gpRead, GXBool* fifowrap); +void GXGetFifoPtrs(GXFifoObj* fifo, void** readPtr, void** writePtr); +void* GXGetFifoBase(const GXFifoObj* fifo); +u32 GXGetFifoSize(const GXFifoObj* fifo); +void GXGetFifoLimits(const GXFifoObj* fifo, u32* hi, u32* lo); +GXBreakPtCallback GXSetBreakPtCallback(GXBreakPtCallback cb); +void GXEnableBreakPt(void* break_pt); +void GXDisableBreakPt(void); +OSThread* GXSetCurrentGXThread(void); +OSThread* GXGetCurrentGXThread(void); +GXFifoObj* GXGetCPUFifo(void); +GXFifoObj* GXGetGPFifo(void); +u32 GXGetOverflowCount(void); +u32 GXResetOverflowCount(void); +volatile void* GXRedirectWriteGatherPipe(void* ptr); +void GXRestoreWriteGatherPipe(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXFrameBuffer.h b/include/dolphin/gx/GXFrameBuffer.h new file mode 100644 index 000000000..73b513fa3 --- /dev/null +++ b/include/dolphin/gx/GXFrameBuffer.h @@ -0,0 +1,66 @@ +#ifndef _DOLPHIN_GX_GXFRAMEBUFFER_H_ +#define _DOLPHIN_GX_GXFRAMEBUFFER_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GX_MAX_Z24 0x00ffffff + +extern GXRenderModeObj GXNtsc240Ds; +extern GXRenderModeObj GXNtsc240DsAa; +extern GXRenderModeObj GXNtsc240Int; +extern GXRenderModeObj GXNtsc240IntAa; +extern GXRenderModeObj GXNtsc480IntDf; +extern GXRenderModeObj GXNtsc480Int; +extern GXRenderModeObj GXNtsc480IntAa; +extern GXRenderModeObj GXNtsc480Prog; +extern GXRenderModeObj GXNtsc480ProgAa; +extern GXRenderModeObj GXMpal240Ds; +extern GXRenderModeObj GXMpal240DsAa; +extern GXRenderModeObj GXMpal240Int; +extern GXRenderModeObj GXMpal240IntAa; +extern GXRenderModeObj GXMpal480IntDf; +extern GXRenderModeObj GXMpal480Int; +extern GXRenderModeObj GXMpal480IntAa; +extern GXRenderModeObj GXPal264Ds; +extern GXRenderModeObj GXPal264DsAa; +extern GXRenderModeObj GXPal264Int; +extern GXRenderModeObj GXPal264IntAa; +extern GXRenderModeObj GXPal528IntDf; +extern GXRenderModeObj GXPal528Int; +extern GXRenderModeObj GXPal528IntAa; +extern GXRenderModeObj GXEurgb60Hz240Ds; +extern GXRenderModeObj GXEurgb60Hz240DsAa; +extern GXRenderModeObj GXEurgb60Hz240Int; +extern GXRenderModeObj GXEurgb60Hz240IntAa; +extern GXRenderModeObj GXEurgb60Hz480IntDf; +extern GXRenderModeObj GXEurgb60Hz480Int; +extern GXRenderModeObj GXEurgb60Hz480IntAa; + +void GXAdjustForOverscan(const GXRenderModeObj* rmin, GXRenderModeObj* rmout, u16 hor, u16 ver); +void GXSetDispCopySrc(u16 left, u16 top, u16 wd, u16 ht); +void GXSetTexCopySrc(u16 left, u16 top, u16 wd, u16 ht); +void GXSetDispCopyDst(u16 wd, u16 ht); +void GXSetTexCopyDst(u16 wd, u16 ht, GXTexFmt fmt, GXBool mipmap); +void GXSetDispCopyFrame2Field(GXCopyMode mode); +void GXSetCopyClamp(GXFBClamp clamp); +u32 GXSetDispCopyYScale(f32 vscale); +void GXSetCopyClear(GXColor clear_clr, u32 clear_z); +void GXSetCopyFilter(GXBool aa, const u8 sample_pattern[12][2], GXBool vf, const u8 vfilter[7]); +void GXSetDispCopyGamma(GXGamma gamma); +void GXCopyDisp(void* dest, GXBool clear); +void GXCopyTex(void* dest, GXBool clear); +void GXClearBoundingBox(void); +void GXReadBoundingBox(u16* left, u16* top, u16* right, u16* bottom); +u16 GXGetNumXfbLines(u16 efbHeight, f32 yScale); +f32 GXGetYScaleFactor(u16 efbHeight, u16 xfbHeight); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXGeometry.h b/include/dolphin/gx/GXGeometry.h new file mode 100644 index 000000000..188fa7a59 --- /dev/null +++ b/include/dolphin/gx/GXGeometry.h @@ -0,0 +1,47 @@ +#ifndef _DOLPHIN_GX_GXGEOMETRY_H_ +#define _DOLPHIN_GX_GXGEOMETRY_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void __GXCalculateVLim(); +void GXSetVtxDesc(GXAttr attr, GXAttrType type); +void GXSetVtxDescv(const GXVtxDescList* attrPtr); +void GXClearVtxDesc(void); +void GXSetVtxAttrFmt(GXVtxFmt vtxfmt, GXAttr attr, GXCompCnt cnt, GXCompType type, u8 frac); +void GXSetVtxAttrFmtv(GXVtxFmt vtxfmt, const GXVtxAttrFmtList* list); +void GXSetArray(GXAttr attr, void* base_ptr, u8 stride); +void GXInvalidateVtxCache(void); +void GXSetTexCoordGen2(GXTexCoordID dst_coord, GXTexGenType func, GXTexGenSrc src_param, u32 mtx, GXBool normalize, u32 pt_texmtx); +void GXSetNumTexGens(u8 nTexGens); + +static inline void GXSetTexCoordGen(GXTexCoordID dst_coord, GXTexGenType func, GXTexGenSrc src_param, u32 mtx) { + GXSetTexCoordGen2(dst_coord, func, src_param, mtx, GX_FALSE, GX_PTIDENTITY); +} + +void GXBegin(GXPrimitive type, GXVtxFmt vtxfmt, u16 nverts); + +static inline void GXEnd(void) { +#if DEBUG + extern GXBool __GXinBegin; + extern void OSPanic(char* file, int line, char* msg, ...); + if (!__GXinBegin) { + OSPanic(__FILE__, 118, "GXEnd: called without a GXBegin"); + } + __GXinBegin = GX_FALSE; +#endif +} + +void GXSetLineWidth(u8 width, GXTexOffset texOffsets); +void GXSetPointSize(u8 pointSize, GXTexOffset texOffsets); +void GXEnableTexOffsets(GXTexCoordID coord, u8 line_enable, u8 point_enable); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXGet.h b/include/dolphin/gx/GXGet.h new file mode 100644 index 000000000..d1ba630a4 --- /dev/null +++ b/include/dolphin/gx/GXGet.h @@ -0,0 +1,64 @@ +#ifndef _DOLPHIN_GX_GXGET_H_ +#define _DOLPHIN_GX_GXGET_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Attr +void GXGetVtxDesc(GXAttr attr, GXAttrType* type); +void GXGetVtxDescv(GXVtxDescList* vcd); +void GXGetVtxAttrFmt(GXVtxFmt fmt, GXAttr attr, GXCompCnt* cnt, GXCompType* type, u8* frac); +void GXGetVtxAttrFmtv(GXVtxFmt fmt, GXVtxAttrFmtList* vat); + +// Geometry +void GXGetLineWidth(u8* width, GXTexOffset* texOffsets); +void GXGetPointSize(u8* pointSize, GXTexOffset* texOffsets); +void GXGetCullMode(GXCullMode* mode); + +// Light +void GXGetLightAttnA(const GXLightObj* lt_obj, f32* a0, f32* a1, f32* a2); +void GXGetLightAttnK(const GXLightObj* lt_obj, f32* k0, f32* k1, f32* k2); +void GXGetLightPos(const GXLightObj* lt_obj, f32* x, f32* y, f32* z); +void GXGetLightDir(const GXLightObj* lt_obj, f32* nx, f32* ny, f32* nz); +void GXGetLightColor(const GXLightObj* lt_obj, GXColor* color); + +// Texture +GXBool GXGetTexObjMipMap(const GXTexObj* to); +GXTexFmt GXGetTexObjFmt(const GXTexObj* to); +u16 GXGetTexObjWidth(const GXTexObj* to); +u16 GXGetTexObjHeight(const GXTexObj* to); +GXTexWrapMode GXGetTexObjWrapS(const GXTexObj* to); +GXTexWrapMode GXGetTexObjWrapT(const GXTexObj* to); +void* GXGetTexObjData(const GXTexObj* to);; +void GXGetTexObjAll(const GXTexObj* obj, void** image_ptr, u16* width, u16* height, GXTexFmt* format, GXTexWrapMode* wrap_s, GXTexWrapMode* wrap_t, u8* mipmap); +void GXGetTexObjLODAll(const GXTexObj* tex_obj, GXTexFilter* min_filt, GXTexFilter* mag_filt, f32* min_lod, f32* max_lod, f32* lod_bias, u8* bias_clamp, u8* do_edge_lod, GXAnisotropy* max_aniso); +GXTexFilter GXGetTexObjMinFilt(const GXTexObj* tex_obj); +GXTexFilter GXGetTexObjMagFilt(const GXTexObj* tex_obj); +f32 GXGetTexObjMinLOD(const GXTexObj* tex_obj); +f32 GXGetTexObjMaxLOD(const GXTexObj* tex_obj); +f32 GXGetTexObjLODBias(const GXTexObj* tex_obj); +GXBool GXGetTexObjBiasClamp(const GXTexObj* tex_obj); +GXBool GXGetTexObjEdgeLOD(const GXTexObj* tex_obj); +GXAnisotropy GXGetTexObjMaxAniso(const GXTexObj* tex_obj); +u32 GXGetTexObjTlut(const GXTexObj* tex_obj); +void GXGetTlutObjAll(const GXTlutObj* tlut_obj, void** data, GXTlutFmt* format, u16* numEntries); +void* GXGetTlutObjData(const GXTlutObj* tlut_obj); +GXTlutFmt GXGetTlutObjFmt(const GXTlutObj* tlut_obj); +u16 GXGetTlutObjNumEntries(const GXTlutObj* tlut_obj); +void GXGetTexRegionAll(const GXTexRegion* region, u8* is_cached, u8* is_32b_mipmap, u32* tmem_even, u32* size_even, u32* tmem_odd, u32* size_odd); +void GXGetTlutRegionAll(const GXTlutRegion* region, u32* tmem_addr, GXTlutSize* tlut_size); + +// Transform +void GXGetProjectionv(f32* ptr); +void GXGetViewportv(f32* vp); +void GXGetScissor(u32* left, u32* top, u32* wd, u32* ht); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXLighting.h b/include/dolphin/gx/GXLighting.h new file mode 100644 index 000000000..83c5aae42 --- /dev/null +++ b/include/dolphin/gx/GXLighting.h @@ -0,0 +1,32 @@ +#ifndef _DOLPHIN_GX_GXLIGHTING_H_ +#define _DOLPHIN_GX_GXLIGHTING_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXInitLightAttn(GXLightObj* lt_obj, f32 a0, f32 a1, f32 a2, f32 k0, f32 k1, f32 k2); +void GXInitLightAttnA(GXLightObj* lt_obj, f32 a0, f32 a1, f32 a2); +void GXInitLightAttnK(GXLightObj* lt_obj, f32 k0, f32 k1, f32 k2); +void GXInitLightSpot(GXLightObj* lt_obj, f32 cutoff, GXSpotFn spot_func); +void GXInitLightDistAttn(GXLightObj* lt_obj, f32 ref_dist, f32 ref_br, GXDistAttnFn dist_func); +void GXInitLightPos(GXLightObj* lt_obj, f32 x, f32 y, f32 z); +void GXInitLightDir(GXLightObj* lt_obj, f32 nx, f32 ny, f32 nz); +void GXInitSpecularDir(GXLightObj* lt_obj, f32 nx, f32 ny, f32 nz); +void GXInitSpecularDirHA(GXLightObj* lt_obj, f32 nx, f32 ny, f32 nz, f32 hx, f32 hy, f32 hz); +void GXInitLightColor(GXLightObj* lt_obj, GXColor color); +void GXLoadLightObjImm(const GXLightObj* lt_obj, GXLightID light); +void GXLoadLightObjIndx(u32 lt_obj_indx, GXLightID light); +void GXSetChanAmbColor(GXChannelID chan, GXColor amb_color); +void GXSetChanMatColor(GXChannelID chan, GXColor mat_color); +void GXSetNumChans(u8 nChans); +void GXSetChanCtrl(GXChannelID chan, GXBool enable, GXColorSrc amb_src, GXColorSrc mat_src, u32 light_mask, GXDiffuseFn diff_fn, GXAttnFn attn_fn); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXManage.h b/include/dolphin/gx/GXManage.h new file mode 100644 index 000000000..fd899d361 --- /dev/null +++ b/include/dolphin/gx/GXManage.h @@ -0,0 +1,36 @@ +#ifndef _DOLPHIN_GX_GXMANAGE_H_ +#define _DOLPHIN_GX_GXMANAGE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*GXDrawSyncCallback)(u16 token); +typedef void (*GXDrawDoneCallback)(void); + +// Init +BOOL IsWriteGatherBufferEmpty(void); +GXFifoObj* GXInit(void* base, u32 size); + +// Misc +void GXSetMisc(GXMiscToken token, u32 val); +void GXFlush(void); +void GXResetWriteGatherPipe(void); +void GXAbortFrame(void); +void GXSetDrawSync(u16 token); +u16 GXReadDrawSync(void); +void GXSetDrawDone(void); +void GXWaitDrawDone(void); +void GXDrawDone(void); +void GXPixModeSync(void); +void GXTexModeSync(void); +GXDrawSyncCallback GXSetDrawSyncCallback(GXDrawSyncCallback cb); +GXDrawDoneCallback GXSetDrawDoneCallback(GXDrawDoneCallback cb); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXPerf.h b/include/dolphin/gx/GXPerf.h new file mode 100644 index 000000000..bd1b474aa --- /dev/null +++ b/include/dolphin/gx/GXPerf.h @@ -0,0 +1,30 @@ +#ifndef _DOLPHIN_GX_GXPERF_H_ +#define _DOLPHIN_GX_GXPERF_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetGPMetric(GXPerf0 perf0, GXPerf1 perf1); +void GXReadGPMetric(u32* cnt0, u32* cnt1); +void GXClearGPMetric(void); +u32 GXReadGP0Metric(void); +u32 GXReadGP1Metric(void); +void GXReadMemMetric(u32* cp_req, u32* tc_req, u32* cpu_rd_req, u32* cpu_wr_req, u32* dsp_req, u32* io_req, u32* vi_req, u32* pe_req, u32* rf_req, u32* fi_req); +void GXClearMemMetric(void); +void GXReadPixMetric(u32* top_pixels_in, u32* top_pixels_out, u32* bot_pixels_in, u32* bot_pixels_out, u32* clr_pixels_in, u32* copy_clks); +void GXClearPixMetric(void); +void GXSetVCacheMetric(GXVCachePerf attr); +void GXReadVCacheMetric(u32* check, u32* miss, u32* stall); +void GXClearVCacheMetric(void); +void GXInitXfRasMetric(void); +void GXReadXfRasMetric(u32* xf_wait_in, u32* xf_wait_out, u32* ras_busy, u32* clocks); +u32 GXReadClksPerVtx(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXPixel.h b/include/dolphin/gx/GXPixel.h new file mode 100644 index 000000000..d61838d1a --- /dev/null +++ b/include/dolphin/gx/GXPixel.h @@ -0,0 +1,30 @@ +#ifndef _DOLPHIN_GX_GXPIXEL_H_ +#define _DOLPHIN_GX_GXPIXEL_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetFog(GXFogType type, f32 startz, f32 endz, f32 nearz, f32 farz, GXColor color); +void GXInitFogAdjTable(GXFogAdjTable* table, u16 width, const f32 projmtx[4][4]); +void GXSetFogRangeAdj(GXBool enable, u16 center, const GXFogAdjTable* table); +void GXSetBlendMode(GXBlendMode type, GXBlendFactor src_factor, GXBlendFactor dst_factor, GXLogicOp op); +void GXSetColorUpdate(GXBool update_enable); +void GXSetAlphaUpdate(GXBool update_enable); +void GXSetZMode(GXBool compare_enable, GXCompare func, GXBool update_enable); +void GXSetZCompLoc(GXBool before_tex); +void GXSetPixelFmt(GXPixelFmt pix_fmt, GXZFmt16 z_fmt); +void GXSetDither(GXBool dither); +void GXSetDstAlpha(GXBool enable, u8 alpha); +void GXSetFieldMask(GXBool odd_mask, GXBool even_mask); +void GXSetFieldMode(GXBool field_mode, GXBool half_aspect_ratio); +void GXSetFogColor(GXColor color); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXStruct.h b/include/dolphin/gx/GXStruct.h new file mode 100644 index 000000000..0e7dc0be6 --- /dev/null +++ b/include/dolphin/gx/GXStruct.h @@ -0,0 +1,75 @@ +#ifndef _DOLPHIN_GX_GXSTRUCT_H_ +#define _DOLPHIN_GX_GXSTRUCT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _GXRenderModeObj { + /* 0x00 */ VITVMode viTVmode; + /* 0x04 */ u16 fbWidth; + /* 0x06 */ u16 efbHeight; + /* 0x08 */ u16 xfbHeight; + /* 0x0A */ u16 viXOrigin; + /* 0x0C */ u16 viYOrigin; + /* 0x0E */ u16 viWidth; + /* 0x10 */ u16 viHeight; + /* 0x14 */ VIXFBMode xFBmode; + /* 0x18 */ u8 field_rendering; + /* 0x19 */ u8 aa; + /* 0x20 */ u8 sample_pattern[12][2]; + /* 0x38 */ u8 vfilter[7]; +} GXRenderModeObj; + +typedef struct _GXColor { + u8 r, g, b, a; +} GXColor; + +typedef struct _GXColorS10 { + s16 r, g, b, a; +} GXColorS10; + +typedef struct _GXTexObj { + u32 dummy[8]; +} GXTexObj; + +typedef struct _GXLightObj { + u32 dummy[16]; +} GXLightObj; + +typedef struct _GXTexRegion { + u32 dummy[4]; +} GXTexRegion; + +typedef struct _GXTlutObj { + u32 dummy[3]; +} GXTlutObj; + +typedef struct _GXTlutRegion { + u32 dummy[4]; +} GXTlutRegion; + +typedef struct _GXFogAdjTable { + u16 r[10]; +} GXFogAdjTable; + +typedef struct _GXVtxDescList { + GXAttr attr; + GXAttrType type; +} GXVtxDescList; + +typedef struct _GXVtxAttrFmtList { + GXAttr attr; + GXCompCnt cnt; + GXCompType type; + u8 frac; +} GXVtxAttrFmtList; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXTev.h b/include/dolphin/gx/GXTev.h new file mode 100644 index 000000000..8deb22d08 --- /dev/null +++ b/include/dolphin/gx/GXTev.h @@ -0,0 +1,33 @@ +#ifndef _DOLPHIN_GX_GXTEV_H_ +#define _DOLPHIN_GX_GXTEV_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetTevOp(GXTevStageID id, GXTevMode mode); +void GXSetTevColorIn(GXTevStageID stage, GXTevColorArg a, GXTevColorArg b, GXTevColorArg c, GXTevColorArg d); +void GXSetTevAlphaIn(GXTevStageID stage, GXTevAlphaArg a, GXTevAlphaArg b, GXTevAlphaArg c, GXTevAlphaArg d); +void GXSetTevColorOp(GXTevStageID stage, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp, GXTevRegID out_reg); +void GXSetTevAlphaOp(GXTevStageID stage, GXTevOp op, GXTevBias bias, GXTevScale scale, GXBool clamp, GXTevRegID out_reg); +void GXSetTevColor(GXTevRegID id, GXColor color); +void GXSetTevColorS10(GXTevRegID id, GXColorS10 color); +void GXSetTevKColor(GXTevKColorID id, GXColor color); +void GXSetTevKColorSel(GXTevStageID stage, GXTevKColorSel sel); +void GXSetTevKAlphaSel(GXTevStageID stage, GXTevKAlphaSel sel); +void GXSetTevSwapMode(GXTevStageID stage, GXTevSwapSel ras_sel, GXTevSwapSel tex_sel); +void GXSetTevSwapModeTable(GXTevSwapSel table, GXTevColorChan red, GXTevColorChan green, GXTevColorChan blue, GXTevColorChan alpha); +void GXSetTevClampMode(void); +void GXSetAlphaCompare(GXCompare comp0, u8 ref0, GXAlphaOp op, GXCompare comp1, u8 ref1); +void GXSetZTexture(GXZTexOp op, GXTexFmt fmt, u32 bias); +void GXSetTevOrder(GXTevStageID stage, GXTexCoordID coord, GXTexMapID map, GXChannelID color); +void GXSetNumTevStages(u8 nStages); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXTexture.h b/include/dolphin/gx/GXTexture.h new file mode 100644 index 000000000..f42dc2295 --- /dev/null +++ b/include/dolphin/gx/GXTexture.h @@ -0,0 +1,52 @@ +#ifndef _DOLPHIN_GX_GXTEXTURE_H_ +#define _DOLPHIN_GX_GXTEXTURE_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef GXTexRegion *(*GXTexRegionCallback)(GXTexObj* t_obj, GXTexMapID id); +typedef GXTlutRegion *(*GXTlutRegionCallback)(u32 idx); + +u32 GXGetTexBufferSize(u16 width, u16 height, u32 format, u8 mipmap, u8 max_lod); +void GXInitTexObj(GXTexObj* obj, void* image_ptr, u16 width, u16 height, GXTexFmt format, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, u8 mipmap); +void GXInitTexObjCI(GXTexObj* obj, void* image_ptr, u16 width, u16 height, GXCITexFmt format, GXTexWrapMode wrap_s, GXTexWrapMode wrap_t, u8 mipmap, u32 tlut_name); +void GXInitTexObjLOD(GXTexObj* obj, GXTexFilter min_filt, GXTexFilter mag_filt, + f32 min_lod, f32 max_lod, f32 lod_bias, GXBool bias_clamp, + GXBool do_edge_lod, GXAnisotropy max_aniso); +void GXInitTexObjData(GXTexObj* obj, void* image_ptr); +void GXInitTexObjWrapMode(GXTexObj* obj, GXTexWrapMode s, GXTexWrapMode t); +void GXInitTexObjTlut(GXTexObj* obj, u32 tlut_name); +void GXInitTexObjUserData(GXTexObj* obj, void* user_data); +void* GXGetTexObjUserData(const GXTexObj* obj); +void GXLoadTexObjPreLoaded(GXTexObj* obj, GXTexRegion* region, GXTexMapID id); +void GXLoadTexObj(GXTexObj* obj, GXTexMapID id); +void GXInitTlutObj(GXTlutObj* tlut_obj, void* lut, GXTlutFmt fmt, u16 n_entries); +void GXLoadTlut(GXTlutObj* tlut_obj, u32 tlut_name); +void GXInitTexCacheRegion(GXTexRegion* region, u8 is_32b_mipmap, u32 tmem_even, GXTexCacheSize size_even, u32 tmem_odd, GXTexCacheSize size_odd); +void GXInitTexPreLoadRegion(GXTexRegion* region, u32 tmem_even, u32 size_even, u32 tmem_odd, u32 size_odd); +void GXInitTlutRegion(GXTlutRegion* region, u32 tmem_addr, GXTlutSize tlut_size); +void GXInvalidateTexRegion(GXTexRegion* region); +void GXInvalidateTexAll(void); +GXTexRegionCallback GXSetTexRegionCallback(GXTexRegionCallback f); +GXTlutRegionCallback GXSetTlutRegionCallback(GXTlutRegionCallback f); +void GXPreLoadEntireTexture(GXTexObj* tex_obj, GXTexRegion* region); +void GXSetTexCoordScaleManually(GXTexCoordID coord, u8 enable, u16 ss, u16 ts); +void GXSetTexCoordCylWrap(GXTexCoordID coord, u8 s_enable, u8 t_enable); +void GXSetTexCoordBias(GXTexCoordID coord, u8 s_enable, u8 t_enable); +void GXInitTexObjFilter(GXTexObj* obj, GXTexFilter min_filt, GXTexFilter mag_filt); +void GXInitTexObjMaxLOD(GXTexObj* obj, f32 max_lod); +void GXInitTexObjMinLOD(GXTexObj* obj, f32 min_lod); +void GXInitTexObjLODBias(GXTexObj* obj, f32 lod_bias); +void GXInitTexObjBiasClamp(GXTexObj* obj, u8 bias_clamp); +void GXInitTexObjEdgeLOD(GXTexObj* obj, u8 do_edge_lod); +void GXInitTexObjMaxAniso(GXTexObj* obj, GXAnisotropy max_aniso); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXTransform.h b/include/dolphin/gx/GXTransform.h new file mode 100644 index 000000000..1e7f94e57 --- /dev/null +++ b/include/dolphin/gx/GXTransform.h @@ -0,0 +1,34 @@ +#ifndef _DOLPHIN_GX_GXTRANSFORM_H_ +#define _DOLPHIN_GX_GXTRANSFORM_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GX_PROJECTION_SZ 7 +#define GX_VIEWPORT_SZ 6 + +void GXProject(f32 x, f32 y, f32 z, const f32 mtx[3][4], const f32* pm, const f32* vp, f32* sx, f32* sy, f32* sz); +void GXSetProjection(const f32 mtx[4][4], GXProjectionType type); +void GXSetProjectionv(const f32* ptr); +void GXLoadPosMtxImm(const f32 mtx[3][4], u32 id); +void GXLoadPosMtxIndx(u16 mtx_indx, u32 id); +void GXLoadNrmMtxImm(const f32 mtx[3][4], u32 id); +void GXLoadNrmMtxImm3x3(const f32 mtx[3][3], u32 id); +void GXLoadNrmMtxIndx3x3(u16 mtx_indx, u32 id); +void GXSetCurrentMtx(u32 id); +void GXLoadTexMtxImm(const f32 mtx[][4], u32 id, GXTexMtxType type); +void GXLoadTexMtxIndx(u16 mtx_indx, u32 id, GXTexMtxType type); +void GXSetViewportJitter(f32 left, f32 top, f32 wd, f32 ht, f32 nearz, f32 farz, u32 field); +void GXSetViewport(f32 left, f32 top, f32 wd, f32 ht, f32 nearz, f32 farz); +void GXSetScissorBoxOffset(s32 x_off, s32 y_off); +void GXSetClipMode(GXClipMode mode); +void GXSetZScaleOffset(f32 scale, f32 offset); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXVerify.h b/include/dolphin/gx/GXVerify.h new file mode 100644 index 000000000..93a1b29e5 --- /dev/null +++ b/include/dolphin/gx/GXVerify.h @@ -0,0 +1,29 @@ +#ifndef _DOLPHIN_GX_GXVERIFY_H_ +#define _DOLPHIN_GX_GXVERIFY_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + GX_WARN_NONE, + GX_WARN_SEVERE, + GX_WARN_MEDIUM, + GX_WARN_ALL +} GXWarningLevel; + +typedef void (*GXVerifyCallback)(GXWarningLevel level, u32 id, char* msg); + +void GXSetVerifyLevel(GXWarningLevel level); +GXVerifyCallback GXSetVerifyCallback(GXVerifyCallback cb); + +void __GXVerifyVATImm(GXAttr attr, GXCompCnt cnt, GXCompType type, u8 frac); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/gx/GXVert.h b/include/dolphin/gx/GXVert.h new file mode 100644 index 000000000..edb245cbc --- /dev/null +++ b/include/dolphin/gx/GXVert.h @@ -0,0 +1,140 @@ +#ifndef _DOLPHIN_GX_GXVERT_H_ +#define _DOLPHIN_GX_GXVERT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GXFIFO_ADDR 0xCC008000 + +typedef union { + u8 u8; + u16 u16; + u32 u32; + u64 u64; + s8 s8; + s16 s16; + s32 s32; + s64 s64; + f32 f32; + f64 f64; +} PPCWGPipe; + +#ifdef __MWERKS__ +volatile PPCWGPipe GXWGFifo AT_ADDRESS(GXFIFO_ADDR); +#else +#define GXWGFifo (*(volatile PPCWGPipe *)GXFIFO_ADDR) +#endif + +#if DEBUG + +// external functions + +#define FUNC_1PARAM(name, T) void name##1##T(T x); +#define FUNC_2PARAM(name, T) void name##2##T(T x, T y); +#define FUNC_3PARAM(name, T) void name##3##T(T x, T y, T z); +#define FUNC_4PARAM(name, T) void name##4##T(T x, T y, T z, T w); +#define FUNC_INDEX8(name) void name##1x8(u8 x); +#define FUNC_INDEX16(name) void name##1x16(u16 x); + +#else + +// inline functions + +#define FUNC_1PARAM(name, T) \ +static inline void name##1##T(T x) { GXWGFifo.T = x; } + +#define FUNC_2PARAM(name, T) \ +static inline void name##2##T(T x, T y) { GXWGFifo.T = x; GXWGFifo.T = y; } + +#define FUNC_3PARAM(name, T) \ +static inline void name##3##T(T x, T y, T z) { GXWGFifo.T = x; GXWGFifo.T = y; GXWGFifo.T = z; } + +#define FUNC_4PARAM(name, T) \ +static inline void name##4##T(T x, T y, T z, T w) { GXWGFifo.T = x; GXWGFifo.T = y; GXWGFifo.T = z; GXWGFifo.T = w; } + +#define FUNC_INDEX8(name) \ +static inline void name##1x8(u8 x) { GXWGFifo.u8 = x; } + +#define FUNC_INDEX16(name) \ +static inline void name##1x16(u16 x) { GXWGFifo.u16 = x; } + +#endif + +// GXCmd +FUNC_1PARAM(GXCmd, u8) +FUNC_1PARAM(GXCmd, u16) +FUNC_1PARAM(GXCmd, u32) + +// GXParam +FUNC_1PARAM(GXParam, u8) +FUNC_1PARAM(GXParam, u16) +FUNC_1PARAM(GXParam, u32) +FUNC_1PARAM(GXParam, s8) +FUNC_1PARAM(GXParam, s16) +FUNC_1PARAM(GXParam, s32) +FUNC_1PARAM(GXParam, f32) +FUNC_3PARAM(GXParam, f32) +FUNC_4PARAM(GXParam, f32) + +// GXPosition +FUNC_3PARAM(GXPosition, f32) +FUNC_3PARAM(GXPosition, u8) +FUNC_3PARAM(GXPosition, s8) +FUNC_3PARAM(GXPosition, u16) +FUNC_3PARAM(GXPosition, s16) +FUNC_2PARAM(GXPosition, f32) +FUNC_2PARAM(GXPosition, u8) +FUNC_2PARAM(GXPosition, s8) +FUNC_2PARAM(GXPosition, u16) +FUNC_2PARAM(GXPosition, s16) +FUNC_INDEX16(GXPosition) +FUNC_INDEX8(GXPosition) + +// GXNormal +FUNC_3PARAM(GXNormal, f32) +FUNC_3PARAM(GXNormal, s16) +FUNC_3PARAM(GXNormal, s8) +FUNC_INDEX16(GXNormal) +FUNC_INDEX8(GXNormal) + +// GXColor +FUNC_4PARAM(GXColor, u8) +FUNC_1PARAM(GXColor, u32) +FUNC_3PARAM(GXColor, u8) +FUNC_1PARAM(GXColor, u16) +FUNC_INDEX16(GXColor) +FUNC_INDEX8(GXColor) + +// GXTexCoord +FUNC_2PARAM(GXTexCoord, f32) +FUNC_2PARAM(GXTexCoord, s16) +FUNC_2PARAM(GXTexCoord, u16) +FUNC_2PARAM(GXTexCoord, s8) +FUNC_2PARAM(GXTexCoord, u8) +FUNC_1PARAM(GXTexCoord, f32) +FUNC_1PARAM(GXTexCoord, s16) +FUNC_1PARAM(GXTexCoord, u16) +FUNC_1PARAM(GXTexCoord, s8) +FUNC_1PARAM(GXTexCoord, u8) +FUNC_INDEX16(GXTexCoord) +FUNC_INDEX8(GXTexCoord) + +// GXMatrixIndex +FUNC_1PARAM(GXMatrixIndex, u8) + +#undef FUNC_1PARAM +#undef FUNC_2PARAM +#undef FUNC_3PARAM +#undef FUNC_4PARAM +#undef FUNC_INDEX8 +#undef FUNC_INDEX16 + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/hio.h b/include/dolphin/hio.h new file mode 100644 index 000000000..dc83ee19a --- /dev/null +++ b/include/dolphin/hio.h @@ -0,0 +1,28 @@ +#ifndef _DOLPHIN_HIO_H_ +#define _DOLPHIN_HIO_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*HIOCallback)(void); +typedef BOOL (*HIOEnumCallback)(s32 chan); + +BOOL HIOEnumDevices(HIOEnumCallback callback); +BOOL HIOInit(s32 chan, HIOCallback callback); +BOOL HIOInitEx(s32 chan, u32 dev, HIOCallback callback); +BOOL HIOReadMailbox(u32* word); +BOOL HIOWriteMailbox(u32 word); +BOOL HIORead(u32 addr, void* buffer, s32 size); +BOOL HIOWrite(u32 addr, void* buffer, s32 size); +BOOL HIOReadAsync(u32 addr, void* buffer, s32 size, HIOCallback callback); +BOOL HIOWriteAsync(u32 addr, void* buffer, s32 size, HIOCallback callback); +BOOL HIOReadStatus(u32* status); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/hw_regs.h b/include/dolphin/hw_regs.h new file mode 100644 index 000000000..1f5700a16 --- /dev/null +++ b/include/dolphin/hw_regs.h @@ -0,0 +1,116 @@ +#ifndef _DOLPHIN_HW_REGS_H_ +#define _DOLPHIN_HW_REGS_H_ + +#include + +#ifdef __MWERKS__ +volatile u16 __VIRegs[59] AT_ADDRESS(0xCC002000); +volatile u32 __PIRegs[12] AT_ADDRESS(0xCC003000); +volatile u16 __MEMRegs[64] AT_ADDRESS(0xCC004000); +volatile u16 __DSPRegs[] AT_ADDRESS(0xCC005000); +volatile u32 __DIRegs[] AT_ADDRESS(0xCC006000); +volatile u32 __SIRegs[0x100] AT_ADDRESS(0xCC006400); +volatile u32 __EXIRegs[0x40] AT_ADDRESS(0xCC006800); +volatile u32 __AIRegs[8] AT_ADDRESS(0xCC006C00); +#else +#define __VIRegs ((volatile u16 *)0xCC002000) +#define __PIRegs ((volatile u32 *)0xCC003000) +#define __MEMRegs ((volatile u16 *)0xCC004000) +#define __DSPRegs ((volatile u16 *)0xCC005000) +#define __DIRegs ((volatile u32 *)0xCC006000) +#define __SIRegs ((volatile u32 *)0xCC006400) +#define __EXIRegs ((volatile u32 *)0xCC006800) +#define __AIRegs ((volatile u32 *)0xCC006C00) +#endif + +// Offsets for __VIRegs + +// offsets for __VIRegs[i] +#define VI_VERT_TIMING (0) +#define VI_DISP_CONFIG (1) +#define VI_HORIZ_TIMING_0L (2) +#define VI_HORIZ_TIMING_0U (3) +#define VI_HORIZ_TIMING_1L (4) +#define VI_HORIZ_TIMING_1U (5) +#define VI_VERT_TIMING_ODD (6) +#define VI_VERT_TIMING_ODD_U (7) +#define VI_VERT_TIMING_EVEN (8) +#define VI_VERT_TIMING_EVEN_U (9) + +#define VI_BBI_ODD (10) // burst blanking interval +#define VI_BBI_ODD_U (11) // burst blanking interval +#define VI_BBI_EVEN (12) // burst blanking interval +#define VI_BBI_EVEN_U (13) // burst blanking interval + +#define VI_TOP_FIELD_BASE_LEFT (14) // top in 2d, top of left pic in 3d +#define VI_TOP_FIELD_BASE_LEFT_U (15) // top in 2d, top of left pic in 3d + +#define VI_TOP_FIELD_BASE_RIGHT (16) // top of right pic in 3d +#define VI_TOP_FIELD_BASE_RIGHT_U (17) // top of right pic in 3d + +#define VI_BTTM_FIELD_BASE_LEFT (18) // bottom in 2d, bottom of left pic in 3d +#define VI_BTTM_FIELD_BASE_LEFT_U (19) // bottom in 2d, bottom of left pic in 3d + +#define VI_BTTM_FIELD_BASE_RIGHT (20) // bottom of right pic in 3d +#define VI_BTTM_FIELD_BASE_RIGHT_U (21) // bottom of right pic in 3d + +#define VI_VERT_COUNT (22) // vertical display position +#define VI_HORIZ_COUNT (23) // horizontal display position + +#define VI_DISP_INT_0 (24) // display interrupt 0L +#define VI_DISP_INT_0U (25) // display interrupt 0U +#define VI_DISP_INT_1 (26) // display interrupt 1L +#define VI_DISP_INT_1U (27) // display interrupt 1U +#define VI_DISP_INT_2 (28) // display interrupt 2L +#define VI_DISP_INT_2U (29) // display interrupt 2U +#define VI_DISP_INT_3 (30) // display interrupt 3L +#define VI_DISP_INT_3U (31) // display interrupt 3U + +#define VI_HSW (36) // horizontal scaling width +#define VI_HSR (37) // horizontal scaling register + +#define VI_FCT_0 (38) // filter coefficient table 0L +#define VI_FCT_0U (39) // filter coefficient table 0U +#define VI_FCT_1 (40) // filter coefficient table 1L +#define VI_FCT_1U (41) // filter coefficient table 1U +#define VI_FCT_2 (42) // filter coefficient table 2L +#define VI_FCT_2U (43) // filter coefficient table 2U +#define VI_FCT_3 (44) // filter coefficient table 3L +#define VI_FCT_3U (45) // filter coefficient table 3U +#define VI_FCT_4 (46) // filter coefficient table 4L +#define VI_FCT_4U (47) // filter coefficient table 4U +#define VI_FCT_5 (48) // filter coefficient table 5L +#define VI_FCT_5U (49) // filter coefficient table 5U +#define VI_FCT_6 (50) // filter coefficient table 6L +#define VI_FCT_6U (51) // filter coefficient table 6U + +#define VI_CLOCK_SEL (54) // clock select +#define VI_DTV_STAT (55) // DTV status + +#define VI_WIDTH (56) + +// offsets for __DSPRegs[i] +#define DSP_MAILBOX_IN_HI (0) +#define DSP_MAILBOX_IN_LO (1) +#define DSP_MAILBOX_OUT_HI (2) +#define DSP_MAILBOX_OUT_LO (3) +#define DSP_CONTROL_STATUS (5) + +#define DSP_ARAM_SIZE (9) +#define DSP_ARAM_MODE (11) +#define DSP_ARAM_REFRESH (13) +#define DSP_ARAM_DMA_MM_HI (16) // Main mem address +#define DSP_ARAM_DMA_MM_LO (17) +#define DSP_ARAM_DMA_ARAM_HI (18) // ARAM address +#define DSP_ARAM_DMA_ARAM_LO (19) +#define DSP_ARAM_DMA_SIZE_HI (20) // DMA buffer size +#define DSP_ARAM_DMA_SIZE_LO (21) + +#define DSP_DMA_START_HI (24) // DMA start address +#define DSP_DMA_START_LO (25) +#define DSP_DMA_CONTROL_LEN (27) +#define DSP_DMA_BYTES_LEFT (29) + +#define DSP_DMA_START_FLAG (0x8000) // set to start DSP + +#endif diff --git a/include/dolphin/mcc.h b/include/dolphin/mcc.h new file mode 100644 index 000000000..3e53b463e --- /dev/null +++ b/include/dolphin/mcc.h @@ -0,0 +1,211 @@ +#ifndef _DOLPHIN_MCC_H_ +#define _DOLPHIN_MCC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + MCC_CHANNEL_SYSTEM = 0, + MCC_CHANNEL_1 = 1, + MCC_CHANNEL_2 = 2, + MCC_CHANNEL_3 = 3, + MCC_CHANNEL_4 = 4, + MCC_CHANNEL_5 = 5, + MCC_CHANNEL_6 = 6, + MCC_CHANNEL_7 = 7, + MCC_CHANNEL_8 = 8, + MCC_CHANNEL_9 = 9, + MCC_CHANNEL_10 = 10, + MCC_CHANNEL_11 = 11, + MCC_CHANNEL_12 = 12, + MCC_CHANNEL_13 = 13, + MCC_CHANNEL_14 = 14, + MCC_CHANNEL_15 = 15, +} MCC_CHANNEL; + +typedef struct { + /* 0x00 */ u8 firstBlock; + /* 0x01 */ u8 blockLength; + /* 0x02 */ u8 connect; + /* 0x03 */ u8 isLocked; +} MCC_Info; + +typedef enum { + MCC_EXI_0 = 0, + MCC_EXI_1 = 1, + MCC_EXI_2 = 2, +} MCC_EXI; + +typedef enum { + MCC_SYSEVENT_UNKNOWN = 0, + MCC_SYSEVENT_REBOOT = 1, + MCC_SYSEVENT_INITIALIZED = 2, + MCC_SYSEVENT_PING = 3, + MCC_SYSEVENT_PING_RESULT = 4, + MCC_SYSEVENT_FLUSH = 5, +} MCC_SYSEVENT; + +typedef void (*MCC_CBEvent)(MCC_CHANNEL channel, u32, u32); +typedef void (*MCC_CBSysEvent)(MCC_SYSEVENT sysEvent); +typedef int (*MCC_CBEnumDevices)(s32); + +typedef struct { + /* 0x00 */ u32 length; + /* 0x04 */ u16 rsvd; + /* 0x06 */ u16 protocol; +} MCC_Hdr; + +typedef struct { + /* 0x00 */ u32 code; + /* 0x04 */ u32 number; +} MCC_HdrFio; + +typedef struct { + /* 0x00 */ MCC_Info info; + /* 0x04 */ MCC_CBEvent callbackEvent; + /* 0x08 */ u32 eventMask; + /* 0x0C */ int isStreamDone; + /* 0x10 */ int isStreamConnection; + /* 0x14 */ int isStreamOpened; +} MCC_ChannelInfo; + +typedef enum { + MCC_MODE_MIN = 0, + MCC_MODE_MAX = 1, + MCC_MODE_ALL = 2, +} MCC_MODE; + +typedef enum { + MCC_CONNECT_DISCONNECT = 0, + MCC_CONNECT_HOST_OPEN = 1, + MCC_CONNECT_TARGET_OPEN = 2, + MCC_CONNECT_CONNECTED = 3, +} MCC_CONNECT; + +typedef enum { + MCC_EVENT_CONNECT = 0x1, + MCC_EVENT_DISCONNECT = 0x2, + MCC_EVENT_LOCK = 0x4, + MCC_EVENT_UNLOCK = 0x8, + MCC_EVENT_READ = 0x10, + MCC_EVENT_WRITE = 0x20, + MCC_EVENT_READ_DONE_INSIDE = 0x40, + MCC_EVENT_WRITE_DONE_INSIDE = 0x80, + MCC_EVENT_UNK_0x100 = 0x100, +} MCC_EVENT; + +typedef enum { + MCC_SYNC = 0, + MCC_ASYNC = 1, +} MCC_SYNC_STATE; + +typedef enum { + FIO_ASYNC_STATE_IDOL = 0, + FIO_ASYNC_STATE_BUSY = 1, + FIO_ASYNC_STATE_DONE = 2, +} FIO_ASYNC_STATE; + +typedef struct { + /* 0x00 */ u16 year; + /* 0x02 */ u8 month; + /* 0x03 */ u8 day; +} FIO_Date; + +typedef struct { + /* 0x00 */ u8 hour; + /* 0x01 */ u8 minute; + /* 0x02 */ u8 second; + /* 0x03 */ u8 reserved; +} FIO_Daytime; + +typedef struct { + /* 0x00 */ FIO_Date date; + /* 0x04 */ FIO_Daytime time; +} FIO_Timestamp; + +typedef struct { + /* 0x00 */ u32 fileAttributes; + /* 0x04 */ FIO_Timestamp creationTime; + /* 0x0C */ FIO_Timestamp lastAccessTime; + /* 0x14 */ FIO_Timestamp lastWriteTime; + /* 0x1C */ u32 fileSizeHigh; + /* 0x20 */ u32 fileSizeLow; +} FIO_Stat; + +typedef struct { + /* 0x00 */ FIO_Stat stat; + /* 0x24 */ char filename[256]; +} FIO_Finddata; + +#define FIO_ERROR_NONE 0x00 +#define FIO_ERROR_WRONG_CODE 0x81 +#define FIO_ERROR_WRONG_SEQUENCE 0x82 +#define FIO_ERROR_PACKET_WRITE 0x83 +#define FIO_ERROR_PACKET_READ 0x84 +#define FIO_ERROR_MCC 0x87 +#define FIO_ERROR_TIMEOUT 0x88 +#define FIO_ERROR_MSG_TOO_LONG 0x89 +#define FIO_ERROR_UNK_0x91 0x91 +#define FIO_ERROR_ASYNC_SIZE_TOO_BIG 0xA0 +#define FIO_ERROR_ASYNC_BUSY 0xA1 +#define FIO_ERROR_INVALID_PARAMETERS 0xB0 + +// FIO +int FIOInit(MCC_EXI exiChannel, MCC_CHANNEL chID, u8 blockSize); +void FIOExit(void); +int FIOQuery(void); +u8 FIOGetLastError(); +int FIOFopen(const char* filename, u32 mode); +int FIOFclose(int handle); +u32 FIOFread(int handle, void* data, u32 size); +u32 FIOFwrite(int handle, void* data, u32 size); +u32 FIOFseek(int handle, s32 offset, u32 mode); +int FIOFprintf(int handle, const char* format, ...); +int FIOFflush(int handle); +int FIOFstat(int handle, FIO_Stat* stat); +int FIOFerror(int handle); +int FIOFindFirst(const char* filename, FIO_Finddata* finddata); +int FIOFindNext(FIO_Finddata* finddata); +u32 FIOGetAsyncBufferSize(void); +int FIOFreadAsync(int handle, void* data, u32 size); +int FIOFwriteAsync(int handle, void* data, u32 size); +int FIOCheckAsyncDone(u32* result); + +// MCC +BOOL MCCStreamOpen(MCC_CHANNEL chID, u8 blockSize); +int MCCStreamClose(MCC_CHANNEL chID); +int MCCStreamWrite(MCC_CHANNEL chID, void* data, u32 dataBlockSize); +u32 MCCStreamRead(MCC_CHANNEL chID, void* data); +int MCCInit(MCC_EXI exiChannel, u8 timeout, MCC_CBSysEvent callbackSysEvent); +void MCCExit(void); +int MCCPing(void); +int MCCEnumDevices(MCC_CBEnumDevices callbackEnumDevices); +u8 MCCGetFreeBlocks(MCC_MODE mode); +u8 MCCGetLastError(void); +int MCCGetChannelInfo(MCC_CHANNEL chID, MCC_Info* info); +int MCCGetConnectionStatus(MCC_CHANNEL chID, MCC_CONNECT* connect); +int MCCNotify(MCC_CHANNEL chID, u32 notify); +u32 MCCSetChannelEventMask(MCC_CHANNEL chID, u32 event); +int MCCOpen(MCC_CHANNEL chID, u8 blockSize, MCC_CBEvent callbackEvent); +int MCCClose(MCC_CHANNEL chID); +int MCCLock(MCC_CHANNEL chID); +int MCCUnlock(MCC_CHANNEL chID); +int MCCRead(MCC_CHANNEL chID, u32 offset, void* data, s32 size, MCC_SYNC_STATE async); +int MCCWrite(MCC_CHANNEL chID, u32 offset, void* data, s32 size, MCC_SYNC_STATE async); +int MCCCheckAsyncDone(); + +// TTY +int TTYInit(MCC_EXI exiChannel, MCC_CHANNEL chID); +void TTYExit(void); +int TTYQuery(void); +int TTYPrintf(const char* format, ...); +int TTYFlush(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_MCC_H_ diff --git a/include/dolphin/mix.h b/include/dolphin/mix.h new file mode 100644 index 000000000..f58b3d63d --- /dev/null +++ b/include/dolphin/mix.h @@ -0,0 +1,95 @@ +#ifndef _DOLPHIN_MIX_H_ +#define _DOLPHIN_MIX_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define MIX_SOUND_MODE_MONO 0 +#define MIX_SOUND_MODE_STEREO 1 +#define MIX_SOUND_MODE_SURROUND 2 +#define MIX_SOUND_MODE_DPL2 3 + +typedef struct MIXChannel { + /* 0x00 */ AXVPB* axvpb; + /* 0x04 */ u32 mode; + /* 0x08 */ int input; + /* 0x0C */ int auxA; + /* 0x10 */ int auxB; + /* 0x14 */ int pan; + /* 0x18 */ int span; + /* 0x1C */ int fader; + /* 0x20 */ int l; + /* 0x24 */ int r; + /* 0x28 */ int f; + /* 0x2C */ int b; + /* 0x30 */ int l1; + /* 0x34 */ int r1; + /* 0x38 */ u16 v; + /* 0x3A */ u16 v1; + /* 0x3C */ u16 vL; + /* 0x3E */ u16 vL1; + /* 0x40 */ u16 vR; + /* 0x42 */ u16 vR1; + /* 0x44 */ u16 vS; + /* 0x46 */ u16 vS1; + /* 0x48 */ u16 vAL; + /* 0x4A */ u16 vAL1; + /* 0x4C */ u16 vAR; + /* 0x4E */ u16 vAR1; + /* 0x50 */ u16 vAS; + /* 0x52 */ u16 vAS1; + /* 0x54 */ u16 vBL; + /* 0x56 */ u16 vBL1; + /* 0x58 */ u16 vBR; + /* 0x5A */ u16 vBR1; + /* 0x5C */ u16 vBS; + /* 0x5E */ u16 vBS1; +} MIXChannel; + +void MIXInit(void); +void MIXQuit(void); +void MIXSetSoundMode(u32 mode); +u32 MIXGetSoundMode(void); +void MIXInitChannel(AXVPB* axvpb, u32 mode, int input, int auxA, int auxB, int pan, int span, int fader); +void MIXReleaseChannel(AXVPB* axvpb); +void MIXResetControls(AXVPB* p); +void MIXSetInput(AXVPB* p, int dB); +void MIXAdjustInput(AXVPB* p, int dB); +int MIXGetInput(AXVPB* p); +void MIXAuxAPostFader(AXVPB* p); +void MIXAuxAPreFader(AXVPB* p); +int MIXAuxAIsPostFader(AXVPB* p); +void MIXSetAuxA(AXVPB* p, int dB); +void MIXAdjustAuxA(AXVPB* p, int dB); +int MIXGetAuxA(AXVPB* p); +void MIXAuxBPostFader(AXVPB* p); +void MIXAuxBPreFader(AXVPB* p); +int MIXAuxBIsPostFader(AXVPB* p); +void MIXSetAuxB(AXVPB* p, int dB); +void MIXAdjustAuxB(AXVPB* p, int dB); +int MIXGetAuxB(AXVPB* p); +void MIXSetPan(AXVPB* p, int pan); +void MIXAdjustPan(AXVPB* p, int pan); +int MIXGetPan(AXVPB* p); +void MIXSetSPan(AXVPB* p, int span); +void MIXAdjustSPan(AXVPB* p, int span); +int MIXGetSPan(AXVPB* p); +void MIXMute(AXVPB* p); +void MIXUnMute(AXVPB* p); +int MIXIsMute(AXVPB* p); +void MIXSetFader(AXVPB* p, int dB); +void MIXAdjustFader(AXVPB* p, int dB); +int MIXGetFader(AXVPB* p); +void MIXSetDvdStreamFader(int dB); +int MIXGetDvdStreamFader(void); +void MIXUpdateSettings(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_MIX_H_ diff --git a/include/dolphin/mtx.h b/include/dolphin/mtx.h new file mode 100644 index 000000000..5346bc75e --- /dev/null +++ b/include/dolphin/mtx.h @@ -0,0 +1,375 @@ +#ifndef _DOLPHIN_MTX_H_ +#define _DOLPHIN_MTX_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + f32 x, y, z; +} Vec, *VecPtr, Point3d, *Point3dPtr; + +typedef struct { + s16 x, y, z; +} S16Vec, *S16VecPtr; + +typedef struct { + f32 x, y, z, w; +} Quaternion, *QuaternionPtr, Qtrn, *QtrnPtr; + +typedef f32 Mtx[3][4]; +typedef f32 (*MtxPtr)[4]; + +typedef f32 Mtx44[4][4]; +typedef f32 (*Mtx44Ptr)[4]; + +typedef f32 ROMtx[4][3]; +typedef f32 (*ROMtxPtr)[4]; + +typedef struct { + u32 numMtx; + MtxPtr stackBase; + MtxPtr stackPtr; +} MTXStack; + +#define MTXDegToRad(d) (d * 0.01745329252f) +#define MTXRadToDeg(r) (r * 57.29577951f) + +// MTX +// C version +void C_MTXIdentity(Mtx m); +void C_MTXCopy(const Mtx src, Mtx dst); +void C_MTXConcat(const Mtx a, const Mtx b, Mtx ab); +void C_MTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count); +void C_MTXTranspose(const Mtx src, Mtx xPose); +u32 C_MTXInverse(const Mtx src, Mtx inv); +u32 C_MTXInvXpose(const Mtx src, Mtx invX); +void C_MTXRotRad(Mtx m, char axis, f32 rad); +void C_MTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA); +void C_MTXRotAxisRad(Mtx m, const Vec* axis, f32 rad); +void C_MTXTrans(Mtx m, f32 xT, f32 yT, f32 zT); +void C_MTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT); +void C_MTXScale(Mtx m, f32 xS, f32 yS, f32 zS); +void C_MTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS); +void C_MTXQuat(Mtx m, const Quaternion* q); +void C_MTXReflect(Mtx m, const Vec* p, const Vec* n); + +// PS version +void PSMTXIdentity(Mtx m); +void PSMTXCopy(const Mtx src, Mtx dst); +void PSMTXConcat(const Mtx a, const Mtx b, Mtx ab); +void PSMTXConcatArray(const Mtx a, const Mtx* srcBase, Mtx* dstBase, u32 count); +void PSMTXTranspose(const Mtx src, Mtx xPose); +u32 PSMTXInverse(const Mtx src, Mtx inv); +u32 PSMTXInvXpose(const Mtx src, Mtx invX); +void PSMTXRotRad(Mtx m, char axis, f32 rad); +void PSMTXRotTrig(Mtx m, char axis, f32 sinA, f32 cosA); +void PSMTXRotAxisRad(Mtx m, const Vec* axis, f32 rad); +void PSMTXTrans(Mtx m, f32 xT, f32 yT, f32 zT); +void PSMTXTransApply(const Mtx src, Mtx dst, f32 xT, f32 yT, f32 zT); +void PSMTXScale(Mtx m, f32 xS, f32 yS, f32 zS); +void PSMTXScaleApply(const Mtx src, Mtx dst, f32 xS, f32 yS, f32 zS); +void PSMTXQuat(Mtx m, const Quaternion* q); +void PSMTXReflect(Mtx m, const Vec* p, const Vec* n); + +#ifdef DEBUG +#define MTXIdentity C_MTXIdentity +#define MTXCopy C_MTXCopy +#define MTXConcat C_MTXConcat +#define MTXInverse C_MTXInverse +#define MTXTranspose C_MTXTranspose +#define MTXInverse C_MTXInverse +#define MTXInvXpose C_MTXInvXpose +#define MTXRotRad C_MTXRotRad +#define MTXRotTrig C_MTXRotTrig +#define MTXRotAxisRad C_MTXRotRad +#define MTXTrans C_MTXTrans +#define MTXTransApply C_MTXTransApply +#define MTXScale C_MTXScale +#define MTXScaleApply C_MTXScaleApply +#define MTXQuat C_MTXQuat +#define MTXReflect C_MTXReflect +#else +#define MTXIdentity PSMTXIdentity +#define MTXCopy PSMTXCopy +#define MTXConcat PSMTXConcat +#define MTXInverse PSMTXInverse +#define MTXTranspose PSMTXTranspose +#define MTXInverse PSMTXInverse +#define MTXInvXpose PSMTXInvXpose +#define MTXRotRad PSMTXRotRad +#define MTXRotTrig PSMTXRotTrig +#define MTXRotAxisRad PSMTXRotRad +#define MTXTrans PSMTXTrans +#define MTXTransApply PSMTXTransApply +#define MTXScale PSMTXScale +#define MTXScaleApply PSMTXScaleApply +#define MTXQuat PSMTXQuat +#define MTXReflect PSMTXReflect +#endif + +// C versions only +void C_MTXLookAt(Mtx m, const Point3d* camPos, const Vec* camUp, const Point3d* target); +void C_MTXLightFrustum(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 scaleS, f32 scaleT, f32 transS, f32 transT); +void C_MTXLightPerspective(Mtx m, f32 fovY, f32 aspect, f32 scaleS, f32 scaleT, f32 transS, f32 transT); +void C_MTXLightOrtho(Mtx m, f32 t, f32 b, f32 l, f32 r, f32 scaleS, f32 scaleT, f32 transS, f32 transT); + +#define MTXLookAt C_MTXLookAt +#define MTXLightFrustum C_MTXLightFrustum +#define MTXLightPerspective C_MTXLightPerspective +#define MTXLightOrtho C_MTXLightOrtho + +// MTXVEC +// C versions +void C_MTXMultVec(const Mtx m, const Vec* src, Vec* dst); +void C_MTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); +void C_MTXMultVecSR(const Mtx m, const Vec* src, Vec* dst); +void C_MTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); + +// PS versions +void PSMTXMultVec(const Mtx m, const Vec* src, Vec* dst); +void PSMTXMultVecArray(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXMultVecSR(const Mtx m, const Vec* src, Vec* dst); +void PSMTXMultVecArraySR(const Mtx m, const Vec* srcBase, Vec* dstBase, u32 count); + +#ifdef DEBUG +#define MTXMultVec C_MTXMultVec +#define MTXMultVecArray C_MTXMultVecArray +#define MTXMultVecSR C_MTXMultVecSR +#define MTXMultVecArraySR C_MTXMultVecArraySR +#else +#define MTXMultVec PSMTXMultVec +#define MTXMultVecArray PSMTXMultVecArray +#define MTXMultVecSR PSMTXMultVecSR +#define MTXMultVecArraySR PSMTXMultVecArraySR +#endif + +// MTX44 +// C versions +void C_MTX44Identity(Mtx44 m); +void C_MTX44Copy(const Mtx44 src, Mtx44 dst); +void C_MTX44Concat(const Mtx44 a, const Mtx44 b, Mtx44 ab); +void C_MTX44Transpose(const Mtx44 src, Mtx44 xPose); +void C_MTX44Trans(Mtx44 m, f32 xT, f32 yT, f32 zT); +void C_MTX44TransApply(const Mtx44 src, Mtx44 dst, f32 xT, f32 yT, f32 zT); +void C_MTX44Scale(Mtx44 m, f32 xS, f32 yS, f32 zS); +void C_MTX44ScaleApply(const Mtx44 src, Mtx44 dst, f32 xS, f32 yS, f32 zS); +void C_MTX44RotRad(Mtx44 m, char axis, f32 rad); +void C_MTX44RotTrig(Mtx44 m, char axis, f32 sinA, f32 cosA); +void C_MTX44RotAxisRad(Mtx44 m, const Vec* axis, f32 rad); + +// PS versions +void PSMTX44Identity(Mtx44 m); +void PSMTX44Copy(const Mtx44 src, Mtx44 dst); +void PSMTX44Concat(const Mtx44 a, const Mtx44 b, Mtx44 ab); +void PSMTX44Transpose(const Mtx44 src, Mtx44 xPose); +void PSMTX44Trans(Mtx44 m, f32 xT, f32 yT, f32 zT); +void PSMTX44TransApply(const Mtx44 src, Mtx44 dst, f32 xT, f32 yT, f32 zT); +void PSMTX44Scale(Mtx44 m, f32 xS, f32 yS, f32 zS); +void PSMTX44ScaleApply(const Mtx44 src, Mtx44 dst, f32 xS, f32 yS, f32 zS); +void PSMTX44RotRad(Mtx44 m, char axis, f32 rad); +void PSMTX44RotTrig(Mtx44 m, char axis, f32 sinA, f32 cosA); +void PSMTX44RotAxisRad(Mtx44 m, const Vec* axis, f32 rad); + +#ifdef DEBUG +#define MTX44Identity C_MTX44Identity +#define MTX44Copy C_MTX44Copy +#define MTX44Concat C_MTX44Concat +#define MTX44Transpose C_MTX44Transpose +#define MTX44Trans C_MTX44Trans +#define MTX44TransApply C_MTX44TransApply +#define MTX44Scale C_MTX44Scale +#define MTX44ScaleApply C_MTX44ScaleApply +#define MTX44RotRad C_MTX44RotRad +#define MTX44RotTrig C_MTX44RotTrig +#define MTX44RotAxisRad C_MTX44RotAxisRad +#else +#define MTX44Identity PSMTX44Identity +#define MTX44Copy PSMTX44Copy +#define MTX44Concat PSMTX44Concat +#define MTX44Transpose PSMTX44Transpose +#define MTX44Trans PSMTX44Trans +#define MTX44TransApply PSMTX44TransApply +#define MTX44Scale PSMTX44Scale +#define MTX44ScaleApply PSMTX44ScaleApply +#define MTX44RotRad PSMTX44RotRad +#define MTX44RotTrig PSMTX44RotTrig +#define MTX44RotAxisRad PSMTX44RotAxisRad +#endif + +// C versions only +void C_MTXFrustum(Mtx44 m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f); +void C_MTXPerspective(Mtx44 m, f32 fovY, f32 aspect, f32 n, f32 f); +void C_MTXOrtho(Mtx44 m, f32 t, f32 b, f32 l, f32 r, f32 n, f32 f); +u32 C_MTX44Inverse(const Mtx44 src, Mtx44 inv); + +#define MTXFrustum C_MTXFrustum +#define MTXPerspective C_MTXPerspective +#define MTXOrtho C_MTXOrtho +#define MTX44Inverse C_MTX44Inverse + +// MTX44VEC +// C versions +void C_MTX44MultVec(const Mtx44 m, const Vec* src, Vec* dst); +void C_MTX44MultVecArray(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); +void C_MTX44MultVecSR(const Mtx44 m, const Vec* src, Vec* dst); +void C_MTX44MultVecArraySR(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); + +// PS versions +void PSMTX44MultVec(const Mtx44 m, const Vec* src, Vec* dst); +void PSMTX44MultVecArray(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTX44MultVecSR(const Mtx44 m, const Vec* src, Vec* dst); +void PSMTX44MultVecArraySR(const Mtx44 m, const Vec* srcBase, Vec* dstBase, u32 count); + +#ifdef DEBUG +#define MTX44MultVec C_MTX44MultVec +#define MTX44MultVecArray C_MTX44MultVecArray +#define MTX44MultVecSR C_MTX44MultVecSR +#define MTX44MultVecArraySR C_MTX44MultVecArraySR +#else +#define MTX44MultVec PSMTX44MultVec +#define MTX44MultVecArray PSMTX44MultVecArray +#define MTX44MultVecSR PSMTX44MultVecSR +#define MTX44MultVecArraySR PSMTX44MultVecArraySR +#endif + +// PSMTX +void PSMTXReorder(const Mtx src, ROMtx dest); +void PSMTXROMultVecArray(const ROMtx m, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXROSkin2VecArray(const ROMtx m0, const ROMtx m1, const f32* wtBase, const Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXROMultS16VecArray(const Mtx m, const S16Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXMultS16VecArray(const ROMtx* m, const S16Vec* srcBase, Vec* dstBase, u32 count); + +// MTXSTACK +void MTXInitStack(MTXStack* sPtr, u32 numMtx); +MtxPtr MTXPush(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPushFwd(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPushInv(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPushInvXpose(MTXStack* sPtr, const Mtx m); +MtxPtr MTXPop(MTXStack* sPtr); +MtxPtr MTXGetStackPtr(const MTXStack* sPtr); + +// VEC +// C versions +void C_VECAdd(const Vec* a, const Vec* b, Vec* ab); +void C_VECSubtract(const Vec* a, const Vec* b, Vec* a_b); +void C_VECScale(const Vec* src, Vec* dst, f32 scale); +void C_VECNormalize(const Vec* src, Vec* unit); +f32 C_VECSquareMag(const Vec* v); +f32 C_VECMag(const Vec* v); +f32 C_VECDotProduct(const Vec* a, const Vec* b); +void C_VECCrossProduct(const Vec* a, const Vec* b, Vec* axb); +f32 C_VECSquareDistance(const Vec* a, const Vec* b); +f32 C_VECDistance(const Vec* a, const Vec* b); + +// PS versions +void PSVECAdd(const Vec* a, const Vec* b, Vec* ab); +void PSVECSubtract(const Vec* a, const Vec* b, Vec* a_b); +void PSVECScale(const Vec* src, Vec* dst, f32 scale); +void PSVECNormalize(const Vec* src, Vec* dst); +f32 PSVECSquareMag(const Vec* v); +f32 PSVECMag(const Vec* v); +f32 PSVECDotProduct(const Vec* a, const Vec* b); +void PSVECCrossProduct(const Vec* a, const Vec* b, Vec* axb); +f32 PSVECSquareDistance(const Vec* a, const Vec* b); +f32 PSVECDistance(const Vec* a, const Vec* b); + +#ifdef DEBUG +#define VECAdd C_VECAdd +#define VECSubtract C_VECSubtract +#define VECScale C_VECScale +#define VECNormalize C_VECNormalize +#define VECSquareMag C_VECSquareMag +#define VECMag C_VECMag +#define VECDotProduct C_VECDotProduct +#define VECCrossProduct C_VECCrossProduct +#define VECSquareDistance C_VECSquareDistance +#define VECDistance C_VECDistance +#else +#define VECAdd PSVECAdd +#define VECSubtract PSVECSubtract +#define VECScale PSVECScale +#define VECNormalize PSVECNormalize +#define VECSquareMag PSVECSquareMag +#define VECMag PSVECMag +#define VECDotProduct PSVECDotProduct +#define VECCrossProduct PSVECCrossProduct +#define VECSquareDistance PSVECSquareDistance +#define VECDistance PSVECDistance +#endif + +void C_VECHalfAngle(const Vec* a, const Vec* b, Vec* half); +void C_VECReflect(const Vec* src, const Vec* normal, Vec* dst); + +#define VECHalfAngle C_VECHalfAngle +#define VECReflect C_VECReflect + +// QUAT +// C versions +void C_QUATAdd(const Quaternion* p, const Quaternion* q, Quaternion* r); +void C_QUATSubtract(const Quaternion* p, const Quaternion* q, Quaternion* r); +void C_QUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq); +void C_QUATScale(const Quaternion* q, Quaternion* r, f32 scale); +f32 C_QUATDotProduct(const Quaternion* p, const Quaternion* q); +void C_QUATNormalize(const Quaternion* src, Quaternion* unit); +void C_QUATInverse(const Quaternion* src, Quaternion* inv); +void C_QUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r); + +// PS versions +void PSQUATAdd(const Quaternion* p, const Quaternion* q, Quaternion* r); +void PSQUATSubtract(const Quaternion* p, const Quaternion* q, Quaternion* r); +void PSQUATMultiply(const Quaternion* p, const Quaternion* q, Quaternion* pq); +void PSQUATScale(const Quaternion* q, Quaternion* r, f32 scale); +f32 PSQUATDotProduct(const Quaternion* p, const Quaternion* q); +void PSQUATNormalize(const Quaternion* src, Quaternion* unit); +void PSQUATInverse(const Quaternion* src, Quaternion* inv); +void PSQUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r); + +#ifdef DEBUG +#define QUATAdd C_QUATAdd +#define QUATSubtract C_QUATSubtract +#define QUATMultiply C_QUATMultiply +#define QUATScale C_QUATScale +#define QUATDotProduct C_QUATDotProduct +#define QUATNormalize C_QUATNormalize +#define QUATInverse C_QUATInverse +#define QUATDivide C_QUATDivide +#else +#define QUATAdd PSQUATAdd +#define QUATSubtract PSQUATSubtract +#define QUATMultiply PSQUATMultiply +#define QUATScale PSQUATScale +#define QUATDotProduct PSQUATDotProduct +#define QUATNormalize PSQUATNormalize +#define QUATInverse PSQUATInverse +#define QUATDivide PSQUATDivide +#endif + +// C versions only +void C_QUATExp(const Quaternion* q, Quaternion* r); +void C_QUATLogN(const Quaternion* q, Quaternion* r); +void C_QUATMakeClosest(const Quaternion* q, const Quaternion* qto, Quaternion* r); +void C_QUATRotAxisRad(Quaternion* r, const Vec* axis, f32 rad); +void C_QUATMtx(Quaternion* r, const Mtx m); +void C_QUATLerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t); +void C_QUATSlerp(const Quaternion* p, const Quaternion* q, Quaternion* r, f32 t); +void C_QUATSquad(const Quaternion* p, const Quaternion* a, const Quaternion* b, const Quaternion* q, Quaternion* r, f32 t); +void C_QUATCompA(const Quaternion* qprev, const Quaternion* q, const Quaternion* qnext, Quaternion* a); + +#define QUATExp C_QUATExp +#define QUATLogN C_QUATLogN +#define QUATMakeClosest C_QUATMakeClosest +#define QUATRotAxisRad C_QUATRotAxisRad +#define QUATMtx C_QUATMtx +#define QUATLerp C_QUATLerp +#define QUATSlerp C_QUATSlerp +#define QUATSquad C_QUATSquad +#define QUATCompA C_QUATCompA + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os.h b/include/dolphin/os.h new file mode 100644 index 000000000..05ea543a3 --- /dev/null +++ b/include/dolphin/os.h @@ -0,0 +1,258 @@ +#ifndef _DOLPHIN_OS_H_ +#define _DOLPHIN_OS_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef s64 OSTime; +typedef u32 OSTick; + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// private macro, maybe shouldn't be defined here? +#define OFFSET(addr, align) (((u32)(addr) & ((align)-1))) + +#define DOLPHIN_ALIGNMENT 32 + +// Upper words of the masks, since UIMM is only 16 bits +#define OS_CACHED_REGION_PREFIX 0x8000 +#define OS_UNCACHED_REGION_PREFIX 0xC000 +#define OS_PHYSICAL_MASK 0x3FFF + +#define OS_BASE_CACHED (OS_CACHED_REGION_PREFIX << 16) +#define OS_BASE_UNCACHED (OS_UNCACHED_REGION_PREFIX << 16) + +#ifdef __MWERKS__ +u32 __OSPhysicalMemSize AT_ADDRESS(OS_BASE_CACHED | 0x0028); +volatile int __OSTVMode AT_ADDRESS(OS_BASE_CACHED | 0x00CC); +OSThreadQueue __OSActiveThreadQueue AT_ADDRESS(OS_BASE_CACHED | 0x00DC); +OSThread* __OSCurrentThread AT_ADDRESS(OS_BASE_CACHED | 0x00E4); +u32 __OSSimulatedMemSize AT_ADDRESS(OS_BASE_CACHED | 0x00F0); +u32 __OSBusClock AT_ADDRESS(OS_BASE_CACHED | 0x00F8); +u32 __OSCoreClock AT_ADDRESS(OS_BASE_CACHED | 0x00FC); +volatile u16 __OSDeviceCode AT_ADDRESS(OS_BASE_CACHED | 0x30E6); +u16 __OSWirelessPadFixMode AT_ADDRESS(OS_BASE_CACHED | 0x30E0); + +// unknowns +OSThread* __gUnkThread1 AT_ADDRESS(OS_BASE_CACHED | 0x00D8); +int __gUnknown800030C0[2] AT_ADDRESS(OS_BASE_CACHED | 0x30C0); +u8 __gUnknown800030E3 AT_ADDRESS(OS_BASE_CACHED | 0x30E3); +#else +#define __OSBusClock (*(u32 *)(OS_BASE_CACHED | 0x00F8)) +#define __OSCoreClock (*(u32 *)(OS_BASE_CACHED | 0x00FC)) +#endif + +#define OS_BUS_CLOCK __OSBusClock +#define OS_CORE_CLOCK __OSCoreClock +#define OS_TIMER_CLOCK (OS_BUS_CLOCK/4) + +#define OSTicksToSeconds(ticks) ((ticks) / (OS_TIMER_CLOCK)) +#define OSTicksToMilliseconds(ticks) ((ticks) / (OS_TIMER_CLOCK/1000)) +#define OSTicksToMicroseconds(ticks) ((ticks) * 8 / (OS_TIMER_CLOCK/125000)) +#define OSSecondsToTicks(sec) ((sec) * (OS_TIMER_CLOCK)) +#define OSMillisecondsToTicks(msec) ((msec) * (OS_TIMER_CLOCK / 1000)) +#define OSNanosecondsToTicks(nsec) (((nsec) * (OS_TIMER_CLOCK / 125000)) / 8000) +#define OSMicrosecondsToTicks(usec) (((usec) * (OS_TIMER_CLOCK / 125000)) / 8) + +u32 OSGetConsoleType(void); +void OSInit(void); +void OSRegisterVersion(const char* id); + +void* OSGetArenaHi(void); +void* OSGetArenaLo(void); +void OSSetArenaHi(void* newHi); +void OSSetArenaLo(void* newLo); +void* OSAllocFromArenaLo(u32 size, u32 align); +void* OSAllocFromArenaHi(u32 size, u32 align); + +u32 OSGetPhysicalMemSize(void); + +void __OSPSInit(void); +void __OSFPRInit(void); +u32 __OSGetDIConfig(void); + +void OSDefaultExceptionHandler(__OSException exception, OSContext* context); + +typedef struct OSCalendarTime { + /* 0x00 */ int sec; + /* 0x04 */ int min; + /* 0x08 */ int hour; + /* 0x0C */ int mday; + /* 0x10 */ int mon; + /* 0x14 */ int year; + /* 0x18 */ int wday; + /* 0x1C */ int yday; + /* 0x20 */ int msec; + /* 0x24 */ int usec; +} OSCalendarTime; + +#include +typedef struct OSBootInfo_s { + DVDDiskID DVDDiskID; + u32 magic; + u32 version; + u32 memorySize; + u32 consoleType; + void* arenaLo; + void* arenaHi; + void* FSTLocation; + u32 FSTMaxLength; +} OSBootInfo; + +typedef struct OSStopwatch { + char* name; + u32 hits; + OSTime total; + OSTime min; + OSTime max; + OSTime last; + BOOL running; + u32 _padding; +} OSStopwatch; + +void OSInitStopwatch(OSStopwatch* sw, char* name); +void OSStartStopwatch(OSStopwatch* sw); +void OSStopStopwatch(OSStopwatch* sw); +OSTime OSCheckStopwatch(OSStopwatch* sw); +void OSResetStopwatch(OSStopwatch* sw); +void OSDumpStopwatch(OSStopwatch* sw); + +OSTick OSGetTick(void); +OSTime OSGetTime(void); +void OSTicksToCalendarTime(OSTime ticks, OSCalendarTime* td); +OSTime OSCalendarTimeToTicks(OSCalendarTime* td); +BOOL OSEnableInterrupts(void); +BOOL OSDisableInterrupts(void); +BOOL OSRestoreInterrupts(BOOL level); + +#define OS_CONSOLE_MASK 0xF0000000 +#define OS_CONSOLE_RETAIL 0x00000000 +#define OS_CONSOLE_DEVELOPMENT 0x10000000 +#define OS_CONSOLE_TDEV 0x20000000 + +#define OS_CONSOLE_RETAIL4 0x00000004 +#define OS_CONSOLE_RETAIL3 0x00000003 +#define OS_CONSOLE_RETAIL2 0x00000002 +#define OS_CONSOLE_RETAIL1 0x00000001 +#define OS_CONSOLE_TDEVHW4 0x20000007 +#define OS_CONSOLE_TDEVHW3 0x20000006 +#define OS_CONSOLE_TDEVHW2 0x20000005 +#define OS_CONSOLE_TDEVHW1 0x20000004 +#define OS_CONSOLE_DEVHW4 0x10000007 +#define OS_CONSOLE_DEVHW3 0x10000006 +#define OS_CONSOLE_DEVHW2 0x10000005 +#define OS_CONSOLE_DEVHW1 0x10000004 +#define OS_CONSOLE_MINNOW 0x10000003 +#define OS_CONSOLE_ARTHUR 0x10000002 +#define OS_CONSOLE_PC_EMULATOR 0x10000001 +#define OS_CONSOLE_EMULATOR 0x10000000 + +#define OS_SOUND_MODE_MONO 0 +#define OS_SOUND_MODE_STEREO 1 + +u32 OSGetSoundMode(void); +void OSSetSoundMode(u32 mode); + +__declspec(weak) void OSReport(const char* msg, ...); +__declspec(weak) void OSVReport(const char* msg, va_list list); +__declspec(weak) void OSPanic(const char* file, int line, const char* msg, ...); +void OSFatal(GXColor fg, GXColor bg, const char* msg); + +#define OSRoundUp32B(x) (((u32)(x) + 32 - 1) & ~(32 - 1)) +#define OSRoundDown32B(x) (((u32)(x)) & ~(32 - 1)) + +void* OSPhysicalToCached(u32 paddr); +void* OSPhysicalToUncached(u32 paddr); +u32 OSCachedToPhysical(void* caddr); +u32 OSUncachedToPhysical(void* ucaddr); +void* OSCachedToUncached(void* caddr); +void* OSUncachedToCached(void* ucaddr); + +#if !DEBUG +#define OSPhysicalToCached(paddr) ((void*) ((u32)(OS_BASE_CACHED + (u32)(paddr)))) +#define OSPhysicalToUncached(paddr) ((void*) ((u32)(OS_BASE_UNCACHED + (u32)(paddr)))) +#define OSCachedToPhysical(caddr) ((u32) ((u32)(caddr) - OS_BASE_CACHED)) +#define OSUncachedToPhysical(ucaddr) ((u32) ((u32)(ucaddr) - OS_BASE_UNCACHED)) +#define OSCachedToUncached(caddr) ((void*) ((u8*)(caddr) + (OS_BASE_UNCACHED - OS_BASE_CACHED))) +#define OSUncachedToCached(ucaddr) ((void*) ((u8*)(ucaddr) - (OS_BASE_UNCACHED - OS_BASE_CACHED))) +#endif + +// unsorted externs +extern OSTime __OSGetSystemTime(void); +__declspec(weak) extern int __OSIsGcam; +extern OSExecParams __OSRebootParams; +extern OSTime __OSStartTime; +extern int __OSInIPL; + +// helper for assert line numbers in different revisions +#if SDK_REVISION < 1 + #define LINE(l0, l1, l2) (l0) +#elif SDK_REVISION < 2 + #define LINE(l0, l1, l2) (l1) +#else + #define LINE(l0, l1, l2) (l2) +#endif + + +#ifdef DEBUG +#define ASSERTLINE(line, cond) \ + ((cond) || (OSPanic(__FILE__, line, "Failed assertion " #cond), 0)) + +#define ASSERTMSGLINE(line, cond, msg) \ + ((cond) || (OSPanic(__FILE__, line, msg), 0)) + +// This is dumb but we dont have a Metrowerks way to do variadic macros in the macro to make this done in a not scrubby way. +#define ASSERTMSG1LINE(line, cond, msg, arg1) \ + ((cond) || (OSPanic(__FILE__, line, msg, arg1), 0)) + +#define ASSERTMSG2LINE(line, cond, msg, arg1, arg2) \ + ((cond) || (OSPanic(__FILE__, line, msg, arg1, arg2), 0)) + +#define ASSERTMSGLINEV(line, cond, ...) \ + ((cond) || (OSPanic(__FILE__, line, __VA_ARGS__), 0)) + +#else +#define ASSERTLINE(line, cond) (void)0 +#define ASSERTMSGLINE(line, cond, msg) (void)0 +#define ASSERTMSG1LINE(line, cond, msg, arg1) (void)0 +#define ASSERTMSG2LINE(line, cond, msg, arg1, arg2) (void)0 +#define ASSERTMSGLINEV(line, cond, ...) (void)0 +#endif + +#define ASSERT(cond) ASSERTLINE(__LINE__, cond) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSAlarm.h b/include/dolphin/os/OSAlarm.h new file mode 100644 index 000000000..310503918 --- /dev/null +++ b/include/dolphin/os/OSAlarm.h @@ -0,0 +1,36 @@ +#ifndef _DOLPHIN_OSALARM_H_ +#define _DOLPHIN_OSALARM_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct OSAlarm OSAlarm; +typedef void (*OSAlarmHandler)(OSAlarm* alarm, OSContext* context); +struct OSAlarm { + OSAlarmHandler handler; + u32 tag; + OSTime fire; + OSAlarm* prev; + OSAlarm* next; + OSTime period; + OSTime start; +}; + +BOOL OSCheckAlarmQueue(void); +void OSInitAlarm(void); +void OSCreateAlarm(OSAlarm* alarm); +void OSSetAlarm(OSAlarm* alarm, OSTime tick, OSAlarmHandler handler); +void OSSetAbsAlarm(OSAlarm* alarm, OSTime time, OSAlarmHandler handler); +void OSSetPeriodicAlarm(OSAlarm* alarm, OSTime start, OSTime period, OSAlarmHandler handler); +void OSCancelAlarm(OSAlarm *alarm); +void OSSetAlarmTag(OSAlarm* alarm, u32 tag); +void OSCancelAlarms(u32 tag); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSALARM_H_ diff --git a/include/dolphin/os/OSAlloc.h b/include/dolphin/os/OSAlloc.h new file mode 100644 index 000000000..77eb88661 --- /dev/null +++ b/include/dolphin/os/OSAlloc.h @@ -0,0 +1,34 @@ +#ifndef _DOLPHIN_OSALLOC_H_ +#define _DOLPHIN_OSALLOC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef int OSHeapHandle; + +extern volatile OSHeapHandle __OSCurrHeap; + +void* OSAllocFromHeap(int heap, u32 size); +void* OSAllocFixed(void* rstart, void* rend); +void OSFreeToHeap(int heap, void* ptr); +int OSSetCurrentHeap(int heap); +void* OSInitAlloc(void* arenaStart, void* arenaEnd, int maxHeaps); +int OSCreateHeap(void* start, void* end); +void OSDestroyHeap(int heap); +void OSAddToHeap(int heap, void* start, void* end); +s32 OSCheckHeap(int heap); +u32 OSReferentSize(void* ptr); +void OSDumpHeap(int heap); +void OSVisitAllocated(void (*visitor)(void*, u32)); + +#define OSAlloc(size) OSAllocFromHeap(__OSCurrHeap, (size)) +#define OSFree(ptr) OSFreeToHeap(__OSCurrHeap, (ptr)) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSCache.h b/include/dolphin/os/OSCache.h new file mode 100644 index 000000000..89e7ce96b --- /dev/null +++ b/include/dolphin/os/OSCache.h @@ -0,0 +1,38 @@ +#ifndef _DOLPHIN_OSCACHE_H_ +#define _DOLPHIN_OSCACHE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void DCInvalidateRange(void* addr, u32 nBytes); +void DCFlushRange(void* addr, u32 nBytes); +void DCStoreRange(void* addr, u32 nBytes); +void DCFlushRangeNoSync(void* addr, u32 nBytes); +void DCStoreRangeNoSync(void* addr, u32 nBytes); +void DCZeroRange(void* addr, u32 nBytes); +void DCTouchRange(void* addr, u32 nBytes); +void ICInvalidateRange(void* addr, u32 nBytes); + +#define LC_BASE_PREFIX 0xE000 +#define LC_BASE (LC_BASE_PREFIX << 16) +#define LCGetBase() ((void*)LC_BASE) + +void LCEnable(void); +void LCDisable(void); +void LCLoadBlocks(void* destTag, void* srcAddr, u32 numBlocks); +void LCStoreBlocks(void* destAddr, void* srcTag, u32 numBlocks); +u32 LCLoadData(void* destAddr, void* srcAddr, u32 nBytes); +u32 LCStoreData(void* destAddr, void* srcAddr, u32 nBytes); +u32 LCQueueLength(void); +void LCQueueWait(u32 len); +void LCFlushQueue(void); +void __OSCacheInit(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSContext.h b/include/dolphin/os/OSContext.h new file mode 100644 index 000000000..cbb0b92e4 --- /dev/null +++ b/include/dolphin/os/OSContext.h @@ -0,0 +1,173 @@ +#ifndef _DOLPHIN_OSCONTEXT_H_ +#define _DOLPHIN_OSCONTEXT_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define __OS_CONTEXT_FRAME 768 + +#define OS_CONTEXT_R0 0 +#define OS_CONTEXT_R1 4 +#define OS_CONTEXT_R2 8 +#define OS_CONTEXT_R3 12 +#define OS_CONTEXT_R4 16 +#define OS_CONTEXT_R5 20 +#define OS_CONTEXT_R6 24 +#define OS_CONTEXT_R7 28 +#define OS_CONTEXT_R8 32 +#define OS_CONTEXT_R9 36 +#define OS_CONTEXT_R10 40 +#define OS_CONTEXT_R11 44 +#define OS_CONTEXT_R12 48 +#define OS_CONTEXT_R13 52 +#define OS_CONTEXT_R14 56 +#define OS_CONTEXT_R15 60 +#define OS_CONTEXT_R16 64 +#define OS_CONTEXT_R17 68 +#define OS_CONTEXT_R18 72 +#define OS_CONTEXT_R19 76 +#define OS_CONTEXT_R20 80 +#define OS_CONTEXT_R21 84 +#define OS_CONTEXT_R22 88 +#define OS_CONTEXT_R23 92 +#define OS_CONTEXT_R24 96 +#define OS_CONTEXT_R25 100 +#define OS_CONTEXT_R26 104 +#define OS_CONTEXT_R27 108 +#define OS_CONTEXT_R28 112 +#define OS_CONTEXT_R29 116 +#define OS_CONTEXT_R30 120 +#define OS_CONTEXT_R31 124 + +#define OS_CONTEXT_CR 128 +#define OS_CONTEXT_LR 132 +#define OS_CONTEXT_CTR 136 +#define OS_CONTEXT_XER 140 + +#define OS_CONTEXT_FPR0 144 +#define OS_CONTEXT_FPR1 152 +#define OS_CONTEXT_FPR2 160 +#define OS_CONTEXT_FPR3 168 +#define OS_CONTEXT_FPR4 176 +#define OS_CONTEXT_FPR5 184 +#define OS_CONTEXT_FPR6 192 +#define OS_CONTEXT_FPR7 200 +#define OS_CONTEXT_FPR8 208 +#define OS_CONTEXT_FPR9 216 +#define OS_CONTEXT_FPR10 224 +#define OS_CONTEXT_FPR11 232 +#define OS_CONTEXT_FPR12 240 +#define OS_CONTEXT_FPR13 248 +#define OS_CONTEXT_FPR14 256 +#define OS_CONTEXT_FPR15 264 +#define OS_CONTEXT_FPR16 272 +#define OS_CONTEXT_FPR17 280 +#define OS_CONTEXT_FPR18 288 +#define OS_CONTEXT_FPR19 296 +#define OS_CONTEXT_FPR20 304 +#define OS_CONTEXT_FPR21 312 +#define OS_CONTEXT_FPR22 320 +#define OS_CONTEXT_FPR23 328 +#define OS_CONTEXT_FPR24 336 +#define OS_CONTEXT_FPR25 344 +#define OS_CONTEXT_FPR26 352 +#define OS_CONTEXT_FPR27 360 +#define OS_CONTEXT_FPR28 368 +#define OS_CONTEXT_FPR29 376 +#define OS_CONTEXT_FPR30 384 +#define OS_CONTEXT_FPR31 392 + +#define OS_CONTEXT_FPSCR 400 + +#define OS_CONTEXT_SRR0 408 +#define OS_CONTEXT_SRR1 412 + +#define OS_CONTEXT_MODE 416 +#define OS_CONTEXT_STATE 418 + +#define OS_CONTEXT_GQR0 420 +#define OS_CONTEXT_GQR1 424 +#define OS_CONTEXT_GQR2 428 +#define OS_CONTEXT_GQR3 432 +#define OS_CONTEXT_GQR4 436 +#define OS_CONTEXT_GQR5 440 +#define OS_CONTEXT_GQR6 444 +#define OS_CONTEXT_GQR7 448 +#define __OSCONTEXT_PADDING 452 + +#define OS_CONTEXT_PSF0 456 +#define OS_CONTEXT_PSF1 464 +#define OS_CONTEXT_PSF2 472 +#define OS_CONTEXT_PSF3 480 +#define OS_CONTEXT_PSF4 488 +#define OS_CONTEXT_PSF5 496 +#define OS_CONTEXT_PSF6 504 +#define OS_CONTEXT_PSF7 512 +#define OS_CONTEXT_PSF8 520 +#define OS_CONTEXT_PSF9 528 +#define OS_CONTEXT_PSF10 536 +#define OS_CONTEXT_PSF11 544 +#define OS_CONTEXT_PSF12 552 +#define OS_CONTEXT_PSF13 560 +#define OS_CONTEXT_PSF14 568 +#define OS_CONTEXT_PSF15 576 +#define OS_CONTEXT_PSF16 584 +#define OS_CONTEXT_PSF17 592 +#define OS_CONTEXT_PSF18 600 +#define OS_CONTEXT_PSF19 608 +#define OS_CONTEXT_PSF20 616 +#define OS_CONTEXT_PSF21 624 +#define OS_CONTEXT_PSF22 632 +#define OS_CONTEXT_PSF23 640 +#define OS_CONTEXT_PSF24 648 +#define OS_CONTEXT_PSF25 656 +#define OS_CONTEXT_PSF26 664 +#define OS_CONTEXT_PSF27 672 +#define OS_CONTEXT_PSF28 680 +#define OS_CONTEXT_PSF29 688 +#define OS_CONTEXT_PSF30 696 +#define OS_CONTEXT_PSF31 704 +#define OS_CONTEXT_STATE_EXC 0x02u + +#define OS_CONTEXT_STATE_FPSAVED 0x01u + +typedef struct OSContext { + /* 0x000 */ u32 gpr[32]; + /* 0x080 */ u32 cr; + /* 0x084 */ u32 lr; + /* 0x088 */ u32 ctr; + /* 0x08C */ u32 xer; + /* 0x090 */ f64 fpr[32]; + /* 0x190 */ u32 fpscr_pad; + /* 0x194 */ u32 fpscr; + /* 0x198 */ u32 srr0; + /* 0x19C */ u32 srr1; + /* 0x1A0 */ u16 mode; + /* 0x1A2 */ u16 state; + /* 0x1A4 */ u32 gqr[8]; + /* 0x1C4 */ u32 psf_pad; + /* 0x1C8 */ f64 psf[32]; +} OSContext; + +u32 OSGetStackPointer(void); +void OSDumpContext(OSContext* context); +void OSLoadContext(OSContext* context); +u32 OSSaveContext(OSContext* context); +void OSClearContext(OSContext* context); +OSContext* OSGetCurrentContext(void); +void OSSetCurrentContext(OSContext* context); +void OSLoadFPUContext(OSContext* fpucontext); +void OSSaveFPUContext(OSContext* fpucontext); +u32 OSSwitchStack(u32 newsp); +int OSSwitchFiber(u32 pc, u32 newsp); +void OSInitContext(OSContext* context, u32 pc, u32 newsp); +void OSFillFPUContext(OSContext* context); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSDC.h b/include/dolphin/os/OSDC.h new file mode 100644 index 000000000..bab2d68ed --- /dev/null +++ b/include/dolphin/os/OSDC.h @@ -0,0 +1,23 @@ +#ifndef _DOLPHIN_OSDC_H_ +#define _DOLPHIN_OSDC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +void DCFlashInvalidate(void); +void DCEnable(void); +void DCDisable(void); +void DCFreeze(void); +void DCUnfreeze(void); +void DCTouchLoad(void* addr); +void DCBlockZero(void* addr); +void DCBlockStore(void* addr); +void DCBlockFlush(void* addr); +void DCBlockInvalidate(void* addr); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSError.h b/include/dolphin/os/OSError.h new file mode 100644 index 000000000..4a2fc7bd7 --- /dev/null +++ b/include/dolphin/os/OSError.h @@ -0,0 +1,38 @@ +#ifndef _DOLPHIN_OSERROR_H_ +#define _DOLPHIN_OSERROR_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef u16 OSError; +typedef void (*OSErrorHandler)(OSError error, OSContext* context, ...); + +#define OS_ERROR_SYSTEM_RESET 0 +#define OS_ERROR_MACHINE_CHECK 1 +#define OS_ERROR_DSI 2 +#define OS_ERROR_ISI 3 +#define OS_ERROR_EXTERNAL_INTERRUPT 4 +#define OS_ERROR_ALIGNMENT 5 +#define OS_ERROR_PROGRAM 6 +#define OS_ERROR_FLOATING_POINT 7 +#define OS_ERROR_DECREMENTER 8 +#define OS_ERROR_SYSTEM_CALL 9 +#define OS_ERROR_TRACE 10 +#define OS_ERROR_PERFORMACE_MONITOR 11 +#define OS_ERROR_BREAKPOINT 12 +#define OS_ERROR_SYSTEM_INTERRUPT 13 +#define OS_ERROR_THERMAL_INTERRUPT 14 +#define OS_ERROR_MAX (OS_ERROR_THERMAL_INTERRUPT + 1) + +OSErrorHandler OSSetErrorHandler(OSError error, OSErrorHandler handler); +extern u32 __OSFpscrEnableBits; +extern OSErrorHandler __OSErrorTable[17]; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSException.h b/include/dolphin/os/OSException.h new file mode 100644 index 000000000..e9a2f2256 --- /dev/null +++ b/include/dolphin/os/OSException.h @@ -0,0 +1,61 @@ +#ifndef _DOLPHIN_OSEXCEPTION_H_ +#define _DOLPHIN_OSEXCEPTION_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define __OS_EXCEPTION_SYSTEM_RESET 0 +#define __OS_EXCEPTION_MACHINE_CHECK 1 +#define __OS_EXCEPTION_DSI 2 +#define __OS_EXCEPTION_ISI 3 +#define __OS_EXCEPTION_EXTERNAL_INTERRUPT 4 +#define __OS_EXCEPTION_ALIGNMENT 5 +#define __OS_EXCEPTION_PROGRAM 6 +#define __OS_EXCEPTION_FLOATING_POINT 7 +#define __OS_EXCEPTION_DECREMENTER 8 +#define __OS_EXCEPTION_SYSTEM_CALL 9 +#define __OS_EXCEPTION_TRACE 10 +#define __OS_EXCEPTION_PERFORMACE_MONITOR 11 +#define __OS_EXCEPTION_BREAKPOINT 12 +#define __OS_EXCEPTION_SYSTEM_INTERRUPT 13 +#define __OS_EXCEPTION_THERMAL_INTERRUPT 14 +#define __OS_EXCEPTION_MEMORY_PROTECTION 15 +#define __OS_EXCEPTION_FLOATING_POINT_EXCEPTION 16 +#define __OS_EXCEPTION_MAX \ + (__OS_EXCEPTION_THERMAL_INTERRUPT+1) + +typedef u8 __OSException; +typedef void (*__OSExceptionHandler)(__OSException exception, OSContext* context); + +__OSExceptionHandler __OSSetExceptionHandler(__OSException exception, __OSExceptionHandler handler); +__OSExceptionHandler __OSGetExceptionHandler(__OSException exception); + +#define OS_EXCEPTION_SAVE_GPRS(context) \ + stw r0, OS_CONTEXT_R0(context); \ + stw r1, OS_CONTEXT_R1(context); \ + stw r2, OS_CONTEXT_R2(context); \ + stmw r6, OS_CONTEXT_R6(context); \ + mfspr r0, GQR1; \ + stw r0, OS_CONTEXT_GQR1(context); \ + mfspr r0, GQR2; \ + stw r0, OS_CONTEXT_GQR2(context); \ + mfspr r0, GQR3; \ + stw r0, OS_CONTEXT_GQR3(context); \ + mfspr r0, GQR4; \ + stw r0, OS_CONTEXT_GQR4(context); \ + mfspr r0, GQR5; \ + stw r0, OS_CONTEXT_GQR5(context); \ + mfspr r0, GQR6; \ + stw r0, OS_CONTEXT_GQR6(context); \ + mfspr r0, GQR7; \ + stw r0, OS_CONTEXT_GQR7(context); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSEXCEPTION_H_ diff --git a/include/dolphin/os/OSExec.h b/include/dolphin/os/OSExec.h new file mode 100644 index 000000000..af0dc4da0 --- /dev/null +++ b/include/dolphin/os/OSExec.h @@ -0,0 +1,35 @@ +#ifndef _DOLPHIN_OSEXEC_H_ +#define _DOLPHIN_OSEXEC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + BOOL valid; + u32 restartCode; + u32 bootDol; + void* regionStart; + void* regionEnd; + int argsUseDefault; + void* argsAddr; +} OSExecParams; + +typedef int (*appGetNextCallback)(void*, u32*, u32*); +typedef void (*appInitCallback)(void (*)(char*)); +typedef void* (*appGetEntryCallback)(); +typedef void (*AppLoaderCallback)(appInitCallback*, appGetNextCallback*, appGetEntryCallback*); + +OSExecParams* __OSExecParams AT_ADDRESS(0x800030F0); +s32 __OSAppLoaderOffset AT_ADDRESS(0x800030F4); + +void OSExecv(const char* dolfile, const char** argv); +void OSExecl(const char* dolfile, const char* arg0, ...); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSFont.h b/include/dolphin/os/OSFont.h new file mode 100644 index 000000000..1fff41a62 --- /dev/null +++ b/include/dolphin/os/OSFont.h @@ -0,0 +1,58 @@ +#ifndef _DOLPHIN_OSFONT_H_ +#define _DOLPHIN_OSFONT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_FONT_ENCODE_ANSI 0u +#define OS_FONT_ENCODE_SJIS 1u +#define OS_FONT_ENCODE_MAX 5u +#define OS_FONT_SIZE_ANSI (288 + 131072) // 9 sheets +#define OS_FONT_SIZE_SJIS (3840 + 1179648) // 1 sheet +#define OS_FONT_ROM_SIZE_ANSI 0x03000 +#define OS_FONT_ROM_SIZE_SJIS 0x4D000 + +typedef struct OSFontHeader { + u16 fontType; + u16 firstChar; + u16 lastChar; + u16 invalChar; + u16 ascent; + u16 descent; + u16 width; + u16 leading; + u16 cellWidth; + u16 cellHeight; + u32 sheetSize; + u16 sheetFormat; + u16 sheetColumn; + u16 sheetRow; + u16 sheetWidth; + u16 sheetHeight; + u16 widthTable; + u32 sheetImage; + u32 sheetFullSize; + u8 c0; + u8 c1; + u8 c2; + u8 c3; +} OSFontHeader; + +u16 OSGetFontEncode(void); +u16 OSSetFontEncode(u16 encode); +BOOL OSInitFont(OSFontHeader* fontData); +u32 OSLoadFont(OSFontHeader* fontData, void* tmp); +char* OSGetFontTexture(const char* string, void** image, s32* x, s32* y, s32* width); +char* OSGetFontWidth(const char* string, s32* width); +char* OSGetFontTexel(const char* string, void* image, s32 pos, s32 stride, s32* width); +int OSSetFontWidth(int fixed); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSIC.h b/include/dolphin/os/OSIC.h new file mode 100644 index 000000000..3309d3a6f --- /dev/null +++ b/include/dolphin/os/OSIC.h @@ -0,0 +1,20 @@ +#ifndef _DOLPHIN_OSIC_H_ +#define _DOLPHIN_OSIC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +void ICFlashInvalidate(void); +void ICEnable(void); +void ICDisable(void); +void ICFreeze(void); +void ICUnfreeze(void); +void ICBlockInvalidate(void *addr); +void ICSync(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSInterrupt.h b/include/dolphin/os/OSInterrupt.h new file mode 100644 index 000000000..fb74135a2 --- /dev/null +++ b/include/dolphin/os/OSInterrupt.h @@ -0,0 +1,118 @@ +#ifndef _DOLPHIN_OSINTERRUPT_H_ +#define _DOLPHIN_OSINTERRUPT_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef s16 __OSInterrupt; +typedef u32 OSInterruptMask; + +#define __OS_INTERRUPT_MEM_0 0 +#define __OS_INTERRUPT_MEM_1 1 +#define __OS_INTERRUPT_MEM_2 2 +#define __OS_INTERRUPT_MEM_3 3 +#define __OS_INTERRUPT_MEM_ADDRESS 4 +#define __OS_INTERRUPT_DSP_AI 5 +#define __OS_INTERRUPT_DSP_ARAM 6 +#define __OS_INTERRUPT_DSP_DSP 7 +#define __OS_INTERRUPT_AI_AI 8 +#define __OS_INTERRUPT_EXI_0_EXI 9 +#define __OS_INTERRUPT_EXI_0_TC 10 +#define __OS_INTERRUPT_EXI_0_EXT 11 +#define __OS_INTERRUPT_EXI_1_EXI 12 +#define __OS_INTERRUPT_EXI_1_TC 13 +#define __OS_INTERRUPT_EXI_1_EXT 14 +#define __OS_INTERRUPT_EXI_2_EXI 15 +#define __OS_INTERRUPT_EXI_2_TC 16 +#define __OS_INTERRUPT_PI_CP 17 +#define __OS_INTERRUPT_PI_PE_TOKEN 18 +#define __OS_INTERRUPT_PI_PE_FINISH 19 +#define __OS_INTERRUPT_PI_SI 20 +#define __OS_INTERRUPT_PI_DI 21 +#define __OS_INTERRUPT_PI_RSW 22 +#define __OS_INTERRUPT_PI_ERROR 23 +#define __OS_INTERRUPT_PI_VI 24 +#define __OS_INTERRUPT_PI_DEBUG 25 +#define __OS_INTERRUPT_PI_HSP 26 +#define __OS_INTERRUPT_MAX 32 + +#define OS_INTERRUPTMASK(interrupt) (0x80000000u >> (interrupt)) + +#define OS_INTERRUPTMASK_MEM_0 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_0) +#define OS_INTERRUPTMASK_MEM_1 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_1) +#define OS_INTERRUPTMASK_MEM_2 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_2) +#define OS_INTERRUPTMASK_MEM_3 OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_3) +#define OS_INTERRUPTMASK_MEM_ADDRESS OS_INTERRUPTMASK(__OS_INTERRUPT_MEM_ADDRESS) +#define OS_INTERRUPTMASK_MEM_RESET \ + (OS_INTERRUPTMASK_MEM_0 | OS_INTERRUPTMASK_MEM_1 | OS_INTERRUPTMASK_MEM_2 | \ + OS_INTERRUPTMASK_MEM_3) +#define OS_INTERRUPTMASK_MEM \ + (OS_INTERRUPTMASK_MEM_0 | OS_INTERRUPTMASK_MEM_1 | OS_INTERRUPTMASK_MEM_2 | \ + OS_INTERRUPTMASK_MEM_3 | OS_INTERRUPTMASK_MEM_ADDRESS) +#define OS_INTERRUPTMASK_DSP_AI OS_INTERRUPTMASK(__OS_INTERRUPT_DSP_AI) +#define OS_INTERRUPTMASK_DSP_ARAM OS_INTERRUPTMASK(__OS_INTERRUPT_DSP_ARAM) +#define OS_INTERRUPTMASK_DSP_DSP OS_INTERRUPTMASK(__OS_INTERRUPT_DSP_DSP) +#define OS_INTERRUPTMASK_DSP \ + (OS_INTERRUPTMASK_DSP_AI | OS_INTERRUPTMASK_DSP_ARAM | OS_INTERRUPTMASK_DSP_DSP) +#define OS_INTERRUPTMASK_AI_AI OS_INTERRUPTMASK(__OS_INTERRUPT_AI_AI) +#define OS_INTERRUPTMASK_AI (OS_INTERRUPTMASK_AI_AI) +#define OS_INTERRUPTMASK_EXI_0_EXI OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_0_EXI) +#define OS_INTERRUPTMASK_EXI_0_TC OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_0_TC) +#define OS_INTERRUPTMASK_EXI_0_EXT OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_0_EXT) +#define OS_INTERRUPTMASK_EXI_0 \ + (OS_INTERRUPTMASK_EXI_0_EXI | OS_INTERRUPTMASK_EXI_0_TC | OS_INTERRUPTMASK_EXI_0_EXT) +#define OS_INTERRUPTMASK_EXI_1_EXI OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_1_EXI) +#define OS_INTERRUPTMASK_EXI_1_TC OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_1_TC) +#define OS_INTERRUPTMASK_EXI_1_EXT OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_1_EXT) +#define OS_INTERRUPTMASK_EXI_1 \ + (OS_INTERRUPTMASK_EXI_1_EXI | OS_INTERRUPTMASK_EXI_1_TC | OS_INTERRUPTMASK_EXI_1_EXT) +#define OS_INTERRUPTMASK_EXI_2_EXI OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_2_EXI) +#define OS_INTERRUPTMASK_EXI_2_TC OS_INTERRUPTMASK(__OS_INTERRUPT_EXI_2_TC) +#define OS_INTERRUPTMASK_EXI_2 (OS_INTERRUPTMASK_EXI_2_EXI | OS_INTERRUPTMASK_EXI_2_TC) +#define OS_INTERRUPTMASK_EXI \ + (OS_INTERRUPTMASK_EXI_0_EXI | OS_INTERRUPTMASK_EXI_0_TC | OS_INTERRUPTMASK_EXI_0_EXT | \ + OS_INTERRUPTMASK_EXI_1_EXI | OS_INTERRUPTMASK_EXI_1_TC | OS_INTERRUPTMASK_EXI_1_EXT | \ + OS_INTERRUPTMASK_EXI_2_EXI | OS_INTERRUPTMASK_EXI_2_TC) +#define OS_INTERRUPTMASK_PI_PE_TOKEN OS_INTERRUPTMASK(__OS_INTERRUPT_PI_PE_TOKEN) +#define OS_INTERRUPTMASK_PI_PE_FINISH OS_INTERRUPTMASK(__OS_INTERRUPT_PI_PE_FINISH) +#define OS_INTERRUPTMASK_PI_PE (OS_INTERRUPTMASK_PI_PE_TOKEN | OS_INTERRUPTMASK_PI_PE_FINISH) +#define OS_INTERRUPTMASK_PI_CP OS_INTERRUPTMASK(__OS_INTERRUPT_PI_CP) +#define OS_INTERRUPTMASK_PI_SI OS_INTERRUPTMASK(__OS_INTERRUPT_PI_SI) +#define OS_INTERRUPTMASK_PI_DI OS_INTERRUPTMASK(__OS_INTERRUPT_PI_DI) +#define OS_INTERRUPTMASK_PI_RSW OS_INTERRUPTMASK(__OS_INTERRUPT_PI_RSW) +#define OS_INTERRUPTMASK_PI_ERROR OS_INTERRUPTMASK(__OS_INTERRUPT_PI_ERROR) +#define OS_INTERRUPTMASK_PI_VI OS_INTERRUPTMASK(__OS_INTERRUPT_PI_VI) +#define OS_INTERRUPTMASK_PI_DEBUG OS_INTERRUPTMASK(__OS_INTERRUPT_PI_DEBUG) +#define OS_INTERRUPTMASK_PI_HSP OS_INTERRUPTMASK(__OS_INTERRUPT_PI_HSP) +#define OS_INTERRUPTMASK_PI \ + (OS_INTERRUPTMASK_PI_CP | OS_INTERRUPTMASK_PI_SI | OS_INTERRUPTMASK_PI_DI | \ + OS_INTERRUPTMASK_PI_RSW | OS_INTERRUPTMASK_PI_ERROR | OS_INTERRUPTMASK_PI_VI | \ + OS_INTERRUPTMASK_PI_PE_TOKEN | OS_INTERRUPTMASK_PI_PE_FINISH | OS_INTERRUPTMASK_PI_DEBUG | \ + OS_INTERRUPTMASK_PI_HSP) + +typedef void (*__OSInterruptHandler)(__OSInterrupt interrupt, OSContext* context); + +extern volatile __OSInterrupt __OSLastInterrupt; +extern volatile u32 __OSLastInterruptSrr0; +extern volatile OSTime __OSLastInterruptTime; + +__OSInterruptHandler __OSSetInterruptHandler(__OSInterrupt interrupt, __OSInterruptHandler handler); + +__OSInterruptHandler __OSGetInterruptHandler(__OSInterrupt interrupt); + +void __OSDispatchInterrupt(__OSException exception, OSContext* context); + +OSInterruptMask OSGetInterruptMask(void); +OSInterruptMask OSSetInterruptMask(OSInterruptMask mask); +OSInterruptMask __OSMaskInterrupts(OSInterruptMask mask); +OSInterruptMask __OSUnmaskInterrupts(OSInterruptMask mask); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSL2.h b/include/dolphin/os/OSL2.h new file mode 100644 index 000000000..01b4a620c --- /dev/null +++ b/include/dolphin/os/OSL2.h @@ -0,0 +1,20 @@ +#ifndef _DOLPHIN_OSL2_H_ +#define _DOLPHIN_OSL2_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void L2Enable(void); +void L2Disable(void); +void L2GlobalInvalidate(void); +void L2SetDataOnly(BOOL dataOnly); +void L2SetWriteThrough(BOOL writeThrough); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSLC.h b/include/dolphin/os/OSLC.h new file mode 100644 index 000000000..af49708b1 --- /dev/null +++ b/include/dolphin/os/OSLC.h @@ -0,0 +1,19 @@ +#ifndef _DOLPHIN_OSLC_H_ +#define _DOLPHIN_OSLC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void LCAllocOneTag(BOOL invalidate, void *tag); +void LCAllocTags(BOOL invalidate, void *startTag, u32 numBlocks); +void LCAlloc(void *addr, u32 nBytes); +void LCAllocNoInvalidate(void *addr, u32 nBytes); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSMemory.h b/include/dolphin/os/OSMemory.h new file mode 100644 index 000000000..a5debebc9 --- /dev/null +++ b/include/dolphin/os/OSMemory.h @@ -0,0 +1,28 @@ +#ifndef _DOLPHIN_OSMEMORY_H_ +#define _DOLPHIN_OSMEMORY_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_PROTECT_CHAN0 0 +#define OS_PROTECT_CHAN1 1 +#define OS_PROTECT_CHAN2 2 +#define OS_PROTECT_CHAN3 3 + +#define OS_PROTECT_CONTROL_NONE 0x00 +#define OS_PROTECT_CONTROL_READ 0x01 +#define OS_PROTECT_CONTROL_WRITE 0x02 +#define OS_PROTECT_CONTROL_RDWR (OS_PROTECT_CONTROL_READ | OS_PROTECT_CONTROL_WRITE) + +void OSProtectRange(u32 chan, void* addr, u32 nBytes, u32 control); +u32 OSGetPhysicalMemSize(void); +u32 OSGetConsoleSimulatedMemSize(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSMessage.h b/include/dolphin/os/OSMessage.h new file mode 100644 index 000000000..192f998fb --- /dev/null +++ b/include/dolphin/os/OSMessage.h @@ -0,0 +1,28 @@ +#ifndef _DOLPHIN_OSMESSAGE_H_ +#define _DOLPHIN_OSMESSAGE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + OSThreadQueue queueSend; + OSThreadQueue queueReceive; + void* msgArray; + s32 msgCount; + s32 firstIndex; + s32 usedCount; +} OSMessageQueue; + +void OSInitMessageQueue(OSMessageQueue* mq, void* msgArray, s32 msgCount); +int OSSendMessage(OSMessageQueue* mq, void* msg, s32 flags); +int OSReceiveMessage(OSMessageQueue* mq, void* msg, s32 flags); +int OSJamMessage(OSMessageQueue* mq, void* msg, s32 flags); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSMESSAGE_H_ diff --git a/include/dolphin/os/OSModule.h b/include/dolphin/os/OSModule.h new file mode 100644 index 000000000..6e66e9b00 --- /dev/null +++ b/include/dolphin/os/OSModule.h @@ -0,0 +1,117 @@ +#ifndef _DOLPHIN_OSMODULE_H_ +#define _DOLPHIN_OSMODULE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_MODULE_VERSION 3 +typedef struct OSModuleHeader OSModuleHeader; + +typedef u32 OSModuleID; +typedef struct OSModuleQueue OSModuleQueue; +typedef struct OSModuleLink OSModuleLink; +typedef struct OSModuleInfo OSModuleInfo; +typedef struct OSSectionInfo OSSectionInfo; +typedef struct OSImportInfo OSImportInfo; +typedef struct OSRel OSRel; + +struct OSModuleQueue { + OSModuleInfo* head; + OSModuleInfo* tail; +}; + +struct OSModuleLink { + OSModuleInfo* next; + OSModuleInfo* prev; +}; + +struct OSModuleInfo { + OSModuleID id; // unique identifier for the module + OSModuleLink link; // doubly linked list of modules + u32 numSections; // # of sections + u32 sectionInfoOffset; // offset to section info table + u32 nameOffset; // offset to module name + u32 nameSize; // size of module name + u32 version; // version number +}; + +struct OSModuleHeader { + // CAUTION: info must be the 1st member + OSModuleInfo info; + + // OS_MODULE_VERSION == 1 + u32 bssSize; // total size of bss sections in bytes + u32 relOffset; + u32 impOffset; + u32 impSize; // size in bytes + u8 prologSection; // section # for prolog function + u8 epilogSection; // section # for epilog function + u8 unresolvedSection; // section # for unresolved function + u8 bssSection; // section # for bss section (set at run-time) + u32 prolog; // prolog function offset + u32 epilog; // epilog function offset + u32 unresolved; // unresolved function offset + + // OS_MODULE_VERSION == 2 +#if (2 <= OS_MODULE_VERSION) + u32 align; // module alignment constraint + u32 bssAlign; // bss alignment constraint +#endif + + // OS_MODULE_VERSION == 3 +#if (3 <= OS_MODULE_VERSION) + u32 fixSize; +#endif +}; + +#define OSGetSectionInfo(module) ((OSSectionInfo*)(((OSModuleInfo*)(module))->sectionInfoOffset)) + +struct OSSectionInfo { + u32 offset; + u32 size; +}; + +// OSSectionInfo.offset bit +#define OS_SECTIONINFO_EXEC 0x1 +#define OS_SECTIONINFO_OFFSET(offset) ((offset) & ~0x1) + +struct OSImportInfo { + OSModuleID id; // external module id + u32 offset; // offset to OSRel instructions +}; + +struct OSRel { + u16 offset; // byte offset from the previous entry + u8 type; + u8 section; + u32 addend; +}; + +#define R_DOLPHIN_NOP 201 // C9h current offset += OSRel.offset +#define R_DOLPHIN_SECTION 202 // CAh current section = OSRel.section +#define R_DOLPHIN_END 203 // CBh +#define R_DOLPHIN_MRKREF 204 // CCh + +void OSSetStringTable(void* stringTable); +BOOL OSLink(OSModuleInfo* newModule, void* bss); + +#if (3 <= OS_MODULE_VERSION) +BOOL OSLinkFixed(OSModuleInfo* newModule, void* bss); +#endif + +BOOL OSUnlink(OSModuleInfo* oldModule); + +OSModuleInfo* OSSearchModule(void* ptr, u32* section, u32* offset); + +// debugger notification +void OSNotifyLink(OSModuleInfo* module); +void OSNotifyUnlink(OSModuleInfo* module); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSMutex.h b/include/dolphin/os/OSMutex.h new file mode 100644 index 000000000..ef5565eb6 --- /dev/null +++ b/include/dolphin/os/OSMutex.h @@ -0,0 +1,33 @@ +#ifndef _DOLPHIN_OSMUTEX_H_ +#define _DOLPHIN_OSMUTEX_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct OSMutex { + /* 0x00 */ OSThreadQueue queue; + /* 0x08 */ OSThread* thread; + /* 0x0C */ s32 count; + /* 0x10 */ OSMutexLink link; +}; + +typedef struct OSCond { + OSThreadQueue queue; +} OSCond; + +void OSInitMutex(OSMutex* mutex); +void OSLockMutex(OSMutex* mutex); +void OSUnlockMutex(OSMutex* mutex); +BOOL OSTryLockMutex(OSMutex* mutex); +void OSInitCond(OSCond* cond); +void OSWaitCond(OSCond* cond, OSMutex* mutex); +void OSSignalCond(OSCond* cond); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSReboot.h b/include/dolphin/os/OSReboot.h new file mode 100644 index 000000000..650953479 --- /dev/null +++ b/include/dolphin/os/OSReboot.h @@ -0,0 +1,19 @@ +#ifndef _DOLPHIN_OSREBOOT_H_ +#define _DOLPHIN_OSREBOOT_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void OSSetSaveRegion(void* start, void* end); +void OSGetSaveRegion(void** start, void** end); +void OSGetSavedRegion(void** start, void** end); +void __OSReboot(u32 resetCode, u32 bootDol); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSReset.h b/include/dolphin/os/OSReset.h new file mode 100644 index 000000000..15c2ba62f --- /dev/null +++ b/include/dolphin/os/OSReset.h @@ -0,0 +1,39 @@ +#ifndef _DOLPHIN_OSRESET_H_ +#define _DOLPHIN_OSRESET_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_RESET_RESTART 0 +#define OS_RESET_HOTRESET 1 +#define OS_RESET_SHUTDOWN 2 + +typedef struct OSResetFunctionInfo OSResetFunctionInfo; +typedef struct OSResetFunctionQueue { + OSResetFunctionInfo* head; + OSResetFunctionInfo* tail; +} OSResetFunctionQueue; + +typedef BOOL (*OSResetFunction)(BOOL); + +struct OSResetFunctionInfo { + OSResetFunction func; + u32 priority; + OSResetFunctionInfo* next; + OSResetFunctionInfo* prev; +}; + +void OSRegisterResetFunction(OSResetFunctionInfo* info); +void OSUnregisterResetFunction(OSResetFunctionInfo* info); +void OSResetSystem(int reset, u32 resetCode, BOOL forceMenu); +u32 OSGetResetCode(); +u32 OSSetBootDol(u32 dolOffset); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSResetSW.h b/include/dolphin/os/OSResetSW.h new file mode 100644 index 000000000..3c630b857 --- /dev/null +++ b/include/dolphin/os/OSResetSW.h @@ -0,0 +1,20 @@ +#ifndef _DOLPHIN_OSRESETSW_H_ +#define _DOLPHIN_OSRESETSW_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*OSResetCallback)(void); + +OSResetCallback OSSetResetCallback(OSResetCallback callback); +BOOL OSGetResetSwitchState(void); +BOOL OSGetResetButtonState(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSRtc.h b/include/dolphin/os/OSRtc.h new file mode 100644 index 000000000..ed3c3dd81 --- /dev/null +++ b/include/dolphin/os/OSRtc.h @@ -0,0 +1,77 @@ +#ifndef _DOLPHIN_OSRTC_H_ +#define _DOLPHIN_OSRTC_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// make the assert happy +#define OS_SOUND_MODE_MONO 0 +#define OS_SOUND_MODE_STEREO 1 + +// make the asserts happy +#define OS_VIDEO_MODE_NTSC 0 +#define OS_VIDEO_MODE_MPAL 2 + +#define OS_PROGRESSIVE_MODE_OFF 0 +#define OS_PROGRESSIVE_MODE_ON 1 + +#define OS_EURGB60_OFF 0 +#define OS_EURGB60_ON 1 + +typedef struct OSSram { + u16 checkSum; + u16 checkSumInv; + u32 ead0; + u32 ead1; + u32 counterBias; + s8 displayOffsetH; + u8 ntd; + u8 language; + u8 flags; +} OSSram; + +typedef struct OSSramEx { + u8 flashID[2][12]; + u32 wirelessKeyboardID; + u16 wirelessPadID[4]; + u8 dvdErrorCode; + u8 _padding0; + u8 flashIDCheckSum[2]; + u16 gbs; + u8 _padding1[2]; +} OSSramEx; + +#define SRAM_SIZE (sizeof(OSSram) + sizeof(OSSramEx)) + +typedef struct SramControl { + u8 sram[SRAM_SIZE]; // dummy for OSSram + OSSramEx + u32 offset; + BOOL enabled; + BOOL locked; + int sync; + void (*callback)(); +} SramControl; + +u32 OSGetSoundMode(void); +void OSSetSoundMode(u32 mode); +u32 OSGetVideoMode(void); +void OSSetVideoMode(u32 mode); +u8 OSGetLanguage(void); +void OSSetLanguage(u8 language); +u16 OSGetGbsMode(void); +void OSSetGbsMode(u16 mode); +u32 OSGetProgressiveMode(void); +void OSSetProgressiveMode(u32 on); +u32 OSGetEuRgb60Mode(void); +void OSSetEuRgb60Mode(u32 on); +u16 OSGetWirelessID(s32 chan); +void OSSetWirelessID(s32 chan, u16 id); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSRTC_H_ diff --git a/include/dolphin/os/OSSemaphore.h b/include/dolphin/os/OSSemaphore.h new file mode 100644 index 000000000..aac23811a --- /dev/null +++ b/include/dolphin/os/OSSemaphore.h @@ -0,0 +1,25 @@ +#ifndef _DOLPHIN_OSSEMAPHORE_H_ +#define _DOLPHIN_OSSEMAPHORE_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct OSSemaphore { + s32 count; + OSThreadQueue queue; +} OSSemaphore; + +void OSInitSemaphore(OSSemaphore* sem, s32 count); +s32 OSWaitSemaphore(OSSemaphore* sem); +s32 OSTryWaitSemaphore(OSSemaphore* sem); +s32 OSSignalSemaphore(OSSemaphore* sem); +s32 OSGetSemaphoreCount(OSSemaphore* sem); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSSEMAPHORE_H_ diff --git a/include/dolphin/os/OSSerial.h b/include/dolphin/os/OSSerial.h new file mode 100644 index 000000000..7c38395f7 --- /dev/null +++ b/include/dolphin/os/OSSerial.h @@ -0,0 +1,6 @@ +#ifndef _DOLPHIN_OSSERIAL_H +#define _DOLPHIN_OSSERIAL_H + +#include + +#endif // _DOLPHIN_OSSERIAL_H diff --git a/include/dolphin/os/OSThread.h b/include/dolphin/os/OSThread.h new file mode 100644 index 000000000..5511c7595 --- /dev/null +++ b/include/dolphin/os/OSThread.h @@ -0,0 +1,112 @@ +#ifndef _DOLPHIN_OSTHREAD_H_ +#define _DOLPHIN_OSTHREAD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef s32 OSPriority; + +typedef struct OSThread OSThread; +typedef struct OSMutex OSMutex; +typedef struct OSThreadQueue OSThreadQueue; +typedef struct OSMutexQueue OSMutexQueue; +typedef struct OSThreadLink OSThreadLink; +typedef struct OSMutexLink OSMutexLink; + +struct OSThreadQueue { + OSThread* head; + OSThread* tail; +}; + +struct OSThreadLink { + OSThread* next; + OSThread* prev; +}; + +struct OSMutexQueue { + OSMutex* head; + OSMutex* tail; +}; + +struct OSMutexLink { + OSMutex* next; + OSMutex* prev; +}; + +struct OSThread { + /* 0x000 */ OSContext context; + /* 0x2C8 */ u16 state; + /* 0x2CA */ u16 attr; + /* 0x2CC */ s32 suspend; + /* 0x2D0 */ OSPriority priority; + /* 0x2D4 */ OSPriority base; + /* 0x2D8 */ void* val; + /* 0x2DC */ OSThreadQueue* queue; + /* 0x2E0 */ OSThreadLink link; + /* 0x2E8 */ OSThreadQueue queueJoin; + /* 0x2F0 */ OSMutex* mutex; + /* 0x2F4 */ OSMutexQueue queueMutex; + /* 0x2FC */ OSThreadLink linkActive; + /* 0x304 */ u8* stackBase; + /* 0x308 */ u32* stackEnd; + /* 0x30C */ s32 error; + /* 0x310 */ void* specific[2]; +}; + +enum OS_THREAD_STATE { + OS_THREAD_STATE_READY = 1, + OS_THREAD_STATE_RUNNING = 2, + OS_THREAD_STATE_WAITING = 4, + OS_THREAD_STATE_MORIBUND = 8, +}; + +#define OS_PRIORITY_MIN 0 // highest +#define OS_PRIORITY_MAX 31 // lowest +#define OS_PRIORITY_IDLE OS_PRIORITY_MAX + +#define OS_THREAD_SPECIFIC_MAX 2 + +#define OS_THREAD_ATTR_DETACH 0x0001u + +#define OS_THREAD_STACK_MAGIC 0xDEADBABE + +typedef void (*OSSwitchThreadCallback)(OSThread*, OSThread*); +typedef void (*OSIdleFunction)(void*); + +void OSInitThreadQueue(OSThreadQueue* queue); +void OSSleepThread(OSThreadQueue* queue); +void OSWakeupThread(OSThreadQueue* queue); +s32 OSSuspendThread(OSThread* thread); +s32 OSResumeThread(OSThread* thread); +OSThread* OSGetCurrentThread(void); +s32 OSEnableScheduler(void); +s32 OSDisableScheduler(void); +void OSCancelThread(OSThread* thread); +void OSClearStack(u8 val); +BOOL OSIsThreadSuspended(OSThread* thread); +BOOL OSIsThreadTerminated(OSThread* thread); +void OSYieldThread(void); +int OSCreateThread(OSThread* thread, void* (*func)(void*), void* param, void* stack, u32 stackSize, OSPriority priority, u16 attr); +void OSExitThread(void* val); +int OSJoinThread(OSThread* thread, void* val); +void OSDetachThread(OSThread* thread); +int OSSetThreadPriority(OSThread* thread, OSPriority priority); +s32 OSGetThreadPriority(OSThread* thread); +OSThread* OSSetIdleFunction(OSIdleFunction idleFunction, void* param, void* stack, u32 stackSize); +OSThread* OSGetIdleFunction(void); +s32 OSCheckActiveThreads(void); +void OSSetThreadSpecific(s32 index, void* ptr); +void* OSGetThreadSpecific(s32 index); + +OSSwitchThreadCallback OSSetSwitchThreadCallback(OSSwitchThreadCallback callback); + +#define IsSuspended(suspend) (suspend > 0) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/os/OSTime.h b/include/dolphin/os/OSTime.h new file mode 100644 index 000000000..118adee7c --- /dev/null +++ b/include/dolphin/os/OSTime.h @@ -0,0 +1,44 @@ +#ifndef _DOLPHIN_OSTIME_H_ +#define _DOLPHIN_OSTIME_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Time base frequency = 1/4 bus clock +#define OS_TIME_SPEED (OS_BUS_CLOCK / 4) + +// OS time -> Real time +#define OS_TICKS_TO_SEC(x) ((x) / (OS_TIME_SPEED)) +#define OS_TICKS_TO_MSEC(x) ((x) / (OS_TIME_SPEED / 1000)) +#define OS_TICKS_TO_USEC(x) (((x)*8) / (OS_TIME_SPEED / 125000)) +#define OS_TICKS_TO_NSEC(x) (((x)*8000) / (OS_TIME_SPEED / 125000)) + +// Real time -> OS time +#define OS_SEC_TO_TICKS(x) ((x) * (OS_TIME_SPEED)) +#define OS_MSEC_TO_TICKS(x) ((x) * (OS_TIME_SPEED / 1000)) +#define OS_USEC_TO_TICKS(x) ((x) * (OS_TIME_SPEED / 125000) / 8) +#define OS_NSEC_TO_TICKS(x) ((x) * (OS_TIME_SPEED / 125000) / 8000) + +#define USEC_MAX 1000 +#define MSEC_MAX 1000 +#define MONTH_MAX 12 +#define WEEK_DAY_MAX 7 +#define YEAR_DAY_MAX 365 + +#define SECS_IN_MIN 60 +#define SECS_IN_HOUR (SECS_IN_MIN * 60) +#define SECS_IN_DAY (SECS_IN_HOUR * 24) +#define SECS_IN_YEAR (SECS_IN_DAY * 365) + +#define BIAS 0xB2575 + +#define __OSSystemTime (OSTime*)0x800030D8 + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSTIME_H_ diff --git a/include/dolphin/os/OSTimer.h b/include/dolphin/os/OSTimer.h new file mode 100644 index 000000000..490cccb67 --- /dev/null +++ b/include/dolphin/os/OSTimer.h @@ -0,0 +1,21 @@ +#ifndef _DOLPHIN_OSTIMER_H_ +#define _DOLPHIN_OSTIMER_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*OSTimerCallback)(void); + +OSTimerCallback OSSetTimerCallback(OSTimerCallback callback); +void OSInitTimer(u32 time, u32 mode); +void OSStartTimer(void); +void OSStopTimer(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSTIMER_H_ diff --git a/include/dolphin/os/OSUtf.h b/include/dolphin/os/OSUtf.h new file mode 100644 index 000000000..2f721d578 --- /dev/null +++ b/include/dolphin/os/OSUtf.h @@ -0,0 +1,23 @@ +#ifndef _DOLPHIN_OSUTF_H_ +#define _DOLPHIN_OSUTF_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +char* OSUTF8to32(const char* utf8, u32* utf32); +char* OSUTF32to8(u32 utf32, char* utf8); +u16* OSUTF16to32(const u16* utf16, u32* utf32); +u16* OSUTF32to16(u32 utf32, u16* utf16); +u8 OSUTF32toANSI(u32 utf32); +u32 OSANSItoUTF32(u8 ansi); +u16 OSUTF32toSJIS(u32 utf32); +u32 OSSJIStoUTF32(u16 sjis); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSUTF_H_ diff --git a/include/dolphin/pad.h b/include/dolphin/pad.h new file mode 100644 index 000000000..d966b8094 --- /dev/null +++ b/include/dolphin/pad.h @@ -0,0 +1,104 @@ +#ifndef _DOLPHIN_PAD_H_ +#define _DOLPHIN_PAD_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define PAD_SPEC_0 0 +#define PAD_SPEC_1 1 +#define PAD_SPEC_2 2 +#define PAD_SPEC_3 3 +#define PAD_SPEC_4 4 +#define PAD_SPEC_5 5 + +#define PAD_MOTOR_STOP 0 +#define PAD_MOTOR_RUMBLE 1 +#define PAD_MOTOR_STOP_HARD 2 + +#define PAD_CHAN0_BIT 0x80000000 +#define PAD_CHAN1_BIT 0x40000000 +#define PAD_CHAN2_BIT 0x20000000 +#define PAD_CHAN3_BIT 0x10000000 + +#define PAD_MAX_CONTROLLERS 4 + +#define PAD_BUTTON_LEFT (1 << 0) // 0x0001 +#define PAD_BUTTON_RIGHT (1 << 1) // 0x0002 +#define PAD_BUTTON_DOWN (1 << 2) // 0x0004 +#define PAD_BUTTON_UP (1 << 3) // 0x0008 +#define PAD_TRIGGER_Z (1 << 4) // 0x0010 +#define PAD_TRIGGER_R (1 << 5) // 0x0020 +#define PAD_TRIGGER_L (1 << 6) // 0x0040 +#define PAD_BUTTON_A (1 << 8) // 0x0100 +#define PAD_BUTTON_B (1 << 9) // 0x0200 +#define PAD_BUTTON_X (1 << 10) // 0x0400 +#define PAD_BUTTON_Y (1 << 11) // 0x0800 +#define PAD_BUTTON_MENU (1 << 12) // 0x1000 +#define PAD_BUTTON_START (1 << 12) // 0x1000 + +#define PAD_ERR_NONE 0 +#define PAD_ERR_NO_CONTROLLER -1 +#define PAD_ERR_NOT_READY -2 +#define PAD_ERR_TRANSFER -3 + +#define RES_WIRELESS_LITE 0x40000 + +typedef struct PADStatus { + /* 0x00 */ u16 button; + /* 0x02 */ s8 stickX; + /* 0x03 */ s8 stickY; + /* 0x04 */ s8 substickX; + /* 0x05 */ s8 substickY; + /* 0x06 */ u8 triggerLeft; + /* 0x07 */ u8 triggerRight; + /* 0x08 */ u8 analogA; + /* 0x09 */ u8 analogB; + /* 0x0A */ s8 err; +} PADStatus; + +typedef struct PADClampRegion { + u8 minTrigger; + u8 maxTrigger; + s8 minStick; + s8 maxStick; + s8 xyStick; + s8 minSubstick; + s8 maxSubstick; + s8 xySubstick; + s8 radStick; + s8 radSubstick; +} PADClampRegion; + +typedef void (*PADSamplingCallback)(void); + +// Pad +int PADReset(u32 mask); +BOOL PADRecalibrate(u32 mask); +BOOL PADInit(); +u32 PADRead(PADStatus* status); +void PADSetSamplingRate(u32 msec); +void __PADTestSamplingRate(u32 tvmode); +void PADControlAllMotors(const u32* commandArray); +void PADControlMotor(s32 chan, u32 command); +void PADSetSpec(u32 spec); +u32 PADGetSpec(); +int PADGetType(s32 chan, u32* type); +BOOL PADSync(void); +void PADSetAnalogMode(u32 mode); +BOOL __PADDisableRecalibration(BOOL disable); +BOOL PADIsBarrel(s32 chan); + +PADSamplingCallback PADSetSamplingCallback(PADSamplingCallback callback); + +// Padclamp +void PADClamp(PADStatus* status); +void PADClampCircle(PADStatus* status); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/perf.h b/include/dolphin/perf.h new file mode 100644 index 000000000..71471a53a --- /dev/null +++ b/include/dolphin/perf.h @@ -0,0 +1,99 @@ +#ifndef _DOLPHIN_PERF_H_ +#define _DOLPHIN_PERF_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef u8 PERFId; + +typedef enum { + PERF_CPU_EVENT, + PERF_CPU_GP_EVENT, + PERF_GP_EVENT, +} PerfType; + +typedef struct PerfSample { + /* 0x00 */ u8 id; + /* 0x04 */ u32 cpuTimeStampStart; + /* 0x08 */ u32 cpuTimeStampEnd; + /* 0x0C */ u32 gpTimeStampStart; + /* 0x10 */ u32 gpTimeStampEnd; + /* 0x14 */ int interrupted; + /* 0x18 */ u32 origcpuStart; + /* 0x1C */ u32 origgpStart; + /* 0x20 */ u32 cacheMisses[4]; + /* 0x30 */ u32 instructions[4]; + /* 0x40 */ u32 cpReq[2]; + /* 0x48 */ u32 tcReq[2]; + /* 0x50 */ u32 cpuRdReq[2]; + /* 0x58 */ u32 cpuWrReq[2]; + /* 0x60 */ u32 dspReq[2]; + /* 0x68 */ u32 ioReq[2]; + /* 0x70 */ u32 viReq[2]; + /* 0x78 */ u32 peReq[2]; + /* 0x80 */ u32 rfReq[2]; + /* 0x88 */ u32 fiReq[2]; + /* 0x90 */ u32 xfWaitIn[2]; + /* 0x98 */ u32 xfWaitOut[2]; + /* 0xA0 */ u32 rasBusy[2]; + /* 0xA8 */ u32 rasClocks[2]; +} PerfSample; + +typedef struct { + PerfSample* samples; + s32 lastSample; + u32 end; + u32 cachemisscycles; +} Frame; + +typedef struct { + char* name; + PerfType type; + s32 currSample; + GXColor color; +} PerfEvent; + +typedef void* (*PERFAllocator)(u32 size); +typedef void (*PERFDeallocator)(void* block); +typedef void (*PERFDrawCallback)(void); + +extern void (*GameDrawInit)(); + +u32 PERFInit(u32 numSamples, u32 numFramesHistory, u32 numTypes, PERFAllocator allocator, PERFDeallocator deallocator, PERFDrawCallback initDraw); +void PERFEventStart(PERFId id); +void PERFEventEnd(PERFId id); +void PERFSetEvent(PERFId id, char* name, PerfType type); +void PERFStartFrame(void); +void PERFEndFrame(void); +void PERFStartAutoSampling(f32 msInterval); +void PERFStopAutoSampling(void); + +void PERFPreDraw(void); +void PERFDumpScreen(void); +void PERFPostDraw(void); +void PERFSetDrawBWBarKey(BOOL tf); +void PERFSetDrawBWBar(BOOL tf); +void PERFSetDrawCPUBar(BOOL tf); +void PERFSetDrawXFBars(BOOL tf); +void PERFSetDrawRASBar(BOOL tf); +void PERFToggleDrawBWBarKey(void); +void PERFToggleDrawBWBar(void); +void PERFToggleDrawCPUBar(void); +void PERFToggleDrawXFBars(void); +void PERFToggleDrawRASBar(void); +void PERFShutDown(void); +void PERFSetDrawFrames(u32 frames); + +extern Frame* PERFFrames; +extern u32 PERFCurrFrame; +extern PerfEvent* PERFEvents; +extern u32 PERFNumEvents; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/seq.h b/include/dolphin/seq.h new file mode 100644 index 000000000..754798093 --- /dev/null +++ b/include/dolphin/seq.h @@ -0,0 +1,54 @@ +#ifndef _DOLPHIN_SEQ_H_ +#define _DOLPHIN_SEQ_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _SEQTRACK { + /* 0x00 */ void* sequence; + /* 0x04 */ u8* start; + /* 0x08 */ u8* end; + /* 0x0C */ u8* current; + /* 0x10 */ u8 status; + /* 0x14 */ f32 beatsPerSec; + /* 0x18 */ u32 defaultTicksPerFrame; + /* 0x1C */ u32 ticksPerFrame; + /* 0x20 */ u32 delay; + /* 0x24 */ u32 state; +} SEQTRACK; + +typedef struct _SEQSEQUENCE { + /* 0x0000 */ void* next; + /* 0x0004 */ u32 state; + /* 0x0008 */ u16 nTracks; + /* 0x000A */ s16 timeFormat; + /* 0x000C */ u32 tracksRunning; + /* 0x0010 */ u32 end; + /* 0x0014 */ SYNSYNTH synth; + /* 0x3154 */ void (*callback[128])(void*, u8); + /* 0x3354 */ SEQTRACK track[64]; +} SEQSEQUENCE; + +#define SEQ_ALL_TRACKS -1 + +void SEQInit(void); +void SEQQuit(void); +void SEQRunAudioFrame(void); +void SEQAddSequence(SEQSEQUENCE* sequence, u8* midiStream, void* wt, u32 aramBase, u32 zeroBase, u32 priorityVoiceAlloc, u32 priorityNoteOn, u32 priorityNoteRelease); +void SEQRemoveSequence(SEQSEQUENCE* sequence); +void SEQRegisterControllerCallback(SEQSEQUENCE* sequence, u8 controller, void (*callback)(void*, u8)); +void SEQSetState(SEQSEQUENCE* sequence, u32 state); +u32 SEQGetState(SEQSEQUENCE* sequence); +void SEQSetTempo(SEQSEQUENCE* sequence, u32 trackIndex, f32 bpm); +f32 SEQGetTempo(SEQSEQUENCE* sequence, u32 trackIndex); +void SEQSetVolume(SEQSEQUENCE* sequence, s32 dB); +s32 SEQGetVolume(SEQSEQUENCE* sequence); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_SEQ_H_ diff --git a/include/dolphin/si.h b/include/dolphin/si.h new file mode 100644 index 000000000..04b01ba4d --- /dev/null +++ b/include/dolphin/si.h @@ -0,0 +1,175 @@ +#ifndef _DOLPHIN_SI_H_ +#define _DOLPHIN_SI_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SI_MAX_CHAN 4 +#define SI_MAX_TYPE 4 + +#define SI_COMCSR_IDX 13 +#define SI_STATUS_IDX 14 + +#define SI_COMCSR_TCINT_MASK (1 << 31) +#define SI_COMCSR_TCINTMSK_MASK (1 << 30) +#define SI_COMCSR_COMERR_MASK (1 << 29) +#define SI_COMCSR_RDSTINT_MASK (1 << 28) +#define SI_COMCSR_RDSTINTMSK_MASK (1 << 27) + +// 4 bits of padding +#define SI_COMCSR_OUTLNGTH_MASK (1 << 22) \ + | (1 << 21) \ + | (1 << 20) \ + | (1 << 19) \ + | (1 << 18) \ + | (1 << 17) \ + | (1 << 16) + +// 1 bit of padding +#define SI_COMCSR_INLNGTH_MASK (1 << 14) \ + | (1 << 13) \ + | (1 << 12) \ + | (1 << 11) \ + | (1 << 10) \ + | (1 << 9) \ + | (1 << 8) + +// 5 bits of padding +#define SI_COMCSR_CHANNEL_MASK (1 << 2) \ + | (1 << 1) + +#define SI_COMCSR_TSTART_MASK (1 << 0) + +#define SI_ERROR_UNDER_RUN 0x0001 +#define SI_ERROR_OVER_RUN 0x0002 +#define SI_ERROR_COLLISION 0x0004 +#define SI_ERROR_NO_RESPONSE 0x0008 +#define SI_ERROR_WRST 0x0010 +#define SI_ERROR_RDST 0x0020 +#define SI_ERROR_UNKNOWN 0x0040 +#define SI_ERROR_BUSY 0x0080 + +#define SI_TYPE_MASK 0x18000000u +#define SI_TYPE_N64 0x00000000u +#define SI_TYPE_DOLPHIN 0x08000000u +#define SI_TYPE_GC SI_TYPE_DOLPHIN +#define SI_GC_WIRELESS 0x80000000 +#define SI_GC_NOMOTOR 0x20000000 +#define SI_GC_STANDARD 0x01000000 +#define SI_WIRELESS_RECEIVED 0x40000000 +#define SI_WIRELESS_IR 0x04000000 +#define SI_WIRELESS_STATE 0x02000000 +#define SI_WIRELESS_ORIGIN 0x00200000 +#define SI_WIRELESS_FIX_ID 0x00100000 +#define SI_WIRELESS_TYPE 0x000f0000 +#define SI_WIRELESS_LITE_MASK 0x000c0000 +#define SI_WIRELESS_LITE 0x00040000 +#define SI_WIRELESS_CONT_MASK 0x00080000 +#define SI_WIRELESS_CONT 0x00000000 +#define SI_WIRELESS_ID 0x00c0ff00 +#define SI_WIRELESS_TYPE_ID (SI_WIRELESS_TYPE | SI_WIRELESS_ID) +#define SI_N64_CONTROLLER (SI_TYPE_N64 | 0x05000000) +#define SI_N64_MIC (SI_TYPE_N64 | 0x00010000) +#define SI_N64_KEYBOARD (SI_TYPE_N64 | 0x00020000) +#define SI_N64_MOUSE (SI_TYPE_N64 | 0x02000000) +#define SI_GBA (SI_TYPE_N64 | 0x00040000) +#define SI_GC_CONTROLLER (SI_TYPE_GC | SI_GC_STANDARD) +#define SI_GC_RECEIVER (SI_TYPE_GC | SI_GC_WIRELESS) +#define SI_GC_WAVEBIRD (SI_TYPE_GC | SI_GC_WIRELESS | SI_GC_STANDARD | SI_WIRELESS_STATE | SI_WIRELESS_FIX_ID) +#define SI_GC_KEYBOARD (SI_TYPE_GC | 0x00200000) +#define SI_GC_STEERING (SI_TYPE_GC | 0x00000000) + +typedef void (*SICallback)(s32 chan, u32 sr, OSContext *context); +typedef void (*SITypeCallback)(s32 chan, u32 type); + +typedef struct { + s32 chan; + u32 poll; + u32 inputBytes; + void* input; + SICallback callback; +} SIControl; + +typedef struct { + s32 chan; + void* output; + u32 outputBytes; + void* input; + u32 inputBytes; + SICallback callback; + OSTime fire; +} SIPacket; + +// SIBios +BOOL SIBusy(void); +BOOL SIIsChanBusy(s32 chan); +BOOL SIRegisterPollingHandler(__OSInterruptHandler handler); +BOOL SIUnregisterPollingHandler(__OSInterruptHandler handler); +void SIInit(void); +u32 SISync(void); +u32 SIGetStatus(s32 chan); +void SISetCommand(s32 chan, u32 command); +u32 SIGetCommand(s32 chan); +void SITransferCommands(void); +u32 SISetXY(u32 x, u32 y); +u32 SIEnablePolling(u32 poll); +u32 SIDisablePolling(u32 poll); +BOOL SIGetResponse(s32 chan, void* data); +BOOL SITransfer(s32 chan, void* output, u32 outputBytes, void* input, u32 inputBytes, SICallback callback, OSTime delay); +u32 SIGetType(s32 chan); +u32 SIGetTypeAsync(s32 chan, SITypeCallback callback); +u32 SIDecodeType(u32 type); +u32 SIProbe(s32 chan); +char* SIGetTypeString(u32 type); + +extern u32 __PADFixBits; + +// SISamplingRate +void SISetSamplingRate(u32 msec); +void SIRefreshSamplingRate(void); + +// SISteering +typedef void (*SISteeringCallback)(s32 chan, s32); + +typedef struct { + u8 output[3]; + u8 input[8]; + u32 outputBytes; + u32 inputBytes; + SISteeringCallback callback; + s32 ret; + OSThreadQueue threadQueue; + void (*proc)(s32); +} SISteeringControl; + +typedef struct { + u16 button; + u8 misc; + s8 steering; + u8 gas; + u8 brake; + u8 left; + u8 right; + s8 err; +} SISteeringStatus; + +extern SISteeringControl __SISteering[4]; +extern u32 __SISteeringEnableBits; +extern BOOL __SIResetSteering; + +void SIInitSteering(void); +s32 SIResetSteeringAsync(s32 chan, SISteeringCallback callback); +s32 SIResetSteering(s32 chan); + +s32 SIReadSteering(s32 chan, SISteeringStatus* status); +void (* SISetSteeringSamplingCallback(void (*callback)()))(); +void SIControlSteering(s32 chan, u32 control, s32 level); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_SI_H_ diff --git a/include/dolphin/sp.h b/include/dolphin/sp.h new file mode 100644 index 000000000..52f4fff02 --- /dev/null +++ b/include/dolphin/sp.h @@ -0,0 +1,40 @@ +#ifndef _DOLPHIN_SP_H_ +#define _DOLPHIN_SP_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + AXPBADPCM adpcm; + AXPBADPCMLOOP adpcmloop; +} SPADPCM; + +typedef struct { + u32 type; + u32 sampleRate; + u32 loopAddr; + u32 loopEndAddr; + u32 endAddr; + u32 currentAddr; + SPADPCM* adpcm; +} SPSoundEntry; + +typedef struct { + u32 entries; + SPSoundEntry sound[1]; +} SPSoundTable; + +void SPInitSoundTable(SPSoundTable* table, u32 aramBase, u32 zeroBase); +SPSoundEntry* SPGetSoundEntry(SPSoundTable* table, u32 index); +void SPPrepareSound(SPSoundEntry* sound, AXVPB* axvpb, u32 sampleRate); +void SPPrepareEnd(SPSoundEntry* sound, AXVPB* axvpb); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/syn.h b/include/dolphin/syn.h new file mode 100644 index 000000000..8373c5db9 --- /dev/null +++ b/include/dolphin/syn.h @@ -0,0 +1,172 @@ +#ifndef _DOLPHIN_SYN_H_ +#define _DOLPHIN_SYN_H_ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SYN_INPUT_BUFFER_SIZE 0x100 + +typedef struct WTINST { + /* 0x00 */ u16 keyRegion[128]; +} WTINST; + +typedef struct WTREGION { + /* 0x00 */ u8 unityNote; + /* 0x01 */ u8 keyGroup; + /* 0x02 */ s16 fineTune; + /* 0x04 */ s32 attn; + /* 0x08 */ u32 loopStart; + /* 0x0C */ u32 loopLength; + /* 0x10 */ u32 articulationIndex; + /* 0x14 */ u32 sampleIndex; +} WTREGION; + +typedef struct WTART { + /* 0x00 */ s32 lfoFreq; + /* 0x04 */ s32 lfoDelay; + /* 0x08 */ s32 lfoAtten; + /* 0x0C */ s32 lfoPitch; + /* 0x10 */ s32 lfoMod2Atten; + /* 0x14 */ s32 lfoMod2Pitch; + /* 0x18 */ s32 eg1Attack; + /* 0x1C */ s32 eg1Decay; + /* 0x20 */ s32 eg1Sustain; + /* 0x24 */ s32 eg1Release; + /* 0x28 */ s32 eg1Vel2Attack; + /* 0x2C */ s32 eg1Key2Decay; + /* 0x30 */ s32 eg2Attack; + /* 0x34 */ s32 eg2Decay; + /* 0x38 */ s32 eg2Sustain; + /* 0x3C */ s32 eg2Release; + /* 0x40 */ s32 eg2Vel2Attack; + /* 0x44 */ s32 eg2Key2Decay; + /* 0x48 */ s32 eg2Pitch; + /* 0x4C */ s32 pan; +} WTART; + +typedef struct WTSAMPLE { + /* 0x00 */ u16 format; + /* 0x02 */ u16 sampleRate; + /* 0x04 */ u32 offset; + /* 0x08 */ u32 length; + /* 0x0C */ u16 adpcmIndex; +} WTSAMPLE; + +typedef struct WTADPCM { + /* 0x00 */ u16 a[8][2]; + /* 0x20 */ u16 gain; + /* 0x22 */ u16 pred_scale; + /* 0x24 */ u16 yn1; + /* 0x26 */ u16 yn2; + /* 0x28 */ u16 loop_pred_scale; + /* 0x2A */ u16 loop_yn1; + /* 0x2C */ u16 loop_yn2; +} WTADPCM; + +typedef struct SYNSYNTH { + /* 0x0000 */ void* next; + /* 0x0004 */ WTINST* percussiveInst; + /* 0x0008 */ WTINST* melodicInst; + /* 0x000C */ WTREGION* region; + /* 0x0010 */ WTART* art; + /* 0x0014 */ WTSAMPLE* sample; + /* 0x0018 */ WTADPCM* adpcm; + /* 0x001C */ u32 aramBaseWord; + /* 0x0020 */ u32 aramBaseByte; + /* 0x0024 */ u32 aramBaseNibble; + /* 0x0028 */ u32 zeroBaseWord; + /* 0x002C */ u32 zeroBaseByte; + /* 0x0030 */ u32 zeroBaseNibble; + /* 0x0034 */ u32 priorityVoiceAlloc; + /* 0x0038 */ u32 priorityNoteOn; + /* 0x003C */ u32 priorityNoteRelease; + /* 0x0040 */ WTINST* inst[16]; + /* 0x0080 */ s32 masterVolume; + /* 0x0084 */ u8 controller[16][128]; + /* 0x0844 */ u8 rpn[16]; + /* 0x0894 */ s16 dataEntry[16]; + /* 0x08B4 */ s32 pwMaxCents[16]; + /* 0x08F4 */ s32 pwCents[16]; + /* 0x0934 */ s32 volAttn[16]; + /* 0x0974 */ s32 expAttn[16]; + /* 0x09B4 */ s32 auxAAttn[16]; + /* 0x09F4 */ s32 auxBAttn[16]; + /* 0x0A34 */ u8 input[SYN_INPUT_BUFFER_SIZE][3]; + /* 0x0D34 */ u8* inputPosition; + /* 0x0D38 */ u32 inputCounter; + /* 0x0D3C */ u32 notes; + /* 0x0D40 */ void* keyGroup[16][16]; + /* 0x1140 */ void* voice[16][128]; +} SYNSYNTH; + +typedef struct SYNVOICE { + /* 0x00 */ void* next; + /* 0x04 */ AXVPB* axvpb; + /* 0x08 */ SYNSYNTH* synth; + /* 0x0C */ u8 midiChannel; + /* 0x0D */ u8 keyNum; + /* 0x0E */ u8 keyVel; + /* 0x0F */ u8 pan; + /* 0x10 */ u8 keyGroup; + /* 0x14 */ WTREGION* region; + /* 0x18 */ WTART* art; + /* 0x1C */ WTSAMPLE* sample; + /* 0x20 */ WTADPCM* adpcm; + /* 0x24 */ u32 hold; + /* 0x28 */ u32 type; + /* 0x2C */ f32 srcRatio; + /* 0x30 */ s32 cents; + /* 0x34 */ s32 attn; + /* 0x38 */ s32 lfoState; + /* 0x3C */ s32 lfoAttn; + /* 0x40 */ s32 lfoCents; + /* 0x44 */ s32 lfoFreq; + /* 0x48 */ s32 lfoDelay; + /* 0x4C */ s32 lfoAttn_; + /* 0x50 */ s32 lfoCents_; + /* 0x54 */ s32 lfoModAttn; + /* 0x58 */ s32 lfoModCents; + /* 0x5C */ u32 veState; + /* 0x60 */ s32 veAttn; + /* 0x64 */ s32 veAttack; + /* 0x68 */ s32 veAttackDelta; + /* 0x6C */ s32 veDecay; + /* 0x70 */ s32 veSustain; + /* 0x74 */ s32 veRelease; + /* 0x78 */ u32 peState; + /* 0x7C */ s32 peCents; + /* 0x80 */ s32 peAttack; + /* 0x84 */ s32 peDecay; + /* 0x88 */ s32 peSustain; + /* 0x8C */ s32 peRelease; + /* 0x90 */ s32 pePitch; +} SYNVOICE; + +// sample formats +#define SYN_SAMPLE_FORMAT_ADPCM 0 +#define SYN_SAMPLE_FORMAT_PCM16 1 +#define SYN_SAMPLE_FORMAT_PCM8 2 + +// SYN +void SYNInit(void); +void SYNQuit(void); +void SYNRunAudioFrame(void); +void SYNInitSynth(SYNSYNTH* synth, void* wavetable, u32 aramBase, u32 zeroBase, u32 priorityVoiceAlloc, u32 priorityNoteOn, u32 priorityNoteRelease); +void SYNQuitSynth(SYNSYNTH* synth); +void SYNMidiInput(SYNSYNTH* synth, u8* input); +void SYNSetMasterVolume(SYNSYNTH* synth, s32 dB); +s32 SYNGetMasterVolume(SYNSYNTH* synth); +u32 SYNGetActiveNotes(SYNSYNTH* synth); + +// SYNCTRL +u8 SYNGetMidiController(SYNSYNTH* synth, u8 midiChannel, u8 function); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_SYN_H_ diff --git a/include/dolphin/types.h b/include/dolphin/types.h new file mode 100644 index 000000000..b77602b10 --- /dev/null +++ b/include/dolphin/types.h @@ -0,0 +1,47 @@ +#ifndef _DOLPHIN_TYPES_H_ +#define _DOLPHIN_TYPES_H_ + +typedef signed char s8; +typedef unsigned char u8; +typedef signed short int s16; +typedef unsigned short int u16; +typedef signed long s32; +typedef unsigned long u32; +typedef signed long long int s64; +typedef unsigned long long int u64; + +typedef float f32; +typedef double f64; + +typedef char* Ptr; + +typedef int BOOL; + +#define FALSE 0 +#define TRUE 1 + +#if defined(__MWERKS__) +#define AT_ADDRESS(addr) : (addr) +#elif defined(__GNUC__) +//#define AT_ADDRESS(addr) __attribute__((address((addr)))) +#define AT_ADDRESS(addr) // was removed in GCC. define in linker script instead. +#else +#error unknown compiler +#endif + +#define ATTRIBUTE_ALIGN(num) __attribute__((aligned(num))) + +#define INT_MAX 2147483647 + +#ifndef NULL +#define NULL ((void*)0) +#endif + +#include "stdio.h" +#include "stdarg.h" +#include "string.h" +#include "ctype.h" + +#include "cmath" + +#endif diff --git a/include/dolphin/vi.h b/include/dolphin/vi.h new file mode 100644 index 000000000..af4184426 --- /dev/null +++ b/include/dolphin/vi.h @@ -0,0 +1,7 @@ +#ifndef _DOLPHIN_VI_H_ +#define _DOLPHIN_VI_H_ + +#include +#include + +#endif diff --git a/include/dolphin/vi/vifuncs.h b/include/dolphin/vi/vifuncs.h new file mode 100644 index 000000000..eb95984ed --- /dev/null +++ b/include/dolphin/vi/vifuncs.h @@ -0,0 +1,36 @@ +#ifndef _DOLPHIN_VIFUNCS_H_ +#define _DOLPHIN_VIFUNCS_H_ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +VIRetraceCallback VISetPreRetraceCallback(VIRetraceCallback cb); +VIRetraceCallback VISetPostRetraceCallback(VIRetraceCallback cb); +void VIInit(void); +void VIWaitForRetrace(void); +void VIConfigure(const GXRenderModeObj* rm); +void VIConfigurePan(u16 xOrg, u16 yOrg, u16 width, u16 height); +void VIFlush(void); +void VISetNextFrameBuffer(void* fb); +void VISetNextRightFrameBuffer(void* fb); +void VISetBlack(BOOL black); +void VISet3D(BOOL threeD); +u32 VIGetRetraceCount(void); +u32 VIGetNextField(void); +u32 VIGetCurrentLine(void); +u32 VIGetTvFormat(void); +void* VIGetNextFrameBuffer(void); +void* VIGetCurrentFrameBuffer(void); +u32 VIGetScanMode(void); +u32 VIGetDTVStatus(void); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/vi/vitypes.h b/include/dolphin/vi/vitypes.h new file mode 100644 index 000000000..983a89b7e --- /dev/null +++ b/include/dolphin/vi/vitypes.h @@ -0,0 +1,41 @@ +#ifndef _DOLPHIN_VITYPES_H_ +#define _DOLPHIN_VITYPES_H_ + +#include + +#define VI_TVMODE(format, interlace) (((format) << 2) + (interlace)) + +#define VI_INTERLACE 0 +#define VI_NON_INTERLACE 1 +#define VI_PROGRESSIVE 2 + +#define VI_NTSC 0 +#define VI_PAL 1 +#define VI_MPAL 2 +#define VI_DEBUG 3 +#define VI_DEBUG_PAL 4 +#define VI_EURGB60 5 + +typedef enum { + VI_TVMODE_NTSC_INT = VI_TVMODE(VI_NTSC, VI_INTERLACE), + VI_TVMODE_NTSC_DS = VI_TVMODE(VI_NTSC, VI_NON_INTERLACE), + VI_TVMODE_NTSC_PROG = VI_TVMODE(VI_NTSC, VI_PROGRESSIVE), + VI_TVMODE_PAL_INT = VI_TVMODE(VI_PAL, VI_INTERLACE), + VI_TVMODE_PAL_DS = VI_TVMODE(VI_PAL, VI_NON_INTERLACE), + VI_TVMODE_EURGB60_INT = VI_TVMODE(VI_EURGB60, VI_INTERLACE), + VI_TVMODE_EURGB60_DS = VI_TVMODE(VI_EURGB60, VI_NON_INTERLACE), + VI_TVMODE_MPAL_INT = VI_TVMODE(VI_MPAL, VI_INTERLACE), + VI_TVMODE_MPAL_DS = VI_TVMODE(VI_MPAL, VI_NON_INTERLACE), + VI_TVMODE_DEBUG_INT = VI_TVMODE(VI_DEBUG, VI_INTERLACE), + VI_TVMODE_DEBUG_PAL_INT = VI_TVMODE(VI_DEBUG_PAL, VI_INTERLACE), + VI_TVMODE_DEBUG_PAL_DS = VI_TVMODE(VI_DEBUG_PAL, VI_NON_INTERLACE) +} VITVMode; + +typedef enum { + VI_XFBMODE_SF = 0, + VI_XFBMODE_DF +} VIXFBMode; + +typedef void (*VIRetraceCallback)(u32 retraceCount); + +#endif diff --git a/src/SB/Core/gc/iSnd.cpp b/src/SB/Core/gc/iSnd.cpp index be7dca015..7ac9e89af 100644 --- a/src/SB/Core/gc/iSnd.cpp +++ b/src/SB/Core/gc/iSnd.cpp @@ -1,10 +1,10 @@ #include "iSnd.h" -#include "intrin.h" - #include +#include + +#include "intrin.h" -#include "dolphin/dolphin.h" #include "iMix.h" #include "xCutscene.h" #include "xSnd.h"