diff --git a/include/dolphin/CARDPriv.h b/include/dolphin/CARDPriv.h new file mode 100644 index 00000000..ca28f6e1 --- /dev/null +++ b/include/dolphin/CARDPriv.h @@ -0,0 +1,132 @@ +#ifndef _DOLPHIN_CARDPRIV +#define _DOLPHIN_CARDPRIV + +#ifdef __cplusplus +extern "C" { +#endif + +#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_PAGE_SIZE 128u +#define CARD_SEG_SIZE 512u + +#define CARD_NUM_SYSTEM_BLOCK 5 +#define CARD_SYSTEM_BLOCK_SIZE (8 * 1024u) + +#define CARD_MAX_MOUNT_STEP (CARD_NUM_SYSTEM_BLOCK + 2) + +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 CARDDirCheck { + u8 padding0[64 - 2 * 4]; + u16 padding1; + s16 checkCode; + u16 checkSum; + u16 checkSumInv; +} CARDDirCheck; + +typedef struct CARDControl { + BOOL attached; + s32 result; + u16 size; + u16 pageSize; + s32 sectorSize; + u16 cBlock; + u16 vendorID; + s32 latency; + u8 id[12]; + int mountStep; + int formatStep; + u32 scramble; + DSPTaskInfo task; + void* workArea; + CARDDir* currentDir; + u16* currentFat; + OSThreadQueue threadQueue; + u8 cmd[9]; + s32 cmdlen; + vu32 mode; + int retry; + int repeat; + u32 addr; + void* buffer; + s32 xferred; + u16 freeNo; + u16 startBlock; + CARDFileInfo* fileInfo; + CARDCallback extCallback; + CARDCallback txCallback; + CARDCallback exiCallback; + CARDCallback apiCallback; + CARDCallback xferCallback; + CARDCallback eraseCallback; + CARDCallback unlockCallback; + OSAlarm alarm; + u32 cid; + const DVDDiskID* diskID; +} CARDControl; + +typedef struct CARDID { + u8 serial[32]; // flashID[12] + timebase[8] + counterBias[4] + language[4] + XXX[4] + u16 deviceID; + u16 size; + u16 encode; // character set -- 0: S-JIS, 1: ANSI + + u8 padding[512 - 32 - 5 * 2]; + + u16 checkSum; + u16 checkSumInv; +} CARDID; + +void __CARDDefaultApiCallback(s32 chan, s32 result); + +#define CARDIsValidBlockNo(card, iBlock) \ + (CARD_NUM_SYSTEM_BLOCK <= (iBlock) && (iBlock) < (card)->cBlock) +#define __CARDGetDirCheck(dir) ((CARDDirCheck*)&(dir)[CARD_MAX_FILE]) + +CARDDir* __CARDGetDirBlock(CARDControl* card); +u16* __CARDGetFatBlock(CARDControl* card); +s32 __CARDUpdateFatBlock(s32 chan, u16* fat, CARDCallback callback); +void __CARDCheckSum(void* ptr, int length, u16* checkSum, u16* checkSumInv); +u16 __CARDGetFontEncode(); +void __CARDExiHandler(s32 chan, OSContext* context); +void __CARDExtHandler(s32 chan, OSContext* context); +void __CARDUnlockedHandler(s32 chan, OSContext* context); +s32 __CARDAccess(CARDControl* card, CARDDir* ent); +BOOL __CARDIsWritable(CARDDir* ent); + +#define TRUNC(n, a) (((u32)(n)) & ~((a)-1)) +#define OFFSET(n, a) (((u32)(n)) & ((a)-1)) + +extern CARDControl __CARDBlock[2]; +extern DVDDiskID __CARDDiskNone; +extern u16 __CARDVendorID; + +#ifdef __cplusplus +} +#endif +#endif // _DOLPHIN_CARDPRIV diff --git a/include/dolphin/DVDPriv.h b/include/dolphin/DVDPriv.h new file mode 100644 index 00000000..66560730 --- /dev/null +++ b/include/dolphin/DVDPriv.h @@ -0,0 +1,50 @@ +#ifndef _DOLPHIN_DVDPRIV +#define _DOLPHIN_DVDPRIV + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct DVDDriveInfo { + u16 revisionLevel; + u16 deviceCode; + u32 releaseDate; + u8 padding[24]; +} DVDDriveInfo; + +typedef struct DVDBB1 { + u32 appLoaderLength; + void* appLoaderFunc1; + void* appLoaderFunc2; + void* appLoaderFunc3; +} DVDBB1; + +typedef struct DVDBB2 { + u32 bootFilePosition; + u32 FSTPosition; + u32 FSTLength; + u32 FSTMaxLength; + void* FSTAddress; + u32 userPosition; + u32 userLength; + + u32 padding0; +} DVDBB2; + +typedef void (*DVDOptionalCommandChecker)(DVDCommandBlock* block, void (*cb)(u32 intType)); +typedef void (*DVDLowCallback)(u32 intType); +extern DVDDiskID* DVDGetCurrentDiskID(); +DVDLowCallback DVDLowClearCallback(); +BOOL DVDLowSeek(u32 offset, DVDLowCallback callback); +void __DVDLowSetWAType(u32 type, u32 location); +DVDCommandBlock* __DVDPopWaitingQueue(); + +#ifdef __cplusplus +} +#endif // _DOLPHIN_DVDPRIV + +#endif __DVDPRIV_H__ diff --git a/include/dolphin/GBAPriv.h b/include/dolphin/GBAPriv.h new file mode 100644 index 00000000..32fe4fcd --- /dev/null +++ b/include/dolphin/GBAPriv.h @@ -0,0 +1,80 @@ +#ifndef _DOLPHIN_GBAPRIV +#define _DOLPHIN_GBAPRIV + +#include "types.h" + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*GBATransferCallback)(s32 chan); + +typedef struct GBASecParam { + u8 readbuf[4]; + s32 paletteColor; + s32 paletteSpeed; + s32 length; + u32* out; + u8 _padding0[12]; + u32 keyA; + s32 keyB; + u8 _padding1[24]; +} GBASecParam; + +typedef struct GBABootInfo { + s32 paletteColor; + s32 paletteSpeed; + u8* programp; + s32 length; + u8* status; + GBACallback callback; + u8 readbuf[4]; + u8 writebuf[4]; + int i; + OSTick start; + OSTime begin; + int firstXfer; + int curOffset; + u32 crc; + u32 dummyWord[7]; + u32 keyA; + s32 keyB; + u32 initialCode; + int realLength; +} GBABootInfo; + +typedef struct GBAControl { + u8 output[5]; + u8 input[5]; + s32 outputBytes; + s32 inputBytes; + u8* status; + u8* ptr; + GBACallback callback; + s32 ret; + OSThreadQueue threadQueue; + OSTime delay; + GBATransferCallback proc; + GBABootInfo bootInfo; + DSPTaskInfo task; + GBASecParam* param; +} GBAControl; + +extern GBAControl __GBA[4]; +extern BOOL __GBAReset; + +void __GBAHandler(s32 chan, u32 error, OSContext* context); +void __GBASyncCallback(s32 chan, s32 ret); +s32 __GBASync(s32 chan); +OSTime __GBASetDelay(s32 chan, OSTime delay); +s32 __GBATransfer(s32 chan, s32 w1, s32 w2, GBATransferCallback callback); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GBAPRIV diff --git a/include/dolphin/OSRtcPriv.h b/include/dolphin/OSRtcPriv.h new file mode 100644 index 00000000..949c71e7 --- /dev/null +++ b/include/dolphin/OSRtcPriv.h @@ -0,0 +1,34 @@ +#ifndef _DOLPHIN_OSRTCPRIV +#define _DOLPHIN_OSRTCPRIV + +#include + +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; + +OSSram* __OSLockSram(); +OSSramEx* __OSLockSramEx(); +void OSSetWirelessID(s32 chan, u16 id); +u16 OSGetWirelessID(s32 chan); + +#endif // _DOLPHIN_OSRTCPRIV diff --git a/include/dolphin/PPCArch.h b/include/dolphin/PPCArch.h new file mode 100644 index 00000000..14eecf2d --- /dev/null +++ b/include/dolphin/PPCArch.h @@ -0,0 +1,500 @@ +#ifndef _DOLPHIN_PPCARCH +#define _DOLPHIN_PPCARCH + +#include "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 0x80000000 // Enable MCP +#define HID0_DBP 0x40000000 // Enable 60x bus address and data parity chk +#define HID0_EBA 0x20000000 // Enable 60x address parity checking +#define HID0_EBD 0x10000000 // Enable 60x data parity checking +#define HID0_BCLK 0x08000000 // CLK_OUT output enable and clk selection +#define HID0_ECLK 0x02000000 // CLK_OUT output enable and clk selection +#define HID0_PAR 0x01000000 // Disable !ARTRY precharge +#define HID0_DOZE 0x00800000 // Doze mode enable +#define HID0_NAP 0x00400000 // Nap mode enable +#define HID0_SLEEP 0x00200000 // Sleep mode enable +#define HID0_DPM 0x00100000 // Dynamic power management enable +#define HID0_NHR 0x00010000 // Not hard reset (0 hard reset if s/w set it) +#define HID0_ICE 0x00008000 // Instruction cache enable +#define HID0_DCE 0x00004000 // Data cache enable +#define HID0_ILOCK 0x00002000 // ICache lock +#define HID0_DLOCK 0x00001000 // DCache lock +#define HID0_ICFI 0x00000800 // ICache flash invalidate +#define HID0_DCFI 0x00000400 // DCache flash invalidate +#define HID0_SPD 0x00000200 // Speculative cache access enable (0 enable) +#define HID0_IFEM 0x00000100 // Enable M bit on bus for Ifetch +#define HID0_SGE 0x00000080 // Store gathering enable +#define HID0_DCFA 0x00000040 // DCache flush assist - set before a flush +#define HID0_BTIC 0x00000020 // Branch target icache enable +#define HID0_ABE 0x00000008 // Address bcast enable +#define HID0_BHT 0x00000004 // Branch history table enable +#define HID0_NOOPTI 0x00000001 // 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 + +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(); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_PPCARCH diff --git a/include/dolphin/__ppc_eabi_init.h b/include/dolphin/__ppc_eabi_init.h new file mode 100644 index 00000000..5dcba28d --- /dev/null +++ b/include/dolphin/__ppc_eabi_init.h @@ -0,0 +1,19 @@ +#ifndef _DOLPHIN__PPC_EABI_INIT +#define _DOLPHIN__PPC_EABI_INIT + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif +__declspec(section ".init") void __init_hardware(void); +__declspec(section ".init") void __flush_cache(register void* address, register unsigned int size); + +void __init_user(void); +void __init_cpp(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN__PPC_EABI_INIT diff --git a/include/dolphin/__start.h b/include/dolphin/__start.h new file mode 100644 index 00000000..128828fb --- /dev/null +++ b/include/dolphin/__start.h @@ -0,0 +1,44 @@ +#ifndef _DOLPHIN__START +#define _DOLPHIN__START + +#include "dolphin/db.h" +#include "types.h" + +#define PAD3_BUTTON_ADDR 0x800030E4 +#define OS_RESET_RESTART 0 +#define EXCEPTIONMASK_ADDR 0x80000044 +#define BOOTINFO2_ADDR 0x800000F4 +#define OS_BI2_DEBUGFLAG_OFFSET 0xC +#define ARENAHI_ADDR 0x80000034 +#define DEBUGFLAG_ADDR 0x800030E8 +#define DVD_DEVICECODE_ADDR 0x800030E6 + +#define MSR_FP 0x2000 + +extern void InitMetroTRK(); + +u16 Pad3Button : PAD3_BUTTON_ADDR; +static u8 Debug_BBA = 0; + +extern void memset(void*, int, int); +extern int main(int argc, char* argv[]); +extern void exit(int); +extern void __init_user(void); +extern void OSInit(void); +extern void DBInit(void); +extern void OSResetSystem(BOOL reset, u32 resetCode, BOOL forceMenu); +extern void __OSCacheInit(void); +extern void __OSPSInit(void); + +__declspec(section ".init") extern void __check_pad3(void); +__declspec(section ".init") extern void __start(void); +__declspec(section ".init") extern void __init_registers(void); +__declspec(section ".init") extern void __init_data(void); +__declspec(section ".init") extern void __init_hardware(void); +__declspec(section ".init") extern void __flush_cache(void* address, unsigned int size); + +__declspec(section ".init") extern char _stack_addr[]; +__declspec(section ".init") extern char _SDA_BASE_[]; +__declspec(section ".init") extern char _SDA2_BASE_[]; + +#endif // _DOLPHIN__START diff --git a/include/dolphin/ai.h b/include/dolphin/ai.h new file mode 100644 index 00000000..e998e831 --- /dev/null +++ b/include/dolphin/ai.h @@ -0,0 +1,43 @@ +#ifndef _DOLPHIN_AI +#define _DOLPHIN_AI + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif +typedef void (*AISCallback)(u32 count); +typedef void (*AIDCallback)(); + +AIDCallback AIRegisterDMACallback(AIDCallback callback); +void AIInitDMA(u32 start_addr, u32 length); +BOOL AIGetDMAEnableFlag(); +void AIStartDMA(); +void AIStopDMA(); +u32 AIGetDMABytesLeft(); +u32 AIGetDMAStartAddr(); +u32 AIGetDMALength(); +u32 AIGetDSPSampleRate(); +void AISetDSPSampleRate(u32 rate); +AISCallback AIRegisterStreamCallback(AISCallback callback); +u32 AIGetStreamSampleCount(); +void AIResetStreamSampleCount(); +void AISetStreamTrigger(u32 trigger); +u32 AIGetStreamTrigger(); +void AISetStreamPlayState(u32 state); +u32 AIGetStreamPlayState(); +void AISetStreamSampleRate(u32 rate); +u32 AIGetStreamSampleRate(); +void AISetStreamVolLeft(u8 vol); +void AISetStreamVolRight(u8 vol); +u8 AIGetStreamVolLeft(); +u8 AIGetStreamVolRight(); +void AIInit(u8* stack); +BOOL AICheckInit(); +void AIReset(); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_AI diff --git a/include/dolphin/ar.h b/include/dolphin/ar.h new file mode 100644 index 00000000..db0adaf3 --- /dev/null +++ b/include/dolphin/ar.h @@ -0,0 +1,45 @@ +#ifndef _DOLPHIN_AR +#define _DOLPHIN_AR + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define AR_STACK_INDEX_ENTRY_SIZE sizeof(u32) + +#define ARAM_DIR_MRAM_TO_ARAM 0x00 +#define ARAM_DIR_ARAM_TO_MRAM 0x01 + +#define AR_CLEAR_INTERNAL_ALL 0x00 +#define AR_CLEAR_INTERNAL_USER 0x01 +#define AR_CLEAR_EXPANSION 0x02 + +typedef void (*ARCallback)(void); + +ARCallback ARRegisterDMACallback(ARCallback callback); +u32 ARGetDMAStatus(void); +void ARStartDMA(u32 type, u32 mainmem_addr, u32 aram_addr, u32 length); +u32 ARInit(u32* stack_index_addr, u32 num_entries); +u32 ARGetBaseAddress(void); +BOOL ARCheckInit(void); +void ARReset(void); +u32 ARAlloc(u32 length); +u32 ARFree(u32* length); +u32 ARGetSize(void); +u32 ARGetInternalSize(void); +void ARSetSize(void); +void ARClear(u32 flag); + +void __ARClearInterrupt(void); +u16 __ARGetInterruptStatus(void); + +#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) + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_AR diff --git a/include/dolphin/arq.h b/include/dolphin/arq.h new file mode 100644 index 00000000..5b7a194c --- /dev/null +++ b/include/dolphin/arq.h @@ -0,0 +1,53 @@ +#ifndef _DOLPHIN_ARQ +#define _DOLPHIN_ARQ + +#include "types.h" + +#include "dolphin/ar.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#include "dolphin/ar.h" + +#define ARQ_DMA_ALIGNMENT 32 +#define ARQ_CHUNK_SIZE_DEFAULT 4096 + +#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 + +typedef void (*ARQCallback)(u32 pointerToARQRequest); + +typedef struct ARQRequest { + + struct ARQRequest* next; + u32 owner; + u32 type; + u32 priority; + u32 source; + u32 dest; + u32 length; + ARQCallback callback; + +} ARQRequest; + +void ARQInit(void); +void ARQReset(void); +void ARQPostRequest(ARQRequest* task, u32 owner, u32 type, u32 priority, u32 source, u32 dest, + u32 length, ARQCallback callback); +void ARQRemoveRequest(ARQRequest* task); +void ARQRemoveOwnerRequest(u32 owner); +void ARQFlushQueue(void); +void ARQSetChunkSize(u32 size); +u32 ARQGetChunkSize(void); +BOOL ARQCheckInit(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_ARQ diff --git a/include/dolphin/card.h b/include/dolphin/card.h new file mode 100644 index 00000000..7d0602d0 --- /dev/null +++ b/include/dolphin/card.h @@ -0,0 +1,176 @@ +#ifndef _DOLPHIN_CARD +#define _DOLPHIN_CARD + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif +#define CARD_ENCODE_ANSI 0u +#define CARD_ENCODE_SJIS 1u + +/* Sizes */ +#define CARD_WORKAREA_SIZE (5 * 8 * 1024) +#define CARD_READ_SIZE 512 +#define CARD_MAX_FILE 127 +#define CARD_COMMENT_SIZE 64 +#define CARD_FILENAME_MAX 32 +#define CARD_ICON_MAX 8 +#define CARD_ICON_WIDTH 32 +#define CARD_ICON_HEIGHT 32 +#define CARD_BANNER_WIDTH 96 +#define CARD_BANNER_HEIGHT 32 + +/* Icon animation */ +#define CARD_MODE_NORMAL 0 +#define CARD_MODE_FAST 1 + +#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) + +#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_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_STAT_ANIM_LOOP 0x00 +#define CARD_STAT_ANIM_BOUNCE 0x04 +#define CARD_STAT_ANIM_MASK 0x04 + +#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_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 + +typedef struct CARDFileInfo { + s32 chan; + s32 fileNo; + + s32 offset; + s32 length; + u16 iBlock; + u16 __padding; +} CARDFileInfo; + +typedef struct CARDStat { + char fileName[CARD_FILENAME_MAX]; + u32 length; + u32 time; // seconds since 01/01/2000 midnight + u8 gameName[4]; + u8 company[2]; + + u8 bannerFormat; + u8 __padding; + u32 iconAddr; // offset to the banner, bannerTlut, icon, iconTlut data set. + u16 iconFormat; + u16 iconSpeed; + u32 commentAddr; // offset to the pair of 32 byte character strings. + + u32 offsetBanner; + u32 offsetBannerTlut; + u32 offsetIcon[CARD_ICON_MAX]; + u32 offsetIconTlut; + u32 offsetData; +} CARDStat; + +typedef void (*CARDCallback)(s32 chan, s32 result); + +void CARDInit(void); +BOOL CARDGetFastMode(void); +BOOL CARDSetFastMode(BOOL enable); + +s32 CARDCheck(s32 chan); +s32 CARDCheckAsync(s32 chan, CARDCallback callback); +s32 CARDCheckEx(s32 chan, s32* xferBytes); +s32 CARDCheckExAsync(s32 chan, s32* xferBytes, CARDCallback callback); +s32 CARDCreate(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo); +s32 CARDCreateAsync(s32 chan, const char* fileName, u32 size, CARDFileInfo* fileInfo, + CARDCallback callback); +s32 CARDDelete(s32 chan, const char* fileName); +s32 CARDDeleteAsync(s32 chan, const char* fileName, CARDCallback callback); +s32 CARDFastDelete(s32 chan, s32 fileNo); +s32 CARDFastDeleteAsync(s32 chan, s32 fileNo, CARDCallback callback); +s32 CARDFastOpen(s32 chan, s32 fileNo, CARDFileInfo* fileInfo); +s32 CARDFormat(s32 chan); +s32 CARDFormatAsync(s32 chan, CARDCallback callback); +s32 CARDFreeBlocks(s32 chan, s32* byteNotUsed, s32* filesNotUsed); +s32 CARDGetAttributes(s32 chan, s32 fileNo, u8* attr); +s32 CARDGetEncoding(s32 chan, u16* encode); +s32 CARDGetMemSize(s32 chan, u16* size); +s32 CARDGetResultCode(s32 chan); +s32 CARDGetSectorSize(s32 chan, u32* size); +s32 CARDGetSerialNo(s32 chan, u64* serialNo); +s32 CARDGetStatus(s32 chan, s32 fileNo, CARDStat* stat); +s32 CARDGetXferredBytes(s32 chan); +s32 CARDMount(s32 chan, void* workArea, CARDCallback detachCallback); +s32 CARDMountAsync(s32 chan, void* workArea, CARDCallback detachCallback, + CARDCallback attachCallback); +s32 CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo); +BOOL CARDProbe(s32 chan); +s32 CARDProbeEx(s32 chan, s32* memSize, s32* sectorSize); +s32 CARDRename(s32 chan, const char* oldName, const char* newName); +s32 CARDRenameAsync(s32 chan, const char* oldName, const char* newName, CARDCallback callback); +s32 CARDSetAttributesAsync(s32 chan, s32 fileNo, u8 attr, CARDCallback callback); +s32 CARDSetAttributes(s32 chan, s32 fileNo, u8 attr); +s32 CARDSetStatus(s32 chan, s32 fileNo, CARDStat* stat); +s32 CARDSetStatusAsync(s32 chan, s32 fileNo, CARDStat* stat, CARDCallback callback); +s32 CARDUnmount(s32 chan); +s32 CARDGetCurrentMode(s32 chan, u32* mode); +s32 CARDCancel(CARDFileInfo* fileInfo); +s32 CARDClose(CARDFileInfo* fileInfo); +s32 CARDRead(CARDFileInfo* fileInfo, void* addr, s32 length, s32 offset); +s32 CARDReadAsync(CARDFileInfo* fileInfo, void* addr, s32 length, s32 offset, + CARDCallback callback); +s32 CARDWrite(CARDFileInfo* fileInfo, const void* addr, s32 length, s32 offset); +s32 CARDWriteAsync(CARDFileInfo* fileInfo, const void* addr, s32 length, s32 offset, + CARDCallback callback); + +#ifdef __cplusplus +} +#endif +#endif // _DOLPHIN_CARD diff --git a/include/dolphin/db.h b/include/dolphin/db.h new file mode 100644 index 00000000..08851a4a --- /dev/null +++ b/include/dolphin/db.h @@ -0,0 +1,31 @@ +#ifndef _DOLPHIN_DB +#define _DOLPHIN_DB + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_DBINTERFACE_ADDR 0x00000040 + +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); +static void __DBExceptionDestination(void); +void DBPrintf(char* format, ...); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DB diff --git a/include/dolphin/dsp.h b/include/dolphin/dsp.h new file mode 100644 index 00000000..368138c9 --- /dev/null +++ b/include/dolphin/dsp.h @@ -0,0 +1,70 @@ +#ifndef _DOLPHIN_DSP +#define _DOLPHIN_DSP + +#include "types.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define DSP_TASK_FLAG_CLEARALL 0x00000000 +#define DSP_TASK_FLAG_ATTACHED 0x00000001 +#define DSP_TASK_FLAG_CANCEL 0x00000002 + +#define DSP_TASK_STATE_INIT 0 +#define DSP_TASK_STATE_RUN 1 +#define DSP_TASK_STATE_YIELD 2 +#define DSP_TASK_STATE_DONE 3 + +typedef void (*DSPCallback)(void* task); + +typedef struct STRUCT_DSP_TASK { + vu32 state; + vu32 priority; + vu32 flags; + u16* iram_mmem_addr; + u32 iram_length; + u32 iram_addr; + + u16* dram_mmem_addr; + u32 dram_length; + u32 dram_addr; + + u16 dsp_init_vector; + u16 dsp_resume_vector; + + DSPCallback init_cb; + DSPCallback res_cb; + DSPCallback done_cb; + DSPCallback req_cb; + + struct STRUCT_DSP_TASK* next; + struct STRUCT_DSP_TASK* prev; + + OSTime t_context; + OSTime t_task; + +} DSPTaskInfo; + +void DSPInit(); +void DSPReset(); +void DSPHalt(); +void DSPSendMailToDSP(u32 mail); +u32 DSPCheckMailToDSP(); +u32 DSPCheckMailFromDSP(); +u32 DSPGetDMAStatus(); + +DSPTaskInfo* DSPAddTask(DSPTaskInfo* task); + +void __DSP_exec_task(DSPTaskInfo* curr, DSPTaskInfo* next); +void __DSP_boot_task(DSPTaskInfo* task); +void __DSP_remove_task(DSPTaskInfo* task); +void __DSP_add_task(DSPTaskInfo* task); +void __DSP_debug_printf(const char* fmt, ...); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DSP diff --git a/include/dolphin/dtk.h b/include/dolphin/dtk.h new file mode 100644 index 00000000..f2661905 --- /dev/null +++ b/include/dolphin/dtk.h @@ -0,0 +1,47 @@ +#ifndef _DOLPHIN_DTK +#define _DOLPHIN_DTK + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif +typedef void (*DTKCallback)(u32 eventMask); +typedef void (*DTKFlushCallback)(void); + +typedef struct DTKTrack { + struct DTKTrack* prev; + struct DTKTrack* next; + char* fileName; + u32 eventMask; + DTKCallback callback; + DVDFileInfo dvdFileInfo; + +} DTKTrack; + +void DTKInit(void); +void DTKShutdown(void); +u32 DTKQueueTrack(char* fileName, DTKTrack* track, u32 eventMask, DTKCallback callback); +u32 DTKRemoveTrack(DTKTrack* track); +void DTKFlushTracks(DTKFlushCallback callback); +void DTKSetSampleRate(u32 samplerate); +u32 DTKGetSampleRate(void); +void DTKSetInterruptFrequency(u32 samples); +u32 DTKGetInterruptFrequency(void); +void DTKSetRepeatMode(u32 repeat); +u32 DTKGetRepeatMode(void); +void DTKSetState(u32 state); +u32 DTKGetState(void); +void DTKNextTrack(void); +void DTKPrevTrack(void); +u32 DTKGetPosition(void); +DTKTrack* DTKGetCurrentTrack(void); +void DTKSetVolume(u8 left, u8 right); +u16 DTKGetVolume(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DTK diff --git a/include/dolphin/dvd.h b/include/dolphin/dvd.h new file mode 100644 index 00000000..ad4a8a7d --- /dev/null +++ b/include/dolphin/dvd.h @@ -0,0 +1,131 @@ +#ifndef _DOLPHIN_DVD +#define _DOLPHIN_DVD + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DVD_MIN_TRANSFER_SIZE 32 + +#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_FILEINFO_READY 0 +#define DVD_FILEINFO_BUSY 1 + +#define DVD_RESULT_GOOD 0 +#define DVD_RESULT_FATAL_ERROR -1 +#define DVD_RESULT_IGNORED -2 +#define DVD_RESULT_CANCELED -3 + +#define DVD_AIS_SUCCESS 0x0 + +typedef struct DVDDiskID { + char gameName[4]; + char company[2]; + u8 diskNumber; + u8 gameVersion; + u8 streaming; + u8 streamingBufSize; // 0 = default + u8 padding[22]; // 0's are stored +} DVDDiskID; + +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; +}; + +typedef struct { + u32 entryNum; + u32 location; + u32 next; +} DVDDir; + +typedef struct { + u32 entryNum; + BOOL isDir; + char* name; +} DVDDirEntry; + +void DVDInit(); +BOOL DVDClose(DVDFileInfo* f); +BOOL DVDSetAutoFatalMessaging(BOOL); +void DVDReset(); +s32 DVDCancel(DVDCommandBlock* block); +BOOL DVDOpen(char* fileName, DVDFileInfo* fileInfo); +BOOL DVDFastOpen(s32 entrynum, DVDFileInfo* fileInfo); +s32 DVDGetCommandBlockStatus(const DVDCommandBlock* block); +BOOL DVDCancelAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDCancel(DVDCommandBlock* block); +BOOL DVDCancelAllAsync(DVDCBCallback callback); +s32 DVDCancelAll(void); +BOOL DVDPrepareStreamAsync(DVDFileInfo* fInfo, u32 length, u32 offset, DVDCallback callback); +s32 DVDPrepareStream(DVDFileInfo* fInfo, u32 length, u32 offset); + +BOOL DVDCancelStreamAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDCancelStream(DVDCommandBlock* block); + +BOOL DVDStopStreamAtEndAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDStopStreamAtEnd(DVDCommandBlock* block); + +BOOL DVDGetStreamErrorStatusAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDGetStreamErrorStatus(DVDCommandBlock* block); + +BOOL DVDGetStreamPlayAddrAsync(DVDCommandBlock* block, DVDCBCallback callback); +s32 DVDGetStreamPlayAddr(DVDCommandBlock* block); + +s32 DVDGetDriveStatus(); + +s32 DVDConvertPathToEntrynum(char* pathPtr); + +BOOL DVDReadAsyncPrio(DVDFileInfo* fileInfo, void* addr, s32 length, s32 offset, + DVDCallback callback, s32 prio); + +#define DVDReadAsync(fileInfo, addr, length, offset, callback) \ + DVDReadAsyncPrio((fileInfo), (addr), (length), (offset), (callback), 2) +#define DVDSeekAsync(fileInfo, offset, callback) \ + DVDSeekAsyncPrio((fileInfo), (offset), (callback), 2) + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_DVD diff --git a/include/dolphin/gba.h b/include/dolphin/gba.h new file mode 100644 index 00000000..692f568f --- /dev/null +++ b/include/dolphin/gba.h @@ -0,0 +1,65 @@ +#ifndef _DOLPHIN_GBA +#define _DOLPHIN_GBA + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GBA_CHAN0 0 +#define GBA_CHAN1 1 +#define GBA_CHAN2 2 +#define GBA_CHAN3 3 +#define GBA_MAX_CHAN 4 + +#define GBA_ALL_KEY_MASK 0x03ff +#define GBA_A_BUTTON 0x0001 +#define GBA_B_BUTTON 0x0002 +#define GBA_SELECT_BUTTON 0x0004 +#define GBA_START_BUTTON 0x0008 +#define GBA_R_KEY 0x0010 +#define GBA_L_KEY 0x0020 +#define GBA_U_KEY 0x0040 +#define GBA_D_KEY 0x0080 +#define GBA_R_BUTTON 0x0100 +#define GBA_L_BUTTON 0x0200 + +#define GBA_JSTAT_MASK 0x3a +#define GBA_JSTAT_FLAGS_SHIFT 4 +#define GBA_JSTAT_FLAGS_MASK 0x30 +#define GBA_JSTAT_PSF1 0x20 +#define GBA_JSTAT_PSF0 0x10 +#define GBA_JSTAT_SEND 0x08 +#define GBA_JSTAT_RECV 0x02 + +#define GBA_READY 0 +#define GBA_NOT_READY 1 +#define GBA_BUSY 2 +#define GBA_JOYBOOT_UNKNOWN_STATE 3 +#define GBA_JOYBOOT_ERR_INVALID 4 + +#define GBA_JOYBOOT_PROGRAM_SIZE_MAX 0x40000 + +#define GBA_JOYBOOT_BOOTPARAM_OFFSET 0xc8 +#define GBA_JOYBOOT_BOOTPARAM_SIZE 0x18 +typedef void (*GBACallback)(s32 chan, s32 ret); +void GBAInit(void); +s32 GBAGetStatus(s32 chan, u8* status); +s32 GBAGetStatusAsync(s32 chan, u8* status, GBACallback callback); +s32 GBAReset(s32 chan, u8* status); +s32 GBAResetAsync(s32 chan, u8* status, GBACallback callback); +s32 GBAGetProcessStatus(s32 chan, u8* percentp); +s32 GBARead(s32 chan, u8* dst, u8* status); +s32 GBAReadAsync(s32 chan, u8* dst, u8* status, GBACallback callback); +s32 GBAWrite(s32 chan, u8* src, u8* status); +s32 GBAWriteAsync(s32 chan, u8* src, u8* status, GBACallback callback); +s32 GBAJoyBoot(s32 chan, s32 palette_color, s32 palette_speed, u8* programp, s32 length, + u8* status); +s32 GBAJoyBootAsync(s32 chan, s32 palette_color, s32 palette_speed, u8* programp, s32 length, + u8* status, GBACallback callback); +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GBA diff --git a/include/dolphin/gx.h b/include/dolphin/gx.h new file mode 100644 index 00000000..856842b7 --- /dev/null +++ b/include/dolphin/gx.h @@ -0,0 +1,26 @@ +#ifndef _DOLPHIN_GX +#define _DOLPHIN_GX + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // _DOLPHIN_GX diff --git a/include/dolphin/gx/GXBump.h b/include/dolphin/gx/GXBump.h new file mode 100644 index 00000000..a936ddca --- /dev/null +++ b/include/dolphin/gx/GXBump.h @@ -0,0 +1,30 @@ +#ifndef _DOLPHIN_GXBUMP +#define _DOLPHIN_GXBUMP + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetTevDirect(GXTevStageID tev_stage); +void GXSetNumIndStages(u8 nIndStages); +#ifdef TARGET_PC +void GXSetIndTexMtx(GXIndTexMtxID mtx_sel, const void* offset, s8 scale_exp); +#else +void GXSetIndTexMtx(GXIndTexMtxID mtx_sel, f32 offset[2][3], s8 scale_exp); +#endif +void GXSetIndTexOrder(GXIndTexStageID ind_stage, GXTexCoordID tex_coord, GXTexMapID tex_map); +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 ind_lod, + GXIndTexAlphaSel alpha_sel); +void GXSetTevIndWarp(GXTevStageID tev_stage, GXIndTexStageID ind_stage, GXBool signed_offsets, + GXBool replace_mode, GXIndTexMtxID matrix_sel); +void GXSetIndTexCoordScale(GXIndTexStageID ind_state, GXIndTexScale scale_s, GXIndTexScale scale_t); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXBUMP diff --git a/include/dolphin/gx/GXCommandList.h b/include/dolphin/gx/GXCommandList.h new file mode 100644 index 00000000..cf3a5172 --- /dev/null +++ b/include/dolphin/gx/GXCommandList.h @@ -0,0 +1,35 @@ +#ifndef _DOLPHIN_GXCOMMANDLIST +#define _DOLPHIN_GXCOMMANDLIST + +#ifdef __cplusplus +extern "C" { +#endif + +#define GX_NOP 0x00 +#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_LOAD_BP_REG 0x61 +#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_CMD_CALL_DL 0x40 +#define GX_CMD_INVL_VC 0x48 + +#define GX_OPCODE_MASK 0xF8 +#define GX_VAT_MASK 0x07 + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXCOMMANDLIST diff --git a/include/dolphin/gx/GXCull.h b/include/dolphin/gx/GXCull.h new file mode 100644 index 00000000..b5699302 --- /dev/null +++ b/include/dolphin/gx/GXCull.h @@ -0,0 +1,18 @@ +#ifndef _DOLPHIN_GXCULL +#define _DOLPHIN_GXCULL + +#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 // _DOLPHIN_GXCULL diff --git a/include/dolphin/gx/GXDispList.h b/include/dolphin/gx/GXDispList.h new file mode 100644 index 00000000..552eda2d --- /dev/null +++ b/include/dolphin/gx/GXDispList.h @@ -0,0 +1,18 @@ +#ifndef _DOLPHIN_GXDISPLIST +#define _DOLPHIN_GXDISPLIST + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXBeginDisplayList(void* list, u32 size); +u32 GXEndDisplayList(void); +void GXCallDisplayList(const void* list, u32 nbytes); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXDISPLIST diff --git a/include/dolphin/gx/GXDraw.h b/include/dolphin/gx/GXDraw.h new file mode 100644 index 00000000..3901ebfe --- /dev/null +++ b/include/dolphin/gx/GXDraw.h @@ -0,0 +1,16 @@ +#ifndef _DOLPHIN_GXDRAW +#define _DOLPHIN_GXDRAW + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXDrawSphere(u8 numMajor, u8 numMinor); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXDRAW diff --git a/include/dolphin/gx/GXEnum.h b/include/dolphin/gx/GXEnum.h new file mode 100644 index 00000000..d6fed014 --- /dev/null +++ b/include/dolphin/gx/GXEnum.h @@ -0,0 +1,910 @@ +#ifndef _DOLPHIN_GXENUM +#define _DOLPHIN_GXENUM + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef TARGET_PC +#include + +typedef bool GXBool; +#else +typedef u8 GXBool; +#endif + +#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; + +#define GX_MAX_VTXDESCLIST_SZ (GX_VA_MAX_ATTR + 1) + +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, + GX_MAX_TEXGENSRC, +} 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 = GX_FOG_PERSP_LIN, + GX_FOG_EXP = GX_FOG_PERSP_EXP, + GX_FOG_EXP2 = GX_FOG_PERSP_EXP2, + GX_FOG_REVEXP = GX_FOG_PERSP_REVEXP, + GX_FOG_REVEXP2 = GX_FOG_PERSP_REVEXP2, +} GXFogType; + +typedef enum _GXTevColorArg { + GX_CC_CPREV, + GX_CC_APREV, + GX_CC_C0, + GX_CC_A0, + GX_CC_C1, + GX_CC_A1, + GX_CC_C2, + GX_CC_A2, + GX_CC_TEXC, + GX_CC_TEXA, + GX_CC_RASC, + GX_CC_RASA, + GX_CC_ONE, + GX_CC_HALF, + GX_CC_KONST, + GX_CC_ZERO, +} GXTevColorArg; + +typedef enum _GXTevAlphaArg { + GX_CA_APREV, + GX_CA_A0, + GX_CA_A1, + GX_CA_A2, + GX_CA_TEXA, + GX_CA_RASA, + GX_CA_KONST, + GX_CA_ZERO, +} 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_8_8 = 0x00, + GX_TEV_KCSEL_7_8 = 0x01, + GX_TEV_KCSEL_6_8 = 0x02, + GX_TEV_KCSEL_5_8 = 0x03, + GX_TEV_KCSEL_4_8 = 0x04, + GX_TEV_KCSEL_3_8 = 0x05, + GX_TEV_KCSEL_2_8 = 0x06, + GX_TEV_KCSEL_1_8 = 0x07, + GX_TEV_KCSEL_1 = GX_TEV_KCSEL_8_8, + GX_TEV_KCSEL_3_4 = GX_TEV_KCSEL_6_8, + GX_TEV_KCSEL_1_2 = GX_TEV_KCSEL_4_8, + GX_TEV_KCSEL_1_4 = GX_TEV_KCSEL_2_8, + 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_8_8 = 0x00, + GX_TEV_KASEL_7_8 = 0x01, + GX_TEV_KASEL_6_8 = 0x02, + GX_TEV_KASEL_5_8 = 0x03, + GX_TEV_KASEL_4_8 = 0x04, + GX_TEV_KASEL_3_8 = 0x05, + GX_TEV_KASEL_2_8 = 0x06, + GX_TEV_KASEL_1_8 = 0x07, + GX_TEV_KASEL_1 = GX_TEV_KASEL_8_8, + GX_TEV_KASEL_3_4 = GX_TEV_KASEL_6_8, + GX_TEV_KASEL_1_2 = GX_TEV_KASEL_4_8, + GX_TEV_KASEL_1_4 = GX_TEV_KASEL_2_8, + 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 _GXClipMode { + GX_CLIP_ENABLE = 0, + GX_CLIP_DISABLE = 1, +} GXClipMode; + +typedef enum _GXTlut { + GX_TLUT0 = 0, + GX_TLUT1 = 1, + GX_TLUT2 = 2, + GX_TLUT3 = 3, + GX_TLUT4 = 4, + GX_TLUT5 = 5, + GX_TLUT6 = 6, + GX_TLUT7 = 7, + GX_TLUT8 = 8, + GX_TLUT9 = 9, + GX_TLUT10 = 10, + GX_TLUT11 = 11, + GX_TLUT12 = 12, + GX_TLUT13 = 13, + GX_TLUT14 = 14, + GX_TLUT15 = 15, + GX_BIGTLUT0 = 16, + GX_BIGTLUT1 = 17, + GX_BIGTLUT2 = 18, + GX_BIGTLUT3 = 19, +} GXTlut; + +typedef enum _GXTlutFmt { + GX_TL_IA8, + GX_TL_RGB565, + GX_TL_RGB5A3, + GX_MAX_TLUTFMT, +} GXTlutFmt; + +typedef enum _GXMiscToken { + GX_MT_NULL = 0, + GX_MT_XF_FLUSH = 1, + GX_MT_DL_SAVE_CONTEXT = 2, + GX_MT_ABORT_WAIT_COPYOUT = 3, +} GXMiscToken; + +typedef enum _GXTexCacheSize { + GX_TEXCACHE_32K, + GX_TEXCACHE_128K, + GX_TEXCACHE_512K, + GX_TEXCACHE_NONE +} GXTexCacheSize; + +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, + GX_VC_NRM, + GX_VC_CLR0, + GX_VC_CLR1, + GX_VC_TEX0, + GX_VC_TEX1, + GX_VC_TEX2, + GX_VC_TEX3, + GX_VC_TEX4, + GX_VC_TEX5, + GX_VC_TEX6, + GX_VC_TEX7, + GX_VC_ALL = 0xf + +} GXVCachePerf; + +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 = 0, + GX_READ_FF = 1, + GX_READ_NONE = 2, + +} _GXAlphaReadMode; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXENUM diff --git a/include/dolphin/gx/GXExtra.h b/include/dolphin/gx/GXExtra.h new file mode 100644 index 00000000..afd29caa --- /dev/null +++ b/include/dolphin/gx/GXExtra.h @@ -0,0 +1,36 @@ +#ifndef _DOLPHIN_GXEXTRA +#define _DOLPHIN_GXEXTRA + +// Extra types for PC +#ifdef TARGET_PC +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + float r; + float g; + float b; + float a; +} GXColorF32; + +typedef enum { + GX_TF_R8_PC = 0x60, + GX_TF_RGBA8_PC = 0x61, +} GXPCTexFmt; + +void GXDestroyTexObj(GXTexObj* obj); +void GXDestroyTlutObj(GXTlutObj* obj); + +void GXColor4f32(float r, float g, float b, float a); + +#ifdef __cplusplus +} +#endif + +#endif // TARGET_PC + +#endif // _DOLPHIN_GXEXTRA diff --git a/include/dolphin/gx/GXFifo.h b/include/dolphin/gx/GXFifo.h new file mode 100644 index 00000000..85d61685 --- /dev/null +++ b/include/dolphin/gx/GXFifo.h @@ -0,0 +1,37 @@ +#ifndef _DOLPHIN_GXFIFO +#define _DOLPHIN_GXFIFO + +#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 GXGetFifoPtrs(GXFifoObj* fifo, void** readPtr, void** writePtr); +GXFifoObj* GXGetCPUFifo(void); +GXFifoObj* GXGetGPFifo(void); +void GXSetCPUFifo(GXFifoObj* fifo); +void GXSetGPFifo(GXFifoObj* fifo); +void GXSaveCPUFifo(GXFifoObj* fifo); +void GXGetFifoStatus(GXFifoObj* fifo, GXBool* overhi, GXBool* underlow, u32* fifoCount, + GXBool* cpu_write, GXBool* gp_read, GXBool* fifowrap); +void GXGetGPStatus(GXBool* overhi, GXBool* underlow, GXBool* readIdle, GXBool* cmdIdle, + GXBool* brkpt); +void GXInitFifoLimits(GXFifoObj* fifo, u32 hiWaterMark, u32 loWaterMark); +GXBreakPtCallback GXSetBreakPtCallback(GXBreakPtCallback cb); +void GXEnableBreakPt(void* breakPt); +void GXDisableBreakPt(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXFIFO diff --git a/include/dolphin/gx/GXFrameBuffer.h b/include/dolphin/gx/GXFrameBuffer.h new file mode 100644 index 00000000..55b97bc5 --- /dev/null +++ b/include/dolphin/gx/GXFrameBuffer.h @@ -0,0 +1,62 @@ +#ifndef _DOLPHIN_GXFRAMEBUFFER +#define _DOLPHIN_GXFRAMEBUFFER + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// 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 GXNtsc480ProgSoft; +// 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 GXPal524IntAa; +// extern GXRenderModeObj GXEurgb60Hz240Ds; +// extern GXRenderModeObj GXEurgb60Hz240DsAa; +// extern GXRenderModeObj GXEurgb60Hz240Int; +// extern GXRenderModeObj GXEurgb60Hz240IntAa; +extern GXRenderModeObj GXEurgb60Hz480IntDf; +// extern GXRenderModeObj GXEurgb60Hz480Int; +// extern GXRenderModeObj GXEurgb60Hz480IntAa; + +#define GX_MAX_Z24 0x00FFFFFF + +void GXSetCopyClear(GXColor clear_clr, u32 clear_z); +void GXAdjustForOverscan(GXRenderModeObj* rmin, GXRenderModeObj* rmout, u16 hor, u16 ver); +void GXCopyDisp(void* dest, GXBool clear); +void GXSetDispCopyGamma(GXGamma gamma); +void GXSetDispCopySrc(u16 left, u16 top, u16 wd, u16 ht); +void GXSetDispCopyDst(u16 wd, u16 ht); +u32 GXSetDispCopyYScale(f32 vscale); +void GXSetCopyFilter(GXBool aa, u8 sample_pattern[12][2], GXBool vf, u8 vfilter[7]); +void GXSetPixelFmt(GXPixelFmt pix_fmt, GXZFmt16 z_fmt); +void GXSetTexCopySrc(u16 left, u16 top, u16 wd, u16 ht); +void GXSetTexCopyDst(u16 wd, u16 ht, GXTexFmt fmt, GXBool mipmap); +void GXCopyTex(void* dest, GXBool clear); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXFRAMEBUFFER diff --git a/include/dolphin/gx/GXGeometry.h b/include/dolphin/gx/GXGeometry.h new file mode 100644 index 00000000..632ebc69 --- /dev/null +++ b/include/dolphin/gx/GXGeometry.h @@ -0,0 +1,37 @@ +#ifndef _DOLPHIN_GXGEOMETRY +#define _DOLPHIN_GXGEOMETRY + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetVtxDesc(GXAttr attr, GXAttrType type); +void GXSetVtxDescv(GXVtxDescList* list); +void GXClearVtxDesc(void); +void GXSetVtxAttrFmt(GXVtxFmt vtxfmt, GXAttr attr, GXCompCnt cnt, GXCompType type, u8 frac); +void GXSetNumTexGens(u8 nTexGens); +void GXBegin(GXPrimitive type, GXVtxFmt vtxfmt, u16 nverts); +void GXSetTexCoordGen2(GXTexCoordID dst_coord, GXTexGenType func, GXTexGenSrc src_param, u32 mtx, + GXBool normalize, u32 postmtx); +void GXSetLineWidth(u8 width, GXTexOffset texOffsets); +void GXSetPointSize(u8 pointSize, GXTexOffset texOffsets); +void GXEnableTexOffsets(GXTexCoordID coord, GXBool line_enable, GXBool point_enable); +#ifdef TARGET_PC +void GXSetArray(GXAttr attr, const void* data, u32 size, u8 stride); +#else +void GXSetArray(GXAttr attr, const void* data, u8 stride); +#endif +void GXInvalidateVtxCache(void); + +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); +} + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXGEOMETRY diff --git a/include/dolphin/gx/GXGet.h b/include/dolphin/gx/GXGet.h new file mode 100644 index 00000000..1eff8eb2 --- /dev/null +++ b/include/dolphin/gx/GXGet.h @@ -0,0 +1,28 @@ +#ifndef _DOLPHIN_GXGET +#define _DOLPHIN_GXGET + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +GXBool GXGetTexObjMipMap(const GXTexObj* obj); +GXTexFmt GXGetTexObjFmt(const GXTexObj* obj); +u16 GXGetTexObjHeight(const GXTexObj* obj); +u16 GXGetTexObjWidth(const GXTexObj* obj); +GXTexWrapMode GXGetTexObjWrapS(const GXTexObj* obj); +GXTexWrapMode GXGetTexObjWrapT(const GXTexObj* obj); +void* GXGetTexObjData(const GXTexObj* obj); +void GXGetProjectionv(f32* p); +void GXGetLightPos(const GXLightObj* lt_obj, f32* x, f32* y, f32* z); +void GXGetLightColor(const GXLightObj* lt_obj, GXColor* color); +void GXGetVtxAttrFmt(GXVtxFmt idx, GXAttr attr, GXCompCnt* compCnt, GXCompType* compType, + u8* shift); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXGET diff --git a/include/dolphin/gx/GXLighting.h b/include/dolphin/gx/GXLighting.h new file mode 100644 index 00000000..a7e0ccc6 --- /dev/null +++ b/include/dolphin/gx/GXLighting.h @@ -0,0 +1,32 @@ +#ifndef _DOLPHIN_GXLIGHTING +#define _DOLPHIN_GXLIGHTING + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +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); +void GXSetChanAmbColor(GXChannelID chan, GXColor amb_color); +void GXSetChanMatColor(GXChannelID chan, GXColor mat_color); + +void GXInitLightSpot(GXLightObj* lt_obj, f32 cutoff, GXSpotFn spot_func); +void GXInitLightDistAttn(GXLightObj* lt_obj, f32 ref_distance, f32 ref_brightness, + 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 GXInitLightColor(GXLightObj* lt_obj, GXColor color); +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 GXLoadLightObjImm(GXLightObj* lt_obj, GXLightID light); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXLIGHTING diff --git a/include/dolphin/gx/GXManage.h b/include/dolphin/gx/GXManage.h new file mode 100644 index 00000000..ab3a72c8 --- /dev/null +++ b/include/dolphin/gx/GXManage.h @@ -0,0 +1,24 @@ +#ifndef _DOLPHIN_GXMANAGE +#define _DOLPHIN_GXMANAGE + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*GXDrawDoneCallback)(void); + +GXFifoObj* GXInit(void* base, u32 size); +GXDrawDoneCallback GXSetDrawDoneCallback(GXDrawDoneCallback cb); +void GXDrawDone(void); +void GXSetDrawDone(void); +void GXFlush(void); +void GXPixModeSync(void); +void GXSetMisc(GXMiscToken token, u32 val); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXMANAGE diff --git a/include/dolphin/gx/GXPerf.h b/include/dolphin/gx/GXPerf.h new file mode 100644 index 00000000..c3850dc3 --- /dev/null +++ b/include/dolphin/gx/GXPerf.h @@ -0,0 +1,16 @@ +#ifndef _DOLPHIN_GXPERF +#define _DOLPHIN_GXPERF + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXReadXfRasMetric(u32* xf_wait_in, u32* xf_wait_out, u32* ras_busy, u32* clocks); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXPERF diff --git a/include/dolphin/gx/GXPixel.h b/include/dolphin/gx/GXPixel.h new file mode 100644 index 00000000..5efb0ead --- /dev/null +++ b/include/dolphin/gx/GXPixel.h @@ -0,0 +1,29 @@ +#ifndef _DOLPHIN_GXPIXEL +#define _DOLPHIN_GXPIXEL + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void GXSetFog(GXFogType type, f32 startz, f32 endz, f32 nearz, f32 farz, GXColor color); +void GXSetFogColor(GXColor color); +// ? GXSetFogRangeAdj(); +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); +// ? GXSetFieldMask(); +void GXSetFieldMode(u8 field_mode, u8 half_aspect_ratio); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXPIXEL diff --git a/include/dolphin/gx/GXPriv.h b/include/dolphin/gx/GXPriv.h new file mode 100644 index 00000000..ea3d2318 --- /dev/null +++ b/include/dolphin/gx/GXPriv.h @@ -0,0 +1,361 @@ +#ifndef _DOLPHIN_GXPRIV +#define _DOLPHIN_GXPRIV + +#include "dolphin/gx/GXVert.h" + +typedef struct GXLightObjInt { + u32 padding[3]; + u32 color; + float a0; + float a1; + float a2; + float k0; + float k1; + float k2; + float px; + float py; + float pz; + float nx; + float ny; + float nz; +} GXLightObjInt; + +#define XF_LIGHT_BASE 0x0600 +#define XF_LIGHT_SIZE 0x10 + +#define GX_FIFO_ADDR 0xCC008000 + +#define GX_WRITE_U8(v) (GXWGFifo.u8 = v) +#define GX_WRITE_U32(v) (GXWGFifo.u32 = v) + +typedef struct __GXData_struct { + u16 vNumNot; + u16 bpSentNot; + u16 vNum; + u16 vLim; + u32 cpEnable; + u32 cpStatus; + u32 cpClr; + u32 vcdLo; + u32 vcdHi; + u32 vatA[8]; + u32 vatB[8]; + u32 vatC[8]; + u32 lpSize; + u32 matIdxA; + u32 matIdxB; + u32 indexBase[4]; + u32 indexStride[4]; + u32 ambColor[2]; + u32 matColor[2]; + u32 suTs0[8]; + u32 suTs1[8]; + u32 suScis0; + u32 suScis1; + u32 tref[8]; + u32 iref; + u32 bpMask; + u32 IndTexScale0; + u32 IndTexScale1; + u32 tevc[16]; + u32 teva[16]; + u32 tevKsel[8]; + u32 cmode0; + u32 cmode1; + u32 zmode; + u32 peCtrl; + u32 cpDispSrc; + u32 cpDispSize; + u32 cpDispStride; + u32 cpDisp; + u32 cpTexSrc; + u32 cpTexSize; + u32 cpTexStride; + u32 cpTex; + GXBool cpTexZ; + u32 genMode; + GXTexRegion TexRegions[8]; + GXTexRegion TexRegionsCI[4]; + u32 nextTexRgn; + u32 nextTexRgnCI; + GXTlutRegion TlutRegions[20]; + GXTexRegion* (*texRegionCallback)(GXTexObj*, GXTexMapID); + GXTlutRegion* (*tlutRegionCallback)(u32); + GXAttrType nrmType; + GXBool hasNrms; + GXBool hasBiNrms; + u32 projType; + f32 projMtx[6]; + f32 vpLeft; + f32 vpTop; + f32 vpWd; + f32 vpHt; + f32 vpNearz; + f32 vpFarz; + u8 fgRange; + f32 fgSideX; + u32 tImage0[8]; + u32 tMode0[8]; + u32 texmapId[16]; + u32 tcsManEnab; + u32 tevTcEnab; + GXPerf0 perf0; + GXPerf1 perf1; + u32 perfSel; + GXBool inDispList; + GXBool dlSaveContext; + u8 dirtyVAT; + u32 dirtyState; +} GXData; + +extern GXData* gx; +// #define gx __GXData + +void __GXInitGX(); + +#define GX_REG_ASSERT(c) ASSERTMSG(c, "GX Internal: Register field out of range") + +#define GX_FLAG_SET(regOrg, newFlag, regName) \ + do { \ + GX_REG_ASSERT(!((newFlag) & ~((1 << (regName##_SIZE)) - 1))); \ + (regOrg) = (((u32)(regOrg) & ~(regName##_MASK)) | \ + (((u32)(newFlag) << (regName##_SHIFT)) & (regName##_MASK))); \ + } while (0) + +#define GX_GENMODE_ID 0 +#define GX_GENMODE_REG_ID_SIZE 8 +#define GX_GENMODE_REG_ID_SHIFT 24 +#define GX_GENMODE_REG_ID_MASK 0xff000000 +#define GX_GENMODE_GET_REG_ID(genMode) \ + ((((u32)(genMode)) & GX_GENMODE_REG_ID_MASK) >> GX_GENMODE_REG_ID_SHIFT) + +#define GX_BPMASK_ID 15 +#define GX_BPMASK_REG_ID_SIZE 8 +#define GX_BPMASK_REG_ID_SHIFT 24 +#define GX_BPMASK_REG_ID_MASK 0xff000000 + +#define GX_LPSIZE_ID 34 +#define GX_LPSIZE_REG_ID_SIZE 8 +#define GX_LPSIZE_REG_ID_SHIFT 24 +#define GX_LPSIZE_REG_ID_MASK 0xff000000 + +#define TEV_COLOR_ENV_REG_ID_SIZE 8 +#define TEV_COLOR_ENV_REG_ID_SHIFT 24 +#define TEV_COLOR_ENV_REG_ID_MASK 0xff000000 + +#define TEV_ALPHA_ENV_REG_ID_SIZE 8 +#define TEV_ALPHA_ENV_REG_ID_SHIFT 24 +#define TEV_ALPHA_ENV_REG_ID_MASK 0xff000000 + +#define TEV_COLOR_ENV_0_ID 0x000000c0 +#define TEV_ALPHA_ENV_0_ID 0x000000c1 +#define TEV_COLOR_ENV_1_ID 0x000000c2 +#define TEV_ALPHA_ENV_1_ID 0x000000c3 +#define TEV_COLOR_ENV_2_ID 0x000000c4 +#define TEV_ALPHA_ENV_2_ID 0x000000c5 +#define TEV_COLOR_ENV_3_ID 0x000000c6 +#define TEV_ALPHA_ENV_3_ID 0x000000c7 +#define TEV_COLOR_ENV_4_ID 0x000000c8 +#define TEV_ALPHA_ENV_4_ID 0x000000c9 +#define TEV_COLOR_ENV_5_ID 0x000000ca +#define TEV_ALPHA_ENV_5_ID 0x000000cb +#define TEV_COLOR_ENV_6_ID 0x000000cc +#define TEV_ALPHA_ENV_6_ID 0x000000cd +#define TEV_COLOR_ENV_7_ID 0x000000ce +#define TEV_ALPHA_ENV_7_ID 0x000000cf +#define TEV_COLOR_ENV_8_ID 0x000000d0 +#define TEV_ALPHA_ENV_8_ID 0x000000d1 +#define TEV_COLOR_ENV_9_ID 0x000000d2 +#define TEV_ALPHA_ENV_9_ID 0x000000d3 +#define TEV_COLOR_ENV_A_ID 0x000000d4 +#define TEV_ALPHA_ENV_A_ID 0x000000d5 +#define TEV_COLOR_ENV_B_ID 0x000000d6 +#define TEV_ALPHA_ENV_B_ID 0x000000d7 +#define TEV_COLOR_ENV_C_ID 0x000000d8 +#define TEV_ALPHA_ENV_C_ID 0x000000d9 +#define TEV_COLOR_ENV_D_ID 0x000000da +#define TEV_ALPHA_ENV_D_ID 0x000000db +#define TEV_COLOR_ENV_E_ID 0x000000dc +#define TEV_ALPHA_ENV_E_ID 0x000000dd +#define TEV_COLOR_ENV_F_ID 0x000000de +#define TEV_ALPHA_ENV_F_ID 0x000000df + +#define TEV_KSEL_REG_ID_SIZE 8 +#define TEV_KSEL_REG_ID_SHIFT 24 +#define TEV_KSEL_REG_ID_MASK 0xff000000 + +#define TEV_KSEL_0_ID 0x000000f6 +#define TEV_KSEL_1_ID 0x000000f7 +#define TEV_KSEL_2_ID 0x000000f8 +#define TEV_KSEL_3_ID 0x000000f9 +#define TEV_KSEL_4_ID 0x000000fa +#define TEV_KSEL_5_ID 0x000000fb +#define TEV_KSEL_6_ID 0x000000fc +#define TEV_KSEL_7_ID 0x000000fd + +#define RAS_IREF_ID 39 +#define RAS_IREF_REG_ID_SIZE 8 +#define RAS_IREF_REG_ID_SHIFT 24 +#define RAS_IREF_REG_ID_MASK 0xff000000 + +#define RAS_TREF0_ID 40 +#define RAS_TREF_REG_ID_SIZE 8 +#define RAS_TREF_REG_ID_SHIFT 24 +#define RAS_TREF_REG_ID_MASK 0xff000000 + +#define SU_TS0_REG_ID_SIZE 8 +#define SU_TS0_REG_ID_SHIFT 24 +#define SU_TS0_REG_ID_MASK 0xff000000 + +#define SU_TS1_REG_ID_SIZE 8 +#define SU_TS1_REG_ID_SHIFT 24 +#define SU_TS1_REG_ID_MASK 0xff000000 + +#define SU_SCIS0_ID 0x00000020 +#define SU_SCIS1_ID 0x00000021 + +#define SU_SCIS0_REG_ID_SIZE 8 +#define SU_SCIS0_REG_ID_SHIFT 24 +#define SU_SCIS0_REG_ID_MASK 0xff000000 + +#define SU_SCIS1_REG_ID_SIZE 8 +#define SU_SCIS1_REG_ID_SHIFT 24 +#define SU_SCIS1_REG_ID_MASK 0xff000000 + +#define SU_SSIZE0_ID 0x00000030 +#define SU_TSIZE0_ID 0x00000031 +#define SU_SSIZE1_ID 0x00000032 +#define SU_TSIZE1_ID 0x00000033 +#define SU_SSIZE2_ID 0x00000034 +#define SU_TSIZE2_ID 0x00000035 +#define SU_SSIZE3_ID 0x00000036 +#define SU_TSIZE3_ID 0x00000037 +#define SU_SSIZE4_ID 0x00000038 +#define SU_TSIZE4_ID 0x00000039 +#define SU_SSIZE5_ID 0x0000003a +#define SU_TSIZE5_ID 0x0000003b +#define SU_SSIZE6_ID 0x0000003c +#define SU_TSIZE6_ID 0x0000003d +#define SU_SSIZE7_ID 0x0000003e +#define SU_TSIZE7_ID 0x0000003f + +#define GX_ZMODE_ID 64 +#define GX_ZMODE_REG_ID_SIZE 8 +#define GX_ZMODE_REG_ID_SHIFT 24 +#define GX_ZMODE_REG_ID_MASK 0xff000000 + +#define GX_CMODE0_ID 65 +#define GX_CMODE0_REG_ID_SIZE 8 +#define GX_CMODE0_REG_ID_SHIFT 24 +#define GX_CMODE0_REG_ID_MASK 0xff000000 + +#define GX_CMODE1_ID 66 +#define GX_CMODE1_REG_ID_SIZE 8 +#define GX_CMODE1_REG_ID_SHIFT 24 +#define GX_CMODE1_REG_ID_MASK 0xff000000 + +#define PE_CONTROL_ID 67 +#define PE_CONTROL_REG_ID_SIZE 8 +#define PE_CONTROL_REG_ID_SHIFT 24 +#define PE_CONTROL_REG_ID_MASK 0xff000000 + +#define PE_COPY_CMD_GAMMA_SIZE 2 +#define PE_COPY_CMD_GAMMA_SHIFT 7 +#define PE_COPY_CMD_GAMMA_MASK 0x00000180 + +#define GEN_MODE_REG_ID_SIZE 8 +#define GEN_MODE_REG_ID_SHIFT 24 +#define GEN_MODE_REG_ID_MASK 0xff000000 + +#define GX_OPCODE_INDEX_SIZE 3 +#define GX_OPCODE_INDEX_SHIFT 0 +#define GX_OPCODE_INDEX_MASK 0x00000007 + +#define GX_OPCODE_CMD_SHIFT 3 + +#define GX_OPCODE(index, cmd) \ + ((((u32)(index)) << GX_OPCODE_INDEX_SHIFT) | (((u32)(cmd)) << GX_OPCODE_CMD_SHIFT)) + +#ifdef _DEBUG +#define GX_WRITE_RA_REG(reg) \ + { \ + GX_WRITE_U8(GX_OPCODE(1, 12)); \ + GX_WRITE_U32((reg)); \ + __gxVerif->rasRegs[GX_GENMODE_GET_REG_ID(reg)] = reg; \ + } +#else +#define GX_WRITE_RA_REG(reg) \ + { \ + GX_WRITE_U8(GX_OPCODE(1, 12)); \ + GX_WRITE_U32((reg)); \ + } +#endif + +#define CP_STREAM_REG_INDEX_SIZE 4 +#define CP_STREAM_REG_INDEX_SHIFT 0 +#define CP_STREAM_REG_INDEX_MASK 0x0000000f + +#define CP_STREAM_REG_ADDR_SIZE 4 +#define CP_STREAM_REG_ADDR_SHIFT 4 +#define CP_STREAM_REG_ADDR_MASK 0x000000f0 + +#define CP_STREAM_REG(index, addr) \ + ((((unsigned long)(index)) << CP_STREAM_REG_INDEX_SHIFT) | \ + (((unsigned long)(addr)) << CP_STREAM_REG_ADDR_SHIFT)) + +#ifdef _DEBUG +#define GX_WRITE_CP_STRM_REG(addr, vtxfmt, data) \ + { \ + s32 regAddr; \ + GX_WRITE_U8(GX_OPCODE(0, 1)); \ + GX_WRITE_U8(CP_STREAM_REG((vtxfmt), (addr))); \ + GX_WRITE_U32((data)); \ + regAddr = (vtxfmt)-GX_POS_MTX_ARRAY + GX_VA_POS; \ + if ((addr) == 10) { \ + if (regAddr >= 0 && regAddr < 4) \ + gx->indexBase[regAddr] = (data); \ + } else if ((addr) == 11) { \ + if (regAddr >= 0 && regAddr < 4) \ + gx->indexStride[regAddr] = (data); \ + } \ + } +#else +#define GX_WRITE_CP_STRM_REG(addr, vtxfmt, data) \ + { \ + GX_WRITE_U8(GX_OPCODE(0, 1)); \ + GX_WRITE_U8(CP_STREAM_REG((vtxfmt), (addr))); \ + GX_WRITE_U32((data)); \ + } +#endif + +#define PE_REFRESH_REG_ID_SIZE 8 +#define PE_REFRESH_REG_ID_SHIFT 24 +#define PE_REFRESH_REG_ID_MASK 0xff000000 + +#define PE_REFRESH_INTERVAL_SHIFT 0 +#define PE_REFRESH_ENABLE_SHIFT 9 +#define PE_REFRESH_TOTAL_SIZE 32 +#define PE_REFRESH(interval, enable, rid) \ + ((((u32)(interval)) << PE_REFRESH_INTERVAL_SHIFT) | \ + (((u32)(enable)) << PE_REFRESH_ENABLE_SHIFT) | (((u32)(rid)) << PE_REFRESH_REG_ID_SHIFT)) + +#define TX_REFRESH_REG_ID_SIZE 8 +#define TX_REFRESH_REG_ID_SHIFT 24 +#define TX_REFRESH_REG_ID_MASK 0xff000000 + +#define TX_REFRESH_INTERVAL_SHIFT 0 +#define TX_REFRESH_ENABLE_SHIFT 10 +#define TX_REFRESH_TOTAL_SIZE 32 +#define TX_REFRESH(interval, enable, rid) \ + ((((u32)(interval)) << TX_REFRESH_INTERVAL_SHIFT) | \ + (((u32)(enable)) << TX_REFRESH_ENABLE_SHIFT) | (((u32)(rid)) << TX_REFRESH_REG_ID_SHIFT)) + +#define GX_VAT_REG_A_UNK_SIZE 1 +#define GX_VAT_REG_A_UNK_SHIFT 30 +#define GX_VAT_REG_A_UNK_MASK 0x40000000 + +#define GX_VAT_REG_B_UNK_SIZE 1 +#define GX_VAT_REG_B_UNK_SHIFT 31 +#define GX_VAT_REG_B_UNK_MASK 0x80000000 + +#endif // _DOLPHIN_GXPRIV diff --git a/include/dolphin/gx/GXStruct.h b/include/dolphin/gx/GXStruct.h new file mode 100644 index 00000000..4df23062 --- /dev/null +++ b/include/dolphin/gx/GXStruct.h @@ -0,0 +1,87 @@ +#ifndef _DOLPHIN_GXSTRUCT +#define _DOLPHIN_GXSTRUCT + +#include +#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; + u8 aa; + u8 sample_pattern[12][2]; + u8 vfilter[7]; +} GXRenderModeObj; + +typedef struct _GXColor { + u8 r; + u8 g; + u8 b; + u8 a; +} GXColor; + +typedef struct _GXTexObj { +#ifdef TARGET_PC + u32 dummy[22]; +#else + u32 dummy[8]; +#endif +} GXTexObj; + +typedef struct _GXTlutObj { +#ifdef TARGET_PC + u32 dummy[4]; +#else + u32 dummy[3]; +#endif +} GXTlutObj; + +typedef struct _GXLightObj { + u32 dummy[16]; +} GXLightObj; + +typedef struct _GXVtxDescList { + GXAttr attr; + GXAttrType type; +} GXVtxDescList; + +typedef struct _GXColorS10 { + s16 r; + s16 g; + s16 b; + s16 a; +} GXColorS10; + +typedef struct _GXTexRegion { + u32 dummy[4]; +} GXTexRegion; + +typedef struct _GXTlutRegion { + u32 dummy[4]; +} GXTlutRegion; + +typedef struct _GXVtxAttrFmtList { + // total size: 0x10 + GXAttr attr; // offset 0x0, size 0x4 + GXCompCnt cnt; // offset 0x4, size 0x4 + GXCompType type; // offset 0x8, size 0x4 + u8 frac; // offset 0xC, size 0x1 +} GXVtxAttrFmtList; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXSTRUCT diff --git a/include/dolphin/gx/GXTev.h b/include/dolphin/gx/GXTev.h new file mode 100644 index 00000000..01290a9d --- /dev/null +++ b/include/dolphin/gx/GXTev.h @@ -0,0 +1,37 @@ +#ifndef _DOLPHIN_GXTEV +#define _DOLPHIN_GXTEV + +#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 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 // _DOLPHIN_GXTEV diff --git a/include/dolphin/gx/GXTexture.h b/include/dolphin/gx/GXTexture.h new file mode 100644 index 00000000..32de49ca --- /dev/null +++ b/include/dolphin/gx/GXTexture.h @@ -0,0 +1,37 @@ +#ifndef _DOLPHIN_GXTEXTURE +#define _DOLPHIN_GXTEXTURE + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef GXTexRegion* (*GXTexRegionCallback)(const GXTexObj* obj, GXTexMapID id); + +void GXInitTexObj(GXTexObj* obj, const void* data, u16 width, u16 height, u32 format, + GXTexWrapMode wrapS, GXTexWrapMode wrapT, GXBool mipmap); +void GXInitTexObjCI(GXTexObj* obj, const void* data, u16 width, u16 height, GXCITexFmt format, + GXTexWrapMode wrapS, GXTexWrapMode wrapT, GXBool mipmap, u32 tlut); +void GXInitTexObjData(GXTexObj* obj, const void* data); +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 GXLoadTexObj(GXTexObj* obj, GXTexMapID id); +u32 GXGetTexBufferSize(u16 width, u16 height, u32 format, GXBool mipmap, u8 max_lod); +void GXInvalidateTexAll(); +void GXInitTexObjWrapMode(GXTexObj* obj, GXTexWrapMode s, GXTexWrapMode t); +void GXInitTlutObj(GXTlutObj* obj, void* data, GXTlutFmt format, u16 entries); +void GXLoadTlut(const GXTlutObj* obj, GXTlut idx); +void GXSetTexCoordScaleManually(GXTexCoordID coord, GXBool enable, u16 ss, u16 ts); +void GXInitTexCacheRegion(GXTexRegion* region, GXBool is_32b_mipmap, u32 tmem_even, + GXTexCacheSize size_even, u32 tmem_odd, GXTexCacheSize size_odd); +GXTexRegionCallback GXSetTexRegionCallback(GXTexRegionCallback callback); +void GXInvalidateTexRegion(const GXTexRegion* region); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXTEXTURE diff --git a/include/dolphin/gx/GXTransform.h b/include/dolphin/gx/GXTransform.h new file mode 100644 index 00000000..bc3bf107 --- /dev/null +++ b/include/dolphin/gx/GXTransform.h @@ -0,0 +1,33 @@ +#ifndef _DOLPHIN_GXTRANSFORM +#define _DOLPHIN_GXTRANSFORM + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define GX_PROJECTION_SZ 7 + +#ifdef TARGET_PC +void GXSetProjection(const void* mtx, GXProjectionType type); +void GXLoadPosMtxImm(const void* mtx, u32 id); +void GXLoadNrmMtxImm(const void* mtx, u32 id); +void GXLoadTexMtxImm(const void* mtx, u32 id, GXTexMtxType type); +#else +void GXSetProjection(f32 mtx[4][4], GXProjectionType type); +void GXLoadPosMtxImm(f32 mtx[3][4], u32 id); +void GXLoadNrmMtxImm(f32 mtx[3][4], u32 id); +void GXLoadTexMtxImm(f32 mtx[][4], u32 id, GXTexMtxType type); +#endif +void GXSetViewport(f32 left, f32 top, f32 wd, f32 ht, f32 nearz, f32 farz); +void GXSetCurrentMtx(u32 id); +void GXSetViewportJitter(f32 left, f32 top, f32 wd, f32 ht, f32 nearz, f32 farz, u32 field); +void GXSetScissorBoxOffset(s32 x_off, s32 y_off); +void GXSetClipMode(GXClipMode mode); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXTRANSFORM diff --git a/include/dolphin/gx/GXVerify.h b/include/dolphin/gx/GXVerify.h new file mode 100644 index 00000000..a4e40cfb --- /dev/null +++ b/include/dolphin/gx/GXVerify.h @@ -0,0 +1,47 @@ +#ifndef _DOLPHIN_GXVERIFY +#define _DOLPHIN_GXVERIFY + +#include + +typedef enum { + GX_WARN_NONE, + GX_WARN_SEVERE, + GX_WARN_MEDIUM, + GX_WARN_ALL, +} GXWarningLevel; + +#ifdef _DEBUG +extern void GXSetVerifyLevel(GXWarningLevel level); +#else +#define GXSetVerifyLevel(level) ((void)0) +#endif + +typedef void (*GXVerifyCallback)(GXWarningLevel level, u32 id, const char* msg); + +typedef struct __GXVerifyData { + GXVerifyCallback cb; // offset 0x0, size 0x4 + GXWarningLevel verifyLevel; // offset 0x4, size 0x4 + u32 xfRegs[80]; // offset 0x8, size 0x140 + u32 xfMtx[256]; // offset 0x148, size 0x400 + u32 xfNrm[96]; // offset 0x548, size 0x180 + u32 xfDMtx[256]; // offset 0x6C8, size 0x400 + u32 xfLight[128]; // offset 0xAC8, size 0x200 + u32 rasRegs[256]; // offset 0xCC8, size 0x400 + u8 xfRegsDirty[80]; // offset 0x10C8, size 0x50 + u8 xfMtxDirty[256]; // offset 0x1118, size 0x100 + u8 xfNrmDirty[96]; // offset 0x1218, size 0x60 + u8 xfDMtxDirty[256]; // offset 0x1278, size 0x100 + u8 xfLightDirty[128]; // offset 0x1378, size 0x80 +} GXVerifyData; + +#ifdef _DEBUG +GXVerifyCallback GXSetVerifyCallback(GXVerifyCallback cb); +#else +#define GXSetVerifyCallback(cb) ((GXVerifyCallback)0) +#endif + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXVERIFY diff --git a/include/dolphin/gx/GXVert.h b/include/dolphin/gx/GXVert.h new file mode 100644 index 00000000..af0eec30 --- /dev/null +++ b/include/dolphin/gx/GXVert.h @@ -0,0 +1,141 @@ +#ifndef _DOLPHIN_GXVERT +#define _DOLPHIN_GXVERT + +#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 : GXFIFO_ADDR; +#else +#define GXWGFifo (*(volatile PPCWGPipe*)GXFIFO_ADDR) +#endif + +#ifdef TARGET_PC + +void GXPosition3f32(f32 x, f32 y, f32 z); +void GXPosition3u16(u16 x, u16 y, u16 z); +void GXPosition3s16(s16 x, s16 y, s16 z); +void GXPosition3u8(u8 x, u8 y, u8 z); +void GXPosition3s8(s8 x, s8 y, s8 z); + +void GXPosition2f32(f32 x, f32 y); +void GXPosition2u16(u16 x, u16 y); +void GXPosition2s16(s16 x, s16 y); +void GXPosition2u8(u8 x, u8 y); +void GXPosition2s8(s8 x, s8 y); + +void GXPosition1x16(u16 index); +void GXPosition1x8(u8 index); + +void GXNormal3f32(f32 x, f32 y, f32 z); +void GXNormal3s16(s16 x, s16 y, s16 z); +void GXNormal3s8(s8 x, s8 y, s8 z); + +void GXNormal1x16(u16 index); +void GXNormal1x8(u8 index); + +void GXColor4u8(u8 r, u8 g, u8 b, u8 a); + +void GXColor3u8(u8 r, u8 g, u8 b); + +void GXColor1u32(u32 clr); +void GXColor1u16(u16 clr); + +void GXColor1x16(u16 index); +void GXColor1x8(u8 index); + +void GXTexCoord2f32(f32 s, f32 t); +void GXTexCoord2u16(u16 s, u16 t); +void GXTexCoord2s16(s16 s, s16 t); +void GXTexCoord2u8(u8 s, u8 t); +void GXTexCoord2s8(s8 s, s8 t); + +void GXTexCoord1f32(f32 s, f32 t); +void GXTexCoord1u16(u16 s, u16 t); +void GXTexCoord1s16(s16 s, s16 t); +void GXTexCoord1u8(u8 s, u8 t); +void GXTexCoord1s8(s8 s, s8 t); + +void GXTexCoord1x16(u16 index); +void GXTexCoord1x8(u8 index); + +extern void GXEnd(void); + +#else + +static inline void GXPosition2f32(const f32 x, const f32 y) { + GXWGFifo.f32 = x; + GXWGFifo.f32 = y; +} + +static inline void GXPosition3s16(const s16 x, const s16 y, const s16 z) { + GXWGFifo.s16 = x; + GXWGFifo.s16 = y; + GXWGFifo.s16 = z; +} + +static inline void GXPosition3f32(const f32 x, const f32 y, const f32 z) { + GXWGFifo.f32 = x; + GXWGFifo.f32 = y; + GXWGFifo.f32 = z; +} + +static inline void GXNormal3f32(const f32 x, const f32 y, const f32 z) { + GXWGFifo.f32 = x; + GXWGFifo.f32 = y; + GXWGFifo.f32 = z; +} + +static inline void GXColor1u32(const u32 v) { + GXWGFifo.u32 = v; +} + +static inline void GXColor4u8(const u8 r, const u8 g, const u8 b, const u8 a) { + GXWGFifo.u8 = r; + GXWGFifo.u8 = g; + GXWGFifo.u8 = b; + GXWGFifo.u8 = a; +} + +static inline void GXTexCoord2s16(const s16 u, const s16 v) { + GXWGFifo.s16 = u; + GXWGFifo.s16 = v; +} + +static inline void GXTexCoord2f32(const f32 u, const f32 v) { + GXWGFifo.f32 = u; + GXWGFifo.f32 = v; +} + + +static inline void GXPosition1x8(u8 index) { + GXWGFifo.u8 = index; +} + +static inline void GXEnd(void) {} + +#endif + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GXVERT diff --git a/include/dolphin/hw_regs.h b/include/dolphin/hw_regs.h new file mode 100644 index 00000000..52dcd5a7 --- /dev/null +++ b/include/dolphin/hw_regs.h @@ -0,0 +1,237 @@ +#ifndef _DOLPHIN_HW_REGS +#define _DOLPHIN_HW_REGS + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __MWERKS__ + +vu16 __VIRegs[59] : 0xCC002000; + +// 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) + +vu32 __PIRegs[12] : 0xCC003000; + +// offsets for __PIRegs[i] + +#define PI_INTRPT_SRC (0) // interrupt cause +#define PI_INTRPT_MASK (1) // interrupt mask +#define PI_FIFO_START (3) // FIFO base start +#define PI_FIFO_END (4) // FIFO base end +#define PI_FIFO_PTR (5) // FIFO current write pointer + +#define PI_RESETCODE (9) // reset code, used by OSReset + +// PI Interrupt causes. +#define PI_INTRPT_ERR (0x1) // GP runtime error +#define PI_INTRPT_RSW (0x2) // reset switch +#define PI_INTRPT_DVD (0x4) // DVD/DI interrupt +#define PI_INTRPT_SI (0x8) // serial/controller interrupt +#define PI_INTRPT_EXI (0x10) // external mem interrupt +#define PI_INTRPT_AI (0x20) // audio streaming interrupt +#define PI_INTRPT_DSP (0x40) // digital signal proc interrupt +#define PI_INTRPT_MEM (0x80) // memory interface interrupt +#define PI_INTRPT_VI (0x100) // video interface interrupt +#define PI_INTRPT_PE_TOKEN (0x200) // pixel engine token +#define PI_INTRPT_PE_FINISH (0x400) // pixel engine finish +#define PI_INTRPT_CP (0x800) // command FIFO +#define PI_INTRPT_DEBUG (0x1000) // external debugger +#define PI_INTRPT_HSP (0x2000) // high speed port +#define PI_INTRPT_RSWST (0x10000) // reset switch state (1 when pressed) + + +vu16 __MEMRegs[64] : 0xCC004000; + +// offsets for __MEMRegs[i] +#define MEM_PROT_1 (0) // protected region 1 +#define MEM_PROT_2 (2) // protected region 1 +#define MEM_PROT_3 (4) // protected region 1 +#define MEM_PROT_4 (6) // protected region 1 +#define MEM_PROT_TYPE (8) // protection type + +#define MEM_INTRPT_MASK (14) // interrupt mask +#define MEM_INTRPT_SRC (15) // interrupt cause +#define MEM_INTRPT_FLAG (16) // set when interrupt happens +#define MEM_INTRPT_ADDR_LO (17) // address that caused interrupt +#define MEM_INTRPT_ADDR_HI (18) // address that caused interrupt + +#define MEM_UNK_FLAG (20) // unknown memory flag, set in __OSInitMemoryProtection + +vu16 __DSPRegs[32] : 0xCC005000; + +// 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) + + +vu32 __DIRegs[16] : 0xCC006000; + +// offsets for __DIRegs[i] +#define DI_STATUS (0) +#define DI_COVER_STATUS (1) // cover status - 0=normal, 1=interrupt/open +#define DI_CMD_BUF_0 (2) // command buffer 0 +#define DI_CMD_BUF_1 (3) // command buffer 1 +#define DI_CMD_BUF_2 (4) // command buffer 2 +#define DI_DMA_MEM_ADDR (5) // DMA address +#define DI_DMA_LENGTH (6) // transfer length address +#define DI_CONTROL (7) +#define DI_MM_BUF (8) // Main memory buffer +#define DI_CONFIG (9) + +vu32 __SIRegs[64] : 0xCC006400; + +// offsets for __SIRegs[i] +// Channel 0/Joy-channel 1 +#define SI_CHAN_0_BUF (0) // output buffer +#define SI_CHAN_0_BTN_1 (1) // button 1 +#define SI_CHAN_0_BTN_2 (2) // button 2 +// Channel 1/Joy-channel 2 +#define SI_CHAN_1_BUF (3) // output buffer +#define SI_CHAN_1_BTN_1 (4) // button 1 +#define SI_CHAN_1_BTN_2 (5) // button 2 +// Channel 2/Joy-channel 3 +#define SI_CHAN_2_BUF (6) // output buffer +#define SI_CHAN_2_BTN_1 (7) // button 1 +#define SI_CHAN_2_BTN_2 (8) // button 2 +// Channel 3/Joy-channel 4 +#define SI_CHAN_3_BUF (9) // output buffer +#define SI_CHAN_3_BTN_1 (10) // button 1 +#define SI_CHAN_3_BTN_2 (11) // button 2 + +#define SI_POLL (12) +#define SI_CC_STAT (13) // communication control status +#define SI_STAT (14) +#define SI_EXI_LOCK (15) // exi clock lock + +#define SI_IO_BUFFER (32) // start of buffer (32 to 63) + +vu32 __EXIRegs[16] : 0xCC006800; + +// offsets for __EXIRegs[i] +// Channel 0 +#define EXI_CHAN_0_STAT (0) // parameters/status +#define EXI_CHAN_0_DMA_ADDR (1) // DMA start address +#define EXI_CHAN_0_LEN (2) // DMA transfer length +#define EXI_CHAN_0_CONTROL (3) // control register +#define EXI_CHAN_0_IMM (4) // immediate data +// Channel 1 +#define EXI_CHAN_1_STAT (5) // parameters/status +#define EXI_CHAN_1_DMA_ADDR (6) // DMA start address +#define EXI_CHAN_1_LEN (7) // DMA transfer length +#define EXI_CHAN_1_CONTROL (8) // control register +#define EXI_CHAN_1_IMM (9) // immediate data +// Channel 2 +#define EXI_CHAN_2_STAT (10) // parameters/status +#define EXI_CHAN_2_DMA_ADDR (11) // DMA start address +#define EXI_CHAN_2_LEN (12) // DMA transfer length +#define EXI_CHAN_2_CONTROL (13) // control register +#define EXI_CHAN_2_IMM (14) // immediate data + + +vu32 __AIRegs[8] : 0xCC006C00; + +// offsets for __AIRegs[i] +#define AI_CONTROL (0) // control +#define AI_VOLUME (1) // volume +#define AI_SAMPLE_COUNTER (2) // number of stereo samples output +#define AI_INTRPT_TIMING (3) // interrupt timing + +#else +#define __VIRegs ((vu16*)0xCC002000) +#define __PIRegs ((vu32*)0xCC003000) +#define __MEMRegs ((vu16*)0xCC004000) +#define __DSPRegs ((vu16*)0xCC005000) +#define __DIRegs ((vu32*)0xCC006000) +#define __SIRegs ((vu32*)0xCC006400) +#define __EXIRegs ((vu32*)0xCC006800) +#define __AIRegs ((vu32*)0xCC006C00) +#endif + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_HW_REGS diff --git a/include/dolphin/mtx.h b/include/dolphin/mtx.h new file mode 100644 index 00000000..56e48b91 --- /dev/null +++ b/include/dolphin/mtx.h @@ -0,0 +1,322 @@ +#ifndef _DOLPHIN_MTX +#define _DOLPHIN_MTX + +#include +#include +#ifdef __cplusplus +extern "C" { +#endif +#define GEKKO +#ifndef GEKKO +#define MTX_USE_C +#undef MTX_USE_PS +#endif + +#if (!defined(MTX_USE_PS) && !defined(MTX_USE_C)) +#ifndef _DEBUG +#define MTX_USE_PS +#endif +#endif + + +#define MTX_PTR_OFFSET 3 + +#define MTX44_PTR_OFFSET 4 + +typedef struct { + + u32 numMtx; + MtxPtr stackBase; + MtxPtr stackPtr; + +} MtxStack, *MtxStackPtr; + +#define MTXDegToRad(a) ((a)*0.01745329252f) +#define MTXRadToDeg(a) ((a)*57.29577951f) +#define MTXRowCol(m, r, c) ((m)[(r)][(c)]) + +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); + +#ifdef GEKKO +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); +#endif + +#ifdef MTX_USE_PS +#define MTXIdentity PSMTXIdentity +#define MTXCopy PSMTXCopy +#define MTXConcat PSMTXConcat +#define MTXConcatArray PSMTXConcatArray +#define MTXTranspose PSMTXTranspose +#define MTXInverse PSMTXInverse +#define MTXInvXpose PSMTXInvXpose +#else +#define MTXIdentity C_MTXIdentity +#define MTXCopy C_MTXCopy +#define MTXConcat C_MTXConcat +#define MTXConcatArray C_MTXConcatArray +#define MTXTranspose C_MTXTranspose +#define MTXInverse C_MTXInverse +#define MTXInvXpose C_MTXInvXpose +#endif + +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); + +#ifdef GEKKO +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); +#endif + +#ifdef MTX_USE_PS +#define MTXMultVec PSMTXMultVec +#define MTXMultVecArray PSMTXMultVecArray +#define MTXMultVecSR PSMTXMultVecSR +#define MTXMultVecArraySR PSMTXMultVecArraySR +#else // MTX_USE_C +#define MTXMultVec C_MTXMultVec +#define MTXMultVecArray C_MTXMultVecArray +#define MTXMultVecSR C_MTXMultVecSR +#define MTXMultVecArraySR C_MTXMultVecArraySR +#endif + +void C_MTXQuat(Mtx m, const Quaternion* q); +void C_MTXReflect(Mtx m, const Vec* p, const Vec* n); + +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_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); + +#ifdef GEKKO +void PSMTXQuat(Mtx m, const Quaternion* q); +void PSMTXReflect(Mtx m, const Vec* p, const Vec* n); + +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 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); +#endif + +#ifdef MTX_USE_PS +#define MTXQuat PSMTXQuat +#define MTXReflect PSMTXReflect +#define MTXTrans PSMTXTrans +#define MTXTransApply PSMTXTransApply +#define MTXScale PSMTXScale +#define MTXScaleApply PSMTXScaleApply +#define MTXRotRad PSMTXRotRad +#define MTXRotTrig PSMTXRotTrig +#define MTXRotAxisRad PSMTXRotAxisRad + +#define MTXRotDeg(m, axis, deg) PSMTXRotRad(m, axis, MTXDegToRad(deg)) +#define MTXRotAxisDeg(m, axis, deg) PSMTXRotAxisRad(m, axis, MTXDegToRad(deg)) + +#else // MTX_USE_C +#define MTXQuat C_MTXQuat +#define MTXReflect C_MTXReflect +#define MTXTrans C_MTXTrans +#define MTXTransApply C_MTXTransApply +#define MTXScale C_MTXScale +#define MTXScaleApply C_MTXScaleApply +#define MTXRotRad C_MTXRotRad +#define MTXRotTrig C_MTXRotTrig +#define MTXRotAxisRad C_MTXRotAxisRad + +#define MTXRotDeg(m, axis, deg) C_MTXRotRad(m, axis, MTXDegToRad(deg)) +#define MTXRotAxisDeg(m, axis, deg) C_MTXRotAxisRad(m, axis, MTXDegToRad(deg)) + +#endif + +void C_MTXLookAt(Mtx m, const Point3d* camPos, const Vec* camUp, const Point3d* target); + +#define MTXLookAt C_MTXLookAt + +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); + +#define MTXFrustum C_MTXFrustum +#define MTXPerspective C_MTXPerspective +#define MTXOrtho C_MTXOrtho + +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 MTXLightFrustum C_MTXLightFrustum +#define MTXLightPerspective C_MTXLightPerspective +#define MTXLightOrtho C_MTXLightOrtho + +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); +void C_VECReflect(const Vec* src, const Vec* normal, Vec* dst); +void C_VECHalfAngle(const Vec* a, const Vec* b, Vec* half); + +#ifdef GEKKO +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* unit); +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); +#endif + +// TODO +#if defined( MTX_USE_PS) && 0 +#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 +#else // MTX_USE_C +#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 +#endif + +#define VECReflect C_VECReflect +#define VECHalfAngle C_VECHalfAngle + +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_QUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r); +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_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); + +#ifdef GEKKO +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 PSQUATDivide(const Quaternion* p, const Quaternion* q, Quaternion* r); +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); +#endif + +#ifdef MTX_USE_PS +#define QUATAdd PSQUATAdd +#define QUATSubtract PSQUATSubtract +#define QUATMultiply PSQUATMultiply +#define QUATDivide PSQUATDivide +#define QUATScale PSQUATScale +#define QUATDotProduct PSQUATDotProduct +#define QUATNormalize PSQUATNormalize +#define QUATInverse PSQUATInverse +#else // MTX_USE_C +#define QUATAdd C_QUATAdd +#define QUATSubtract C_QUATSubtract +#define QUATMultiply C_QUATMultiply +#define QUATDivide C_QUATDivide +#define QUATScale C_QUATScale +#define QUATDotProduct C_QUATDotProduct +#define QUATNormalize C_QUATNormalize +#define QUATInverse C_QUATInverse +#endif + +#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 GEKKO +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 PSMTXMultS16VecArray(const Mtx m, const S16Vec* srcBase, Vec* dstBase, u32 count); +void PSMTXROMultS16VecArray(const ROMtx m, const S16Vec* srcBase, Vec* dstBase, u32 count); +#endif + +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); + +#define MTXAllocStack(sPtr, numMtx) \ + (((MtxStackPtr)(sPtr))->stackBase = (MtxPtr)OSAlloc(((numMtx) * sizeof(Mtx)))) + +#define MTXFreeStack(sPtr) (OSFree((void*)(((MtxStackPtr)(sPtr))->stackBase))) + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_MTX diff --git a/include/dolphin/mtx/GeoTypes.h b/include/dolphin/mtx/GeoTypes.h new file mode 100644 index 00000000..7e9b64da --- /dev/null +++ b/include/dolphin/mtx/GeoTypes.h @@ -0,0 +1,39 @@ +#ifndef _DOLPHIN_GEOTYPES +#define _DOLPHIN_GEOTYPES + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + f32 x, y, z; +} Vec, *VecPtr, Point3d, *Point3dPtr; + +typedef struct { + s16 x; + s16 y; + s16 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 ROMtx[4][3]; + +typedef f32 (*ROMtxPtr)[3]; + +typedef f32 Mtx44[4][4]; + +typedef f32 (*Mtx44Ptr)[4]; +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_GEOTYPES diff --git a/include/dolphin/os.h b/include/dolphin/os.h new file mode 100644 index 00000000..f7d61d97 --- /dev/null +++ b/include/dolphin/os.h @@ -0,0 +1,244 @@ +#ifndef _DOLPHIN_OS +#define _DOLPHIN_OS + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// 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__ +#define AT_ADDRESS(xyz) : (xyz) +#else +#define AT_ADDRESS +#endif +typedef s64 OSTime; +typedef u32 OSTick; +u32 __OSBusClock AT_ADDRESS(OS_BASE_CACHED | 0x00F8); // sync with OSLoMem.h +u32 __OSCoreClock AT_ADDRESS(OS_BASE_CACHED | 0x00FC); // sync with OSLoMem.h +#define OS_BUS_CLOCK (u32)__OSBusClock +#define OS_CORE_CLOCK __OSCoreClock +#define OS_TIMER_CLOCK (OS_BUS_CLOCK / 4) + +#ifndef _DEBUG +#define OSPhysicalToCached(paddr) ((void*)((u32)(paddr) + OS_BASE_CACHED)) +#define OSPhysicalToUncached(paddr) ((void*)((u32)(paddr) + OS_BASE_UNCACHED)) +#define OSCachedToPhysical(caddr) ((u32)((u8*)(caddr)-OS_BASE_CACHED)) +#define OSUncachedToPhysical(ucaddr) ((u32)((u8*)(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))) +#else +u32 OSPhysicalToCached(void* paddr); +u32 OSPhysicalToUncached(void* paddr); +u32 OSCachedToPhysical(void* caddr); +u32 OSUncachedToPhysical(void* ucaddr); +u32 OSCachedToUncached(void* caddr); +u32 OSUncachedToCached(void* ucaddr); +#endif + +#define OSTicksToCycles(ticks) (((ticks) * ((OS_CORE_CLOCK * 2) / OS_TIMER_CLOCK)) / 2) +#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 OSTicksToNanoseconds(ticks) (((ticks)*8000) / (OS_TIMER_CLOCK / 125000)) +#define OSSecondsToTicks(sec) ((sec)*OS_TIMER_CLOCK) +#define OSMillisecondsToTicks(msec) ((msec) * (OS_TIMER_CLOCK / 1000)) +#define OSMicrosecondsToTicks(usec) (((usec) * (OS_TIMER_CLOCK / 125000)) / 8) +#define OSNanosecondsToTicks(nsec) (((nsec) * (OS_TIMER_CLOCK / 125000)) / 8000) + +#define OSDiffTick(tick1, tick0) ((s32)(tick1) - (s32)(tick0)) + +#define OSRoundUp32B(v) (((u32)(v + 31) & ~31)) + +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); + +void OSInit(); + +OSTime OSGetTime(); +OSTick OSGetTick(); + +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 in AD [1, ...] + 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; + +OSTime OSCalendarTimeToTicks(OSCalendarTime* td); +void OSTicksToCalendarTime(OSTime ticks, OSCalendarTime* td); + +#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 + +u32 OSGetConsoleType(); + +#define OS_SOUND_MODE_MONO 0u +#define OS_SOUND_MODE_STEREO 1u + +u32 OSGetSoundMode(void); +void OSSetSoundMode(u32 mode); + +#define OS_PROGRESSIVE_MODE_OFF 0u +#define OS_PROGRESSIVE_MODE_ON 1u + +u32 OSGetProgressiveMode(void); +void OSSetProgressiveMode(u32 on); + +#define OS_LANG_ENGLISH 0u +#define OS_LANG_GERMAN 1u +#define OS_LANG_FRENCH 2u +#define OS_LANG_SPANISH 3u +#define OS_LANG_ITALIAN 4u +#define OS_LANG_DUTCH 5u + +u8 OSGetLanguage(void); +void OSSetLanguage(u8 language); + +#define OS_EURGB60_OFF 0u +#define OS_EURGB60_ON 1u + +u32 OSGetEuRgb60Mode(void); +void OSSetEuRgb60Mode(u32 on); + +void OSRegisterVersion(const char* id); + +BOOL OSDisableInterrupts(void); +BOOL OSEnableInterrupts(void); +BOOL OSRestoreInterrupts(BOOL level); + +#define OSHalt(msg) OSPanic(__FILE__, __LINE__, msg) + +#ifdef _DEBUG + +#ifndef ASSERT +#define ASSERT(exp) (void)((exp) || (OSPanic(__FILE__, __LINE__, "Failed assertion " #exp), 0)) +#endif + +#ifndef ASSERTMSG +#if defined(__STDC_VERSION__) && (199901L <= __STDC_VERSION__) || defined(__MWERKS__) || \ + defined(__SN__) +#define ASSERTMSG(exp, ...) (void)((exp) || (OSPanic(__FILE__, __LINE__, __VA_ARGS__), 0)) +#else +#define ASSERTMSG(exp, msg) (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg)), 0)) +#endif +#endif + +#ifndef ASSERTMSG1 +#define ASSERTMSG1(exp, msg, param1) \ + (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1)), 0)) +#endif + +#ifndef ASSERTMSG2 +#define ASSERTMSG2(exp, msg, param1, param2) \ + (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1), (param2)), 0)) +#endif + +#ifndef ASSERTMSG3 +#define ASSERTMSG3(exp, msg, param1, param2, param3) \ + (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1), (param2), (param3)), 0)) +#endif + +#ifndef ASSERTMSG4 +#define ASSERTMSG4(exp, msg, param1, param2, param3, param4) \ + (void)((exp) || (OSPanic(__FILE__, __LINE__, (msg), (param1), (param2), (param3), (param4)), 0)) +#endif + +#else // _DEBUG + +#ifndef ASSERT +#define ASSERT(exp) ((void)0) +#endif + +#ifndef ASSERTMSG +#if defined(__STDC_VERSION__) && (199901L <= __STDC_VERSION__) || defined(__MWERKS__) || \ + defined(__SN__) +#define ASSERTMSG(exp, ...) ((void)0) +#else +#define ASSERTMSG(exp, msg) ((void)0) +#endif +#endif + +#ifndef ASSERTMSG1 +#define ASSERTMSG1(exp, msg, param1) ((void)0) +#endif +#ifndef ASSERTMSG2 +#define ASSERTMSG2(exp, msg, param1, param2) ((void)0) +#endif +#ifndef ASSERTMSG3 +#define ASSERTMSG3(exp, msg, param1, param2, param3) ((void)0) +#endif +#ifndef ASSERTMSG4 +#define ASSERTMSG4(exp, msg, param1, param2, param3, param4) ((void)0) +#endif + +#endif // _DEBUG + +void OSReport(const char* msg, ...); +void OSPanic(const char* file, int line, const char* msg, ...); +void OSFatal(GXColor fg, GXColor bg, const char* msg); + +#ifdef __cplusplus +} +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif // _DOLPHIN_OS diff --git a/include/dolphin/os/OSAlarm.h b/include/dolphin/os/OSAlarm.h new file mode 100644 index 00000000..a0c9d380 --- /dev/null +++ b/include/dolphin/os/OSAlarm.h @@ -0,0 +1,39 @@ +#ifndef _DOLPHIN_OSALARM +#define _DOLPHIN_OSALARM + +#include +#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; +}; + +void OSInitAlarm(void); +void OSSetAlarm(OSAlarm* alarm, OSTime tick, OSAlarmHandler handler); +void OSSetAlarmTag(OSAlarm* alarm, u32 tag); +void OSSetAbsAlarm(OSAlarm* alarm, OSTime time, OSAlarmHandler handler); +void OSSetPeriodicAlarm(OSAlarm* alarm, OSTime start, OSTime period, OSAlarmHandler handler); +void OSCreateAlarm(OSAlarm* alarm); +void OSCancelAlarm(OSAlarm* alarm); +void OSCancelAlarms(u32 tag); + +BOOL OSCheckAlarmQueue(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSALARM diff --git a/include/dolphin/os/OSAlloc.h b/include/dolphin/os/OSAlloc.h new file mode 100644 index 00000000..afa1d9be --- /dev/null +++ b/include/dolphin/os/OSAlloc.h @@ -0,0 +1,30 @@ +#ifndef _DOLPHIN_OSALLOC +#define _DOLPHIN_OSALLOC + +#include + +#ifdef __cplusplus +extern "C" { +#endif +typedef int OSHeapHandle; +typedef void (*OSAllocVisitor)(void* obj, u32 size); +void* OSInitAlloc(void* arenaStart, void* arenaEnd, int maxHeaps); +OSHeapHandle OSCreateHeap(void* start, void* end); +void OSDestroyHeap(OSHeapHandle heap); +void OSAddToHeap(OSHeapHandle heap, void* start, void* end); +OSHeapHandle OSSetCurrentHeap(OSHeapHandle heap); +void* OSAllocFromHeap(OSHeapHandle heap, u32 size); +void* OSAllocFixed(void** rstart, void** rend); +void OSFreeToHeap(OSHeapHandle heap, void* ptr); +long OSCheckHeap(OSHeapHandle heap); +void OSDumpHeap(OSHeapHandle heap); +u32 OSReferentSize(void* ptr); +void OSVisitAllocated(OSAllocVisitor visitor); +extern volatile OSHeapHandle __OSCurrHeap; +#define OSAlloc(size) OSAllocFromHeap(__OSCurrHeap, (size)) +#define OSFree(ptr) OSFreeToHeap(__OSCurrHeap, (ptr)) +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSALLOC diff --git a/include/dolphin/os/OSArena.h b/include/dolphin/os/OSArena.h new file mode 100644 index 00000000..9dc15701 --- /dev/null +++ b/include/dolphin/os/OSArena.h @@ -0,0 +1,13 @@ +#ifndef _DOLPHIN_OSARENA +#define _DOLPHIN_OSARENA + +#include + +void* OSGetArenaHi(void); +void* OSGetArenaLo(void); +void OSSetArenaHi(void* addr); +void OSSetArenaLo(void* addr); +void* OSAllocFromArenaLo(u32 size, u32 align); +void* OSAllocFromArenaLo(u32 size, u32 align); + +#endif // _DOLPHIN_OSARENA diff --git a/include/dolphin/os/OSBootInfo.h b/include/dolphin/os/OSBootInfo.h new file mode 100644 index 00000000..a78d135f --- /dev/null +++ b/include/dolphin/os/OSBootInfo.h @@ -0,0 +1,50 @@ +#ifndef _DOLPHIN_OSBOOTINFO +#define _DOLPHIN_OSBOOTINFO + +#include "dolphin/DVDPriv.h" +#include "dolphin/types.h" + +typedef struct OSBootInfo { + DVDDiskID DVDDiskID; + u32 magic; + u32 version; + u32 memorySize; + u32 consoleType; + void* arenaLo; + void* arenaHi; + void* FSTLocation; + u32 FSTMaxLength; +} OSBootInfo; + +typedef struct { + BOOL valid; + u32 restartCode; + u32 bootDol; + void* regionStart; + void* regionEnd; + BOOL argsUseDefault; + void* argsAddr; // valid only when argsUseDefault = FALSE + +} OSExecParams; + +typedef struct BI2Debug { + s32 debugMonSize; // 0x0 + s32 simMemSize; // 0x4 + u32 argOffset; // 0x8 + u32 debugFlag; // 0xC + int trackLocation; // 0x10 + int trackSize; // 0x14 + u32 countryCode; // 0x18 + u8 unk[8]; // 0x1C + u32 padSpec; // 0x24 +} BI2Debug; + +// Magic number defines. +#define OS_BOOTINFO_MAGIC 0x0D15EA5E +#define OS_BOOTINFO_MAGIC_JTAG 0xE5207C22 +#define OS_DVD_MAGIC_NINTENDO 0xC2339F3D +#define OS_THREAD_STACK_MAGIC 0xDEADBABE + +#define OS_BOOTROM_ADDR 0x81300000 + +#endif // _DOLPHIN_OSBOOTINFO diff --git a/include/dolphin/os/OSCache.h b/include/dolphin/os/OSCache.h new file mode 100644 index 00000000..b3dd94a2 --- /dev/null +++ b/include/dolphin/os/OSCache.h @@ -0,0 +1,37 @@ +#ifndef _DOLPHIN_OSCACHE +#define _DOLPHIN_OSCACHE + +#include "dolphin/types.h" + +#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 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); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSCACHE diff --git a/include/dolphin/os/OSContext.h b/include/dolphin/os/OSContext.h new file mode 100644 index 00000000..bbd0aaa1 --- /dev/null +++ b/include/dolphin/os/OSContext.h @@ -0,0 +1,170 @@ +#ifndef _DOLPHIN_OSCONTEXT +#define _DOLPHIN_OSCONTEXT + +#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 { + 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; + +u32 OSSaveContext(OSContext* context); +void OSClearContext(OSContext* context); +OSContext* OSGetCurrentContext(); +void OSSetCurrentContext(OSContext* context); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSCONTEXT diff --git a/include/dolphin/os/OSError.h b/include/dolphin/os/OSError.h new file mode 100644 index 00000000..8764fbe6 --- /dev/null +++ b/include/dolphin/os/OSError.h @@ -0,0 +1,39 @@ +#ifndef _DOLPHIN_OSERROR +#define _DOLPHIN_OSERROR + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#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_PROTECTION 15 +#define OS_ERROR_FPE 16 + +#define OS_ERROR_MAX (OS_ERROR_FPE + 1) + +typedef u16 OSError; +typedef void (*OSErrorHandler)( OSError error, OSContext* context, ... ); + +OSErrorHandler OSSetErrorHandler(OSError code, OSErrorHandler handler); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSERROR diff --git a/include/dolphin/os/OSException.h b/include/dolphin/os/OSException.h new file mode 100644 index 00000000..f3423697 --- /dev/null +++ b/include/dolphin/os/OSException.h @@ -0,0 +1,56 @@ + +#ifndef _DOLPHIN_OSEXCEPTION +#define _DOLPHIN_OSEXCEPTION + +#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_MAX \ + (__OS_EXCEPTION_THERMAL_INTERRUPT+1) + +typedef u8 __OSException; +typedef void (*__OSExceptionHandler)(__OSException exception, OSContext* context); + +#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 diff --git a/include/dolphin/os/OSExpansion.h b/include/dolphin/os/OSExpansion.h new file mode 100644 index 00000000..6e848b88 --- /dev/null +++ b/include/dolphin/os/OSExpansion.h @@ -0,0 +1,79 @@ +#ifndef _DOLPHIN_OSEXPANSION +#define _DOLPHIN_OSEXPANSION + +#include +#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_ETHER_VIEWER 0x04220001 +#define EXI_STREAM_HANGER 0x04130000 + +#define EXI_MARLIN 0x03010000 + +#define EXI_IS_VIEWER 0x05070000 + +#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 + +#define EXI_READ 0 +#define EXI_WRITE 1 + +#define EXI_STATE_IDLE 0x00 +#define EXI_STATE_DMA 0x01 +#define EXI_STATE_IMM 0x02 +#define EXI_STATE_BUSY (EXI_STATE_DMA | EXI_STATE_IMM) +#define EXI_STATE_SELECTED 0x04 +#define EXI_STATE_ATTACHED 0x08 +#define EXI_STATE_LOCKED 0x10 + +BOOL EXIProbe(s32 chan); +s32 EXIProbeEx(s32 chan); + +s32 EXIGetType(s32 chan, u32 dev, u32* type); +char* EXIGetTypeString(u32 type); +u32 EXIClearInterrupts(s32 chan, BOOL exi, BOOL tc, BOOL ext); +s32 EXIGetID(s32 chan, u32 dev, u32* id); + +typedef void (*EXICallback)(s32 chan, OSContext* context); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSEXPANSION diff --git a/include/dolphin/os/OSFastCast.h b/include/dolphin/os/OSFastCast.h new file mode 100644 index 00000000..b6ca50d1 --- /dev/null +++ b/include/dolphin/os/OSFastCast.h @@ -0,0 +1,48 @@ +#ifndef _DOLPHIN_OSFASTCAST +#define _DOLPHIN_OSFASTCAST + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_GQR_F32 0x0000 +#define OS_GQR_U8 0x0004 +#define OS_GQR_U16 0x0005 +#define OS_GQR_S8 0x0006 +#define OS_GQR_S16 0x0007 + +#define OS_FASTCAST_U8 2 +#define OS_FASTCAST_U16 3 +#define OS_FASTCAST_S16 5 +// clang-format off +static inline void OSInitFastCast(void) { +#ifdef __MWERKS__ + asm + { + li r3, OS_GQR_U8 + oris r3, r3, OS_GQR_U8 + mtspr GQR2, r3 + + li r3, OS_GQR_U16 + oris r3, r3, OS_GQR_U16 + mtspr GQR3, r3 + + li r3, OS_GQR_S8 + oris r3, r3, OS_GQR_S8 + mtspr GQR4, r3 + + li r3, OS_GQR_S16 + oris r3, r3, OS_GQR_S16 + mtspr GQR5, r3 + } +#else + +#endif +} +// clang-format off + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSFASTCAST diff --git a/include/dolphin/os/OSFont.h b/include/dolphin/os/OSFont.h new file mode 100644 index 00000000..99238bad --- /dev/null +++ b/include/dolphin/os/OSFont.h @@ -0,0 +1,28 @@ +#ifndef _DOLPHIN_OSFONT +#define _DOLPHIN_OSFONT + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_FONT_ENCODE_ANSI 0u +#define OS_FONT_ENCODE_SJIS 1u +#define OS_FONT_ENCODE_UTF8 3u // UTF-8 [RFC 3629] +#define OS_FONT_ENCODE_UTF16 4u // UTF-16BE [RFC 2781] +#define OS_FONT_ENCODE_UTF32 5u // UTF-32 +#define OS_FONT_ENCODE_MAX 5u +#define OS_FONT_ENCODE_VOID 0xffffu + +#define OS_FONT_PROPORTIONAL FALSE +#define OS_FONT_FIXED TRUE + +u16 OSGetFontEncode(void); +u16 OSSetFontEncode(u16 encode); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSFONT diff --git a/include/dolphin/os/OSInterrupt.h b/include/dolphin/os/OSInterrupt.h new file mode 100644 index 00000000..9e5d2aa0 --- /dev/null +++ b/include/dolphin/os/OSInterrupt.h @@ -0,0 +1,115 @@ +#ifndef _DOLPHIN_OSINTERRUPT +#define _DOLPHIN_OSINTERRUPT + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#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 \ + (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 s16 __OSInterrupt; +typedef void (*__OSInterruptHandler)(__OSInterrupt interrupt, OSContext* context); + +typedef u32 OSInterruptMask; + +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 // _DOLPHIN_OSINTERRUPT diff --git a/include/dolphin/os/OSMemory.h b/include/dolphin/os/OSMemory.h new file mode 100644 index 00000000..00c6ab08 --- /dev/null +++ b/include/dolphin/os/OSMemory.h @@ -0,0 +1,26 @@ +#ifndef _DOLPHIN_OSMEMORY +#define _DOLPHIN_OSMEMORY + +#include "types.h" + +#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); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSMEMORY diff --git a/include/dolphin/os/OSMessage.h b/include/dolphin/os/OSMessage.h new file mode 100644 index 00000000..f67a84e3 --- /dev/null +++ b/include/dolphin/os/OSMessage.h @@ -0,0 +1,34 @@ +#ifndef _DOLPHIN_OSMESSAGE +#define _DOLPHIN_OSMESSAGE + +#ifdef __cplusplus +extern "C" { +#endif + +#include +typedef struct OSMessageQueue OSMessageQueue; +typedef void* OSMessage; + +struct OSMessageQueue { + OSThreadQueue queueSend; + OSThreadQueue queueReceive; + OSMessage* msgArray; + s32 msgCount; + s32 firstIndex; + s32 usedCount; +}; + +// Flags to turn blocking on/off when sending/receiving message +#define OS_MESSAGE_NOBLOCK 0 +#define OS_MESSAGE_BLOCK 1 + +void OSInitMessageQueue(OSMessageQueue* mq, OSMessage* msgArray, s32 msgCount); +BOOL OSSendMessage(OSMessageQueue* mq, OSMessage msg, s32 flags); +BOOL OSJamMessage(OSMessageQueue* mq, OSMessage msg, s32 flags); +BOOL OSReceiveMessage(OSMessageQueue* mq, OSMessage* msg, s32 flags); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSMESSAGE diff --git a/include/dolphin/os/OSModule.h b/include/dolphin/os/OSModule.h new file mode 100644 index 00000000..7baf2a9f --- /dev/null +++ b/include/dolphin/os/OSModule.h @@ -0,0 +1,115 @@ +#ifndef _DOLPHIN_OSMODULE +#define _DOLPHIN_OSMODULE + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_MODULE_VERSION 2 +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(const 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 // _DOLPHIN_OSMODULE diff --git a/include/dolphin/os/OSMutex.h b/include/dolphin/os/OSMutex.h new file mode 100644 index 00000000..9ee6ffe3 --- /dev/null +++ b/include/dolphin/os/OSMutex.h @@ -0,0 +1,35 @@ +#ifndef _DOLPHIN_OSMUTEX +#define _DOLPHIN_OSMUTEX + +#include "types.h" + +#include "dolphin/os/OSThread.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct OSMutex { + OSThreadQueue queue; + OSThread* thread; // the current owner + s32 count; // lock count + OSMutexLink link; // for OSThread.queueMutex +}; + +struct OSCond { + OSThreadQueue queue; +}; + +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 // _DOLPHIN_OSMUTEX diff --git a/include/dolphin/os/OSPriv.h b/include/dolphin/os/OSPriv.h new file mode 100644 index 00000000..8b914f25 --- /dev/null +++ b/include/dolphin/os/OSPriv.h @@ -0,0 +1,18 @@ +#ifndef _DOLPHIN_OSPRIV +#define _DOLPHIN_OSPRIV + +#include "dolphin/os.h" + +#ifdef __cplusplus +extern "C" { +#endif + +__OSExceptionHandler __OSGetExceptionHandler(__OSException exception); +OSTime __OSGetSystemTime(); +OSTime __OSTimeToSystemTime(OSTime); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSPRIV diff --git a/include/dolphin/os/OSReset.h b/include/dolphin/os/OSReset.h new file mode 100644 index 00000000..a4cb6416 --- /dev/null +++ b/include/dolphin/os/OSReset.h @@ -0,0 +1,46 @@ +#ifndef _DOLPHIN_OSRESET +#define _DOLPHIN_OSRESET + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_RESETCODE_RESTART 0x80000000 +#define OS_RESETCODE_SYSTEM 0x40000000 + +#define OS_RESETCODE_EXEC 0xC0000000 +#define OS_RESETCODE_NETCONFIG 0xC0010000 + +#define OS_RESET_TIMEOUT OSMillisecondsToTicks(1000) + +#define OS_RESET_RESTART 0 +#define OS_RESET_HOTRESET 1 +#define OS_RESET_SHUTDOWN 2 + +#define OS_RESET_PRIO_SO 110 +#define OS_RESET_PRIO_IP 111 +#define OS_RESET_PRIO_CARD 127 +#define OS_RESET_PRIO_PAD 127 +#define OS_RESET_PRIO_GX 127 +#define OS_RESET_PRIO_ALARM 4294967295 + +typedef BOOL (*OSResetFunction)(BOOL final); +typedef struct OSResetFunctionInfo OSResetFunctionInfo; + +struct OSResetFunctionInfo { + // public + OSResetFunction func; + u32 priority; + + // private + OSResetFunctionInfo* next; + OSResetFunctionInfo* prev; +}; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSRESET diff --git a/include/dolphin/os/OSResetSW.h b/include/dolphin/os/OSResetSW.h new file mode 100644 index 00000000..5551f68c --- /dev/null +++ b/include/dolphin/os/OSResetSW.h @@ -0,0 +1,22 @@ +#ifndef _DOLPHIN_OSRESETSW +#define _DOLPHIN_OSRESETSW + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*OSResetCallback)(void); + +BOOL OSGetResetButtonState(void); + +BOOL OSGetResetSwitchState(void); +OSResetCallback OSSetResetCallback(OSResetCallback callback); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSRESETSW diff --git a/include/dolphin/os/OSSerial.h b/include/dolphin/os/OSSerial.h new file mode 100644 index 00000000..f0a6a4d3 --- /dev/null +++ b/include/dolphin/os/OSSerial.h @@ -0,0 +1,69 @@ +#ifndef _DOLPHIN_OSSERIAL +#define _DOLPHIN_OSSERIAL + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define SI_MAX_CHAN 4 +#define SI_MAX_COMCSR_INLNGTH 128 +#define SI_MAX_COMCSR_OUTLNGTH 128 +#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_CHAN0 0 +#define SI_CHAN1 1 +#define SI_CHAN2 2 +#define SI_CHAN3 3 +#define SI_CHAN0_BIT 0x80000000 +#define SI_CHAN1_BIT 0x40000000 +#define SI_CHAN2_BIT 0x20000000 +#define SI_CHAN3_BIT 0x10000000 +#define SI_CHAN_BIT(chan) (SI_CHAN0_BIT >> (chan)) +#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) + +u32 SIProbe(s32 chan); +char* SIGetTypeString(u32 type); +void SIRefreshSamplingRate(void); +void SISetSamplingRate(u32 msec); + +#ifdef __cplusplus +} +#endif +#endif // _DOLPHIN_OSSERIAL diff --git a/include/dolphin/os/OSThread.h b/include/dolphin/os/OSThread.h new file mode 100644 index 00000000..7464e685 --- /dev/null +++ b/include/dolphin/os/OSThread.h @@ -0,0 +1,113 @@ +#ifndef _DOLPHIN_OSTHREAD +#define _DOLPHIN_OSTHREAD + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define OS_THREAD_SPECIFIC_MAX 2 + +typedef struct OSThread OSThread; +typedef struct OSThreadQueue OSThreadQueue; +typedef struct OSThreadLink OSThreadLink; +typedef s32 OSPriority; // 0 highest, 31 lowest + +typedef struct OSMutex OSMutex; +typedef struct OSMutexQueue OSMutexQueue; +typedef struct OSMutexLink OSMutexLink; +typedef struct OSCond OSCond; + +typedef void (*OSIdleFunction)(void* param); +typedef void (*OSSwitchThreadCallback)(OSThread* from, OSThread* to); + +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 { + OSContext context; + u16 state; + u16 attr; + s32 suspend; + OSPriority priority; + OSPriority base; + void* val; + OSThreadQueue* queue; + OSThreadLink link; + OSThreadQueue queueJoin; + OSMutex* mutex; + OSMutexQueue queueMutex; + OSThreadLink linkActive; + u8* stackBase; + u32* stackEnd; + s32 error; + void* specific[OS_THREAD_SPECIFIC_MAX]; +}; + +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_THREAD_ATTR_DETACH 0x0001u + +#define OS_THREAD_STACK_MAGIC 0xDEADBABE + +#define OS_PRIORITY_MIN 0 // highest +#define OS_PRIORITY_MAX 31 // lowest +#define OS_PRIORITY_IDLE OS_PRIORITY_MAX + + +void OSInitThreadQueue(OSThreadQueue* queue); +OSThread* OSGetCurrentThread(void); +BOOL OSIsThreadSuspended(OSThread* thread); +BOOL OSIsThreadTerminated(OSThread* thread); +s32 OSDisableScheduler(void); +s32 OSEnableScheduler(void); +void OSYieldThread(void); +BOOL OSCreateThread(OSThread* thread, void* (*func)(void*), void* param, void* stack, u32 stackSize, + OSPriority priority, u16 attr); +void OSExitThread(void* val); +void OSCancelThread(OSThread* thread); +BOOL OSJoinThread(OSThread* thread, void** val); +void OSDetachThread(OSThread* thread); +s32 OSResumeThread(OSThread* thread); +s32 OSSuspendThread(OSThread* thread); +BOOL OSSetThreadPriority(OSThread* thread, OSPriority priority); +OSPriority OSGetThreadPriority(OSThread* thread); +void OSSleepThread(OSThreadQueue* queue); +void OSWakeupThread(OSThreadQueue* queue); + +void* OSGetThreadSpecific(s32 index); +void OSSetThreadSpecific(s32 index, void* ptr); + +OSThread* OSSetIdleFunction(OSIdleFunction idleFunction, void* param, void* stack, u32 stackSize); +OSThread* OSGetIdleFunction(void); +void OSClearStack(u8 val); +long OSCheckActiveThreads(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_OSTHREAD diff --git a/include/dolphin/pad.h b/include/dolphin/pad.h new file mode 100644 index 00000000..0d525004 --- /dev/null +++ b/include/dolphin/pad.h @@ -0,0 +1,128 @@ +#ifndef _DOLPHIN_PAD +#define _DOLPHIN_PAD + +#include + +extern u32 __PADFixBits; + +#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_CHAN0 0 +#define PAD_CHAN1 1 +#define PAD_CHAN2 2 +#define PAD_CHAN3 3 +#define PAD_CHANMAX 4 + +#define PAD_MOTOR_STOP 0 +#define PAD_MOTOR_RUMBLE 1 +#define PAD_MOTOR_STOP_HARD 2 + +#define PAD_ERR_NONE 0 +#define PAD_ERR_NO_CONTROLLER -1 +#define PAD_ERR_NOT_READY -2 +#define PAD_ERR_TRANSFER -3 + +#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_MENU 0x1000 +#define PAD_BUTTON_START 0x1000 + +#define PAD_CHAN0_BIT 0x80000000 +#define PAD_CHAN1_BIT 0x40000000 +#define PAD_CHAN2_BIT 0x20000000 +#define PAD_CHAN3_BIT 0x10000000 + +#define PADButtonDown(buttonLast, button) ((((buttonLast) ^ (button)) & (button))) + +#define PADButtonUp(buttonLast, button) ((((buttonLast) ^ (button)) & (buttonLast))) + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*PADSamplingCallback)(void); + +typedef struct PADStatus { + u16 button; + s8 stickX; + s8 stickY; + s8 substickX; + s8 substickY; + u8 triggerL; + u8 triggerR; + u8 analogA; + u8 analogB; + s8 err; +} PADStatus; + +BOOL PADInit(); +u32 PADRead(PADStatus* status); +BOOL PADReset(u32 mask); +BOOL PADRecalibrate(u32 mask); +void PADClamp(PADStatus* status); +void PADClampCircle(PADStatus* status); +void PADControlMotor(s32 chan, u32 cmd); +void PADSetSpec(u32 spec); +void PADControlAllMotors(const u32* cmdArr); +void PADSetAnalogMode(u32 mode); +PADSamplingCallback PADSetSamplingCallback(PADSamplingCallback); + +#ifdef TARGET_PC +/* New API to facilitate controller interactions */ +typedef struct PADDeadZones { + bool emulateTriggers; + bool useDeadzones; + u16 stickDeadZone; + u16 substickDeadZone; + u16 leftTriggerActivationZone; + u16 rightTriggerActivationZone; +} PADDeadZones; + +typedef u16 PADButton; + +typedef struct PADButtonMapping { + u32 nativeButton; + PADButton padButton; +} PADButtonMapping; + +/* Returns the total number of controllers */ +u32 PADCount(); +/* Returns the controller name for the given index into the controller map */ +const char* PADGetNameForControllerIndex(u32 idx); +void PADSetPortForIndex(u32 index, s32 port); +s32 PADGetIndexForPort(u32 port); +void PADGetVidPid(u32 port, u32* vid, u32* pid); +void PADClearPort(u32 port); +const char* PADGetName(u32 port); +void PADSetButtonMapping(u32 port, PADButtonMapping mapping); +void PADSetAllButtonMappings(u32 port, PADButtonMapping buttons[12]); +PADButtonMapping* PADGetButtonMappings(u32 port, u32* buttonCount); +void PADSerializeMappings(); +PADDeadZones* PADGetDeadZones(u32 port); +const char* PADGetButtonName(PADButton); +const char* PADGetNativeButtonName(u32 button); +/* Returns any pressed native button */ +s32 PADGetNativeButtonPressed(u32 port); +void PADRestoreDefaultMapping(u32 port); +void PADBlockInput(bool block); +#endif + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_PAD diff --git a/include/dolphin/sipriv.h b/include/dolphin/sipriv.h new file mode 100644 index 00000000..8c8508c8 --- /dev/null +++ b/include/dolphin/sipriv.h @@ -0,0 +1,52 @@ +#ifndef _DOLPHIN_SIPRIV +#define _DOLPHIN_SIPRIV + +#include "dolphin/os.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void (*SICallback)(s32 chan, u32 sr, OSContext* context); +typedef void (*SITypeAndStatusCallback)(s32 chan, u32 type); + +typedef struct SIPacket { + s32 chan; + void* output; + u32 outputBytes; + void* input; + u32 inputBytes; + SICallback callback; + OSTime fire; +} SIPacket; + +void SIInit(void); +u32 SIGetStatus(s32 chan); + +BOOL SIBusy(void); +BOOL SIIsChanBusy(s32 chan); + +BOOL SITransfer(s32 chan, void* output, u32 outputBytes, void* input, u32 inputBytes, + SICallback callback, OSTime delay); +u32 SISync(void); + +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 SIRegisterPollingHandler(__OSInterruptHandler handler); +BOOL SIUnregisterPollingHandler(__OSInterruptHandler handler); + +u32 SIGetType(s32 chan); +u32 SIGetTypeAsync(s32 chan, SITypeAndStatusCallback callback); +u32 SIDecodeType(u32 type); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_SIPRIV diff --git a/include/dolphin/thp.h b/include/dolphin/thp.h new file mode 100644 index 00000000..2cd24bc4 --- /dev/null +++ b/include/dolphin/thp.h @@ -0,0 +1,88 @@ +#ifndef _DOLPHIN_THP +#define _DOLPHIN_THP + +#include "dolphin/types.h" +#include "dolphin/thp/THPAudio.h" +#include "dolphin/thp/THPVideoDecode.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef u8 THPSample; +typedef s16 THPCoeff; +typedef f32 THPQuantTab[64]; + +typedef struct _THPHuffmanTab { + u8 quick[32]; + u8 increment[32]; + u8* Vij; + s32 maxCode[18]; + s32 valPtr[18]; + u8 Vij1; + u8 pad[11]; +} THPHuffmanTab; + +typedef struct _THPComponent { + u8 quantizationTableSelector; + u8 DCTableSelector; + u8 ACTableSelector; + THPCoeff predDC; +} THPComponent; + +typedef struct _THPFileInfo { + THPQuantTab quantTabs[3]; + THPHuffmanTab huffmanTabs[4]; + THPComponent components[3]; + u16 xPixelSize; + u16 yPixelSize; + u16 MCUsPerRow; + u16 decompressedY; + u8* c; + u32 currByte; + u32 cnt; + u8 validHuffmanTabs; + u8 RST; + u16 nMCU; + u16 currMCU; + u8* dLC[3]; +} THPFileInfo; + +s32 __THPAudioGetNewSample(THPAudioDecodeInfo*); +void __THPAudioInitialize(THPAudioDecodeInfo*, u8*); + +static void __THPSetupBuffers(void); +static u8 __THPReadFrameHeader(void); +static u8 __THPReadScaneHeader(void); +static u8 __THPReadQuantizationTable(void); +static u8 __THPReadHuffmanTableSpecification(void); +static void __THPHuffGenerateSizeTable(void); +static void __THPHuffGenerateCodeTable(void); +static void __THPHuffGenerateDecoderTables(u8 tabIndex); +static void __THPRestartDefinition(void); +static void __THPPrepBitStream(void); +static void __THPDecompressYUV(void*, void*, void*); +static void __THPGQRRestore(void); +static void __THPDecompressiMCURow512x448(void); +static void __THPDecompressiMCURow640x480(void); +static void __THPDecompressiMCURowNxN(void); +static void __THPInverseDCTNoYPos(THPCoeff*, u32); +static void __THPHuffDecodeDCTCompY(THPFileInfo*, THPCoeff*); +static void __THPHuffDecodeDCTCompU(THPFileInfo*, THPCoeff*); +static void __THPHuffDecodeDCTCompV(THPFileInfo*, THPCoeff*); + +static const u8 __THPJpegNaturalOrder[80] = { + 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, + 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, + 47, 55, 62, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63}; + +static const f64 __THPAANScaleFactor[8] = { + 1.0f, 1.387039845f, 1.306562965f, 1.175875602f, 1.0f, 0.785694958f, 0.541196100f, 0.275899379f, +}; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_THP diff --git a/include/dolphin/thp/THPAudio.h b/include/dolphin/thp/THPAudio.h new file mode 100644 index 00000000..35884e90 --- /dev/null +++ b/include/dolphin/thp/THPAudio.h @@ -0,0 +1,38 @@ +#ifndef _DOLPHIN_THPAUDIO +#define _DOLPHIN_THPAUDIO + +#include "dolphin/types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct THPAudioRecordHeader { + u32 offsetNextChannel; + u32 sampleSize; + s16 lCoef[8][2]; + s16 rCoef[8][2]; + s16 lYn1; + s16 lYn2; + s16 rYn1; + s16 rYn2; +} THPAudioRecordHeader; + +typedef struct THPAudioDecodeInfo { + u8* encodeData; + u32 offsetNibbles; + u8 predictor; + u8 scale; + s16 yn1; + s16 yn2; +} THPAudioDecodeInfo; + +u32 THPAudioDecode(s16* audioBuffer, u8* audioFrame, s32 flag); +static s32 __THPAudioGetNewSample(THPAudioDecodeInfo* info); +static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_THPAUDIO diff --git a/include/dolphin/thp/THPAudioDecode.h b/include/dolphin/thp/THPAudioDecode.h new file mode 100644 index 00000000..3ac2aeaf --- /dev/null +++ b/include/dolphin/thp/THPAudioDecode.h @@ -0,0 +1,29 @@ +#ifndef _THP_THPAUDIODECODE_H +#define _THP_THPAUDIODECODE_H + +#include "Dolphin/os.h" +#include "THP/THPAudio.h" + +static void* AudioDecoderForOnMemory(void* bufPtr); +static void* AudioDecoder(void* _); +static void AudioDecode(THPReadBuffer* readBuffer); + +#ifdef __cplusplus +extern "C" { +#endif + +BOOL CreateAudioDecodeThread(OSPriority prio, void* param); +void AudioDecodeThreadStart(); +void AudioDecodeThreadCancel(); + +void PushFreeAudioBuffer(void* buf); +void PushDecodedAudioBuffer(void* buf); + +void* PopFreeAudioBuffer(); +void* PopDecodedAudioBuffer(s32 flags); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/thp/THPBuffer.h b/include/dolphin/thp/THPBuffer.h new file mode 100644 index 00000000..ee684f1f --- /dev/null +++ b/include/dolphin/thp/THPBuffer.h @@ -0,0 +1,36 @@ +#ifndef _THP_THPBUFFER_H +#define _THP_THPBUFFER_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Size 0x10 +typedef struct THPTextureSet { + u8* mYTexture; // _00 + u8* mUTexture; // _04 + u8* mVTexture; // _08 + s32 mFrameNumber; // _0C +} THPTextureSet; + +// Size 0xC +typedef struct THPAudioBuffer { + s16* mBuffer; // _00 + s16* mCurPtr; // _04 + u32 mValidSample; // _08 +} THPAudioBuffer; + +// Size 0xC +typedef struct THPReadBuffer { + u8* mPtr; // _00 + s32 mFrameNumber; // _04 + BOOL mIsValid; // _08 +} THPReadBuffer; + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/include/dolphin/thp/THPDraw.h b/include/dolphin/thp/THPDraw.h new file mode 100644 index 00000000..63e724a5 --- /dev/null +++ b/include/dolphin/thp/THPDraw.h @@ -0,0 +1,21 @@ +#ifndef _THP_THPDRAW_H +#define _THP_THPDRAW_H + +#include "types.h" +#include "Dolphin/GX/GXTypes.h" + +#ifdef __cplusplus +extern "C" { +#endif // ifdef __cplusplus + +void THPGXRestore(void); +void THPGXYuv2RgbSetup(GXRenderModeObj* obj); +void THPGXYuv2RgbDraw(u32* yImage, u32* uImage, u32* vImage, s16 x, s16 y, s16 texWidth, s16 texHeight, s16 polyWidth, s16 polyHeight); +void THPPlayerStop(); +BOOL THPPlayerSetVolume(int, int); + +#ifdef __cplusplus +}; +#endif // ifdef __cplusplus + +#endif diff --git a/include/dolphin/thp/THPFile.h b/include/dolphin/thp/THPFile.h new file mode 100644 index 00000000..b47ebe64 --- /dev/null +++ b/include/dolphin/thp/THPFile.h @@ -0,0 +1,30 @@ +#ifndef _THP_THPFILE_H +#define _THP_THPFILE_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Size 0x30 +typedef struct THPHeader { + char mMagic[4]; // _00 + u32 mVersion; // _04 + u32 mBufferSize; // _08 + u32 mAudioMaxSamples; // _0C + f32 mFrameRate; // _10 + u32 mNumFrames; // _14 + u32 mFirstFrameSize; // _18 + u32 mMovieDataSize; // _1C + u32 mCompInfoDataOffsets; // _20 + u32 mOffsetDataOffsets; // _24 + u32 mMovieDataOffsets; // _28 + u32 mFinalFrameDataOffsets; // _2C +} THPHeader; + +#ifdef __cplusplus +} +#endif + +#endif \ No newline at end of file diff --git a/include/dolphin/thp/THPInfo.h b/include/dolphin/thp/THPInfo.h new file mode 100644 index 00000000..400bc707 --- /dev/null +++ b/include/dolphin/thp/THPInfo.h @@ -0,0 +1,35 @@ +#ifndef _THP_THPINFO_H +#define _THP_THPINFO_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Size 0xC +typedef struct THPVideoInfo { + u32 mXSize; // _00 + u32 mYSize; // _04 + u32 mVideoType; // _08 +} THPVideoInfo; + +// Size 0x10 +typedef struct THPAudioInfo { + u32 mSndChannels; // _00 + u32 mSndFrequency; // _04 + u32 mSndNumSamples; // _08 + u32 mSndNumTracks; // _0C +} THPAudioInfo; + +// Size 0x14 +typedef struct THPFrameCompInfo { + u32 mNumComponents; // _00 + u8 mFrameComp[16]; // _04 +} THPFrameCompInfo; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dolphin/thp/THPPlayer.h b/include/dolphin/thp/THPPlayer.h new file mode 100644 index 00000000..8cd1e6ca --- /dev/null +++ b/include/dolphin/thp/THPPlayer.h @@ -0,0 +1,91 @@ +#ifndef _THP_THPPLAYER_H +#define _THP_THPPLAYER_H + +#include "types.h" +#include "Dolphin/os.h" +#include "Dolphin/gx.h" +#include "THP/THPBuffer.h" +#include "THP/THPFile.h" +#include "THP/THPInfo.h" + +#ifdef __cplusplus +extern "C" { +#endif + +// Size: 0x1D0 +typedef struct THPPlayer { + DVDFileInfo mFileInfo; // _00 + THPHeader mHeader; // _3C + THPFrameCompInfo mCompInfo; // _6C + THPVideoInfo mVideoInfo; // _80 + THPAudioInfo mAudioInfo; // _8C + void* mThpWorkArea; // _9C + BOOL mIsOpen; // _A0 + u8 mState; // _A4 + u8 mInternalState; // _A5 + u8 mPlayFlag; // _A6 + u8 mAudioExist; // _A7 + s32 mDvdError; // _A8 + s32 mVideoError; // _AC + BOOL mIsOnMemory; // _B0 + u8* mMovieData; // _B4 + s32 mInitOffset; // _B8 + s32 mInitReadSize; // _BC + s32 mInitReadFrame; // _C0 + u32 mCurField; // _C4 + s64 mRetraceCount; // _C8 + s32 mPrevCount; // _D0 + s32 mCurCount; // _D4 + s32 mVideoDecodeCount; // _D8 + f32 mCurVolume; // _DC + f32 mTargetVolume; // _E0 + f32 mDeltaVolume; // _E4 + s32 mRampCount; // _E8 + s32 mCurAudioTrack; // _EC + s32 mCurVideoNumber; // _F0 + s32 mCurAudioNumber; // _F4 + THPTextureSet* mDispTextureSet; // _F8 + THPAudioBuffer* mPlayAudioBuffer; // _FC + THPReadBuffer mReadBuffer[10]; // _100 + THPTextureSet mTextureSet[3]; // _178 + THPAudioBuffer mAudioBuffer[3]; // _1A8 +} THPPlayer; + +extern THPPlayer ActivePlayer; + +BOOL THPPlayerInit(int _); +void THPPlayerQuit(); +BOOL THPPlayerOpen(const char* fileName, BOOL onMemory); +BOOL THPPlayerClose(); +BOOL THPPlayerPlay(); +void THPPlayerStop(); +BOOL THPPlayerPause(); +BOOL THPPlayerPrepare(int offset, u8 flag, int audioTrack); + +BOOL THPPlayerSetBuffer(u8* data); + +u32 THPPlayerCalcNeedMemory(); + +BOOL THPPlayerGetVideoInfo(void* dst); +BOOL THPPlayerGetAudioInfo(void* dst); +// f32 THPPlayerGetFrameRate(); +BOOL THPPlayerSetVolume(int vol, int duration); + +int THPPlayerDrawCurrentFrame(GXRenderModeObj* obj, int x, int y, int polyWidth, + int polyHeight); // TODO, parameter names from dwarf info if it exists +u32 THPPlayerGetTotalFrame(); +u8 THPPlayerGetState(); + +void THPPlayerDrawDone(); +void THPPlayerPostDrawDone(); + +// this should go in a dolphin THP header eventually +BOOL THPInit(void); + +#ifdef __cplusplus +} +#endif + +void PrepareReady(int msg); + +#endif /* _THP_THPPLAYER_H */ diff --git a/include/dolphin/thp/THPRead.h b/include/dolphin/thp/THPRead.h new file mode 100644 index 00000000..61ae892d --- /dev/null +++ b/include/dolphin/thp/THPRead.h @@ -0,0 +1,28 @@ +#ifndef _THP_THPREAD_H +#define _THP_THPREAD_H + +#include "dolphin/thp/THPBuffer.h" +#include "dolphin/os.h" + +static void* Reader(void* arg); + +#ifdef __cplusplus +extern "C" { +#endif // ifdef __cplusplus + +BOOL CreateReadThread(OSPriority priority); +void ReadThreadStart(); +void ReadThreadCancel(); +OSMessage PopReadedBuffer(); +BOOL PushReadedBuffer(OSMessage*); +OSMessage PopFreeReadBuffer(); +BOOL PushFreeReadBuffer(OSMessage*); +OSMessage PopReadedBuffer2(); +BOOL PushReadedBuffer2(OSMessage*); + +extern u8 gTHPReaderDvdAccess; +#ifdef __cplusplus +}; +#endif + +#endif diff --git a/include/dolphin/thp/THPVideoDecode.h b/include/dolphin/thp/THPVideoDecode.h new file mode 100644 index 00000000..cd741555 --- /dev/null +++ b/include/dolphin/thp/THPVideoDecode.h @@ -0,0 +1,31 @@ +#ifndef _DOLPHIN_THPVIDEODECODE +#define _DOLPHIN_THPVIDEODECODE + +#include "dolphin/thp/THPRead.h" + +static void* VideoDecoder(void*); +static void* VideoDecoderForOnMemory(void*); +static void VideoDecode(THPReadBuffer*); + +#ifdef __cplusplus +extern "C" { +#endif // ifdef __cplusplus +s32 THPVideoDecode(void* file, void* tileY, void* tileU, void* tileV, void* work); +BOOL CreateVideoDecodeThread(OSPriority priority, void* task); +void VideoDecodeThreadStart(); +void VideoDecodeThreadCancel(); +OSMessage PopFreeTextureSet(); +BOOL PushFreeTextureSet(OSMessage*); +OSMessage PopDecodedTextureSet(s32 flags); +BOOL PushDecodedTextureSet(OSMessage*); + +extern BOOL VideoDecodeThreadCreated; +extern OSMessageQueue FreeTextureSetQueue; +extern OSMessageQueue DecodedTextureSetQueue; +extern OSThread VideoDecodeThread; + +#ifdef __cplusplus +}; +#endif + +#endif // _DOLPHIN_THPVIDEODECODE diff --git a/include/dolphin/types.h b/include/dolphin/types.h new file mode 100644 index 00000000..822ec081 --- /dev/null +++ b/include/dolphin/types.h @@ -0,0 +1,90 @@ +#ifndef _DOLPHIN_TYPES +#define _DOLPHIN_TYPES + +#ifdef TARGET_PC +#include +typedef int8_t s8; +typedef int16_t s16; +typedef int32_t s32; +typedef int64_t s64; +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; +#else +typedef signed char s8; +typedef signed short int s16; +typedef signed long s32; +typedef signed long long int s64; +typedef unsigned char u8; +typedef unsigned short int u16; +typedef unsigned long u32; +typedef unsigned long long int u64; +#endif + +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; + +#if defined(TARGET_PC) && !defined(_WIN32) +#include +typedef bool BOOL; +#ifndef FALSE +#define FALSE false +#endif +#ifndef TRUE +#define TRUE true +#endif +#else +typedef int BOOL; +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif +#endif + +#ifdef TARGET_PC +#include +#else +#ifndef NULL +#define NULL ((void *)0) +#endif +#endif +#if !defined(__cplusplus) || __cplusplus < 201103L +#ifndef nullptr +#define nullptr NULL +#endif + +#if defined(__MWERKS__) +#ifndef override +#define override +#endif +#endif + +#endif + +#ifndef ATTRIBUTE_ALIGN +#if defined(__MWERKS__) || defined(__GNUC__) +#define ATTRIBUTE_ALIGN(num) __attribute__((aligned(num))) +#elif defined(_MSC_VER) +#define ATTRIBUTE_ALIGN(num) +#else +#error unknown compiler +#endif +#endif + +#endif // _DOLPHIN_TYPES diff --git a/include/dolphin/vi.h b/include/dolphin/vi.h new file mode 100644 index 00000000..f503f4b5 --- /dev/null +++ b/include/dolphin/vi.h @@ -0,0 +1,31 @@ +#ifndef _DOLPHIN_VI +#define _DOLPHIN_VI + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void VIInit(void); +void VIConfigure(const GXRenderModeObj* rm); +void VIFlush(void); +u32 VIGetTvFormat(void); +void VISetNextFrameBuffer(void* fb); +void VIWaitForRetrace(void); +void VISetBlack(BOOL black); + +#ifdef TARGET_PC +void VISetWindowTitle(const char* title); +void VISetWindowFullscreen(bool fullscreen); +bool VIGetWindowFullscreen(); +#endif + + + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_VI diff --git a/include/dolphin/vifuncs.h b/include/dolphin/vifuncs.h new file mode 100644 index 00000000..f7a8ced2 --- /dev/null +++ b/include/dolphin/vifuncs.h @@ -0,0 +1,22 @@ +#ifndef _DOLPHIN_VIFUNCS +#define _DOLPHIN_VIFUNCS + +#include + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +u32 VIGetNextField(void); +VIRetraceCallback VISetPreRetraceCallback(VIRetraceCallback callback); +VIRetraceCallback VISetPostRetraceCallback(VIRetraceCallback callback); +void __VIGetCurrentPosition(s16* x, s16* y); +u32 VIGetDTVStatus(void); + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_VIFUNCS diff --git a/include/dolphin/vitypes.h b/include/dolphin/vitypes.h new file mode 100644 index 00000000..db958702 --- /dev/null +++ b/include/dolphin/vitypes.h @@ -0,0 +1,130 @@ +#ifndef _DOLPHIN_VITYPES +#define _DOLPHIN_VITYPES + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define VI_INTERLACE 0 +#define VI_NON_INTERLACE 1 +#define VI_PROGRESSIVE 2 +#define VI_3D 3 + +#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 +#define VI_GCA 6 + +#define VI_TVMODE(format, interlace) (((format) << 2) + (interlace)) + +typedef enum { + // NTSC + 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_NTSC_3D = VI_TVMODE(VI_NTSC, VI_3D), + // PAL + VI_TVMODE_PAL_INT = VI_TVMODE(VI_PAL, VI_INTERLACE), + VI_TVMODE_PAL_DS = VI_TVMODE(VI_PAL, VI_NON_INTERLACE), + + // MPAL + VI_TVMODE_MPAL_INT = VI_TVMODE(VI_MPAL, VI_INTERLACE), + VI_TVMODE_MPAL_DS = VI_TVMODE(VI_MPAL, VI_NON_INTERLACE), + + // Debug + VI_TVMODE_DEBUG_INT = VI_TVMODE(VI_DEBUG, VI_INTERLACE), + + // Debug PAL + 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), + + // EU RGB60 + VI_TVMODE_EURGB60_INT = VI_TVMODE(VI_EURGB60, VI_INTERLACE), + VI_TVMODE_EURGB60_DS = VI_TVMODE(VI_EURGB60, VI_NON_INTERLACE), + + // GCA + VI_TVMODE_GCA_INT = VI_TVMODE(VI_GCA, VI_INTERLACE), + VI_TVMODE_GCA_DS = VI_TVMODE(VI_GCA, VI_NON_INTERLACE), + VI_TVMODE_GCA_PROG = VI_TVMODE(VI_GCA, VI_PROGRESSIVE), +} VITVMode; + +typedef enum { + VI_XFBMODE_SF = 0, + VI_XFBMODE_DF = 1, +} VIXFBMode; + +typedef void (*VIPositionCallback)(s16 x, s16 y); +typedef void (*VIRetraceCallback)(u32 retraceCount); + +// Structure to use with timing in vi.c (size 0x28). +typedef struct VITimingInfo { + u8 equ; // _00 + u16 acv; // _02 + u16 prbOdd; // _04 + u16 prbEven; // _06 + u16 psbOdd; // _08 + u16 psbEven; // _0A + u8 bs1; // _0C + u8 bs2; // _0D + u8 bs3; // _0E + u8 bs4; // _0F + u16 be1; // _10 + u16 be2; // _12 + u16 be3; // _14 + u16 be4; // _16 + u16 numHalfLines; // _18 + u16 hlw; // _1A + u8 hsy; // _1C + u8 hcs; // _1D + u8 hce; // _1E + u8 hbe640; // _1F + u16 hbs640; // _20 + u8 hbeCCIR656; // _24 + u16 hbsCCIR656; // _26 +} VITimingInfo; + +// Structure to use with HorVer in vi.c (size 0x58). +typedef struct VIPositionInfo { + u16 dispPosX; // _00 + u16 dispPosY; // _02 + u16 dispSizeX; // _04 + u16 dispSizeY; // _06 + u16 adjDispPosX; // _08 + u16 adjDispPosY; // _0A + u16 adjDispSizeY; // _0C + u16 adjPanPosY; // _0E + u16 adjPanSizeY; // _10 + u16 fbSizeX; // _12 + u16 fbSizeY; // _14 + u16 panPosX; // _16 + u16 panPosY; // _18 + u16 panSizeX; // _1A + u16 panSizeY; // _1C + VIXFBMode xfbMode; // _20 + u32 nonInter; // _24 + u32 tv; // _28 + u8 wordPerLine; // _2C + u8 std; // _2D + u8 wpl; // _2E + u32 bufAddr; // _30 + u32 tfbb; // _34 + u32 bfbb; // _38 + u8 xof; // _3C + BOOL isBlack; // _40 + BOOL is3D; // _44 + u32 rbufAddr; // _48 + u32 rtfbb; // _4C + u32 rbfbb; // _50 + VITimingInfo* timing; // _54 +} VIPositionInfo; + +#ifdef __cplusplus +} +#endif + +#endif // _DOLPHIN_VITYPES diff --git a/include/functions.h b/include/functions.h index b9c6d3ec..209b4967 100644 --- a/include/functions.h +++ b/include/functions.h @@ -4,11 +4,6 @@ #include "types.h" #include "common_structs.h" -void OSReport(const char * format, ...); -void* OSAllocFromHeap(int heap, u32 size); -s32 OSCheckHeap(int heap); -void DCFlushRangeNoSync(void *addr, u32 size); -void DCFlushRange(void *addr, u32 size); void* HuPrcCreate(void (*), s32, s32, s32); void Hu3DBGColorSet(u8, u8, u8); void Hu3DCameraCreate(s16); diff --git a/include/types.h b/include/types.h index 388ebfcc..462b4f66 100644 --- a/include/types.h +++ b/include/types.h @@ -1,24 +1,6 @@ #ifndef _TYPES_H_ #define _TYPES_H_ -#define NULL ((void *)0) -typedef unsigned char u8; -typedef unsigned short u16; -typedef unsigned long u32; -typedef unsigned long long u64; -typedef signed char s8; -typedef short s16; -typedef long s32; -typedef long long s64; -typedef volatile unsigned char vu8; -typedef volatile unsigned short vu16; -typedef volatile unsigned long vu32; -typedef volatile unsigned long long vu64; -typedef volatile signed char vs8; -typedef volatile short vs16; -typedef volatile long vs32; -typedef volatile long long vs64; -typedef float f32; -typedef double f64; +#include "dolphin/types.h" -#endif \ No newline at end of file +#endif diff --git a/src/REL/_minigameDLL/_minigameDLL.c b/src/REL/_minigameDLL/_minigameDLL.c index 065b263a..8b5be5a5 100644 --- a/src/REL/_minigameDLL/_minigameDLL.c +++ b/src/REL/_minigameDLL/_minigameDLL.c @@ -1,5 +1,6 @@ #include "common.h" #include "REL/executor.h" +#include "dolphin/os.h" void ModuleProlog(void) { OSReport("minigame dll setup\n"); diff --git a/src/game/decode.c b/src/game/decode.c index 8ee2c55c..ce4c2d9d 100644 --- a/src/game/decode.c +++ b/src/game/decode.c @@ -1,4 +1,5 @@ #include "common.h" +#include "dolphin/os.h" struct decode_data { diff --git a/src/game/malloc.c b/src/game/malloc.c index 08910376..d93463e2 100644 --- a/src/game/malloc.c +++ b/src/game/malloc.c @@ -1,7 +1,7 @@ #include "common.h" +#include "dolphin/os.h" -extern int __OSCurrHeap; -extern int currentHeapHandle; +extern OSHeapHandle currentHeapHandle; static u32 HeapSizeTbl[5] = { 0x240000, 0x140000, 0xA80000, 0x580000, 0 }; static void *HeapTbl[5]; diff --git a/src/game/memory.c b/src/game/memory.c index 990c70db..213f51c8 100644 --- a/src/game/memory.c +++ b/src/game/memory.c @@ -1,4 +1,5 @@ #include "common.h" +#include "dolphin/os.h" #define DATA_GET_BLOCK(ptr) ((struct memory_block *)(((char *)(ptr))-32)) #define BLOCK_GET_DATA(block) (((char *)(block))+32)