diff options
Diffstat (limited to 'arm9/lib/NitroSDK/include')
110 files changed, 6635 insertions, 0 deletions
diff --git a/arm9/lib/NitroSDK/include/CARD_backup.h b/arm9/lib/NitroSDK/include/CARD_backup.h new file mode 100644 index 00000000..e5c0c0cd --- /dev/null +++ b/arm9/lib/NitroSDK/include/CARD_backup.h @@ -0,0 +1,31 @@ +#ifndef POKEDIAMOND_CARD_BACKUP_H +#define POKEDIAMOND_CARD_BACKUP_H + +#include "nitro/types.h" +#include "MI_dma.h" +#include "CARD_common.h" + +BOOL CARDi_RequestStreamCommand(u32 src, u32 dst, u32 len, MIDmaCallback callback, void *arg, BOOL is_async, + CARDRequest req_type, int req_retry, CARDRequestMode req_mode); +u32 CARD_GetBackupSectorSize(void); +BOOL CARD_IdentifyBackup(CARDBackupType type); +BOOL CARD_WaitBackupAsync(void); +BOOL CARD_TryWaitBackupAsync(void); +void CARD_CancelBackupAsync(void); + +static inline BOOL CARDi_ReadBackup(u32 src, void * dst, u32 len, MIDmaCallback callback, void * arg, BOOL is_async) +{ + return CARDi_RequestStreamCommand((u32)src, (u32)dst, len, callback, arg, is_async, CARD_REQ_READ_BACKUP, 1, CARD_REQUEST_MODE_RECV); +} + +static inline BOOL CARDi_WriteBackup(u32 dst, void * src, u32 len, MIDmaCallback callback, void * arg, BOOL is_async) +{ + return CARDi_RequestStreamCommand((u32)src, (u32)dst, len, callback, arg, is_async, CARD_REQ_WRITE_BACKUP, CARD_RETRY_COUNT_MAX, CARD_REQUEST_MODE_SEND); +} + +static inline BOOL CARDi_WriteAndVerifyBackup(u32 dst, void * src, u32 len, MIDmaCallback callback, void * arg, BOOL is_async) +{ + return CARDi_RequestStreamCommand((u32)src, (u32)dst, len, callback, arg, is_async, CARD_REQ_WRITE_BACKUP, CARD_RETRY_COUNT_MAX, CARD_REQUEST_MODE_SEND_VERIFY); +} + +#endif //POKEDIAMOND_CARD_BACKUP_H diff --git a/arm9/lib/NitroSDK/include/CARD_common.h b/arm9/lib/NitroSDK/include/CARD_common.h new file mode 100644 index 00000000..1ae31b7a --- /dev/null +++ b/arm9/lib/NitroSDK/include/CARD_common.h @@ -0,0 +1,233 @@ +#ifndef POKEDIAMOND_CARD_COMMON_H +#define POKEDIAMOND_CARD_COMMON_H + +#include "nitro/types.h" +#include "OS_thread.h" +#include "OS_system.h" +#include "MI_dma.h" +#include "PXI_fifo.h" + +#define CARD_PXI_COMMAND_MASK 0x3f +#define CARD_PXI_COMMAND_PULLED_OUT 0x0011 +#define CARD_PXI_COMMAND_TERMINATE 0x0001 + +#define CARD_THREAD_PRIORITY_DEFAULT 4 + +#define CARD_BACKUP_TYPE_DEVICE_SHIFT 0 +#define CARD_BACKUP_TYPE_DEVICE_MASK 0xFF +#define CARD_BACKUP_TYPE_DEVICE_EEPROM 1 +#define CARD_BACKUP_TYPE_DEVICE_FLASH 2 +#define CARD_BACKUP_TYPE_DEVICE_FRAM 3 +#define CARD_BACKUP_TYPE_SIZEBIT_SHIFT 8 +#define CARD_BACKUP_TYPE_SIZEBIT_MASK 0xFF +#define CARD_BACKUP_TYPE_VENDER_SHIFT 16 +#define CARD_BACKUP_TYPE_DEFINE(type, size, vender) \ + (((CARD_BACKUP_TYPE_DEVICE_ ## type) << CARD_BACKUP_TYPE_DEVICE_SHIFT) | \ + ((size) << CARD_BACKUP_TYPE_SIZEBIT_SHIFT) | \ + ((vender) << CARD_BACKUP_TYPE_VENDER_SHIFT)) + +#define ALIGN_MASK(a) ((a) - 1) +#define CARD_ALIGN_HI_BIT(n) (((u32)(n)) & ~ALIGN_MASK(CARD_ROM_PAGE_SIZE)) +#define CARD_ALIGN_LO_BIT(n) (((u32)(n)) & ALIGN_MASK(CARD_ROM_PAGE_SIZE)) + +#define CARD_BACKUP_CAPS_AVAILABLE (u32)(CARD_BACKUP_CAPS_READ - 1) +#define CARD_BACKUP_CAPS_READ (u32)(1 << CARD_REQ_READ_BACKUP) +#define CARD_BACKUP_CAPS_WRITE (u32)(1 << CARD_REQ_WRITE_BACKUP) +#define CARD_BACKUP_CAPS_PROGRAM (u32)(1 << CARD_REQ_PROGRAM_BACKUP) +#define CARD_BACKUP_CAPS_VERIFY (u32)(1 << CARD_REQ_VERIFY_BACKUP) +#define CARD_BACKUP_CAPS_ERASE_PAGE (u32)(1 << CARD_REQ_ERASE_PAGE_BACKUP) +#define CARD_BACKUP_CAPS_ERASE_SECTOR (u32)(1 << CARD_REQ_ERASE_SECTOR_BACKUP) +#define CARD_BACKUP_CAPS_ERASE_CHIP (u32)(1 << CARD_REQ_ERASE_CHIP_BACKUP) + +typedef enum +{ + CARD_BACKUP_TYPE_EEPROM_4KBITS = CARD_BACKUP_TYPE_DEFINE(EEPROM, 9, 0), + CARD_BACKUP_TYPE_EEPROM_64KBITS = CARD_BACKUP_TYPE_DEFINE(EEPROM, 13, 0), + CARD_BACKUP_TYPE_EEPROM_512KBITS = CARD_BACKUP_TYPE_DEFINE(EEPROM, 16, 0), + CARD_BACKUP_TYPE_FLASH_2MBITS = CARD_BACKUP_TYPE_DEFINE(FLASH, 18, 0), + CARD_BACKUP_TYPE_FLASH_4MBITS = CARD_BACKUP_TYPE_DEFINE(FLASH, 19, 0), + CARD_BACKUP_TYPE_FLASH_8MBITS = CARD_BACKUP_TYPE_DEFINE(FLASH, 20, 0), + CARD_BACKUP_TYPE_FRAM_256KBITS = CARD_BACKUP_TYPE_DEFINE(FRAM, 15, 0), + CARD_BACKUP_TYPE_NOT_USE = 0 +} CARDBackupType; + +typedef enum +{ + CARD_RESULT_SUCCESS = 0, + CARD_RESULT_FAILURE, + CARD_RESULT_INVALID_PARAM, + CARD_RESULT_UNSUPPORTED, + CARD_RESULT_TIMEOUT, + CARD_RESULT_ERROR, + CARD_RESULT_NO_RESPONSE, + CARD_RESULT_CANCELED +} CARDResult; + +typedef enum +{ + CARD_TARGET_NONE, + CARD_TARGET_ROM, + CARD_TARGET_BACKUP +} CARDTargetMode; + +typedef enum +{ + CARD_REQ_INIT = 0, + CARD_REQ_ACK, + CARD_REQ_IDENTIFY, + CARD_REQ_READ_ID, + CARD_REQ_READ_ROM, + CARD_REQ_WRITE_ROM, + CARD_REQ_READ_BACKUP, + CARD_REQ_WRITE_BACKUP, + CARD_REQ_PROGRAM_BACKUP, + CARD_REQ_VERIFY_BACKUP, + CARD_REQ_ERASE_PAGE_BACKUP, + CARD_REQ_ERASE_SECTOR_BACKUP, + CARD_REQ_ERASE_CHIP_BACKUP, + CARD_REQ_MAX +} CARDRequest; + +typedef enum +{ + CARD_REQUEST_MODE_RECV, + CARD_REQUEST_MODE_SEND, + CARD_REQUEST_MODE_SEND_VERIFY, + CARD_REQUEST_MODE_SPECIAL +} CARDRequestMode; + +enum +{ + CARD_STAT_INIT = (1 << 0), + CARD_STAT_INIT_CMD = (1 << 1), + CARD_STAT_BUSY = (1 << 2), + CARD_STAT_TASK = (1 << 3), + CARD_STAT_RECV = (1 << 4), + CARD_STAT_REQ = (1 << 5), + CARD_STAT_CANCEL = (1 << 6) +}; + +typedef s32 CARDiOwner; + +typedef struct CARDiCommandArg +{ + CARDResult result; + CARDBackupType type; + u32 id; + u32 src; + u32 dest; + u32 len; + + struct + { + u32 total_size; + u32 sect_size; + u32 page_size; + u32 addr_width; + u32 program_page; + u32 write_page; + u32 write_page_total; + u32 erase_chip; + u32 erase_chip_total; + u32 erase_sector; + u32 erase_sector_total; + u32 erase_page; + u8 initial_status; + u8 padding1[3]; + u32 caps; + u8 padding2[16]; + } spec; +} CARDiCommandArg; + +typedef struct CARDiCommon +{ + CARDiCommandArg *cmd; + s32 command; + + volatile CARDiOwner lock_owner; + volatile s32 lock_ref; + OSThreadQueue lock_queue[1]; + CARDTargetMode lock_target; + + u32 src; + u32 dst; + u32 len; + u32 dma; + CARDRequest req_type; + s32 req_retry; + CARDRequestMode req_mode; + MIDmaCallback callback; + void *callback_arg; + void (*task_func) (struct CARDiCommon *); + + OSThread thread[1]; + OSThread *cur_th; + + u32 priority; + OSThreadQueue busy_q[1]; + + volatile u32 flag; + + u8 dummy[8]; + + u8 backup_cache_page_buf[256] ALIGN(32); +} CARDiCommon; + +static inline void CARDi_EndTask(CARDiCommon *p, BOOL is_own_task) +{ + const MIDmaCallback func = p->callback; + void *const arg = p->callback_arg; + + { + OSIntrMode bak_psr = OS_DisableInterrupts(); + + p->flag &= ~(CARD_STAT_BUSY | CARD_STAT_TASK | CARD_STAT_CANCEL); + OS_WakeupThread(p->busy_q); + if ((p->flag & CARD_STAT_RECV) != 0) + { + OS_WakeupThreadDirect(p->thread); + } + (void)OS_RestoreInterrupts(bak_psr); + } + + if (is_own_task && func) + { + (*func)(arg); + } +} + +static inline void CARDi_WaitTask(CARDiCommon *p, MIDmaCallback callback, void *callback_arg) +{ + OSIntrMode bak_psr = OS_DisableInterrupts(); + while ((p->flag & CARD_STAT_BUSY) != 0) + { + OS_SleepThread(p->busy_q); + } + p->flag |= CARD_STAT_BUSY; + p->callback = callback; + p->callback_arg = callback_arg; + (void)OS_RestoreInterrupts(bak_psr); +} + +void CARDi_SetTask(void (*task) (CARDiCommon *)); +void CARDi_InitCommon(void); +BOOL CARD_IsEnabled(void); +void CARD_CheckEnabled(void); +void CARD_Enable(BOOL enable); +BOOL CARDi_WaitAsync(void); +BOOL CARDi_TryWaitAsync(void); +CARDResult CARD_GetResultCode(void); +void CARD_LockRom(u16 lock_id); +void CARD_UnlockRom(u16 lock_id); +void CARD_LockBackup(u16 lock_id); +void CARD_UnlockBackup(u16 lock_id); + +#define CARD_RETRY_COUNT_MAX 10 + +static inline void CARDi_SendPxi(u32 data) +{ + while (PXI_SendWordByFifo(PXI_FIFO_TAG_FS, data, TRUE) < 0) + ; +} + +#endif //POKEDIAMOND_CARD_COMMON_H diff --git a/arm9/lib/NitroSDK/include/CARD_pullOut.h b/arm9/lib/NitroSDK/include/CARD_pullOut.h new file mode 100644 index 00000000..bfc0e6d2 --- /dev/null +++ b/arm9/lib/NitroSDK/include/CARD_pullOut.h @@ -0,0 +1,13 @@ +#ifndef POKEDIAMOND_CARD_PULLOUT_H +#define POKEDIAMOND_CARD_PULLOUT_H + +#include "nitro/types.h" + +typedef BOOL (*CARDPulledOutCallback) (void); + +void CARD_InitPulledOutCallback(void); +BOOL CARD_IsPulledOut(void); +void CARD_TerminateForPulledOut(void); +void CARDi_CheckPulledOutCore(u32 id); + +#endif //POKEDIAMOND_CARD_PULLOUT_H diff --git a/arm9/lib/NitroSDK/include/CARD_request.h b/arm9/lib/NitroSDK/include/CARD_request.h new file mode 100644 index 00000000..1bae75d0 --- /dev/null +++ b/arm9/lib/NitroSDK/include/CARD_request.h @@ -0,0 +1,12 @@ +#ifndef POKEDIAMOND_CARD_REQUEST_H +#define POKEDIAMOND_CARD_REQUEST_H + +#include "nitro/types.h" +#include "PXI_fifo.h" +#include "CARD_common.h" + +void CARDi_OnFifoRecv(PXIFifoTag tag, u32 data, BOOL err); +void CARDi_TaskThread(void *arg); +BOOL CARDi_Request(CARDiCommon *p, s32 req_type, s32 retry_count); + +#endif //POKEDIAMOND_CARD_REQUEST_H diff --git a/arm9/lib/NitroSDK/include/CARD_rom.h b/arm9/lib/NitroSDK/include/CARD_rom.h new file mode 100644 index 00000000..b6fca60b --- /dev/null +++ b/arm9/lib/NitroSDK/include/CARD_rom.h @@ -0,0 +1,101 @@ +#ifndef POKEDIAMOND_CARD_ROM_H +#define POKEDIAMOND_CARD_ROM_H + +#include "nitro/types.h" +#include "MI_exMemory.h" +#include "MI_dma.h" +#include "CARD_common.h" +#include "OS_tcm.h" +#include "mmap.h" + +#define CARD_ROM_PAGE_SIZE 512 + +#define CARDMST_SEL_ROM 0x00 +#define CARDMST_IF_ENABLE 0x40 +#define CARDMST_ENABLE 0x80 + +#define CARD_DATA_READY 0x00800000 +#define CARD_COMMAND_PAGE 0x01000000 +#define CARD_COMMAND_ID 0x07000000 +#define CARD_COMMAND_MASK 0x07000000 +#define CARD_RESET_HI 0x20000000 +#define CARD_READ_MODE 0x00000000 +#define CARD_START 0x80000000 +#define CARD_LATENCY1_MASK 0x00001FFF + +#define MROMOP_G_READ_PAGE 0xB7000000 +#define MROMOP_G_READ_ID 0xB8000000 + +extern CARDiCommon cardi_common; + +typedef struct +{ + u32 offset; + u32 length; +} +CARDRomRegion; + +typedef struct CARDRomStat +{ + void (*read_func) (struct CARDRomStat *); + u32 ctrl; + u8 *cache_page; + u32 dummy[5]; + u8 cache_buf[CARD_ROM_PAGE_SIZE]; +} CARDRomStat; + +static inline const CARDRomRegion * CARD_GetRomRegionOVT(MIProcessor target) +{ + return (target == MI_PROCESSOR_ARM9) + ? (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x50) + : (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x58); +} + +BOOL CARDi_TryReadCardDma(CARDRomStat *p); +void CARDi_ReadCard(CARDRomStat *p); +u32 CARDi_ReadRomIDCore(void); +void CARDi_CheckPulledOutCore(u32 id); +void CARDi_ReadRom(u32 dma, const void *src, void *dst, u32 len, MIDmaCallback callback, void *arg, BOOL is_async); +void CARD_Init(void); +void CARD_WaitRomAsync(void); +void (*CARDi_GetRomAccessor(void)) (CARDRomStat *); + +static inline void CARD_ReadRomAsync(u32 dma, const void * src, void * dst, u32 len, MIDmaCallback callback, void * arg) +{ + CARDi_ReadRom(dma, src, dst, len, callback, arg, TRUE); +} + +static inline const CARDRomRegion * CARD_GetRomRegionFNT() { + return (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x40); +} + +static inline const CARDRomRegion * CARD_GetRomRegionFAT() { + return (const CARDRomRegion *)((const u8 *)HW_ROM_HEADER_BUF + 0x48); +} + +static inline void CARDi_ReadEnd(void) +{ + CARDiCommon *const p = &cardi_common; + CARDi_CheckPulledOutCore(CARDi_ReadRomIDCore()); + p->cmd->result = CARD_RESULT_SUCCESS; + CARDi_EndTask(p, TRUE); +} + +static inline BOOL CARDi_IsInTcm(u32 buf, u32 len) +{ + const u32 i = (u32)HW_ITCM; + const u32 d = OS_GetDTCMAddress(); + return ((i < buf + len) && (i + HW_ITCM_SIZE > buf)) || + ((d < buf + len) && (d + HW_DTCM_SIZE > buf)); +} + +extern u32 cardi_rom_header_addr; + +static inline u32 CARDi_GetRomFlag(u32 flag) +{ + const u32 rom_ctrl = *(vu32 *)(cardi_rom_header_addr + 0x60); + return (u32)((rom_ctrl & ~CARD_COMMAND_MASK) | flag | + CARD_READ_MODE | CARD_START | CARD_RESET_HI); +} + +#endif //POKEDIAMOND_CARD_ROM_H diff --git a/arm9/lib/NitroSDK/include/CARD_spi.h b/arm9/lib/NitroSDK/include/CARD_spi.h new file mode 100644 index 00000000..0181e39f --- /dev/null +++ b/arm9/lib/NitroSDK/include/CARD_spi.h @@ -0,0 +1,8 @@ +#ifndef POKEDIAMOND_CARD_SPI_H +#define POKEDIAMOND_CARD_SPI_H + +#include "CARD_common.h" + +void CARDi_IdentifyBackupCore(CARDBackupType type); + +#endif //POKEDIAMOND_CARD_SPI_H diff --git a/arm9/lib/NitroSDK/include/CP_context.h b/arm9/lib/NitroSDK/include/CP_context.h new file mode 100644 index 00000000..9d392352 --- /dev/null +++ b/arm9/lib/NitroSDK/include/CP_context.h @@ -0,0 +1,17 @@ +#ifndef POKEDIAMOND_CP_CONTEXT_H +#define POKEDIAMOND_CP_CONTEXT_H + +#include "nitro/types.h" + +typedef struct CPContext { + u64 div_numer; + u64 div_denom; + u64 sqrt; + u16 div_mode; + u16 sqrt_mode; +} CPContext; + +void CP_SaveContext(register CPContext *context); +void CPi_RestoreContext(const CPContext* context); + +#endif //POKEDIAMOND_CP_CONTEXT_H diff --git a/arm9/lib/NitroSDK/include/CTRDG_backup.h b/arm9/lib/NitroSDK/include/CTRDG_backup.h new file mode 100644 index 00000000..8b95a7aa --- /dev/null +++ b/arm9/lib/NitroSDK/include/CTRDG_backup.h @@ -0,0 +1,50 @@ +#ifndef POKEDIAMOND_CTRDG_BACKUP_H +#define POKEDIAMOND_CTRDG_BACKUP_H + +#include "nitro/types.h" +#include "CTRDG_flash.h" +#include "CTRDG_task.h" + +#define CTRDG_BACKUP_PHASE_PROGRAM 0x0001 +#define CTRDG_BACKUP_PHASE_SECTOR_ERASE 0x0002 +#define CTRDG_BACKUP_PHASE_CHIP_ERASE 0x0003 +#define CTRDG_BACKUP_PHASE_PARAMETER_CHECK 0x00ff + +#define CTRDG_BACKUP_RESULT_ERROR 0x8000 + +extern u16 ctrdg_flash_remainder; + +typedef struct CTRDGiFlashTypePlusTag +{ + u16 (*CTRDGi_WriteAgbFlashSector)(u16 secNo, u8 *src); + u16 (*CTRDGi_EraseAgbFlashChip)(void); + u16 (*CTRDGi_EraseAgbFlashSector)(u16 secNo); + void (*CTRDGi_WriteAgbFlashSectorAsync)(u16 secNo, u8 *src, CTRDG_TASK_FUNC callback); + void (*CTRDGi_EraseAgbFlashChipAsync)(CTRDG_TASK_FUNC callback); + void (*CTRDGi_EraseAgbFlashSectorAsync)(u16 secNo, CTRDG_TASK_FUNC callback); + u16 (*CTRDGi_PollingSR)(u16 phase, u8 *adr, u16 lastData); + const u16 (*maxtime); + CTRDGFlashType type; +} CTRDGiFlashTypePlus; + +typedef enum +{ + CTRDG_BACKUP_TYPE_FLASH_512K, + CTRDG_BACKUP_TYPE_FLASH_1M, + CTRDG_BACKUP_TYPE_SRAM +} CTRDGBackupType; + +extern const u16 (*ctrdgi_fl_maxtime); + +extern u16 (*CTRDGi_PollingSR)(u16 phase, u8 *adr, u16 lastData); +extern const CTRDGFlashType *AgbFlash; +extern u16 (*CTRDGi_WriteAgbFlashSector)(u16 secNo, u8 *src); +extern u16 (*CTRDGi_EraseAgbFlashChip)(void); +extern u16 (*CTRDGi_EraseAgbFlashSector)(u16 secNo); +extern void (*CTRDGi_WriteAgbFlashSectorAsync)(u16 secNo, u8 *src, CTRDG_TASK_FUNC callback); +extern void (*CTRDGi_EraseAgbFlashChipAsync)(CTRDG_TASK_FUNC callback); +extern void (*CTRDGi_EraseAgbFlashSectorAsync)(u16 secNo, CTRDG_TASK_FUNC callback); + +u16 CTRDG_IdentifyAgbBackup(CTRDGBackupType type); + +#endif //POKEDIAMOND_CTRDG_BACKUP_H diff --git a/arm9/lib/NitroSDK/include/CTRDG_common.h b/arm9/lib/NitroSDK/include/CTRDG_common.h new file mode 100644 index 00000000..2d37c6f8 --- /dev/null +++ b/arm9/lib/NitroSDK/include/CTRDG_common.h @@ -0,0 +1,137 @@ +#ifndef POKEDIAMOND_CTRDG_COMMON_H +#define POKEDIAMOND_CTRDG_COMMON_H + +#include "consts.h" +#include "OS_spinLock.h" +#include "OS_system.h" +#include "MI_exMemory.h" + +typedef struct CTRDGWork +{ + vu16 subpInitialized; + u16 lockID; + +} CTRDGWork; + +typedef struct CTRDGModuleID +{ + union + { + struct + { + u8 bitID; + u8 numberID:5; + u8 :2; + u8 disableExLsiID:1; + }; + u16 raw; + }; +} CTRDGModuleID; + +typedef struct CTRDGModuleInfo +{ + CTRDGModuleID moduleID; + u8 exLsiID[3]; + u8 isAgbCartridge:1; + u8 detectPullOut:1; + u8 :0; //?? + u16 makerCode; + u32 gameCode; +} CTRDGModuleInfo; + +typedef struct CTRDGLockByProc +{ + BOOL locked; + OSIntrMode irq; +} CTRDGLockByProc; + +typedef struct CTRDGHeader +{ + u32 startAddress; + u8 nintendoLogo[0x9c]; + + u8 titleName[12]; + u32 gameCode; + u16 makerCode; + + u8 isRomCode; + + u8 machineCode; + u8 deviceType; + + u8 exLsiID[3]; + + u8 reserved[4]; + u8 softVersion; + u8 complement; + + u16 moduleID; +} CTRDGHeader; + +typedef struct CTRDGRomCycle +{ + MICartridgeRomCycle1st c1; + MICartridgeRomCycle2nd c2; +} CTRDGRomCycle; + +#define CTRDGi_GetModuleInfoAddr() ((CTRDGModuleInfo *)HW_CTRDG_MODULE_INFO_BUF) +#define CTRDGi_GetHeaderAddr() ((CTRDGHeader *)HW_CTRDG_ROM) +#define CTRDGi_GetModuleIDImageAddr() ((u16 *)(HW_CTRDG_ROM + 0x0001fffe)) + +#define CTRDG_IS_ROM_CODE 0x96 +#define CTRDG_LOCKED_BY_MYPROC_FLAG OS_MAINP_LOCKED_FLAG + +#define CTRDGi_FORWARD_TYPE_DMA 0x00000000 +#define CTRDGi_FORWARD_TYPE_CPU 0x00000001 +#define CTRDGi_FORWARD_TYPE_MASK 0x00000001 + +#define CTRDGi_FORWARD_WIDTH_8 0x00000000 +#define CTRDGi_FORWARD_WIDTH_16 0x00000010 +#define CTRDGi_FORWARD_WIDTH_32 0x00000020 + +#define CTRDGi_FORWARD_DMA16 (CTRDGi_FORWARD_TYPE_DMA | CTRDGi_FORWARD_WIDTH_16) +#define CTRDGi_FORWARD_DMA32 (CTRDGi_FORWARD_TYPE_DMA | CTRDGi_FORWARD_WIDTH_32) +#define CTRDGi_FORWARD_CPU8 (CTRDGi_FORWARD_TYPE_CPU | CTRDGi_FORWARD_WIDTH_8) +#define CTRDGi_FORWARD_CPU16 (CTRDGi_FORWARD_TYPE_CPU | CTRDGi_FORWARD_WIDTH_16) +#define CTRDGi_FORWARD_CPU32 (CTRDGi_FORWARD_TYPE_CPU | CTRDGi_FORWARD_WIDTH_32) + +#define CTRDGi_ACCESS_DIR_WRITE 0x00000000 +#define CTRDGi_ACCESS_DIR_READ 0x00000001 + +#define CTRDGi_ACCESS_WIDTH_8 0x00000010 +#define CTRDGi_ACCESS_WIDTH_16 0x00000020 +#define CTRDGi_ACCESS_WIDTH_32 0x00000040 + +#define CTRDGi_ACCESS_WRITE8 (CTRDGi_ACCESS_DIR_WRITE | CTRDGi_ACCESS_WIDTH_8) +#define CTRDGi_ACCESS_WRITE16 (CTRDGi_ACCESS_DIR_WRITE | CTRDGi_ACCESS_WIDTH_16) +#define CTRDGi_ACCESS_WRITE32 (CTRDGi_ACCESS_DIR_WRITE | CTRDGi_ACCESS_WIDTH_32) +#define CTRDGi_ACCESS_READ8 (CTRDGi_ACCESS_DIR_READ | CTRDGi_ACCESS_WIDTH_8) +#define CTRDGi_ACCESS_READ16 (CTRDGi_ACCESS_DIR_READ | CTRDGi_ACCESS_WIDTH_16) +#define CTRDGi_ACCESS_READ32 (CTRDGi_ACCESS_DIR_READ | CTRDGi_ACCESS_WIDTH_32) + +void CTRDGi_InitCommon(void); +BOOL CTRDG_IsAgbCartridge(void); +BOOL CTRDG_IsOptionCartridge(void); +BOOL CTRDGi_IsAgbCartridgeAtInit(void); +u32 CTRDG_GetAgbGameCode(void); +u32 CTRDGi_GetAgbGameCodeAtInit(void); +u16 CTRDG_GetAgbMakerCode(void); +u16 CTRDGi_GetAgbMakerCodeAtInit(void); +BOOL CTRDG_IsPulledOut(void); +BOOL CTRDG_IsExisting(void); +void CTRDGi_ChangeLatestAccessCycle(CTRDGRomCycle *r); +void CTRDGi_RestoreAccessCycle(CTRDGRomCycle *r); +void CTRDGi_LockByProcessor(u16 lockID, CTRDGLockByProc *info); +void CTRDGi_UnlockByProcessor(u16 lockID, CTRDGLockByProc *info); +void CTRDGi_SendtoPxi(u32 data); +BOOL CTRDG_CpuCopy8(const void *src, void *dest, u32 size); +BOOL CTRDG_CpuCopy16(const void *src, void *dest, u32 size); +BOOL CTRDG_CpuCopy32(const void *src, void *dest, u32 size); +BOOL CTRDGi_CopyCommon(u32 dmaNo, const void *src, void *dest, u32 size, u32 forwardType); +BOOL CTRDG_Read32(const u32 *address, u32 *rdata); +BOOL CTRDGi_AccessCommon(void *address, u32 data, void *rdata, u32 accessType); +BOOL CTRDG_IsEnabled(void); +void CTRDG_Enable(BOOL enable); +void CTRDG_CheckEnabled(void); + +#endif //POKEDIAMOND_CTRDG_COMMON_H diff --git a/arm9/lib/NitroSDK/include/CTRDG_flash.h b/arm9/lib/NitroSDK/include/CTRDG_flash.h new file mode 100644 index 00000000..aa02d951 --- /dev/null +++ b/arm9/lib/NitroSDK/include/CTRDG_flash.h @@ -0,0 +1,27 @@ +#ifndef POKEDIAMOND_CTRDG_FLASH_H +#define POKEDIAMOND_CTRDG_FLASH_H + +#include "nitro/types.h" +#include "MI_exMemory.h" + +#define CTRDG_AGB_FLASH_ADR 0x0A000000 + +typedef struct CTRDGiFlashSectorTag +{ + u32 size; + u16 shift; + u16 count; + u16 top; + u8 reserved[2]; +} CTRDGiFlashSector; + +typedef struct CTRDGFlashTypeTag +{ + u32 romSize; + CTRDGiFlashSector sector; + MICartridgeRamCycle agbWait[2]; + u16 makerID; + u16 deviceID; +} CTRDGFlashType; + +#endif //POKEDIAMOND_CTRDG_FLASH_H diff --git a/arm9/lib/NitroSDK/include/CTRDG_flash_AT29LV512.h b/arm9/lib/NitroSDK/include/CTRDG_flash_AT29LV512.h new file mode 100644 index 00000000..64f3efdb --- /dev/null +++ b/arm9/lib/NitroSDK/include/CTRDG_flash_AT29LV512.h @@ -0,0 +1,23 @@ +#ifndef POKEDIAMOND_CTRDG_FLASH_AT29LV512_H +#define POKEDIAMOND_CTRDG_FLASH_AT29LV512_H + +#include "nitro/types.h" +#include "CTRDG_task.h" + +u32 CTRDGi_EraseFlashChipCoreAT(CTRDGTaskInfo *arg); +u32 CTRDGi_EraseFlashSectorCoreAT(CTRDGTaskInfo *arg); +u32 CTRDGi_EraseFlash4KBCoreAT(CTRDGTaskInfo *arg); +u32 CTRDGi_WriteFlashSectorCoreAT(CTRDGTaskInfo *arg); +u32 CTRDGi_WriteFlash4KBCoreAT(CTRDGTaskInfo *arg); +u16 CTRDGi_EraseFlashChipAT(void); +u16 CTRDGi_EraseFlash4KBAT(u16 l_secNo); +u16 CTRDGi_WriteFlash4KBAT(u16 l_secNo, u8 *src); +void CTRDGi_EraseFlashChipAsyncAT(CTRDG_TASK_FUNC callback); +void CTRDGi_EraseFlash4KBAsyncAT(u16 l_secNo, CTRDG_TASK_FUNC callback); +void CTRDGi_WriteFlash4KBAsyncAT(u16 l_secNo, u8 *src, CTRDG_TASK_FUNC callback); +u16 CTRDGi_EraseFlashSectorAT(u16 p_secNo); +u16 CTRDGi_WriteFlashSectorAT(u16 p_secNo, u8 *src); +void CTRDGi_EraseFlashSectorAsyncAT(u16 p_secNo, CTRDG_TASK_FUNC callback); +void CTRDGi_WriteFlashSectorAsyncAT(u16 p_secNo, u8 *src, CTRDG_TASK_FUNC callback); + +#endif //POKEDIAMOND_CTRDG_FLASH_AT29LV512_H diff --git a/arm9/lib/NitroSDK/include/CTRDG_task.h b/arm9/lib/NitroSDK/include/CTRDG_task.h new file mode 100644 index 00000000..2cf7a233 --- /dev/null +++ b/arm9/lib/NitroSDK/include/CTRDG_task.h @@ -0,0 +1,25 @@ +#ifndef POKEDIAMOND_CTRDG_TASK_H +#define POKEDIAMOND_CTRDG_TASK_H + +#include "nitro/types.h" + +struct CTRDGTaskInfo_tag; + +typedef u32 (*CTRDG_TASK_FUNC) (struct CTRDGTaskInfo_tag *); + +typedef struct CTRDGTaskInfo_tag +{ + CTRDG_TASK_FUNC task; + CTRDG_TASK_FUNC callback; + u32 result; + u8 *data; + u8 *adr; + u32 offset; + u32 size; + u8 *dst; + u16 sec_num; + u8 busy; + u8 param[1]; +} CTRDGTaskInfo; + +#endif //POKEDIAMOND_CTRDG_TASK_H diff --git a/arm9/lib/NitroSDK/include/DGT_common.h b/arm9/lib/NitroSDK/include/DGT_common.h new file mode 100644 index 00000000..c74ae7cd --- /dev/null +++ b/arm9/lib/NitroSDK/include/DGT_common.h @@ -0,0 +1,6 @@ +#ifndef NITRO_DGT_COMMON_H_ +#define NITRO_DGT_COMMON_H_ + +#define DGT_HASH2_DIGEST_SIZE (160/8) + +#endif //NITRO_DGT_COMMON_H_ diff --git a/arm9/lib/NitroSDK/include/DGT_dgt.h b/arm9/lib/NitroSDK/include/DGT_dgt.h new file mode 100644 index 00000000..95c7c4e2 --- /dev/null +++ b/arm9/lib/NitroSDK/include/DGT_dgt.h @@ -0,0 +1,8 @@ +#ifndef NITRO_DGT_DGT_H_ +#define NITRO_DGT_DGT_H_ + +#include "nitro/types.h" + +void DGT_Hash2CalcHmac(void* digest, void* bin_ptr, u32 bin_len, void* key_ptr, u32 keylen); + +#endif //NITRO_DGT_DGT_H_ diff --git a/arm9/lib/NitroSDK/include/FS_archive.h b/arm9/lib/NitroSDK/include/FS_archive.h new file mode 100644 index 00000000..3987341c --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_archive.h @@ -0,0 +1,220 @@ +#ifndef NITRO_FS_ARCHIVE_H_ +#define NITRO_FS_ARCHIVE_H_ + +#include "nitro.h" + +#include "OS_thread.h" + +struct FSFile; +struct FSArchive; + +#define FS_ARCHIVE_NAME_LEN_MAX 3 + +#define FS_ARCHIVE_FLAG_REGISTER 0x00000001 +#define FS_ARCHIVE_FLAG_LOADED 0x00000002 +#define FS_ARCHIVE_FLAG_TABLE_LOAD 0x00000004 +#define FS_ARCHIVE_FLAG_SUSPEND 0x00000008 +#define FS_ARCHIVE_FLAG_RUNNING 0x00000010 +#define FS_ARCHIVE_FLAG_CANCELING 0x00000020 +#define FS_ARCHIVE_FLAG_SUSPENDING 0x00000040 +#define FS_ARCHIVE_FLAG_UNLOADING 0x00000080 +#define FS_ARCHIVE_FLAG_IS_ASYNC 0x00000100 +#define FS_ARCHIVE_FLAG_IS_SYNC 0x00000200 + +typedef enum { + FS_COMMAND_ASYNC_BEGIN = 0, + FS_COMMAND_READFILE = FS_COMMAND_ASYNC_BEGIN, + FS_COMMAND_WRITEFILE, + FS_COMMAND_ASYNC_END, + + FS_COMMAND_SYNC_BEGIN = FS_COMMAND_ASYNC_END, + FS_COMMAND_SEEKDIR = FS_COMMAND_SYNC_BEGIN, + FS_COMMAND_READDIR, + FS_COMMAND_FINDPATH, + FS_COMMAND_GETPATH, + FS_COMMAND_OPENFILEFAST, + FS_COMMAND_OPENFILEDIRECT, + FS_COMMAND_CLOSEFILE, + FS_COMMAND_SYNC_END, + + FS_COMMAND_STATUS_BEGIN = FS_COMMAND_SYNC_END, + FS_COMMAND_ACTIVATE = FS_COMMAND_STATUS_BEGIN, + FS_COMMAND_IDLE, + FS_COMMAND_SUSPEND, + FS_COMMAND_RESUME, + FS_COMMAND_STATUS_END, + + FS_COMMAND_INVALID +} FSCommandType; + +/* Asynchronous commands*/ +#define FS_ARCHIVE_PROC_READFILE (1 << FS_COMMAND_READFILE) +#define FS_ARCHIVE_PROC_WRITEFILE (1 << FS_COMMAND_WRITEFILE) +/* All asynchronous commands*/ +#define FS_ARCHIVE_PROC_ASYNC \ + (FS_ARCHIVE_PROC_READFILE | FS_ARCHIVE_PROC_WRITEFILE) + +/* Synchronous commands*/ +#define FS_ARCHIVE_PROC_SEEKDIR (1 << FS_COMMAND_SEEKDIR) +#define FS_ARCHIVE_PROC_READDIR (1 << FS_COMMAND_READDIR) +#define FS_ARCHIVE_PROC_FINDPATH (1 << FS_COMMAND_FINDPATH) +#define FS_ARCHIVE_PROC_GETPATH (1 << FS_COMMAND_GETPATH) +#define FS_ARCHIVE_PROC_OPENFILEFAST (1 << FS_COMMAND_OPENFILEFAST) +#define FS_ARCHIVE_PROC_OPENFILEDIRECT (1 << FS_COMMAND_OPENFILEDIRECT) +#define FS_ARCHIVE_PROC_CLOSEFILE (1 << FS_COMMAND_CLOSEFILE) +/* All synchronous commands*/ +#define FS_ARCHIVE_PROC_SYNC \ + (FS_ARCHIVE_PROC_SEEKDIR | FS_ARCHIVE_PROC_READDIR | \ + FS_ARCHIVE_PROC_FINDPATH | FS_ARCHIVE_PROC_GETPATH | \ + FS_ARCHIVE_PROC_OPENFILEFAST | FS_ARCHIVE_PROC_OPENFILEDIRECT | FS_ARCHIVE_PROC_CLOSEFILE) + +/* Messages when status changes*/ +#define FS_ARCHIVE_PROC_ACTIVATE (1 << FS_COMMAND_ACTIVATE) +#define FS_ARCHIVE_PROC_IDLE (1 << FS_COMMAND_IDLE) +#define FS_ARCHIVE_PROC_SUSPENDING (1 << FS_COMMAND_SUSPEND) +#define FS_ARCHIVE_PROC_RESUME (1 << FS_COMMAND_RESUME) +/* All messages when status changes*/ +#define FS_ARCHIVE_PROC_STATUS \ + (FS_ARCHIVE_PROC_ACTIVATE | FS_ARCHIVE_PROC_IDLE | \ + FS_ARCHIVE_PROC_SUSPENDING | FS_ARCHIVE_PROC_RESUME) + +#define FS_ARCHIVE_PROC_ALL (~0) + +typedef enum { + FS_RESULT_SUCCESS = 0, + FS_RESULT_FAILURE, + FS_RESULT_BUSY, + FS_RESULT_CANCELED, + FS_RESULT_CANCELLED = FS_RESULT_CANCELED, // SDK alias + FS_RESULT_UNSUPPORTED, + FS_RESULT_ERROR, + FS_RESULT_PROC_ASYNC, + FS_RESULT_PROC_DEFAULT, + FS_RESULT_PROC_UNKNOWN +} +FSResult; + +typedef FSResult (*FS_ARCHIVE_READ_FUNC) (struct FSArchive *p, void *dst, u32 pos, u32 size); +typedef FSResult (*FS_ARCHIVE_WRITE_FUNC) (struct FSArchive *p, const void *src, u32 pos, u32 size); +typedef FSResult (*FS_ARCHIVE_PROC_FUNC) (struct FSFile *, FSCommandType); + +typedef struct +{ + struct FSFile * prev; + struct FSFile * next; +} +FSFileLink; + +typedef struct +{ + u32 start; + u16 index; + u16 parent; +} FSArchiveFNT; + +typedef struct +{ + u32 top; + u32 bottom; +} FSArchiveFAT; + +typedef struct FSArchive +{ + union + { + char ptr[4]; + u32 pack; + } name; + struct FSArchive * next; + struct FSArchive * prev; + OSThreadQueue sync_q; + OSThreadQueue stat_q; + u32 flag; + FSFileLink list; + u32 base; + u32 fat; + u32 fat_size; + u32 fnt; + u32 fnt_size; + u32 fat_bak; + u32 fnt_bak; + void * load_mem; + FS_ARCHIVE_READ_FUNC read_func; + FS_ARCHIVE_WRITE_FUNC write_func; + FS_ARCHIVE_READ_FUNC table_func; + FS_ARCHIVE_PROC_FUNC proc; + u32 proc_flag; +} FSArchive; + +static inline BOOL FS_IsArchiveLoaded(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_LOADED) ? TRUE : FALSE; +} + +static inline u32 FS_GetArchiveOffset(const FSArchive * p_arc, u32 pos) +{ + return p_arc->base + pos; +} + +static inline BOOL FSi_IsArchiveCanceling(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_CANCELING) != 0; +} + +static inline BOOL FS_IsArchiveSuspended(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_SUSPEND) ? TRUE : FALSE; +} + +static inline BOOL FSi_IsArchiveSuspending(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_SUSPENDING) != 0; +} + +static inline BOOL FSi_IsArchiveRunning(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_RUNNING) != 0; +} + +static inline BOOL FSi_IsArchiveUnloading(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_UNLOADING) != 0; +} + +static inline BOOL FSi_IsArchiveAsync(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_IS_ASYNC) != 0; +} + +static inline BOOL FSi_IsArchiveSync(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_IS_SYNC) != 0; +} + +static inline BOOL FS_IsArchiveTableLoaded(volatile const FSArchive * p_arc) +{ + return (p_arc->flag & FS_ARCHIVE_FLAG_TABLE_LOAD) ? TRUE : FALSE; +} + +u32 FSi_GetPackedName(const char * name, int name_len); +FSResult FSi_ReadMemCallback(struct FSArchive * p_arc, void * dest, u32 pos, u32 size); +FSResult FSi_WriteMemCallback(struct FSArchive * p_arc, const void * src, u32 pos, u32 size); +FSResult FSi_ReadMemoryCore(struct FSArchive * p_arc, void * dest, u32 pos, u32 size); +struct FSFile * FSi_NextCommand(struct FSArchive * p_arc); +void FSi_ExecuteAsyncCommand(struct FSFile * p_file); +BOOL FSi_ExecuteSyncCommand(struct FSFile * file); +BOOL FSi_SendCommand(struct FSFile * file, FSCommandType command); +void FS_InitArchive(struct FSArchive * p_arc); +struct FSArchive * const FS_FindArchive(const char * path, int offset); +BOOL FS_RegisterArchiveName(struct FSArchive * p_arc, const char * name, int name_len); +void FS_ReleaseArchiveName(struct FSArchive * p_arc); +BOOL FS_LoadArchive(struct FSArchive * p_arc, u32 base, u32 fat, u32 fat_size, u32 fnt, u32 fnt_size, FS_ARCHIVE_READ_FUNC read_func, FS_ARCHIVE_WRITE_FUNC write_func); +BOOL FS_UnloadArchive(struct FSArchive * p_arc); +u32 FS_LoadArchiveTables(struct FSArchive *p_arc, void *p_mem, u32 max_size); +void * FS_UnloadArchiveTables(struct FSArchive * p_arc); +BOOL FS_SuspendArchive(struct FSArchive * p_arc); +BOOL FS_ResumeArchive(struct FSArchive * p_arc); +void FS_SetArchiveProc(struct FSArchive * p_arc, FS_ARCHIVE_PROC_FUNC proc, u32 flags); +void FS_NotifyArchiveAsyncEnd(struct FSArchive *p_arc, FSResult ret); + +#endif //NITRO_FS_ARCHIVE_H_ diff --git a/arm9/lib/NitroSDK/include/FS_command.h b/arm9/lib/NitroSDK/include/FS_command.h new file mode 100644 index 00000000..b5e73bcf --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_command.h @@ -0,0 +1,11 @@ +#ifndef NITRO_FS_COMMAND_H_ +#define NITRO_FS_COMMAND_H_ + +#include "FS_file.h" + +extern FSResult (*const fsi_default_command[])(FSFile *); + +void FSi_ReleaseCommand(FSFile * file, FSResult signal); +FSResult FSi_TranslateCommand(FSFile * file, FSCommandType command); + +#endif //NITRO_FS_COMMAND_H_ diff --git a/arm9/lib/NitroSDK/include/FS_command_default.h b/arm9/lib/NitroSDK/include/FS_command_default.h new file mode 100644 index 00000000..20e20f8f --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_command_default.h @@ -0,0 +1,27 @@ +#ifndef POKEDIAMOND_FS_COMMAND_DEFAULT_H +#define POKEDIAMOND_FS_COMMAND_DEFAULT_H + +#include "nitro/types.h" +#include "FS_archive.h" + +typedef struct +{ + FSArchive *arc; + u32 pos; +} FSiSyncReadParam; + + +u32 FSi_StrNICmp(const char * str1, const char * str2, u32 len); +FSResult FSi_ReadTable(FSiSyncReadParam * p, void * dst, u32 len); +FSResult FSi_SeekDirDirect(FSFile * p_dir, u32 id); +FSResult FSi_ReadFileCommand(FSFile * p_file); +FSResult FSi_WriteFileCommand(FSFile * p_file); +FSResult FSi_SeekDirCommand(FSFile * p_dir); +FSResult FSi_ReadDirCommand(FSFile *p_dir); +FSResult FSi_FindPathCommand(FSFile *p_dir); +FSResult FSi_GetPathCommand(FSFile *p_file); +FSResult FSi_OpenFileFastCommand(FSFile * p_file); +FSResult FSi_OpenFileDirectCommand(FSFile * p_file); +FSResult FSi_CloseFileCommand(FSFile * p_file); + +#endif //POKEDIAMOND_FS_COMMAND_DEFAULT_H diff --git a/arm9/lib/NitroSDK/include/FS_file.h b/arm9/lib/NitroSDK/include/FS_file.h new file mode 100644 index 00000000..f870ad2a --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_file.h @@ -0,0 +1,226 @@ +#ifndef NITRO_FS_FILE_H_ +#define NITRO_FS_FILE_H_ + +#include "nitro.h" + +#include "FS_archive.h" + +#define FS_FILE_STATUS_BUSY 0x00000001 +#define FS_FILE_STATUS_CANCEL 0x00000002 +#define FS_FILE_STATUS_SYNC 0x00000004 +#define FS_FILE_STATUS_ASYNC 0x00000008 +#define FS_FILE_STATUS_IS_FILE 0x00000010 +#define FS_FILE_STATUS_IS_DIR 0x00000020 +#define FS_FILE_STATUS_OPERATING 0x00000040 + +#define FS_FILE_NAME_MAX 127 + +typedef enum FSSeekFileMode +{ + FS_SEEK_SET = 0, + FS_SEEK_CUR, + FS_SEEK_END +} FSSeekFileMode; + +struct FSFile; + +#define FS_DMA_NOT_USE ((u32)~0) + +typedef struct FSDirPos +{ + struct FSArchive *arc; + u16 own_id; + u16 index; + u32 pos; +} +FSDirPos; // size = 0xC + +typedef struct FSFileID +{ + struct FSArchive *arc; + u32 file_id; +} +FSFileID; + +typedef struct +{ + union + { + FSFileID file_id; + FSDirPos dir_id; + }; + u32 is_directory; + u32 name_len; + char name[128]; +} +FSDirEntry; + + +typedef struct +{ + FSDirPos pos; +} +FSSeekDirInfo; + + +typedef struct +{ + FSDirEntry *p_entry; + BOOL skip_string; +} +FSReadDirInfo; + + +typedef struct +{ + FSDirPos pos; + const char *path; + BOOL find_directory; + union + { + FSFileID *file; + FSDirPos *dir; + } + result; +} +FSFindPathInfo; + + +typedef struct +{ + u8 *buf; + u32 buf_len; + u16 total_len; + u16 dir_id; +} +FSGetPathInfo; + + +typedef struct +{ + FSFileID id; +} +FSOpenFileFastInfo; + + +typedef struct +{ + u32 top; + u32 bottom; + u32 index; +} +FSOpenFileDirectInfo; + + +typedef struct +{ + u32 reserved; +} +FSCloseFileInfo; + + +typedef struct +{ + void *dst; + u32 len_org; + u32 len; +} +FSReadFileInfo; + + +typedef struct +{ + const void *src; + u32 len_org; + u32 len; +} +FSWriteFileInfo; + +typedef struct FSFile +{ + FSFileLink link; // 0x00 + struct FSArchive *arc; // 0x08 + u32 stat; // 0xC + FSCommandType command; // 0x10 + FSResult error; // 0x14 + OSThreadQueue queue[1]; // 0x18 + union { + struct + { + u32 own_id; // 0x20 + u32 top; // 0x24 + u32 bottom; // 0x28 + u32 pos; // 0x2C + } file; + struct + { + FSDirPos pos; // 0x20 + u32 parent; // 0x2C + } dir; + } prop; // 0x20 + + union { + FSReadFileInfo readfile; // 0x30 + FSWriteFileInfo writefile; // 0x30 + + FSSeekDirInfo seekdir; // 0x30 + FSReadDirInfo readdir; // 0x30 + FSFindPathInfo findpath; // 0x30 + FSGetPathInfo getpath; // 0x30 + FSOpenFileFastInfo openfilefast; // 0x30 + FSOpenFileDirectInfo openfiledirect; // 0x30 + FSCloseFileInfo closefile; // 0x30 + } arg; // 0x30 +} +FSFile; // size = 0x50 + +void FS_Init(u32 default_dma_no); +BOOL FS_IsAvailable(void); +void FS_InitFile(FSFile * p_file); +int FSi_ReadFileCore(FSFile * p_file, void * dst, s32 len, BOOL async); +BOOL FS_ConvertPathToFileID(FSFileID * p_file_id, const char * path); +BOOL FS_OpenFileDirect(FSFile * p_file, FSArchive * p_arc, u32 image_top, u32 image_bottom, u32 file_index); +BOOL FS_OpenFileFast(FSFile * p_file, FSFileID file_id); +BOOL FS_OpenFile(FSFile * p_file, const char * path); +BOOL FS_CloseFile(FSFile * p_file); +BOOL FS_WaitAsync(FSFile * p_file); +int FS_ReadFileAsync(FSFile * p_file, void * dst, s32 len); +int FS_ReadFile(FSFile * p_file, void * dst, s32 len); +BOOL FS_SeekFile(FSFile * p_file, s32 offset, FSSeekFileMode origin); +BOOL FS_ChangeDir(const char * path); + +static inline u32 const FS_GetFileImageTop(volatile const FSFile * p_file) { + return p_file->prop.file.top; +} + +static inline u32 const FS_GetLength(volatile const FSFile * p_file) +{ + return p_file->prop.file.bottom - p_file->prop.file.top; +} + +static inline BOOL FS_IsCanceling(volatile const FSFile * p_file) +{ + return (p_file->stat & FS_FILE_STATUS_CANCEL) ? TRUE : FALSE; +} + +static inline BOOL FS_IsFileSyncMode(volatile const FSFile * p_file) +{ + return (p_file->stat & FS_FILE_STATUS_SYNC) ? TRUE : FALSE; +} + +static inline BOOL FS_IsBusy(volatile const FSFile * p_file) +{ + return p_file->stat & FS_FILE_STATUS_BUSY ? TRUE : FALSE; +} + +static inline BOOL FS_IsSucceeded(volatile const FSFile * p_file) +{ + return (p_file->error == FS_RESULT_SUCCESS) ? TRUE : FALSE; +} + +static inline BOOL FS_IsDir(volatile const FSFile * p_file) +{ + return (p_file->stat & FS_FILE_STATUS_IS_DIR) ? TRUE : FALSE; +} + +#endif //NITRO_FS_FILE_H_ diff --git a/arm9/lib/NitroSDK/include/FS_mw_dtor.h b/arm9/lib/NitroSDK/include/FS_mw_dtor.h new file mode 100644 index 00000000..a746ed19 --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_mw_dtor.h @@ -0,0 +1,16 @@ +#ifndef NITRO_FS_MW_DTOR_H_ +#define NITRO_FS_MW_DTOR_H_ + +typedef void (*MWI_DESTRUCTOR_FUNC) (void *); + +typedef struct MWiDestructorChain +{ + struct MWiDestructorChain *next; + MWI_DESTRUCTOR_FUNC dtor; + void *obj; +} +MWiDestructorChain; + +extern MWiDestructorChain *__global_destructor_chain; + +#endif //NITRO_FS_MW_DTOR_H_ diff --git a/arm9/lib/NitroSDK/include/FS_overlay.h b/arm9/lib/NitroSDK/include/FS_overlay.h new file mode 100644 index 00000000..7853e4ae --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_overlay.h @@ -0,0 +1,73 @@ +#ifndef NITRO_FS_OVERLAY_H_ +#define NITRO_FS_OVERLAY_H_ + +#if defined(__cplusplus) +extern "C" { +#endif + +#include "nitro.h" +#include "MI_exMemory.h" +#include "FS_file.h" +#include "CARD_rom.h" + +typedef u32 FSOverlayID; + +#define FS_EXTERN_OVERLAY(name) extern u32 SDK_OVERLAY_ ## name ## _ID[1] +#define FS_OVERLAY_ID(name) ((u32)&(SDK_OVERLAY_ ## name ## _ID)) + +typedef void (*FSOverlayInitFunc)(void); + +typedef struct FSOverlayInfoHeader +{ + u32 id; + u8 *ram_address; + u32 ram_size; + u32 bss_size; + FSOverlayInitFunc *sinit_init; + FSOverlayInitFunc *sinit_init_end; + u32 file_id; + u32 compressed: 24; + u32 flag: 8; +} FSOverlayInfoHeader; + +typedef struct FSOverlayInfo +{ + FSOverlayInfoHeader header; + MIProcessor target; + CARDRomRegion file_pos; +} FSOverlayInfo; + +static inline u8 *const FS_GetOverlayAddress(FSOverlayInfo *p_ovi) +{ + return p_ovi->header.ram_address; +} + +static inline u32 const FS_GetOverlayImageSize(FSOverlayInfo *p_ovi) +{ + return p_ovi->header.ram_size; +} + +static inline u32 const FS_GetOverlayTotalSize(FSOverlayInfo *p_ovi) +{ + return p_ovi->header.ram_size + p_ovi->header.bss_size; +} + +u32 FSi_GetOverlayBinarySize(FSOverlayInfo * p_ovi); +void FS_ClearOverlayImage(FSOverlayInfo * p_ovi); +FSFileID FS_GetOverlayFileID(FSOverlayInfo * p_ovi); +BOOL FSi_LoadOverlayInfoCore(FSOverlayInfo * p_ovi, MIProcessor target, FSOverlayID id, FSArchive * arc, u32 offset_arm9, u32 len_arm9, u32 offset_arm7, u32 len_arm7); +BOOL FS_LoadOverlayInfo(FSOverlayInfo *p_ovi, MIProcessor target, FSOverlayID id); +BOOL FS_LoadOverlayImageAsync(FSOverlayInfo *p_ovi, FSFile *p_file); +BOOL FS_LoadOverlayImage(FSOverlayInfo *p_ovi); +BOOL FSi_CompareDigest(const u8 *spec_digest, void *src, u32 len); +void FS_StartOverlay(FSOverlayInfo *p_ovi); +void FS_EndOverlay(FSOverlayInfo *p_ovi); +BOOL FS_UnloadOverlayImage(FSOverlayInfo * p_ovi); +BOOL FS_LoadOverlay(MIProcessor target, FSOverlayID id); +BOOL FS_UnloadOverlay(MIProcessor target, FSOverlayID id); + +#if defined(__cplusplus) +} +#endif + +#endif //NITRO_FS_OVERLAY_H_ diff --git a/arm9/lib/NitroSDK/include/FS_rom.h b/arm9/lib/NitroSDK/include/FS_rom.h new file mode 100644 index 00000000..bd0cd73b --- /dev/null +++ b/arm9/lib/NitroSDK/include/FS_rom.h @@ -0,0 +1,24 @@ +#ifndef NITRO_FS_ROM_H_ +#define NITRO_FS_ROM_H_ + +#include "FS_archive.h" +#include "FS_file.h" +#include "CARD_rom.h" +#include "nitro/types.h" + +extern FSArchive fsi_arc_rom; +extern s32 fsi_card_lock_id; +extern CARDRomRegion fsi_ovt7; +extern CARDRomRegion fsi_ovt9; + +void FSi_OnRomReadDone(void * p_arc); +FSResult FSi_ReadRomCallback(FSArchive * p_arc, void * dst, u32 src, u32 len); +FSResult FSi_WriteDummyCallback(FSArchive * p_arc, const void *src, u32 dst, u32 len); +FSResult FSi_RomArchiveProc(FSFile * p_arc, FSCommandType cmd); +FSResult FSi_ReadDummyCallback(FSArchive *p_arc, void *dst, u32 src, u32 len); +FSResult FSi_EmptyArchiveProc(FSFile *p_file, FSCommandType cmd); +void FSi_InitRom(u32 default_dma_no); +u32 FS_SetDefaultDMA(u32 dma_no); +u32 FS_TryLoadTable(void * p_mem, u32 size); + +#endif //NITRO_FS_ROM_H_ diff --git a/arm9/lib/NitroSDK/include/FSi_util.h b/arm9/lib/NitroSDK/include/FSi_util.h new file mode 100644 index 00000000..2357b446 --- /dev/null +++ b/arm9/lib/NitroSDK/include/FSi_util.h @@ -0,0 +1,46 @@ +#ifndef NITRO_FSI_UTIL_H_ +#define NITRO_FSI_UTIL_H_ + +#include "CARD_common.h" + +#define ALIGN_BYTE(n, a) (((u32)(n) + ALIGN_MASK(a)) & ~ALIGN_MASK(a)) + +#define BIT_MASK(a) ((u32)((1 << (a)) - 1)) + +static inline BOOL FSi_IsSlash(u32 c) +{ + return (c == '/') || (c == '\\'); +} + +static inline void FSi_CutFromListCore(FSFileLink *trg) +{ + FSFile *const pr = trg->prev; + FSFile *const nx = trg->next; + if (pr) + pr->link.next = nx; + if (nx) + nx->link.prev = pr; +} + +static inline void FSi_CutFromList(FSFile *elem) +{ + FSFileLink *const trg = &elem->link; + FSi_CutFromListCore(trg); + trg->next = trg->prev = NULL; +} + +static inline void FSi_AppendToList(FSFile *elem, FSFile *list) +{ + FSFileLink *const trg = &elem->link; + FSi_CutFromListCore(trg); + { + while (list->link.next) + list = list->link.next; + list->link.next = elem; + trg->prev = list; + trg->next = NULL; + } +} + + +#endif //NITRO_FSI_UTIL_H_ diff --git a/arm9/lib/NitroSDK/include/GX_asm.h b/arm9/lib/NitroSDK/include/GX_asm.h new file mode 100644 index 00000000..d2622508 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_asm.h @@ -0,0 +1,6 @@ +#ifndef GUARD_GX_ASM_H +#define GUARD_GX_ASM_H + +void GX_SendFifo48B(register void *pSrc, register void *pDest); + +#endif //GUARD_GX_ASM_H diff --git a/arm9/lib/NitroSDK/include/GX_bgcnt.h b/arm9/lib/NitroSDK/include/GX_bgcnt.h new file mode 100644 index 00000000..b64d4432 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_bgcnt.h @@ -0,0 +1,761 @@ +#ifndef GUARD_GX_BGCNT_H +#define GUARD_GX_BGCNT_H + +void *G2_GetBG0ScrPtr(); +void *G2S_GetBG0ScrPtr(); +void *G2_GetBG1ScrPtr(); +void *G2S_GetBG1ScrPtr(); +void *G2_GetBG2ScrPtr(); +void *G2S_GetBG2ScrPtr(); +void *G2_GetBG3ScrPtr(); +void *G2S_GetBG3ScrPtr(); +void *G2_GetBG0CharPtr(); +void *G2S_GetBG0CharPtr(); +void *G2_GetBG1CharPtr(); +void *G2S_GetBG1CharPtr(); +void *G2_GetBG2CharPtr(); +void *G2S_GetBG2CharPtr(); +void *G2_GetBG3CharPtr(); +void *G2S_GetBG3CharPtr(); + +typedef union +{ + u16 raw; + struct + { + u16 priority:2; + u16 charBase:4; + u16 mosaic:1; + u16 colorMode:1; + u16 screenBase:5; + u16 bgExtPltt:1; + u16 screenSize:2; + }; +} +GXBg01Control; + +typedef union +{ + u16 raw; + struct + { + u16 priority:2; + u16 charBase:4; + u16 mosaic:1; + u16 colorMode:1; + u16 screenBase:5; + u16 _reserve:1; + u16 screenSize:2; + }; +} +GXBg23ControlText; + +typedef union +{ + u16 raw; + struct + { + u16 priority:2; + u16 charBase:4; + u16 mosaic:1; + u16 _reserve:1; + u16 screenBase:5; + u16 areaOver:1; + u16 screenSize:2; + }; +} +GXBg23ControlAffine; + +typedef union +{ + u16 raw; + struct + { + u16 priority:2; + u16 _reserve1:1; + u16 charBase:3; + u16 mosaic:1; + u16 _reserve2:1; + u16 screenBase:5; + u16 areaOver:1; + u16 screenSize:2; + }; +} +GXBg23Control256x16Pltt; + + +typedef union +{ + u16 raw; + struct + { + u16 priority:2; + u16 _reserve1:4; + u16 mosaic:1; + u16 _reserve2:1; + u16 screenBase:5; + u16 areaOver:1; + u16 screenSize:2; + }; +} +GXBg23Control256Bmp, GXBg23ControlDCBmp; + +typedef union +{ + u16 raw; + struct + { + u16 priority:2; + u16 _reserve1:4; + u16 mosaic:1; + u16 _reserve2:6; + u16 areaOver:1; + u16 screenSize:2; + }; +} +GXBg2ControlLargeBmp; + + + +typedef enum +{ + GX_BG_SCRSIZE_TEXT_256x256 = 0, + GX_BG_SCRSIZE_TEXT_512x256 = 1, + GX_BG_SCRSIZE_TEXT_256x512 = 2, + GX_BG_SCRSIZE_TEXT_512x512 = 3 +} +GXBGScrSizeText; + +typedef enum +{ + GX_BG_SCRSIZE_AFFINE_128x128 = 0, + GX_BG_SCRSIZE_AFFINE_256x256 = 1, + GX_BG_SCRSIZE_AFFINE_512x512 = 2, + GX_BG_SCRSIZE_AFFINE_1024x1024 = 3 +} +GXBGScrSizeAffine; + +typedef enum +{ + GX_BG_SCRSIZE_256x16PLTT_128x128 = 0, + GX_BG_SCRSIZE_256x16PLTT_256x256 = 1, + GX_BG_SCRSIZE_256x16PLTT_512x512 = 2, + GX_BG_SCRSIZE_256x16PLTT_1024x1024 = 3 +} +GXBGScrSize256x16Pltt; + +typedef enum +{ + GX_BG_SCRSIZE_256BMP_128x128 = 0, + GX_BG_SCRSIZE_256BMP_256x256 = 1, + GX_BG_SCRSIZE_256BMP_512x256 = 2, + GX_BG_SCRSIZE_256BMP_512x512 = 3 +} +GXBGScrSize256Bmp; + +typedef enum +{ + GX_BG_SCRSIZE_DCBMP_128x128 = 0, + GX_BG_SCRSIZE_DCBMP_256x256 = 1, + GX_BG_SCRSIZE_DCBMP_512x256 = 2, + GX_BG_SCRSIZE_DCBMP_512x512 = 3 +} +GXBGScrSizeDcBmp; + +typedef enum +{ + GX_BG_SCRSIZE_LARGEBMP_512x1024 = 0, + GX_BG_SCRSIZE_LARGEBMP_1024x512 = 1 +} +GXBGScrSizeLargeBmp; + +typedef enum +{ + GX_BG_COLORMODE_16 = 0, + GX_BG_COLORMODE_256 = 1 +} +GXBGColorMode; + +typedef enum +{ + GX_BG_AREAOVER_XLU = 0, + GX_BG_AREAOVER_REPEAT = 1 +} +GXBGAreaOver; + +typedef enum +{ + GX_BG_CHARBASE_0x00000 = 0, + GX_BG_CHARBASE_0x04000 = 1, + GX_BG_CHARBASE_0x08000 = 2, + GX_BG_CHARBASE_0x0c000 = 3, + GX_BG_CHARBASE_0x10000 = 4, + GX_BG_CHARBASE_0x14000 = 5, + GX_BG_CHARBASE_0x18000 = 6, + GX_BG_CHARBASE_0x1c000 = 7, + GX_BG_CHARBASE_0x20000 = 8, + GX_BG_CHARBASE_0x24000 = 9, + GX_BG_CHARBASE_0x28000 = 10, + GX_BG_CHARBASE_0x2c000 = 11, + GX_BG_CHARBASE_0x30000 = 12, + GX_BG_CHARBASE_0x34000 = 13, + GX_BG_CHARBASE_0x38000 = 14, + GX_BG_CHARBASE_0x3c000 = 15 +} +GXBGCharBase; + +typedef enum +{ + GX_BG_SCRBASE_0x0000 = 0, + GX_BG_SCRBASE_0x0800 = 1, + GX_BG_SCRBASE_0x1000 = 2, + GX_BG_SCRBASE_0x1800 = 3, + GX_BG_SCRBASE_0x2000 = 4, + GX_BG_SCRBASE_0x2800 = 5, + GX_BG_SCRBASE_0x3000 = 6, + GX_BG_SCRBASE_0x3800 = 7, + GX_BG_SCRBASE_0x4000 = 8, + GX_BG_SCRBASE_0x4800 = 9, + GX_BG_SCRBASE_0x5000 = 10, + GX_BG_SCRBASE_0x5800 = 11, + GX_BG_SCRBASE_0x6000 = 12, + GX_BG_SCRBASE_0x6800 = 13, + GX_BG_SCRBASE_0x7000 = 14, + GX_BG_SCRBASE_0x7800 = 15, + GX_BG_SCRBASE_0x8000 = 16, + GX_BG_SCRBASE_0x8800 = 17, + GX_BG_SCRBASE_0x9000 = 18, + GX_BG_SCRBASE_0x9800 = 19, + GX_BG_SCRBASE_0xa000 = 20, + GX_BG_SCRBASE_0xa800 = 21, + GX_BG_SCRBASE_0xb000 = 22, + GX_BG_SCRBASE_0xb800 = 23, + GX_BG_SCRBASE_0xc000 = 24, + GX_BG_SCRBASE_0xc800 = 25, + GX_BG_SCRBASE_0xd000 = 26, + GX_BG_SCRBASE_0xd800 = 27, + GX_BG_SCRBASE_0xe000 = 28, + GX_BG_SCRBASE_0xe800 = 29, + GX_BG_SCRBASE_0xf000 = 30, + GX_BG_SCRBASE_0xf800 = 31 +} +GXBGScrBase; + +typedef enum +{ + GX_BG_BMPSCRBASE_0x00000 = 0, + GX_BG_BMPSCRBASE_0x04000 = 1, + GX_BG_BMPSCRBASE_0x08000 = 2, + GX_BG_BMPSCRBASE_0x0c000 = 3, + GX_BG_BMPSCRBASE_0x10000 = 4, + GX_BG_BMPSCRBASE_0x14000 = 5, + GX_BG_BMPSCRBASE_0x18000 = 6, + GX_BG_BMPSCRBASE_0x1c000 = 7, + GX_BG_BMPSCRBASE_0x20000 = 8, + GX_BG_BMPSCRBASE_0x24000 = 9, + GX_BG_BMPSCRBASE_0x28000 = 10, + GX_BG_BMPSCRBASE_0x2c000 = 11, + GX_BG_BMPSCRBASE_0x30000 = 12, + GX_BG_BMPSCRBASE_0x34000 = 13, + GX_BG_BMPSCRBASE_0x38000 = 14, + GX_BG_BMPSCRBASE_0x3c000 = 15, + GX_BG_BMPSCRBASE_0x40000 = 16, + GX_BG_BMPSCRBASE_0x44000 = 17, + GX_BG_BMPSCRBASE_0x48000 = 18, + GX_BG_BMPSCRBASE_0x4c000 = 19, + GX_BG_BMPSCRBASE_0x50000 = 20, + GX_BG_BMPSCRBASE_0x54000 = 21, + GX_BG_BMPSCRBASE_0x58000 = 22, + GX_BG_BMPSCRBASE_0x5c000 = 23, + GX_BG_BMPSCRBASE_0x60000 = 24, + GX_BG_BMPSCRBASE_0x64000 = 25, + GX_BG_BMPSCRBASE_0x68000 = 26, + GX_BG_BMPSCRBASE_0x6c000 = 27, + GX_BG_BMPSCRBASE_0x70000 = 28, + GX_BG_BMPSCRBASE_0x74000 = 29, + GX_BG_BMPSCRBASE_0x78000 = 30, + GX_BG_BMPSCRBASE_0x7c000 = 31 +} +GXBGBmpScrBase; + +typedef enum +{ + GX_BG_EXTPLTT_01 = 0, + GX_BG_EXTPLTT_23 = 1 +} +GXBGExtPltt; + +typedef enum +{ + GX_BG_EXTMODE_256x16PLTT = (0 << REG_G2_BG2CNT_CHARBASE_SHIFT) | (0 << REG_G2_BG2CNT_COLORMODE_SHIFT), + GX_BG_EXTMODE_256BITMAP = (0 << REG_G2_BG2CNT_CHARBASE_SHIFT) | (1 << REG_G2_BG2CNT_COLORMODE_SHIFT), + GX_BG_EXTMODE_DCBITMAP = (1 << REG_G2_BG2CNT_CHARBASE_SHIFT) | (1 << REG_G2_BG2CNT_COLORMODE_SHIFT) +} +GXBGExtMode; + +//GX_capture +typedef enum +{ + GX_CAPTURE_DEST_VRAM_A_0x00000 = 0, + GX_CAPTURE_DEST_VRAM_B_0x00000 = 1, + GX_CAPTURE_DEST_VRAM_C_0x00000 = 2, + GX_CAPTURE_DEST_VRAM_D_0x00000 = 3, + + GX_CAPTURE_DEST_VRAM_A_0x08000 = 4, + GX_CAPTURE_DEST_VRAM_B_0x08000 = 5, + GX_CAPTURE_DEST_VRAM_C_0x08000 = 6, + GX_CAPTURE_DEST_VRAM_D_0x08000 = 7, + + GX_CAPTURE_DEST_VRAM_A_0x10000 = 8, + GX_CAPTURE_DEST_VRAM_B_0x10000 = 9, + GX_CAPTURE_DEST_VRAM_C_0x10000 = 10, + GX_CAPTURE_DEST_VRAM_D_0x10000 = 11, + + GX_CAPTURE_DEST_VRAM_A_0x18000 = 12, + GX_CAPTURE_DEST_VRAM_B_0x18000 = 13, + GX_CAPTURE_DEST_VRAM_C_0x18000 = 14, + GX_CAPTURE_DEST_VRAM_D_0x18000 = 15 +} +GXCaptureDest; + +typedef enum +{ + GX_CAPTURE_SIZE_128x128 = 0, + GX_CAPTURE_SIZE_256x64 = 1, + GX_CAPTURE_SIZE_256x128 = 2, + GX_CAPTURE_SIZE_256x192 = 3 +} +GXCaptureSize; + +typedef enum +{ + GX_CAPTURE_SRCA_2D3D = 0, + GX_CAPTURE_SRCA_3D = 1 +} +GXCaptureSrcA; + +typedef enum +{ + GX_CAPTURE_SRCB_VRAM_0x00000 = 0, + GX_CAPTURE_SRCB_MRAM = 1, + GX_CAPTURE_SRCB_VRAM_0x08000 = 2, + GX_CAPTURE_SRCB_VRAM_0x10000 = 4, + GX_CAPTURE_SRCB_VRAM_0x18000 = 6 +} +GXCaptureSrcB; + +typedef enum +{ + GX_CAPTURE_MODE_A = 0, + GX_CAPTURE_MODE_B = 1, + GX_CAPTURE_MODE_AB = 2 +} +GXCaptureMode; + +static inline void G2_SetBG0Control(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt) +{ + reg_G2_BG0CNT = (u16)((reg_G2_BG0CNT & (REG_G2_BG0CNT_PRIORITY_MASK | REG_G2_BG0CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG0CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2_BG0CNT_COLORMODE_SHIFT) | (screenBase << REG_G2_BG0CNT_SCREENBASE_SHIFT) | (charBase << REG_G2_BG0CNT_CHARBASE_SHIFT) | (bgExtPltt << REG_G2_BG0CNT_BGPLTTSLOT_SHIFT)); +} + +static inline void G2S_SetBG0Control(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt) +{ + reg_G2S_DB_BG0CNT = (u16)((reg_G2S_DB_BG0CNT & (REG_G2S_DB_BG0CNT_PRIORITY_MASK | REG_G2S_DB_BG0CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG0CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2S_DB_BG0CNT_COLORMODE_SHIFT) | (screenBase << REG_G2S_DB_BG0CNT_SCREENBASE_SHIFT) | (charBase << REG_G2S_DB_BG0CNT_CHARBASE_SHIFT) | (bgExtPltt << REG_G2S_DB_BG0CNT_BGPLTTSLOT_SHIFT)); +} + +static inline void G2_SetBG1Control(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt) +{ + reg_G2_BG1CNT = (u16)((reg_G2_BG1CNT & (REG_G2_BG1CNT_PRIORITY_MASK | REG_G2_BG1CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG1CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2_BG1CNT_COLORMODE_SHIFT) | (screenBase << REG_G2_BG1CNT_SCREENBASE_SHIFT) | (charBase << REG_G2_BG1CNT_CHARBASE_SHIFT) | (bgExtPltt << REG_G2_BG1CNT_BGPLTTSLOT_SHIFT)); +} + +static inline void G2S_SetBG1Control(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase, GXBGExtPltt bgExtPltt) +{ + reg_G2S_DB_BG1CNT = (u16)((reg_G2S_DB_BG1CNT & (REG_G2S_DB_BG1CNT_PRIORITY_MASK | REG_G2S_DB_BG1CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG1CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2S_DB_BG1CNT_COLORMODE_SHIFT) | (screenBase << REG_G2S_DB_BG1CNT_SCREENBASE_SHIFT) | (charBase << REG_G2S_DB_BG1CNT_CHARBASE_SHIFT) | (bgExtPltt << REG_G2S_DB_BG1CNT_BGPLTTSLOT_SHIFT)); +} + +static inline void G2_SetBG2ControlText(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & ((REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK))) | (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2_BG2CNT_COLORMODE_SHIFT) | (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (charBase << REG_G2_BG2CNT_CHARBASE_SHIFT)); +} + +static inline void G2S_SetBG2ControlText(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & ((REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK))) | (screenSize << REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2S_DB_BG2CNT_COLORMODE_SHIFT) | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (charBase << REG_G2S_DB_BG2CNT_CHARBASE_SHIFT)); +} + +static inline void G2_SetBG2ControlAffine(GXBGScrSizeAffine screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & ((REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK))) | (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (charBase << REG_G2_BG2CNT_CHARBASE_SHIFT) | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG2ControlAffine(GXBGScrSizeAffine screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & ((REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK))) | (screenSize << REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT) | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (charBase << REG_G2S_DB_BG2CNT_CHARBASE_SHIFT) | (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG2Control256x16Pltt(GXBGScrSize256x16Pltt screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (charBase << REG_G2_BG2CNT_CHARBASE_SHIFT) | GX_BG_EXTMODE_256x16PLTT | (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG2Control256x16Pltt(GXBGScrSize256x16Pltt screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT) | (charBase << REG_G2S_DB_BG2CNT_CHARBASE_SHIFT) | GX_BG_EXTMODE_256x16PLTT | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_256BITMAP | (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG2Control256Bmp(GXBGScrSize256Bmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_256BITMAP | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_DCBITMAP | (screenBase << REG_G2_BG2CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG2ControlDCBmp(GXBGScrSizeDcBmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_DCBITMAP | (screenBase << REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG2ControlLargeBmp(GXBGScrSizeLargeBmp screenSize, GXBGAreaOver areaOver) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & (REG_G2_BG2CNT_PRIORITY_MASK | REG_G2_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG2CNT_SCREENSIZE_SHIFT) | (areaOver << REG_G2_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG2ControlLargeBmp(GXBGScrSizeLargeBmp screenSize, GXBGAreaOver areaOver) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & (REG_G2S_DB_BG2CNT_PRIORITY_MASK | REG_G2S_DB_BG2CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT) | (areaOver << REG_G2S_DB_BG2CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG3ControlText(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & ((REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK))) | (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2_BG3CNT_COLORMODE_SHIFT) | (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (charBase << REG_G2_BG3CNT_CHARBASE_SHIFT)); +} + +static inline void G2S_SetBG3ControlText(GXBGScrSizeText screenSize, GXBGColorMode colorMode, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & ((REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK))) | (screenSize << REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT) | (colorMode << REG_G2S_DB_BG3CNT_COLORMODE_SHIFT) | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (charBase << REG_G2S_DB_BG3CNT_CHARBASE_SHIFT)); +} + +static inline void G2_SetBG3ControlAffine(GXBGScrSizeAffine screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & ((REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK))) | (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (charBase << REG_G2_BG3CNT_CHARBASE_SHIFT) | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG3ControlAffine(GXBGScrSizeAffine screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & ((REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK))) | (screenSize << REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT) | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (charBase << REG_G2S_DB_BG3CNT_CHARBASE_SHIFT) | (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG3Control256x16Pltt(GXBGScrSize256x16Pltt screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (charBase << REG_G2_BG3CNT_CHARBASE_SHIFT) | GX_BG_EXTMODE_256x16PLTT | (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG3Control256x16Pltt(GXBGScrSize256x16Pltt screenSize, GXBGAreaOver areaOver, GXBGScrBase screenBase, GXBGCharBase charBase) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT) | (charBase << REG_G2S_DB_BG3CNT_CHARBASE_SHIFT) | GX_BG_EXTMODE_256x16PLTT | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_256BITMAP | (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG3Control256Bmp(GXBGScrSize256Bmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_256BITMAP | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_DCBITMAP | (screenBase << REG_G2_BG3CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG3ControlDCBmp(GXBGScrSizeDcBmp screenSize, GXBGAreaOver areaOver, GXBGBmpScrBase screenBase) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT) | GX_BG_EXTMODE_DCBITMAP | (screenBase << REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT) | (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2_SetBG3ControlLargeBmp(GXBGScrSizeLargeBmp screenSize, GXBGAreaOver areaOver) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & (REG_G2_BG3CNT_PRIORITY_MASK | REG_G2_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2_BG3CNT_SCREENSIZE_SHIFT) | (areaOver << REG_G2_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2S_SetBG3ControlLargeBmp(GXBGScrSizeLargeBmp screenSize, GXBGAreaOver areaOver) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & (REG_G2S_DB_BG3CNT_PRIORITY_MASK | REG_G2S_DB_BG3CNT_MOSAIC_MASK)) | (screenSize << REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT) | (areaOver << REG_G2S_DB_BG3CNT_AREAOVER_SHIFT)); +} + +static inline void G2_BG0Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2_BG0CNT |= REG_G2_BG0CNT_MOSAIC_MASK; + } + else + { + reg_G2_BG0CNT &= ~REG_G2_BG0CNT_MOSAIC_MASK; + } +} + +static inline void G2S_BG0Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2S_DB_BG0CNT |= REG_G2S_DB_BG0CNT_MOSAIC_MASK; + } + else + { + reg_G2S_DB_BG0CNT &= ~REG_G2S_DB_BG0CNT_MOSAIC_MASK; + } +} + +static inline void G2_BG1Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2_BG1CNT |= REG_G2_BG1CNT_MOSAIC_MASK; + } + else + { + reg_G2_BG1CNT &= ~REG_G2_BG1CNT_MOSAIC_MASK; + } +} + +static inline void G2S_BG1Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2S_DB_BG1CNT |= REG_G2S_DB_BG1CNT_MOSAIC_MASK; + } + else + { + reg_G2S_DB_BG1CNT &= ~REG_G2S_DB_BG1CNT_MOSAIC_MASK; + } +} + +static inline void G2_BG2Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2_BG2CNT |= REG_G2_BG2CNT_MOSAIC_MASK; + } + else + { + reg_G2_BG2CNT &= ~REG_G2_BG2CNT_MOSAIC_MASK; + } +} + +static inline void G2S_BG2Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2S_DB_BG2CNT |= REG_G2S_DB_BG2CNT_MOSAIC_MASK; + } + else + { + reg_G2S_DB_BG2CNT &= ~REG_G2S_DB_BG2CNT_MOSAIC_MASK; + } +} + +static inline void G2_BG3Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2_BG3CNT |= REG_G2_BG3CNT_MOSAIC_MASK; + } + else + { + reg_G2_BG3CNT &= ~REG_G2_BG3CNT_MOSAIC_MASK; + } +} + +static inline void G2S_BG3Mosaic(BOOL enable) +{ + if (enable) + { + reg_G2S_DB_BG3CNT |= REG_G2S_DB_BG3CNT_MOSAIC_MASK; + } + else + { + reg_G2S_DB_BG3CNT &= ~REG_G2S_DB_BG3CNT_MOSAIC_MASK; + } +} + +static inline void G2_SetBG0Priority(int priority) +{ + reg_G2_BG0CNT = (u16)((reg_G2_BG0CNT & ~REG_G2_BG0CNT_PRIORITY_MASK) | (priority << REG_G2_BG0CNT_PRIORITY_SHIFT)); +} + +static inline void G2S_SetBG0Priority(int priority) +{ + reg_G2S_DB_BG0CNT = (u16)((reg_G2S_DB_BG0CNT & ~REG_G2S_DB_BG0CNT_PRIORITY_MASK) | (priority << REG_G2S_DB_BG0CNT_PRIORITY_SHIFT)); +} + +static inline void G2_SetBG1Priority(int priority) +{ + reg_G2_BG1CNT = (u16)((reg_G2_BG1CNT & ~REG_G2_BG1CNT_PRIORITY_MASK) | (priority << REG_G2_BG1CNT_PRIORITY_SHIFT)); +} + +static inline void G2S_SetBG1Priority(int priority) +{ + reg_G2S_DB_BG1CNT = (u16)((reg_G2S_DB_BG1CNT & ~REG_G2S_DB_BG1CNT_PRIORITY_MASK) | (priority << REG_G2S_DB_BG1CNT_PRIORITY_SHIFT)); +} + +static inline void G2_SetBG2Priority(int priority) +{ + reg_G2_BG2CNT = (u16)((reg_G2_BG2CNT & ~REG_G2_BG2CNT_PRIORITY_MASK) | (priority << REG_G2_BG2CNT_PRIORITY_SHIFT)); +} + +static inline void G2S_SetBG2Priority(int priority) +{ + reg_G2S_DB_BG2CNT = (u16)((reg_G2S_DB_BG2CNT & ~REG_G2S_DB_BG2CNT_PRIORITY_MASK) | (priority << REG_G2S_DB_BG2CNT_PRIORITY_SHIFT)); +} + +static inline void G2_SetBG3Priority(int priority) +{ + reg_G2_BG3CNT = (u16)((reg_G2_BG3CNT & ~REG_G2_BG3CNT_PRIORITY_MASK) | (priority << REG_G2_BG3CNT_PRIORITY_SHIFT)); +} + +static inline void G2S_SetBG3Priority(int priority) +{ + reg_G2S_DB_BG3CNT = (u16)((reg_G2S_DB_BG3CNT & ~REG_G2S_DB_BG3CNT_PRIORITY_MASK) | (priority << REG_G2S_DB_BG3CNT_PRIORITY_SHIFT)); +} + +static inline GXBg01Control G2_GetBG0Control(void) +{ + return *(volatile GXBg01Control *)®_G2_BG0CNT; +} + +static inline GXBg01Control G2S_GetBG0Control(void) +{ + return *(volatile GXBg01Control *)®_G2S_DB_BG0CNT; +} + +static inline GXBg01Control G2_GetBG1Control(void) +{ + return *(volatile GXBg01Control *)®_G2_BG1CNT; +} + +static inline GXBg01Control G2S_GetBG1Control(void) +{ + return *(volatile GXBg01Control *)®_G2S_DB_BG1CNT; +} + +static inline GXBg23ControlText G2_GetBG2ControlText(void) +{ + return *(volatile GXBg23ControlText *)®_G2_BG2CNT; +} + +static inline GXBg23ControlText G2S_GetBG2ControlText(void) +{ + return *(volatile GXBg23ControlText *)®_G2S_DB_BG2CNT; +} + +static inline GXBg23ControlAffine G2_GetBG2ControlAffine(void) +{ + return *(volatile GXBg23ControlAffine *)®_G2_BG2CNT; +} + +static inline GXBg23ControlAffine G2S_GetBG2ControlAffine(void) +{ + return *(volatile GXBg23ControlAffine *)®_G2S_DB_BG2CNT; +} + +static inline GXBg23Control256x16Pltt G2_GetBG2Control256x16Pltt(void) +{ + return *(volatile GXBg23Control256x16Pltt *)®_G2_BG2CNT; +} + +static inline GXBg23Control256x16Pltt G2S_GetBG2Control256x16Pltt(void) +{ + return *(volatile GXBg23Control256x16Pltt *)®_G2S_DB_BG2CNT; +} + +static inline GXBg23Control256Bmp G2_GetBG2Control256Bmp(void) +{ + return *(volatile GXBg23Control256Bmp *)®_G2_BG2CNT; +} + +static inline GXBg23Control256Bmp G2S_GetBG2Control256Bmp(void) +{ + return *(volatile GXBg23Control256Bmp *)®_G2S_DB_BG2CNT; +} + +static inline GXBg23ControlDCBmp G2_GetBG2ControlDCBmp(void) +{ + return *(volatile GXBg23ControlDCBmp *)®_G2_BG2CNT; +} + +static inline GXBg23ControlDCBmp G2S_GetBG2ControlDCBmp(void) +{ + return *(volatile GXBg23ControlDCBmp *)®_G2S_DB_BG2CNT; +} + +static inline GXBg2ControlLargeBmp G2_GetBG2ControlLargeBmp(void) +{ + return *(volatile GXBg2ControlLargeBmp *)®_G2_BG2CNT; +} + +static inline GXBg2ControlLargeBmp G2S_GetBG2ControlLargeBmp(void) +{ + return *(volatile GXBg2ControlLargeBmp *)®_G2S_DB_BG2CNT; +} + +static inline GXBg23ControlText G2_GetBG3ControlText(void) +{ + return *(volatile GXBg23ControlText *)®_G2_BG3CNT; +} + +static inline GXBg23ControlText G2S_GetBG3ControlText(void) +{ + return *(volatile GXBg23ControlText *)®_G2S_DB_BG3CNT; +} + +static inline GXBg23ControlAffine G2_GetBG3ControlAffine(void) +{ + return *(volatile GXBg23ControlAffine *)®_G2_BG3CNT; +} + +static inline GXBg23ControlAffine G2S_GetBG3ControlAffine(void) +{ + return *(volatile GXBg23ControlAffine *)®_G2S_DB_BG3CNT; +} + +static inline GXBg23Control256x16Pltt G2_GetBG3Control256x16Pltt(void) +{ + return *(volatile GXBg23Control256x16Pltt *)®_G2_BG3CNT; +} + +static inline GXBg23Control256x16Pltt G2S_GetBG3Control256x16Pltt(void) +{ + return *(volatile GXBg23Control256x16Pltt *)®_G2S_DB_BG3CNT; +} + +static inline GXBg23Control256Bmp G2_GetBG3Control256Bmp(void) +{ + return *(volatile GXBg23Control256Bmp *)®_G2_BG3CNT; +} + +static inline GXBg23Control256Bmp G2S_GetBG3Control256Bmp(void) +{ + return *(volatile GXBg23Control256Bmp *)®_G2S_DB_BG3CNT; +} + +static inline GXBg23ControlDCBmp G2_GetBG3ControlDCBmp(void) +{ + return *(volatile GXBg23ControlDCBmp *)®_G2_BG3CNT; +} + +static inline GXBg23ControlDCBmp G2S_GetBG3ControlDCBmp(void) +{ + return *(volatile GXBg23ControlDCBmp *)®_G2S_DB_BG3CNT; +} + +#endif //GUARD_GX_BGCNT_H diff --git a/arm9/lib/NitroSDK/include/GX_dma.h b/arm9/lib/NitroSDK/include/GX_dma.h new file mode 100644 index 00000000..98f6a4a2 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_dma.h @@ -0,0 +1,53 @@ +#ifndef GUARD_GX_DMA_H +#define GUARD_GX_DMA_H + +#define GX_DMA_NOT_USE -1 +#define GX_CPU_FASTER32_SIZE 0x30 +#define GX_CPU_FASTER16_SIZE 0x1C + +static inline void GXi_DmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size) +{ + if (dmaNo != GX_DMA_NOT_USE && size > GX_CPU_FASTER32_SIZE) + { + MI_DmaCopy32(dmaNo, src, dest, size); + } + else + { + MIi_CpuCopy32(src, dest, size); + } +} + +static inline void GXi_DmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size) +{ + if (dmaNo != GX_DMA_NOT_USE && size > GX_CPU_FASTER16_SIZE) + { + MI_DmaCopy16(dmaNo, src, dest, size); + } + else + { + MIi_CpuCopy16(src, dest, size); + } +} + +static inline void GXi_DmaCopy32Async(u32 dmaNo, const void *src, void *dest, u32 size, + MIDmaCallback callback, void *arg) +{ + if (dmaNo != GX_DMA_NOT_USE) + { + MI_DmaCopy32Async(dmaNo, src, dest, size, callback, arg); + } + else + { + MIi_CpuCopy32(src, dest, size); + } +} + +static inline void GXi_WaitDma(u32 dmaNo) +{ + if (dmaNo != GX_DMA_NOT_USE) + { + MI_WaitDma(dmaNo); + } +} + +#endif //GUARD_GX_DMA_H diff --git a/arm9/lib/NitroSDK/include/GX_g2.h b/arm9/lib/NitroSDK/include/GX_g2.h new file mode 100644 index 00000000..97fa0e10 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_g2.h @@ -0,0 +1,126 @@ +#ifndef GUARD_GX_G2_H +#define GUARD_GX_G2_H + +#include "fx.h" +#include "registers.h" + +void G2x_SetBGyAffine_(u32 ptr, const struct Mtx22 *mtx, fx32 a, fx32 b, fx32 c, fx32 d); +void G2x_SetBlendAlpha_(u32 *ptr, fx32 a, fx32 b, fx32 c, fx32 d); +void G2x_SetBlendBrightness_(u16 *ptr, fx32 a, fx32 brightness); +void G2x_SetBlendBrightnessExt_(u16 *ptr, fx32 a, fx32 b, fx32 c, fx32 d, fx32 brightness); +void G2x_ChangeBlendBrightness_(u16 *ptr, fx32 brightness); + +typedef struct +{ + u8 planeMask:5; + u8 effect:1; + u8 _reserve:2; +} + GXWndPlane; + +typedef enum +{ + GX_WND_PLANEMASK_NONE = 0x0000, + GX_WND_PLANEMASK_BG0 = 0x0001, + GX_WND_PLANEMASK_BG1 = 0x0002, + GX_WND_PLANEMASK_BG2 = 0x0004, + GX_WND_PLANEMASK_BG3 = 0x0008, + GX_WND_PLANEMASK_OBJ = 0x0010 +} + GXWndPlaneMask; + +static inline void G2_SetWndOutsidePlane(int wnd, BOOL effect) +{ + u32 tmp; + + tmp = ((reg_G2_WINOUT & ~REG_G2_WINOUT_WINOUT_MASK) | ((u32)wnd << REG_G2_WINOUT_WINOUT_SHIFT)); + + if (effect) + { + tmp |= (0x20 << REG_G2_WINOUT_WINOUT_SHIFT); // EFCT + } + + reg_G2_WINOUT = (u16)tmp; +} + +static inline void G2_SetBG0Offset(int hOffset, int vOffset) +{ + reg_G2_BG0OFS = (u32)(((hOffset << REG_G2_BG0OFS_HOFFSET_SHIFT) & REG_G2_BG0OFS_HOFFSET_MASK) | + ((vOffset << REG_G2_BG0OFS_VOFFSET_SHIFT) & REG_G2_BG0OFS_VOFFSET_MASK)); +} + +static inline void G2_SetBG1Offset(int hOffset, int vOffset) +{ + reg_G2_BG1OFS = (u32)(((hOffset << REG_G2_BG1OFS_HOFFSET_SHIFT) & REG_G2_BG1OFS_HOFFSET_MASK) | + ((vOffset << REG_G2_BG1OFS_VOFFSET_SHIFT) & REG_G2_BG1OFS_VOFFSET_MASK)); +} + +static inline void G2_SetBG2Offset(int hOffset, int vOffset) +{ + reg_G2_BG2OFS = (u32)(((hOffset << REG_G2_BG2OFS_HOFFSET_SHIFT) & REG_G2_BG2OFS_HOFFSET_MASK) | + ((vOffset << REG_G2_BG2OFS_VOFFSET_SHIFT) & REG_G2_BG2OFS_VOFFSET_MASK)); +} + +static inline void G2_SetBG3Offset(int hOffset, int vOffset) +{ + reg_G2_BG3OFS = (u32)(((hOffset << REG_G2_BG3OFS_HOFFSET_SHIFT) & REG_G2_BG3OFS_HOFFSET_MASK) | + ((vOffset << REG_G2_BG3OFS_VOFFSET_SHIFT) & REG_G2_BG3OFS_VOFFSET_MASK)); +} + +static inline void G2S_SetBG0Offset(int hOffset, int vOffset) +{ + reg_G2S_DB_BG0OFS = (u32)(((hOffset << REG_G2S_DB_BG0OFS_HOFFSET_SHIFT) & REG_G2S_DB_BG0OFS_HOFFSET_MASK) | + ((vOffset << REG_G2S_DB_BG0OFS_VOFFSET_SHIFT) & REG_G2S_DB_BG0OFS_VOFFSET_MASK)); +} + +static inline void G2S_SetBG1Offset(int hOffset, int vOffset) +{ + reg_G2S_DB_BG1OFS = (u32)(((hOffset << REG_G2S_DB_BG1OFS_HOFFSET_SHIFT) & REG_G2S_DB_BG1OFS_HOFFSET_MASK) | + ((vOffset << REG_G2S_DB_BG1OFS_VOFFSET_SHIFT) & REG_G2S_DB_BG1OFS_VOFFSET_MASK)); +} + +static inline void G2S_SetBG2Offset(int hOffset, int vOffset) +{ + reg_G2S_DB_BG2OFS = (u32)(((hOffset << REG_G2S_DB_BG2OFS_HOFFSET_SHIFT) & REG_G2S_DB_BG2OFS_HOFFSET_MASK) | + ((vOffset << REG_G2S_DB_BG2OFS_VOFFSET_SHIFT) & REG_G2S_DB_BG2OFS_VOFFSET_MASK)); +} + +static inline void G2S_SetBG3Offset(int hOffset, int vOffset) +{ + reg_G2S_DB_BG3OFS = (u32)(((hOffset << REG_G2S_DB_BG3OFS_HOFFSET_SHIFT) & REG_G2S_DB_BG3OFS_HOFFSET_MASK) | + ((vOffset << REG_G2S_DB_BG3OFS_VOFFSET_SHIFT) & REG_G2S_DB_BG3OFS_VOFFSET_MASK)); +} + +static inline void G2_SetBG2Affine(const struct Mtx22 *mtx, int centerX, int centerY, int x1, int y1) +{ + G2x_SetBGyAffine_((u32)®_G2_BG2PA, mtx, centerX, centerY, x1, y1); +} + +static inline void G2_SetBG3Affine(const struct Mtx22 *mtx, int centerX, int centerY, int x1, int y1) +{ + G2x_SetBGyAffine_((u32)®_G2_BG3PA, mtx, centerX, centerY, x1, y1); +} + +static inline void G2S_SetBG2Affine(const struct Mtx22 *mtx, int centerX, int centerY, int x1, int y1) +{ + G2x_SetBGyAffine_((u32)®_G2S_DB_BG2PA, mtx, centerX, centerY, x1, y1); +} + +static inline void G2S_SetBG3Affine(const struct Mtx22 *mtx, int centerX, int centerY, int x1, int y1) +{ + G2x_SetBGyAffine_((u32)®_G2S_DB_BG3PA, mtx, centerX, centerY, x1, y1); +} + +static inline void G2_BlendNone(void) +{ + reg_G2_BLDCNT = 0; +} + +static inline void G2S_BlendNone(void) +{ + reg_G2S_DB_BLDCNT = 0; +} + +//The g2 and g2_oam headers contain a lot of inline functions and enums that may want to be ported over at some point + +#endif //GUARD_GX_G2_H diff --git a/arm9/lib/NitroSDK/include/GX_g3.h b/arm9/lib/NitroSDK/include/GX_g3.h new file mode 100644 index 00000000..765ecc64 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_g3.h @@ -0,0 +1,184 @@ +#ifndef GUARD_GX_G3_H +#define GUARD_GX_G3_H + +struct GXDLInfo +{ + u8 *curr_cmd; + u32 *curr_param; + u32 *bottom; + u32 length; + BOOL param0_cmd_flg; +}; + +void G3_BeginMakeDL(struct GXDLInfo *displaylist, void *r1, u32 r2); +s32 G3_EndMakeDL(struct GXDLInfo *displaylist); + +typedef enum +{ + GX_MTXMODE_PROJECTION = 0, + GX_MTXMODE_POSITION = 1, + GX_MTXMODE_POSITION_VECTOR = 2, + GX_MTXMODE_TEXTURE = 3 +} +GXMtxMode; + +typedef enum +{ + GX_BEGIN_TRIANGLES = 0, + GX_BEGIN_QUADS = 1, + GX_BEGIN_TRIANGLE_STRIP = 2, + GX_BEGIN_QUAD_STRIP = 3 +} +GXBegin; + +typedef enum +{ + GX_SORTMODE_AUTO = 0, + GX_SORTMODE_MANUAL = 1 +} +GXSortMode; + +typedef enum +{ + GX_BUFFERMODE_Z = 0, + GX_BUFFERMODE_W = 1 +} +GXBufferMode; + +typedef enum +{ + GX_LIGHTMASK_NONE = 0, + GX_LIGHTMASK_0 = 1, + GX_LIGHTMASK_1 = 2, + GX_LIGHTMASK_01 = 3, + GX_LIGHTMASK_2 = 4, + GX_LIGHTMASK_02 = 5, + GX_LIGHTMASK_12 = 6, + GX_LIGHTMASK_012 = 7, + GX_LIGHTMASK_3 = 8, + GX_LIGHTMASK_03 = 9, + GX_LIGHTMASK_13 = 10, + GX_LIGHTMASK_013 = 11, + GX_LIGHTMASK_23 = 12, + GX_LIGHTMASK_023 = 13, + GX_LIGHTMASK_123 = 14, + GX_LIGHTMASK_0123 = 15 +} +GXLightMask; + +typedef enum +{ + GX_POLYGONMODE_MODULATE = 0, + GX_POLYGONMODE_DECAL = 1, + GX_POLYGONMODE_TOON = 2, + GX_POLYGONMODE_SHADOW = 3 +} +GXPolygonMode; + +typedef enum +{ + GX_CULL_ALL = 0, + GX_CULL_FRONT = 1, + GX_CULL_BACK = 2, + GX_CULL_NONE = 3 +} +GXCull; + +typedef enum +{ + GX_TEXREPEAT_NONE = 0, + GX_TEXREPEAT_S = 1, + GX_TEXREPEAT_T = 2, + GX_TEXREPEAT_ST = 3 +} +GXTexRepeat; + +typedef enum +{ + GX_TEXFLIP_NONE = 0, + GX_TEXFLIP_S = 1, + GX_TEXFLIP_T = 2, + GX_TEXFLIP_ST = 3 +} +GXTexFlip; + +typedef enum +{ + GX_TEXSIZE_S8 = 0, + GX_TEXSIZE_S16 = 1, + GX_TEXSIZE_S32 = 2, + GX_TEXSIZE_S64 = 3, + GX_TEXSIZE_S128 = 4, + GX_TEXSIZE_S256 = 5, + GX_TEXSIZE_S512 = 6, + GX_TEXSIZE_S1024 = 7 +} +GXTexSizeS; + +typedef enum +{ + GX_TEXSIZE_T8 = 0, + GX_TEXSIZE_T16 = 1, + GX_TEXSIZE_T32 = 2, + GX_TEXSIZE_T64 = 3, + GX_TEXSIZE_T128 = 4, + GX_TEXSIZE_T256 = 5, + GX_TEXSIZE_T512 = 6, + GX_TEXSIZE_T1024 = 7 +} +GXTexSizeT; + +typedef enum +{ + GX_TEXFMT_NONE = 0, + GX_TEXFMT_A3I5 = 1, + GX_TEXFMT_PLTT4 = 2, + GX_TEXFMT_PLTT16 = 3, + GX_TEXFMT_PLTT256 = 4, + GX_TEXFMT_COMP4x4 = 5, + GX_TEXFMT_A5I3 = 6, + GX_TEXFMT_DIRECT = 7 +} +GXTexFmt; + +typedef enum +{ + GX_TEXPLTTCOLOR0_USE = 0, + GX_TEXPLTTCOLOR0_TRNS = 1 +} +GXTexPlttColor0; + +typedef enum +{ + GX_TEXGEN_NONE = 0, + GX_TEXGEN_TEXCOORD = 1, + GX_TEXGEN_NORMAL = 2, + GX_TEXGEN_VERTEX = 3 +} +GXTexGen; + +typedef enum +{ + GX_LIGHTID_0 = 0, + GX_LIGHTID_1 = 1, + GX_LIGHTID_2 = 2, + GX_LIGHTID_3 = 3 +} +GXLightId; + +typedef union +{ + u32 val[3]; + struct + { + fx16 x; + fx16 y; + fx16 z; + fx16 width; + fx16 height; + fx16 depth; + }; +} +GXBoxTestParam; + +#endif //GUARD_GX_G3_H diff --git a/arm9/lib/NitroSDK/include/GX_g3_util.h b/arm9/lib/NitroSDK/include/GX_g3_util.h new file mode 100644 index 00000000..a9bc4c17 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_g3_util.h @@ -0,0 +1,11 @@ +#ifndef GUARD_GX_G3_UTIL_H +#define GUARD_GX_G3_UTIL_H + +void G3i_PerspectiveW_(fx32 fovsin, fx32 fovcos, fx32 ratio, fx32 near, fx32 far, fx32 scale, u32 load, struct Mtx44 *mtx); +void G3i_OrthoW_(fx32 top, fx32 bottom, fx32 left, fx32 right, fx32 near, fx32 far, fx32 scale, u32 load, struct Mtx44 *mtx); +void G3i_LookAt_(struct Vecx32 *a, struct Vecx32 *b, struct Vecx32 *c, u32 load, struct Mtx44 *mtx); +void G3_RotX(fx32 sinphi, fx32 cosphi); +void G3_RotY(fx32 sinphi, fx32 cosphi); +void G3_RotZ(fx32 sinphi, fx32 cosphi); + +#endif //GUARD_GX_G3_UTIL_H diff --git a/arm9/lib/NitroSDK/include/GX_g3b.h b/arm9/lib/NitroSDK/include/GX_g3b.h new file mode 100644 index 00000000..d299ea34 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_g3b.h @@ -0,0 +1,21 @@ +#ifndef GUARD_GX_G3B_H +#define GUARD_GX_G3B_H + +#include "GX_g3.h" + +void G3BS_LoadMtx44(struct GXDLInfo *displaylist, struct Mtx44 *mtx); +void G3B_PushMtx(struct GXDLInfo *displaylist); +void G3B_PopMtx(struct GXDLInfo *displaylist, void *mtx); +void G3B_LoadMtx44(struct GXDLInfo *displaylist, struct Mtx44 *mtx); +void G3B_Color(struct GXDLInfo * displaylist, u32 vtx_col); +void G3B_Normal(struct GXDLInfo * displaylist, fx16 x, fx16 y, fx16 z); +void G3B_Vtx(struct GXDLInfo * displaylist, fx32 x, fx32 y, fx32 z); +void G3B_PolygonAttr(struct GXDLInfo *displaylist, u32 r1, u32 r2, u32 r3, u32 r4, u32 r5, u32 r6); +void G3B_MaterialColorDiffAmb(struct GXDLInfo *displaylist, u32 diffuse_col, u32 ambient_col, u32 replace); +void G3B_MaterialColorSpecEmi(struct GXDLInfo *displaylist, u32 specular_col, u32 emission_col, u32 shiny_table); +void G3B_LightVector(struct GXDLInfo * displaylist, u32 light_num, fx16 x, fx16 y, fx16 z); +void G3B_LightColor(struct GXDLInfo * displaylist, u32 light_num, u32 col); +void G3B_Begin(struct GXDLInfo * displaylist, u32 type); +void G3B_End(struct GXDLInfo * displaylist); + +#endif //GUARD_GX_G3B_H diff --git a/arm9/lib/NitroSDK/include/GX_g3imm.h b/arm9/lib/NitroSDK/include/GX_g3imm.h new file mode 100644 index 00000000..f811dc68 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_g3imm.h @@ -0,0 +1,10 @@ +#ifndef GUARD_GX_G3IMM_H +#define GUARD_GX_G3IMM_H + +#include "fx.h" + +void G3_LoadMtx43(struct Mtx43 *mtx); +void G3_MultMtx43(struct Mtx43 *mtx); +void G3_MultMtx33(struct Mtx33 *mtx); + +#endif //GUARD_GX_G3IMM_H diff --git a/arm9/lib/NitroSDK/include/GX_g3x.h b/arm9/lib/NitroSDK/include/GX_g3x.h new file mode 100644 index 00000000..aa65a190 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_g3x.h @@ -0,0 +1,86 @@ +#ifndef GUARD_GX_G3X_H +#define GUARD_GX_G3X_H + +#include "fx.h" + +#include "registers.h" + +void GXi_NopClearFifo128_(void *reg); +void G3X_Init(); +void G3X_ResetMtxStack(); +void G3X_ClearFifo(); +void G3X_InitMtxStack(); +void G3X_ResetMtxStack_2(); +void G3X_SetFog(u32 enable, u32 alphamode, u32 depth, s32 offset); +u32 G3X_GetClipMtx(struct Mtx44 *dst); +u32 G3X_GetVectorMtx(struct Mtx33 *dst); +void G3X_SetEdgeColorTable(void *tbl_ptr); +void G3X_SetFogTable(void *tbl_ptr); +void G3X_SetClearColor(u32 col, u32 alpha, u32 depth, u32 polygon_id, u32 enable_fog); +void G3X_InitTable(); +u32 G3X_GetMtxStackLevelPV(u32 *level); +u32 G3X_GetMtxStackLevelPJ(u32 *level); +u32 G3X_GetBoxTestResult(u32 *result); +void G3X_SetHOffset(u32 offset); + +typedef enum +{ + GX_SHADING_TOON = 0, + GX_SHADING_HIGHLIGHT = 1 +} +GXShading; + +typedef enum +{ + GX_FOGBLEND_COLOR_ALPHA = 0, + GX_FOGBLEND_ALPHA = 1 +} +GXFogBlend; + +typedef enum +{ + GX_FOGSLOPE_0x8000 = 0, + GX_FOGSLOPE_0x4000 = 1, + GX_FOGSLOPE_0x2000 = 2, + GX_FOGSLOPE_0x1000 = 3, + GX_FOGSLOPE_0x0800 = 4, + GX_FOGSLOPE_0x0400 = 5, + GX_FOGSLOPE_0x0200 = 6, + GX_FOGSLOPE_0x0100 = 7, + GX_FOGSLOPE_0x0080 = 8, + GX_FOGSLOPE_0x0040 = 9, + GX_FOGSLOPE_0x0020 = 10 +} +GXFogSlope; + +typedef enum +{ + GX_FIFOINTR_COND_DISABLE = 0, + GX_FIFOINTR_COND_UNDERHALF = 1, + GX_FIFOINTR_COND_EMPTY = 2 +} +GXFifoIntrCond; + +typedef enum +{ + GX_FIFOSTAT_EMPTY = 6, + GX_FIFOSTAT_UNDERHALF = 2, + GX_FIFOSTAT_OVERHALF = 0, + GX_FIFOSTAT_FULL = 1 +} +GXFifoStat; + +static inline void G3X_SetFifoIntrCond(GXFifoIntrCond cond) +{ + reg_G3X_GXSTAT = ((reg_G3X_GXSTAT & ~0xc0000000) | + (cond << 30)); +} + +static inline GXFifoStat G3X_GetCommandFifoStatus(void) +{ + return (GXFifoStat)((reg_G3X_GXSTAT & (0x01000000 | + 0x02000000 | + 0x04000000)) >> 24); +} + +#endif //GUARD_GX_G3X_H diff --git a/arm9/lib/NitroSDK/include/GX_load2d.h b/arm9/lib/NitroSDK/include/GX_load2d.h new file mode 100644 index 00000000..3c9fb5cb --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_load2d.h @@ -0,0 +1,41 @@ +#ifndef GUARD_GX_LOAD2D_H +#define GUARD_GX_LOAD2D_H + +void GX_LoadBGPltt(void *src, u32 offset, u32 size); +void GXS_LoadBGPltt(void *src, u32 offset, u32 size); +void GX_LoadOBJPltt(void *src, u32 offset, u32 size); +void GXS_LoadOBJPltt(void *src, u32 offset, u32 size); +void GX_LoadOAM(void *src, u32 offset, u32 size); +void GXS_LoadOAM(void *src, u32 offset, u32 size); +void GX_LoadOBJ(void *src, u32 offset, u32 size); +void GXS_LoadOBJ(void *src, u32 offset, u32 size); +void GX_LoadBG0Scr(void *src, u32 offset, u32 size); +void GXS_LoadBG0Scr(void *src, u32 offset, u32 size); +void GX_LoadBG1Scr(void *src, u32 offset, u32 size); +void GXS_LoadBG1Scr(void *src, u32 offset, u32 size); +void GX_LoadBG2Scr(void *src, u32 offset, u32 size); +void GXS_LoadBG2Scr(void *src, u32 offset, u32 size); +void GX_LoadBG3Scr(void *src, u32 offset, u32 size); +void GXS_LoadBG3Scr(void *src, u32 offset, u32 size); +void GX_LoadBG0Char(void *src, u32 offset, u32 size); +void GXS_LoadBG0Char(void *src, u32 offset, u32 size); +void GX_LoadBG1Char(void *src, u32 offset, u32 size); +void GXS_LoadBG1Char(void *src, u32 offset, u32 size); +void GX_LoadBG2Char(void *src, u32 offset, u32 size); +void GXS_LoadBG2Char(void *src, u32 offset, u32 size); +void GX_LoadBG3Char(void *src, u32 offset, u32 size); +void GXS_LoadBG3Char(void *src, u32 offset, u32 size); +void GX_BeginLoadBGExtPltt(); +void GX_LoadBGExtPltt(void *src, u32 offset, u32 size); +void GX_EndLoadBGExtPltt(); +void GX_BeginLoadOBJExtPltt(); +void GX_LoadOBJExtPltt(void *src, u32 offset, u32 size); +void GX_EndLoadOBJExtPltt(); +void GXS_BeginLoadBGExtPltt(); +void GXS_LoadBGExtPltt(void *src, u32 offset, u32 size); +void GXS_EndLoadBGExtPltt(); +void GXS_BeginLoadOBJExtPltt(); +void GXS_LoadOBJExtPltt(void *src, u32 offset, u32 size); +void GXS_EndLoadOBJExtPltt(); + +#endif //GUARD_GX_LOAD2D_H diff --git a/arm9/lib/NitroSDK/include/GX_load3d.h b/arm9/lib/NitroSDK/include/GX_load3d.h new file mode 100644 index 00000000..09fd296a --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_load3d.h @@ -0,0 +1,15 @@ +#ifndef GUARD_GX_LOAD3D_H +#define GUARD_GX_LOAD3D_H + +void GX_BeginLoadTex(); +void GX_LoadTex(void *src, u32 offset, u32 size); +void GX_EndLoadTex(); +void GX_BeginLoadTexPltt(); +void GX_LoadTexPltt(void *src, u32 offset, u32 size); +void GX_EndLoadTexPltt(); +void GX_BeginLoadClearImage(); +void GX_LoadClearImageColor(void *src, u32 size); +void GX_LoadClearImageDepth(void *src, u32 size); +void GX_EndLoadClearImage(); + +#endif //GUARD_GX_LOAD3D_H diff --git a/arm9/lib/NitroSDK/include/GX_state.h b/arm9/lib/NitroSDK/include/GX_state.h new file mode 100644 index 00000000..c94b6c07 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_state.h @@ -0,0 +1,24 @@ +#ifndef GUARD_GX_STATE_H +#define GUARD_GX_STATE_H + +struct GX_State +{ + u16 lcdc; + u16 bg; + u16 obj; + u16 arm7; + u16 tex; + u16 texPltt; + u16 clrImg; + u16 bgExtPltt; + u16 objExtPltt; + + u16 sub_bg; + u16 sub_obj; + u16 sub_bgExtPltt; + u16 sub_objExtPltt; +}; + +void GX_InitGXState(); + +#endif //GUARD_GX_STATE_H diff --git a/arm9/lib/NitroSDK/include/GX_struct_2d.h b/arm9/lib/NitroSDK/include/GX_struct_2d.h new file mode 100644 index 00000000..3b544927 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_struct_2d.h @@ -0,0 +1,243 @@ +#ifndef GUARD_GX_STRUCT_2D_H +#define GUARD_GX_STRUCT_2D_H + +typedef u16 GXScrFmtText; +#define GX_SCRFMT_TEXT_CHARNAME_SHIFT (0) +#define GX_SCRFMT_TEXT_CHARNAME_MASK (0x03ff) +#define GX_SCRFMT_TEXT_HF_SHIFT (10) +#define GX_SCRFMT_TEXT_HF_MASK (0x0400) +#define GX_SCRFMT_TEXT_VF_SHIFT (11) +#define GX_SCRFMT_TEXT_VF_MASK (0x0800) +#define GX_SCRFMT_TEXT_COLORPLTT_SHIFT (12) +#define GX_SCRFMT_TEXT_COLORPLTT_MASK (0xf000) +#define GX_SCRFMT_TEXT(pltt, vf, hf, name) \ + ((u16)(((name) << GX_SCRFMT_TEXT_CHARNAME_SHIFT) | \ + ((hf) << GX_SCRFMT_TEXT_HF_SHIFT) | \ + ((vf) << GX_SCRFMT_TEXT_VF_SHIFT) | \ + ((pltt) << GX_SCRFMT_TEXT_COLORPLTT_SHIFT))) + +typedef u8 GXScrFmtAffine; +#define GX_SCRFMT_AFFINE_CHARNAME_SHIFT (0) +#define GX_SCRFMT_AFFINE_CHARNAME_MASK (0xff) + +typedef u8 GXScrFmt256Bmp; +#define GX_SCRFMT_256BMP_COLORNO_SHIFT (0) +#define GX_SCRFMT_256BMP_COLORNO_MASK (0xff) + +typedef union +{ + u32 data32[8]; + u16 data16[16]; + u8 data8[32]; +} +GXCharFmt16; + +typedef union +{ + u32 data32[16]; + u16 data16[32]; + u8 data8[64]; +} +GXCharFmt256; + +typedef union +{ + u16 data16[16]; + u32 data32[8]; + GXRgb rgb[16]; +} +GXBGPltt16; + +typedef GXBGPltt16 GXOBJPltt16; + +typedef union +{ + u16 data16[256]; + u32 data32[128]; + GXRgb rgb[256]; +} +GXBGPltt256; + +typedef GXBGPltt256 GXOBJPltt256; + +typedef union +{ + u16 data16[32 * 32]; + u32 data32[32 * 32 / 2]; + GXScrFmtText scr[32][32]; +} +GXScrText32x32; + +typedef union +{ + u16 data16[64 * 32]; + u32 data32[64 * 32 / 2]; + GXScrFmtText scr[64][32]; +} +GXScrText64x32; + +typedef union +{ + // 4K bytes + u16 data16[32 * 64]; + u32 data32[32 * 64 / 2]; + GXScrFmtText scr[32][64]; +} +GXScrText32x64; + +typedef union +{ + u16 data16[64 * 64]; + u32 data32[64 * 64 / 2]; + GXScrFmtText scr[64][64]; +} +GXScrText64x64; + +typedef union +{ + u8 data8[16 * 16]; + u32 data32[16 * 16 / 4]; + GXScrFmtAffine scr[16][16]; +} +GXScrAffine16x16; + +typedef union +{ + u8 data8[32 * 32]; + u32 data32[32 * 32 / 4]; + GXScrFmtAffine scr[32][32]; +} +GXScrAffine32x32; + +typedef union +{ + u8 data8[64 * 64]; + u32 data32[64 * 64 / 4]; + GXScrFmtAffine scr[64][64]; +} +GXScrAffine64x64; + +typedef union +{ + u8 data8[128 * 128]; + u32 data32[128 * 128 / 4]; + GXScrFmtAffine scr[128][128]; +} +GXScrAffine128x128; + +typedef union +{ + u8 data8[128 * 128]; + u32 data32[128 * 128 / 4]; + GXScrFmt256Bmp scr[128][128]; +} +GXScr256Bmp128x128; + +typedef union +{ + u8 data8[256 * 256]; + u32 data32[256 * 256 / 4]; + GXScrFmt256Bmp scr[256][256]; +} +GXScr256Bmp256x256; + +typedef union +{ + u8 data8[512 * 256]; + u32 data32[512 * 256 / 4]; + GXScrFmt256Bmp scr[512][256]; +} +GXScr256Bmp512x256; + +typedef union +{ + u8 data8[512 * 512]; + u32 data32[512 * 512 / 4]; + GXScrFmt256Bmp scr[512][512]; +} +GXScr256Bmp512x512; + +typedef union +{ + u16 data16[128 * 128]; + u32 data32[128 * 128 / 2]; + GXRgba scr[128][128]; +} +GXScrDCBmp128x128; + +typedef union +{ + u16 data16[256 * 256]; + u32 data32[256 * 256 / 2]; + GXRgba scr[256][256]; +} +GXScrDCBmp256x256; + +typedef union +{ + u16 data16[512 * 256]; + u32 data32[512 * 256 / 2]; + GXRgba scr[512][256]; +} +GXScrDCBmp512x256; + +typedef union +{ + u16 data16[512 * 512]; + u32 data32[512 * 512 / 2]; + GXRgba scr[512][512]; +} +GXScrDCBmp512x512; + +typedef struct +{ + GXCharFmt16 ch[1024]; +} +GXCharBGText16; + +typedef struct +{ + GXCharFmt256 ch[1024]; +} +GXCharBGText256; + +typedef struct +{ + GXCharFmt256 ch[256]; +} +GXCharBGAffine256; + +typedef union +{ + GXBGPltt256 pltt256; + GXBGPltt16 pltt16[16]; +} +GXBGStdPlttData; + +typedef union +{ + GXOBJPltt256 pltt256; + GXOBJPltt16 pltt16[16]; +} +GXOBJStdPlttData; + +typedef struct +{ + GXBGStdPlttData bgPltt; + GXOBJStdPlttData objPltt; +} +GXStdPlttData; + +typedef struct +{ + GXBGPltt256 pltt256[16]; +} +GXBGExtPlttData; + +typedef struct +{ + GXOBJPltt256 pltt256[16]; +} +GXOBJExtPlttData; + +#endif //GUARD_GX_STRUCT_2D_H diff --git a/arm9/lib/NitroSDK/include/GX_vramcnt.h b/arm9/lib/NitroSDK/include/GX_vramcnt.h new file mode 100644 index 00000000..3b82d28c --- /dev/null +++ b/arm9/lib/NitroSDK/include/GX_vramcnt.h @@ -0,0 +1,57 @@ +#ifndef GUARD_GX_VRAMCNT_H +#define GUARD_GX_VRAMCNT_H + +//some of the symbols don't match what the function does +void GX_VRAMCNT_SetLCDC_(u32 mask); +void GX_SetBankForBG(s32 bg); +void GX_SetBankForOBJ(s32 obj); +void GX_SetBankForBGExtPltt(s32 bgextpltt); +void GX_SetBankForOBJExtPltt(s32 objextpltt); +void GX_SetBankForTex(s32 tex); +void GX_SetBankForTexPltt(s32 texpltt); +void GX_SetBankForClearImage(s32 clearimage); +void GX_SetBankForARM7(s32 arm7); +void GX_SetBankForLCDC(s32 lcdc); +void GX_SetBankForSubBG(s32 subbg); +void GX_SetBankForSubOBJ(s32 subobj); +void GX_SetBankForSubBGExtPltt(s32 subbgextpltt); +void GX_SetBankForSubOBJExtPltt(s32 subobjextpltt); +u32 resetBankForX_(u16 *ptr); +u32 GX_ResetBankForBG(); +u32 GX_ResetBankForOBJ(); +u32 GX_ResetBankForBGExtPltt(); +u32 GX_ResetBankForOBJExtPltt(); +u32 GX_ResetBankForTex(); +u32 GX_ResetBankForTexPltt(); +u32 GX_ResetBankForClearImage(); +u32 GX_ResetBankForSubBG(); +u32 GX_ResetBankForSubOBJ(); +u32 GX_ResetBankForSubBGExtPltt(); +u32 GX_ResetBankForSubOBJExtPltt(); +u32 disableBankForX_(u16 *ptr); +u32 GX_DisableBankForBG(); +u32 GX_DisableBankForOBJ(); +u32 GX_DisableBankForBGExtPltt(); +u32 GX_DisableBankForOBJExtPltt(); +u32 GX_DisableBankForTex(); +u32 GX_DisableBankForTexPltt(); +u32 GX_DisableBankForClearImage(); +u32 GX_DisableBankForARM7(); +u32 GX_DisableBankForLCDC(); +u32 GX_DisableBankForSubBG(); +u32 GX_DisableBankForSubOBJ(); +u32 GX_DisableBankForSubBGExtPltt(); +u32 GX_DisableBankForSubOBJExtPltt(); +u32 GX_GetBankForBG(); +u32 GX_GetBankForOBJ(); +u32 GX_GetBankForBGExtPltt(); +u32 GX_GetBankForOBJExtPltt(); +u32 GX_GetBankForTex(); +u32 GX_GetBankForTexPltt(); +u32 GX_GetBankForLCDC(); +u32 GX_GetBankForSubBG(); +u32 GX_GetBankForSubOBJ(); +u32 GX_GetBankForSubBGExtPltt(); +u32 GX_GetBankForSubOBJExtPltt(); + +#endif //GUARD_GX_VRAMCNT_H diff --git a/arm9/lib/NitroSDK/include/GXcommon.h b/arm9/lib/NitroSDK/include/GXcommon.h new file mode 100644 index 00000000..a83f4384 --- /dev/null +++ b/arm9/lib/NitroSDK/include/GXcommon.h @@ -0,0 +1,29 @@ +#ifndef GUARD_GXCOMMON_H +#define GUARD_GXCOMMON_H + +typedef u16 GXRgb; +#define GXRGB_ASSERT(gxrgb) SDK_ASSERT(((gxrgb) & 0x8000) == 0) +#define GX_RGB_R_SHIFT (0) +#define GX_RGB_R_MASK (0x001f) +#define GX_RGB_G_SHIFT (5) +#define GX_RGB_G_MASK (0x03e0) +#define GX_RGB_B_SHIFT (10) +#define GX_RGB_B_MASK (0x7c00) +#define GX_RGB(r, g, b) ((GXRgb)(((r) << GX_RGB_R_SHIFT) | \ + ((g) << GX_RGB_G_SHIFT) | \ + ((b) << GX_RGB_B_SHIFT))) + +typedef u16 GXRgba; +#define GX_RGBA_R_SHIFT (0) +#define GX_RGBA_R_MASK (0x001f) +#define GX_RGBA_G_SHIFT (5) +#define GX_RGBA_G_MASK (0x03e0) +#define GX_RGBA_B_SHIFT (10) +#define GX_RGBA_B_MASK (0x7c00) +#define GX_RGBA_A_SHIFT (15) +#define GX_RGBA_A_MASK (0x8000) +#define GX_RGBA(r, g, b, a) ((GXRgba)(((r) << GX_RGBA_R_SHIFT) | \ + ((g) << GX_RGBA_G_SHIFT) | \ + ((b) << GX_RGBA_B_SHIFT) | \ + ((a) << GX_RGBA_A_SHIFT))) +#endif //GUARD_GXCOMMON_H diff --git a/arm9/lib/NitroSDK/include/MATH_crc.h b/arm9/lib/NitroSDK/include/MATH_crc.h new file mode 100644 index 00000000..4f06fa75 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MATH_crc.h @@ -0,0 +1,45 @@ +#ifndef GUARD_MATH_CRC_H +#define GUARD_MATH_CRC_H + +#include "nitro/types.h" + +typedef u8 MATHCRC8Context; +typedef u16 MATHCRC16Context; +typedef u32 MATHCRC32Context; + +#define MATH_CRC16_CCITT_POLY 0x1021 + +struct MATHCRC8Table { + u8 table[256]; +}; + +struct MATHCRC16Table { + u16 table[256]; +}; + +struct MATHCRC32Table { + u32 table[256]; +}; + +u32 MATH_CalcCRC32(const struct MATHCRC32Table *table, const void *data, u32 dataLength); +void MATHi_CRC32UpdateRev(const struct MATHCRC32Table *table, MATHCRC32Context *context, const void *input, u32 length); +u16 MATH_CalcCRC16CCITT(const struct MATHCRC16Table *table, const void *data, u32 dataLength); +void MATHi_CRC16Update(const struct MATHCRC16Table *table, MATHCRC16Context *context, const void *input, u32 length); +u16 MATH_CalcCRC16(const struct MATHCRC16Table *table, const void *data, u32 dataLength); +void MATHi_CRC16UpdateRev(const struct MATHCRC16Table *table, MATHCRC16Context *context, const void *input, u32 length); +u8 MATH_CalcCRC8(const struct MATHCRC8Table *table, const void *data, u32 dataLength); +void MATHi_CRC8Update(const struct MATHCRC8Table *table, MATHCRC8Context *context, const void *input, u32 length); +void MATHi_CRC32InitTableRev(struct MATHCRC32Table *table, u32 poly); +void MATHi_CRC16UpdateRev(const struct MATHCRC16Table *table, MATHCRC16Context *context, const void *input, u32 length); +void MATHi_CRC16Update(const struct MATHCRC16Table *table, MATHCRC16Context *context, const void *input, u32 length); +void MATHi_CRC16InitTableRev(struct MATHCRC16Table *table, u16 poly); +void MATHi_CRC16InitTable(struct MATHCRC16Table *table, u16 poly); +void MATHi_CRC8Update(const struct MATHCRC8Table *table, MATHCRC8Context *context, const void *input, u32 length); +void MATHi_CRC8InitTable(struct MATHCRC8Table *table, u8 poly); + +static inline void MATH_CRC16InitTable(struct MATHCRC16Table * table) +{ + MATHi_CRC16InitTable(table, MATH_CRC16_CCITT_POLY); +} + +#endif diff --git a/arm9/lib/NitroSDK/include/MATH_dgt.h b/arm9/lib/NitroSDK/include/MATH_dgt.h new file mode 100644 index 00000000..140b4f98 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MATH_dgt.h @@ -0,0 +1,45 @@ +#ifndef GUARD_MATH_DGT_H +#define GUARD_MATH_DGT_H + +#include "dgt.h" +#include "nitro/types.h" + +typedef struct DGTHash1Context MATHMD5Context; +typedef struct DGTHash2Context MATHSHA1Context; + +static inline void MATH_MD5Init(MATHMD5Context *context) { + DGT_Hash1Reset(context); +} + +static inline void MATH_MD5Update(MATHMD5Context *context, const void *input, u32 length) { + DGT_Hash1SetSource(context, (u8*)input, length); +} + +static inline void MATH_MD5GetHash(MATHMD5Context *context, void *digest) { + DGT_Hash1GetDigest_R((u8*)digest, context); +} + +static inline void MATH_MD5GetDigest(MATHMD5Context *context, void *digest) { + MATH_MD5GetHash(context, digest); +} + +static inline void MATH_SHA1Init(MATHSHA1Context *context) { + DGT_Hash2Reset(context); +} + +static inline void MATH_SHA1Update(MATHSHA1Context *context, const void *input, u32 length) { + DGT_Hash2SetSource(context, (u8*)input, length); +} + +static inline void MATH_SHA1GetHash(MATHSHA1Context *context, void *digest) { + DGT_Hash2GetDigest(context, (u8*)digest); +} + +static inline void MATH_SHA1GetDigest(MATHSHA1Context *context, void *digest) { + MATH_SHA1GetHash(context, digest); +} + +void MATH_CalcMD5(void *digest, const void *data, u32 dataLength); +void MATH_CalcSHA1(void *digest, const void *data, u32 dataLength); + +#endif diff --git a/arm9/lib/NitroSDK/include/MATH_pop.h b/arm9/lib/NitroSDK/include/MATH_pop.h new file mode 100644 index 00000000..29a42b22 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MATH_pop.h @@ -0,0 +1,8 @@ +#ifndef GUARD_MATH_POP_H +#define GUARD_MATH_POP_H + +#include "nitro/types.h" + +u8 MATH_CountPopulation(u32); + +#endif diff --git a/arm9/lib/NitroSDK/include/MB_mb.h b/arm9/lib/NitroSDK/include/MB_mb.h new file mode 100644 index 00000000..5bccaf8b --- /dev/null +++ b/arm9/lib/NitroSDK/include/MB_mb.h @@ -0,0 +1,41 @@ +#ifndef POKEDIAMOND_MB_MB_H +#define POKEDIAMOND_MB_MB_H + +#include "consts.h" + +#define MB_TYPE_ILLEGAL 0 +#define MB_TYPE_NORMAL 1 +#define MB_TYPE_MULTIBOOT 2 + +typedef struct { + u16 length; + u16 rssi; + u16 bssid[3]; + u16 ssidLength; + u8 ssid[32]; + u16 capaInfo; + struct { + u16 basic; + u16 support; + } rateSet; + u16 beaconperiod; + u16 dtimPeriod; + u16 channel; + u16 cfpPeriod; + u16 cfpMaxDuration; +} MBParentBssDesc; + +typedef struct { + u16 boot_type; + MBParentBssDesc parent_bss_desc; +} MBParam; + +static inline const MBParam *MB_GetMultiBootParam() { + return (const MBParam *)HW_WM_BOOT_BUF; +} + +static inline BOOL MB_IsMultiBootChild() { + return MB_GetMultiBootParam()->boot_type == MB_TYPE_MULTIBOOT; +} + +#endif //POKEDIAMOND_MB_MB_H diff --git a/arm9/lib/NitroSDK/include/MI_byteAccess.h b/arm9/lib/NitroSDK/include/MI_byteAccess.h new file mode 100644 index 00000000..cad4d518 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_byteAccess.h @@ -0,0 +1,14 @@ +#ifndef NITRO_MI_BYTEACCESS_H_ +#define NITRO_MI_BYTEACCESS_H_ + +static inline u8 MI_ReadByte(const void *address) +{ + return *(u8 *)address; +} + +static inline void MI_WriteByte(void *address, u8 value) +{ + *(u8 *)address = value; +} + +#endif //NITRO_MI_BYTEACCESS_H_ diff --git a/arm9/lib/NitroSDK/include/MI_dma.h b/arm9/lib/NitroSDK/include/MI_dma.h new file mode 100644 index 00000000..99d1cb84 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_dma.h @@ -0,0 +1,80 @@ +#ifndef POKEDIAMOND_ARM9_MI_DMA_H +#define POKEDIAMOND_ARM9_MI_DMA_H + +#include "nitro/MI_dma_shared.h" +#include "consts.h" +#include "OS_system.h" + +typedef void (*MIDmaCallback)(void *); + +#define MI_DMA_MAX_NUM 3 + +#define REG_ADDR_DMA0CNT 0x40000b8 +#define REG_ADDR_DMA0_CLR_DATA 0x40000e0 + +#define MI_CNT_CLEAR32(size) (0x85000000 | ((size)/4)) +#define MI_CNT_CLEAR32_IF(size) (0xc5000000 | ((size)/4)) +#define MI_CNT_COPY32(size) (0x84000000 | ((size)/4)) +#define MI_CNT_COPY32_IF(size) (0xc4000000 | ((size)/4)) +#define MI_CNT_COPY16(size) (0x80000000 | ((size)/2)) + +#define MI_DMA_SRC_FIX (2UL << 23) +#define MI_DMA_SRC_INC (0UL << 23) + +#define MI_DMA_16BIT_BUS (0UL << 26) +#define MI_DMA_32BIT_BUS (1UL << 26) + +#define MIi_DMA_TIMING_ANY (u32)(~0) +#define MI_DMA_TIMING_H_BLANK (2UL << 27) + +typedef union +{ + u32 b32; + u16 b16; +} MIiDmaClearSrc; + +void MI_DmaFill32(u32 dmaNo, void *dest, u32 data, u32 size); +void MI_DmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size); +void MI_DmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size); +void MI_DmaFill32Async(u32 dmaNo, void *dest, u32 data, u32 size, MIDmaCallback callback, void *arg); +void MI_DmaCopy32Async(u32 dmaNo, const void *src, void *dest, u32 size, MIDmaCallback callback, void *arg); +void MI_WaitDma(u32 dmaNo); +void MI_StopDma(u32 dmaNo); +void MIi_CheckAnotherAutoDMA(u32 dmaNo, u32 dmaType); +void MIi_CheckDma0SourceAddress(u32 dmaNo, u32 src, u32 size, u32 dir); +void MIi_DmaSetParams(u32 dmaNo, u32 src, u32 dest, u32 ctrl); +void MIi_DmaSetParams_wait(u32 dmaNo, u32 src, u32 dest, u32 ctrl); +void MIi_DmaSetParams_noInt(u32 dmaNo, u32 src, u32 dest, u32 ctrl); +void MIi_DmaSetParams_wait_noInt(u32 dmaNo, u32 src, u32 dest, u32 ctrl); + +static inline void MIi_DmaSetParams_wait_src32(u32 dmaNo, u32 data, u32 dest, u32 ctrl) +{ + OSIntrMode lastIntrMode = OS_DisableInterrupts(); + + MIiDmaClearSrc *scrp = (MIiDmaClearSrc *) ((u32)REG_ADDR_DMA0_CLR_DATA + dmaNo * 4); + scrp->b32 = data; + MIi_DmaSetParams_wait_noInt(dmaNo, (u32)scrp, dest, ctrl); + + (void)OS_RestoreInterrupts(lastIntrMode); +} + +static inline void MIi_DmaSetParams_src32(u32 dmaNo, u32 data, u32 dest, u32 ctrl) +{ + OSIntrMode lastIntrMode = OS_DisableInterrupts(); + + MIiDmaClearSrc *srcp = (MIiDmaClearSrc *) ((u32)REG_ADDR_DMA0_CLR_DATA + dmaNo * 4); + srcp->b32 = data; + MIi_DmaSetParams_noInt(dmaNo, (u32)srcp, dest, ctrl); + + (void)OS_RestoreInterrupts(lastIntrMode); +} + +static inline void MIi_CallCallback(MIDmaCallback callback, void *arg) +{ + if (callback) + { + (callback) (arg); + } +} + +#endif //POKEDIAMOND_ARM9_MI_DMA_H diff --git a/arm9/lib/NitroSDK/include/MI_dma_card.h b/arm9/lib/NitroSDK/include/MI_dma_card.h new file mode 100644 index 00000000..efd70ba6 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_dma_card.h @@ -0,0 +1,8 @@ +#ifndef POKEDIAMOND_MI_DMA_CARD_H +#define POKEDIAMOND_MI_DMA_CARD_H + +#include "nitro/types.h" + +void MIi_CardDmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size); + +#endif //POKEDIAMOND_MI_DMA_CARD_H diff --git a/arm9/lib/NitroSDK/include/MI_dma_gxcommand.h b/arm9/lib/NitroSDK/include/MI_dma_gxcommand.h new file mode 100644 index 00000000..7cc32ba2 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_dma_gxcommand.h @@ -0,0 +1,34 @@ +#ifndef POKEDIAMOND_MI_DMA_GXCOMMAND_H +#define POKEDIAMOND_MI_DMA_GXCOMMAND_H + +#include "consts.h" +#include "MI_dma.h" +#include "GX_g3x.h" + +#define MIi_GX_LENGTH_ONCE (118 * sizeof(u32)) +#define REG_GXFIFO_ADDR 0x4000400 +#define MI_CNT_SEND32(size) (0x84400000 | (size/4)) +#define MI_CNT_SEND32_IF(size) (0xc4400000 | (size/4)) +#define MI_CNT_GXCOPY_IF(size) (0xfc400000 | (size/4)) + +#define OS_IE_GXFIFO 0x200000 + +typedef struct +{ + volatile BOOL isBusy; + + u32 dmaNo; + u32 src; + u32 length; + MIDmaCallback callback; + void *arg; + + GXFifoIntrCond fifoCond; + void (*fifoFunc) (void); +} MIiGXDmaParams; + +void MI_SendGXCommand(u32 dmaNo, const void *src, u32 commandLength); +void MI_SendGXCommandAsync(u32 dmaNo, const void *src, u32 commandLength, MIDmaCallback callback, void *arg); +void MI_SendGXCommandAsyncFast(u32 dmaNo, const void *src, u32 commandLength, MIDmaCallback callback, void *arg); + +#endif //POKEDIAMOND_MI_DMA_GXCOMMAND_H diff --git a/arm9/lib/NitroSDK/include/MI_dma_hblank.h b/arm9/lib/NitroSDK/include/MI_dma_hblank.h new file mode 100644 index 00000000..1c83ef3e --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_dma_hblank.h @@ -0,0 +1,9 @@ +#ifndef POKEDIAMOND_MI_DMA_HBLANK_H +#define POKEDIAMOND_MI_DMA_HBLANK_H + +#include "nitro/types.h" + +void MI_HBlankDmaCopy32(u32 dmaNo, const void *src, void *dest, u32 size); +void MI_HBlankDmaCopy16(u32 dmaNo, const void *src, void *dest, u32 size); + +#endif //POKEDIAMOND_MI_DMA_HBLANK_H diff --git a/arm9/lib/NitroSDK/include/MI_exMemory.h b/arm9/lib/NitroSDK/include/MI_exMemory.h new file mode 100644 index 00000000..5e21d7e6 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_exMemory.h @@ -0,0 +1,75 @@ +#ifndef POKEDIAMOND_MI_EXMEMORY_H +#define POKEDIAMOND_MI_EXMEMORY_H + +#include "registers.h" + +typedef enum { + MI_PROCESSOR_ARM9 = 0, + MI_PROCESSOR_ARM7 = 1 +} MIProcessor; + +typedef enum +{ + MI_CTRDG_ROMCYCLE1_10 = 0, + MI_CTRDG_ROMCYCLE1_8 = 1, + MI_CTRDG_ROMCYCLE1_6 = 2, + MI_CTRDG_ROMCYCLE1_18 = 3 +} MICartridgeRomCycle1st; + +typedef enum +{ + MI_CTRDG_ROMCYCLE2_6 = 0, + MI_CTRDG_ROMCYCLE2_4 = 1 +} MICartridgeRomCycle2nd; + +typedef enum +{ + MI_CTRDG_RAMCYCLE_10 = 0, + MI_CTRDG_RAMCYCLE_8 = 1, + MI_CTRDG_RAMCYCLE_6 = 2, + MI_CTRDG_RAMCYCLE_18 = 3 +} MICartridgeRamCycle; + +static inline void MIi_SetCardProcessor(MIProcessor proc) +{ + reg_MI_EXMEMCNT = + (u16)((reg_MI_EXMEMCNT & ~0x0800) | (proc << 11)); +} + +static inline void MIi_SetCartridgeProcessor(MIProcessor proc) +{ + reg_MI_EXMEMCNT = + (u16)((reg_MI_EXMEMCNT & ~0x0080) | (proc << 7)); +} + +static inline MICartridgeRomCycle1st MI_GetCartridgeRomCycle1st(void) +{ + return (MICartridgeRomCycle1st)((reg_MI_EXMEMCNT & 0xc) >> 2); +} + +static inline MICartridgeRomCycle2nd MI_GetCartridgeRomCycle2nd(void) +{ + return (MICartridgeRomCycle2nd)((reg_MI_EXMEMCNT & 0x10) >> 4); +} + +static inline void MI_SetCartridgeRomCycle1st(MICartridgeRomCycle1st c1) +{ + reg_MI_EXMEMCNT = (u16)((reg_MI_EXMEMCNT & ~0xc) | (c1 << 2)); +} + +static inline void MI_SetCartridgeRomCycle2nd(MICartridgeRomCycle2nd c2) +{ + reg_MI_EXMEMCNT = (u16)((reg_MI_EXMEMCNT & ~0x10) | (c2 << 4)); +} + +static inline void MI_SetCartridgeRamCycle(MICartridgeRamCycle c) +{ + reg_MI_EXMEMCNT = (u16)((reg_MI_EXMEMCNT & ~3) | (c << 0)); +} + +static inline MICartridgeRamCycle MI_GetCartridgeRamCycle(void) +{ + return (MICartridgeRamCycle)((reg_MI_EXMEMCNT & 3) >> 0); +} + +#endif //POKEDIAMOND_MI_EXMEMORY_H diff --git a/arm9/lib/NitroSDK/include/MI_init.h b/arm9/lib/NitroSDK/include/MI_init.h new file mode 100644 index 00000000..a338ab6b --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_init.h @@ -0,0 +1,6 @@ +#ifndef POKEDIAMOND_MI_INIT_H +#define POKEDIAMOND_MI_INIT_H + +void MI_Init(void); + +#endif //POKEDIAMOND_MI_INIT_H diff --git a/arm9/lib/NitroSDK/include/MI_memory.h b/arm9/lib/NitroSDK/include/MI_memory.h new file mode 100644 index 00000000..4e5722bb --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_memory.h @@ -0,0 +1,68 @@ +#ifndef POKEDIAMOND_ARM9_MI_MEMORY_H +#define POKEDIAMOND_ARM9_MI_MEMORY_H + +#include "nitro/types.h" + +void MIi_CpuClear16(register u16 data, register void *destp, register u32 size); +void MIi_CpuCopy16(register const void *srcp, register void *destp, register u32 size); +void MIi_CpuClear32(register u32 data, register void *destp, register u32 size); +void MIi_CpuCopy32(register const void *srcp, register void *destp, register u32 size); +void MIi_CpuSend32(register const void *srcp, volatile void *destp, u32 size); +void MIi_CpuClearFast(register u32 data, register void *destp, register u32 size); +void MIi_CpuCopyFast(register const void *srcp, register void *destp, register u32 size); +void MI_Copy32B(register const void *pSrc, register void *pDest); +void MI_Copy36B(register const void *pSrc, register void *pDest); +void MI_Copy48B(register const void *pSrc, register void *pDest); +void MI_Copy64B(register const void *pSrc, register void *pDest); +void MI_CpuFill8(register void *dstp, register u8 data, register u32 size); +void MI_CpuCopy8(register const void *srcp, register void *dstp, register u32 size); +void MI_Zero36B(register void *pDest); + +static inline void MI_CpuClearFast(void *destp, u32 size) { + MIi_CpuClearFast(0, destp, size); +} +static inline void MI_CpuClear8(void *dest, u32 size) { + MI_CpuFill8(dest, 0, size); +} + +static inline void MI_CpuFill16(void *dest, u16 data, u32 size) +{ + MIi_CpuClear16(data, dest, size); +} + +static inline void MI_CpuClear16(void * destp, u32 size) +{ + MIi_CpuClear16(0, destp, size); +} + +static inline void MI_CpuFill32(void *dest, u32 data, u32 size) +{ + MIi_CpuClear32(data, dest, size); +} + +static inline void MI_CpuClear32(void *dest, u32 size) +{ + MI_CpuFill32(dest, 0, size); +} + +static inline void MI_CpuCopy16(const void *src, void *dest, u32 size) +{ + MIi_CpuCopy16(src, dest, size); +} + +static inline void MI_CpuCopy32(const void *src, void *dest, u32 size) +{ + MIi_CpuCopy32(src, dest, size); +} + +static inline void MI_CpuFillFast(void *dest, u32 data, u32 size) +{ + MIi_CpuClearFast(data, dest, size); +} + +static inline void MI_CpuCopyFast(const void *src, void *dest, u32 size) +{ + MIi_CpuCopyFast(src, dest, size); +} + +#endif //POKEDIAMOND_ARM9_MI_MEMORY_H diff --git a/arm9/lib/NitroSDK/include/MI_swap.h b/arm9/lib/NitroSDK/include/MI_swap.h new file mode 100644 index 00000000..433b5804 --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_swap.h @@ -0,0 +1,6 @@ +#ifndef NITRO_MI_SWAP_H_ +#define NITRO_MI_SWAP_H_ + +u32 MI_SwapWord(u32 setData, volatile u32 * destp); + +#endif //NITRO_MI_SWAP_H_ diff --git a/arm9/lib/NitroSDK/include/MI_uncompress.h b/arm9/lib/NitroSDK/include/MI_uncompress.h new file mode 100644 index 00000000..defafa8c --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_uncompress.h @@ -0,0 +1,7 @@ +#ifndef POKEDIAMOND_MI_UNCOMPRESS_H +#define POKEDIAMOND_MI_UNCOMPRESS_H + +void MIi_UncompressBackward(void * bottom); +void MI_UncompressLZ8(register const void *srcp, register void *destp); + +#endif //POKEDIAMOND_MI_UNCOMPRESS_H diff --git a/arm9/lib/NitroSDK/include/MI_wram.h b/arm9/lib/NitroSDK/include/MI_wram.h new file mode 100644 index 00000000..fa445a8a --- /dev/null +++ b/arm9/lib/NitroSDK/include/MI_wram.h @@ -0,0 +1,14 @@ +#ifndef POKEDIAMOND_MI_WRAM_H +#define POKEDIAMOND_MI_WRAM_H + +typedef enum +{ + MI_WRAM_ARM9_ALL = 0, + MI_WRAM_1616_1 = 1, + MI_WRAM_1616_2 = 2, + MI_WRAM_ARM7_ALL = 3 +} MIWram; + +void MI_SetWramBank(MIWram cnt); + +#endif //POKEDIAMOND_MI_WRAM_H diff --git a/arm9/lib/NitroSDK/include/OS_alarm.h b/arm9/lib/NitroSDK/include/OS_alarm.h new file mode 100644 index 00000000..00a3c3d3 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_alarm.h @@ -0,0 +1,22 @@ +#ifndef POKEDIAMOND_ARM9_OS_ALARM_H +#define POKEDIAMOND_ARM9_OS_ALARM_H + +#include "nitro/types.h" +#include "OS_thread.h" +#include "OS_tick.h" +#include "nitro/OS_alarm_shared.h" + +struct OSiAlarmQueue +{ + OSAlarm *head; + OSAlarm *tail; +}; + +void OS_InitAlarm(void); +BOOL OS_IsAlarmAvailable(void); +void OS_CreateAlarm(OSAlarm *alarm); +void OS_SetAlarm(OSAlarm *alarm, OSTick tick, OSAlarmHandler handler, void *arg); +void OS_CancelAlarm(OSAlarm *alarm); +void OSi_AlarmHandler(void *arg); + +#endif //POKEDIAMOND_ARM9_OS_ALARM_H diff --git a/arm9/lib/NitroSDK/include/OS_alloc.h b/arm9/lib/NitroSDK/include/OS_alloc.h new file mode 100644 index 00000000..e73c2971 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_alloc.h @@ -0,0 +1,14 @@ +#ifndef POKEDIAMOND_ARM9_OS_ALLOC_H +#define POKEDIAMOND_ARM9_OS_ALLOC_H + +#include "nitro/types.h" +#include "OS_arena.h" +#include "nitro/OS_alloc_shared.h" + +Cell* DLAddFront(Cell* list, Cell* cell); +Cell* DLExtract(Cell* list, Cell* cell); +Cell *DLInsert(Cell *original, Cell *inserted); +void* OS_AllocFromHeap(OSArenaId id, OSHeapHandle heap, u32 size); +void OS_FreeToHeap(OSArenaId id, OSHeapHandle heap, void *ptr); + +#endif //POKEDIAMOND_ARM9_OS_ALLOC_H diff --git a/arm9/lib/NitroSDK/include/OS_arena.h b/arm9/lib/NitroSDK/include/OS_arena.h new file mode 100644 index 00000000..a26cf3bd --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_arena.h @@ -0,0 +1,18 @@ +#ifndef POKEDIAMOND_ARM9_OS_ARENA_H +#define POKEDIAMOND_ARM9_OS_ARENA_H + +#include "nitro/types.h" +#include "nitro/OS_arena_shared.h" + +void OS_InitArena(void); +void OS_InitArenaEx(void); +void* OS_GetArenaHi(OSArenaId id); +void* OS_GetArenaLo(OSArenaId id); +void* OS_GetInitArenaHi(OSArenaId id); +void* OS_GetInitArenaLo(OSArenaId id); +void OS_SetArenaHi(OSArenaId id, void *newHi); +void OS_SetArenaLo(OSArenaId id, void *newLo); +void* OS_AllocFromArenaLo(OSArenaId id, u32 size, u32 align); +void* OS_AllocFromArenaHi(OSArenaId id, u32 size, u32 align); + +#endif //POKEDIAMOND_ARM9_OS_ARENA_H diff --git a/arm9/lib/NitroSDK/include/OS_cache.h b/arm9/lib/NitroSDK/include/OS_cache.h new file mode 100644 index 00000000..425eab3f --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_cache.h @@ -0,0 +1,16 @@ +#ifndef POKEDIAMOND_OS_CACHE_H +#define POKEDIAMOND_OS_CACHE_H + +#include "nitro/types.h" + +void DC_InvalidateAll(void); +void DC_StoreAll(void); +void DC_FlushAll(void); +void DC_InvalidateRange(register void *startAddr, register u32 nBytes); +void DC_StoreRange(register void *startAddr, register u32 nBytes); +void DC_FlushRange(register const void *startAddr, register u32 nBytes); +void DC_WaitWriteBufferEmpty(void); +void IC_InvalidateAll(void); +void IC_InvalidateRange(register void *startAddr, register u32 nBytes); + +#endif //POKEDIAMOND_OS_CACHE_H diff --git a/arm9/lib/NitroSDK/include/OS_context.h b/arm9/lib/NitroSDK/include/OS_context.h new file mode 100644 index 00000000..d3e24673 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_context.h @@ -0,0 +1,22 @@ +#ifndef POKEDIAMOND_ARM9_OS_CONTEXT_H +#define POKEDIAMOND_ARM9_OS_CONTEXT_H + +#include "nitro/types.h" +#include "CP_context.h" + +typedef struct OSContext +{ + u32 cpsr; + u32 r[13]; + u32 sp; + u32 lr; + u32 pc_plus4; + u32 sp_svc; + CPContext cp_context; +} OSContext; + +void OS_InitContext(register OSContext *context, register u32 newpc, register u32 newsp); +BOOL OS_SaveContext(register OSContext *context); +void OS_LoadContext(register OSContext *context); + +#endif //POKEDIAMOND_ARM9_OS_CONTEXT_H diff --git a/arm9/lib/NitroSDK/include/OS_emulator.h b/arm9/lib/NitroSDK/include/OS_emulator.h new file mode 100644 index 00000000..30acec16 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_emulator.h @@ -0,0 +1,13 @@ +// +// Created by red031000 on 2020-05-05. +// + +#ifndef POKEDIAMOND_OS_EMULATOR_H +#define POKEDIAMOND_OS_EMULATOR_H + +#include "consts.h" + +BOOL OS_IsRunOnEmulator(void); +u32 OS_GetConsoleType(void); + +#endif //POKEDIAMOND_OS_EMULATOR_H diff --git a/arm9/lib/NitroSDK/include/OS_entropy.h b/arm9/lib/NitroSDK/include/OS_entropy.h new file mode 100644 index 00000000..7c39aadd --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_entropy.h @@ -0,0 +1,21 @@ +// +// Created by red031000 on 2020-05-03. +// + +#ifndef POKEDIAMOND_OS_ENTROPY_H +#define POKEDIAMOND_OS_ENTROPY_H + +#include "registers.h" + +void OS_GetLowEntropyData(u32 * arr); + +extern vu64 OSi_TickCounter; + +extern u16 OS_GetTickLo(void); + +static inline s32 GX_GetVCount(void) +{ + return reg_GX_VCOUNT; +} + +#endif //POKEDIAMOND_OS_ENTROPY_H diff --git a/arm9/lib/NitroSDK/include/OS_exception.h b/arm9/lib/NitroSDK/include/OS_exception.h new file mode 100644 index 00000000..26fc3525 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_exception.h @@ -0,0 +1,21 @@ +#ifndef POKEDIAMOND_OS_EXCEPTION_H +#define POKEDIAMOND_OS_EXCEPTION_H + +#include "consts.h" +#include "OS_context.h" + +typedef struct +{ + OSContext context; + u32 cp15; + u32 spsr; + u32 exinfo; + u32 debug[4]; +} OSiExContext; + +typedef void (*OSExceptionHandler) (u32, void *); + +void OS_InitException(void); +void OSi_ExceptionHandler(void); + +#endif //POKEDIAMOND_OS_EXCEPTION_H diff --git a/arm9/lib/NitroSDK/include/OS_init.h b/arm9/lib/NitroSDK/include/OS_init.h new file mode 100644 index 00000000..f0b80220 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_init.h @@ -0,0 +1,33 @@ +#ifndef POKEDIAMOND_ARM9_OS_INIT_H +#define POKEDIAMOND_ARM9_OS_INIT_H + +#include "nitro/types.h" +#include "consts.h" +#include "OS_tcm.h" +#include "OS_spinLock.h" +#include "OS_context.h" +#include "OS_timer.h" +#include "OS_tick.h" +#include "OS_alarm.h" +#include "OS_mutex.h" +#include "OS_thread.h" +#include "OS_protectionRegion.h" +#include "OS_protectionUnit.h" +#include "OS_entropy.h" +#include "OS_emulator.h" +#include "OS_arena.h" +#include "OS_alloc.h" +#include "OS_system.h" +#include "OS_terminate_proc.h" +#include "OS_irqHandler.h" +#include "OS_irqTable.h" +#include "OS_interrupt.h" +#include "OS_reset.h" +#include "OS_exception.h" +#include "OS_message.h" +#include "OS_valarm.h" +#include "OS_vramExclusive.h" + +void OS_Init(void); + +#endif //POKEDIAMOND_ARM9_OS_INIT_H diff --git a/arm9/lib/NitroSDK/include/OS_interrupt.h b/arm9/lib/NitroSDK/include/OS_interrupt.h new file mode 100644 index 00000000..19dd0da2 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_interrupt.h @@ -0,0 +1,60 @@ +#ifndef POKEDIAMOND_ARM9_OS_INTERRUPT_H +#define POKEDIAMOND_ARM9_OS_INTERRUPT_H + +#include "registers.h" +#include "nitro/OS_interrupt_shared.h" + +#define REG_OS_IME_IME_SHIFT 0 + +#define OS_IME_DISABLE (0UL << REG_OS_IME_IME_SHIFT) +#define OS_IME_ENABLE (1UL << REG_OS_IME_IME_SHIFT) + +#define OS_IE_V_COUNT (1UL << REG_OS_IE_VE_SHIFT) +#define OS_IE_TIMER0 (1UL << REG_OS_IE_T0_SHIFT) +#define OS_IE_TIMER1 (1UL << REG_OS_IE_T1_SHIFT) +#define OS_IE_TIMER2 (1UL << REG_OS_IE_T2_SHIFT) +#define OS_IE_TIMER3 (1UL << REG_OS_IE_T3_SHIFT) +#define OS_IE_SPFIFO_RECV (1UL << REG_OS_IE_IFN_SHIFT) +#define OS_IE_CARD_DATA (1UL << REG_OS_IE_MC_SHIFT) + +extern OSIrqFunction OS_IRQTable[]; +extern OSIrqCallbackInfo OSi_IrqCallbackInfo[8]; + +void OS_InitIrqTable(void); +void OS_SetIrqFunction(OSIrqMask intrBit, OSIrqFunction function); +OSIrqFunction OS_GetIrqFunction(OSIrqMask intrBit); +void OSi_EnterDmaCallback(u32 dmaNo, void (*callback) (void *), void *arg); +void OSi_EnterTimerCallback(u32 timerNo, void (*callback) (void *), void *arg); +OSIrqMask OS_SetIrqMask(OSIrqMask mask); +OSIrqMask OS_EnableIrqMask(OSIrqMask mask); +OSIrqMask OS_DisableIrqMask(OSIrqMask mask); +OSIrqMask OS_ResetRequestIrqMask(OSIrqMask mask); +void OS_SetIrqStackChecker(void); + +static inline BOOL OS_DisableIrq(void) +{ + u16 prep = reg_OS_IME; + reg_OS_IME = OS_IME_DISABLE; + return (BOOL)prep; +} + +static inline BOOL OS_EnableIrq(void) +{ + u16 prep = reg_OS_IME; + reg_OS_IME = OS_IME_ENABLE; + return (BOOL)prep; +} + +static inline BOOL OS_RestoreIrq(BOOL enable) +{ + u16 prep = reg_OS_IME; + reg_OS_IME = (u16)enable; + return (BOOL)prep; +} + +static inline OSIrqMask OS_GetIrqMask(void) +{ + return reg_OS_IE; +} + +#endif //POKEDIAMOND_ARM9_OS_INTERRUPT_H diff --git a/arm9/lib/NitroSDK/include/OS_irqHandler.h b/arm9/lib/NitroSDK/include/OS_irqHandler.h new file mode 100644 index 00000000..e845298b --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_irqHandler.h @@ -0,0 +1,21 @@ +#ifndef POKEDIAMOND_OS_IRQHANDLER_H +#define POKEDIAMOND_OS_IRQHANDLER_H + +#include "OS_interrupt.h" +#include "mmap.h" + +static inline void OS_ClearIrqCheckFlag(OSIrqMask intr) +{ + *(vu32 *)HW_INTR_CHECK_BUF &= (u32)~intr; +} + +static inline OSIrqMask OS_GetIrqCheckFlag(void) +{ + return *(OSIrqMask *)HW_INTR_CHECK_BUF; +} + +void OS_IrqHandler(void); +void OS_IrqHandler_ThreadSwitch(void); +void OS_WaitIrq(BOOL clear, OSIrqMask irqFlags); + +#endif //POKEDIAMOND_OS_IRQHANDLER_H diff --git a/arm9/lib/NitroSDK/include/OS_irqTable.h b/arm9/lib/NitroSDK/include/OS_irqTable.h new file mode 100644 index 00000000..ba8b45a8 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_irqTable.h @@ -0,0 +1,23 @@ +#ifndef POKEDIAMOND_ARM9_OS_IRQTABLE_H +#define POKEDIAMOND_ARM9_OS_IRQTABLE_H + +#include "mmap.h" +#include "OS_interrupt.h" + +void OS_IrqDummy(void); +void OSi_IrqCallback(s32 index); +void OSi_IrqDma0(void); +void OSi_IrqDma1(void); +void OSi_IrqDma2(void); +void OSi_IrqDma3(void); +void OSi_IrqTimer0(void); +void OSi_IrqTimer1(void); +void OSi_IrqTimer2(void); +void OSi_IrqTimer3(void); + +static inline void OS_SetIrqCheckFlag(OSIrqMask intr) +{ + *(vu32 *)HW_INTR_CHECK_BUF |= (u32)intr; +} + +#endif //POKEDIAMOND_ARM9_OS_IRQTABLE_H diff --git a/arm9/lib/NitroSDK/include/OS_message.h b/arm9/lib/NitroSDK/include/OS_message.h new file mode 100644 index 00000000..b9c570db --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_message.h @@ -0,0 +1,15 @@ +#ifndef POKEDIAMOND_ARM9_OS_MESSAGE_H +#define POKEDIAMOND_ARM9_OS_MESSAGE_H + +#include "OS_thread.h" +#include "OS_context.h" +#include "nitro/types.h" +#include "nitro/OS_message_shared.h" + +void OS_InitMessageQueue(OSMessageQueue *mq, OSMessage *msgArray, s32 msgCount); +BOOL OS_SendMessage(OSMessageQueue *mq, OSMessage msg, s32 flags); +BOOL OS_ReceiveMessage(OSMessageQueue *mq, OSMessage *msg, s32 flags); +BOOL OS_JamMessage(OSMessageQueue *mq, OSMessage msg, s32 flags); +BOOL OS_ReadMessage(OSMessageQueue *mq, OSMessage *msg, s32 flags); + +#endif //POKEDIAMOND_ARM9_OS_MESSAGE_H diff --git a/arm9/lib/NitroSDK/include/OS_mutex.h b/arm9/lib/NitroSDK/include/OS_mutex.h new file mode 100644 index 00000000..23e4337e --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_mutex.h @@ -0,0 +1,17 @@ +#ifndef POKEDIAMOND_ARM9_OS_MUTEX_H +#define POKEDIAMOND_ARM9_OS_MUTEX_H + +#include "OS_thread.h" +#include "OS_context.h" +#include "nitro/OS_mutex_shared.h" +#include "nitro/types.h" + +void OS_InitMutex(OSMutex *mutex); +void OS_LockMutex(OSMutex *mutex); +void OS_UnlockMutex(OSMutex *mutex); +void OSi_UnlockAllMutex(OSThread * thread); +BOOL OS_TryLockMutex(OSMutex *mutex); +void OSi_EnqueueTail(OSThread *thread, OSMutex *mutex); +void OSi_DequeueItem(OSThread *thread, OSMutex *mutex); + +#endif //POKEDIAMOND_ARM9_OS_MUTEX_H diff --git a/arm9/lib/NitroSDK/include/OS_ownerInfo.h b/arm9/lib/NitroSDK/include/OS_ownerInfo.h new file mode 100644 index 00000000..13bae06e --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_ownerInfo.h @@ -0,0 +1,28 @@ +#ifndef POKEDIAMOND_OS_OWNERINFO_H +#define POKEDIAMOND_OS_OWNERINFO_H + +#include "consts.h" +#include "userInfo.h" + +typedef struct OSBirthday +{ + u8 month; + u8 day; +} OSBirthday; + +typedef struct OSOwnerInfo +{ + u8 language; + u8 favoriteColour; + OSBirthday birthday; + u16 nickName[10]; //either 10 or 8 + u16 nickNameLength; + u16 comment[26]; + u16 commentLength; +} OSOwnerInfo; + +void OS_GetMacAddress(u8 *macAddress); +void OS_GetOwnerInfo(OSOwnerInfo* info); +s64 OS_GetOwnerRtcOffset(void); + +#endif //POKEDIAMOND_OS_OWNERINFO_H diff --git a/arm9/lib/NitroSDK/include/OS_printf.h b/arm9/lib/NitroSDK/include/OS_printf.h new file mode 100644 index 00000000..acb7f8c7 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_printf.h @@ -0,0 +1,15 @@ +#ifndef NITRO_OS_PRINTF_H_ +#define NITRO_OS_PRINTF_H_ + +#define OS_Warning( ... ) ((void)0) +#define OS_TPanic(...) OS_Terminate() +#define OS_TWarning(...) ((void)0) + +#include "nitro/types.h" + +s32 OS_SPrintf(s8 *buffer, const s8 *format, ...); +s32 OS_VSPrintf(s8 *buffer, const s8 *format, void *args); +s32 OS_SNPrintf(s8 *buffer, s32 bufsz, const s8 *format, ...); +s32 OS_VSNPrintf(s8 *buffer, s32 bufsz, const s8 *format, void *args); + +#endif //NITRO_OS_PRINTF_H_ diff --git a/arm9/lib/NitroSDK/include/OS_protectionRegion.h b/arm9/lib/NitroSDK/include/OS_protectionRegion.h new file mode 100644 index 00000000..00b7ae63 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_protectionRegion.h @@ -0,0 +1,48 @@ +#ifndef POKEDIAMOND_OS_PROTECTIONREGION_H +#define POKEDIAMOND_OS_PROTECTIONREGION_H + +#include "nitro/types.h" +#include "consts.h" + +void OS_SetDPermissionsForProtectionRegion(register u32 setMask, register u32 flags); +void OS_SetProtectionRegion1(u32 param); +void OS_SetProtectionRegion2(u32 param); + +typedef enum +{ + OSi_PR_BASE_MASK_4KB = 0xfffff000, + OSi_PR_BASE_MASK_8KB = 0xffffe000, + OSi_PR_BASE_MASK_16KB = 0xffffc000, + OSi_PR_BASE_MASK_32KB = 0xffff8000, + OSi_PR_BASE_MASK_64KB = 0xffff0000, + OSi_PR_BASE_MASK_128KB = 0xfffe0000, + OSi_PR_BASE_MASK_256KB = 0xfffc0000, + OSi_PR_BASE_MASK_512KB = 0xfff80000, + OSi_PR_BASE_MASK_1MB = 0xfff00000, + OSi_PR_BASE_MASK_2MB = 0xffe00000, + OSi_PR_BASE_MASK_4MB = 0xffc00000, + OSi_PR_BASE_MASK_8MB = 0xff800000, + OSi_PR_BASE_MASK_16MB = 0xff000000, + OSi_PR_BASE_MASK_32MB = 0xfe000000, + OSi_PR_BASE_MASK_64MB = 0xfc000000, + OSi_PR_BASE_MASK_128MB = 0xf8000000, + OSi_PR_BASE_MASK_256MB = 0xf0000000, + OSi_PR_BASE_MASK_512MB = 0xe0000000, + OSi_PR_BASE_MASK_1GB = 0xc0000000, + OSi_PR_BASE_MASK_2GB = 0x80000000, + OSi_PR_BASE_MASK_4GB = 0x00000000 +} OSiProtectionRegionBaseMask; + +static inline u32 OSi_CalcPRParam(u32 address, u32 size, OSiProtectionRegionBaseMask mask) { + return ((address & mask) | size); +} + +#define OS_SetProtectionRegion(regionNo, address, sizeStr) \ + OS_SetProtectionRegion##regionNo(OSi_CalcPRParam(address, HW_C6_PR_##sizeStr, OSi_PR_BASE_MASK_##sizeStr) \ + | 1) + +#define OS_PR3_ACCESS_MASK (HW_C5_PERMIT_MASK << HW_C5_PR3_SFT) +#define OS_PR3_ACCESS_RW (HW_C5_PERMIT_RW << HW_C5_PR3_SFT) +#define OS_PR3_ACCESS_RO (HW_C5_PERMIT_RO << HW_C5_PR3_SFT) + +#endif //POKEDIAMOND_OS_PROTECTIONREGION_H diff --git a/arm9/lib/NitroSDK/include/OS_protectionUnit.h b/arm9/lib/NitroSDK/include/OS_protectionUnit.h new file mode 100644 index 00000000..e7dc32d8 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_protectionUnit.h @@ -0,0 +1,11 @@ +// +// Created by red031000 on 2020-05-24. +// + +#ifndef POKEDIAMOND_OS_PROTECTIONUNIT_H +#define POKEDIAMOND_OS_PROTECTIONUNIT_H + +void OS_EnableProtectionUnit(void); +void OS_DisableProtectionUnit(void); + +#endif //POKEDIAMOND_OS_PROTECTIONUNIT_H diff --git a/arm9/lib/NitroSDK/include/OS_reset.h b/arm9/lib/NitroSDK/include/OS_reset.h new file mode 100644 index 00000000..756de9fb --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_reset.h @@ -0,0 +1,16 @@ +#ifndef POKEDIAMOND_ARM9_OS_RESET_H +#define POKEDIAMOND_ARM9_OS_RESET_H + +#include "nitro/OS_reset_shared.h" +#include "mmap.h" + +void OS_InitReset(void); +void OS_ResetSystem(u32 parameter); +void OSi_DoBoot(void); + +static inline u32 OS_GetResetParameter(void) +{ + return (u32)*(u32 *)HW_RESET_PARAMETER_BUF; +} + +#endif //POKEDIAMOND_ARM9_OS_RESET_H diff --git a/arm9/lib/NitroSDK/include/OS_spinLock.h b/arm9/lib/NitroSDK/include/OS_spinLock.h new file mode 100644 index 00000000..09c2cf2c --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_spinLock.h @@ -0,0 +1,42 @@ +#ifndef POKEDIAMOND_ARM9_OS_SPINLOCK_H +#define POKEDIAMOND_ARM9_OS_SPINLOCK_H + +#include "nitro/types.h" +#include "nitro/OS_spinLock_shared.h" +#include "syscall.h" + +#define OS_ReadOwnerOfLockCartridge() OS_ReadOwnerOfLockWord( (OSLockWord *)HW_CTRDG_LOCK_BUF ) +#define OS_MAINP_LOCKED_FLAG 0x40 +#define OS_LOCK_SUCCESS 0 + +#define OS_LOCK_ID_ERROR (-3) + +static inline void OSi_WaitByLoop(void) +{ + SVC_WaitByLoop(0x1000 / 4); +} + +void OS_InitLock(void); +s32 OSi_DoLockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void), + BOOL disableFiq); +s32 OS_TryLockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void)); +s32 OSi_DoUnlockByWord(u16 lockID, OSLockWord *lockp, void (*ctrlFuncp) (void), + BOOL disableFIQ); +s32 OS_UnlockByWord(u16 lockId, OSLockWord *lockp, void (*ctrlFuncp) (void)); +s32 OSi_DoTryLockByWord(u16 lockID, OSLockWord *lockp, void (*ctrlFuncp) (void), + BOOL disableFiq); +s32 OS_LockCartridge(u16 lockID); +s32 OS_UnlockCartridge(u16 lockID); +s32 OS_TryLockCartridge(u16 lockID); +void OSi_AllocateCartridgeBus(void); +void OSi_FreeCartridgeBus(void); +s32 OS_TryLockCard(u16 lockID); +s32 OS_UnlockCard(u16 lockID); +void OSi_AllocateCardBus(void); +void OSi_FreeCardBus(void); +u16 OS_ReadOwnerOfLockWord(OSLockWord * lock); +s32 OS_UnLockCartridge(u16 lockID); +s32 OS_GetLockID(void); +void OS_ReleaseLockID(register u16 lockID); + +#endif //POKEDIAMOND_ARM9_OS_SPINLOCK_H diff --git a/arm9/lib/NitroSDK/include/OS_system.h b/arm9/lib/NitroSDK/include/OS_system.h new file mode 100644 index 00000000..37dbbd76 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_system.h @@ -0,0 +1,18 @@ +#ifndef POKEDIAMOND_ARM9_OS_SYSTEM_H +#define POKEDIAMOND_ARM9_OS_SYSTEM_H + +#include "function_target.h" +#include "consts.h" +#include "nitro/OS_system_shared.h" + +OSIntrMode OS_EnableInterrupts(void); +OSIntrMode OS_DisableInterrupts(void); +OSIntrMode OS_RestoreInterrupts(OSIntrMode state); +OSIntrMode OS_DisableInterrupts_IrqAndFiq(void); +OSIntrMode OS_RestoreInterrupts_IrqAndFiq(OSIntrMode state); +OSIntrMode OS_GetCpsrIrq(void); +OSProcMode OS_GetProcMode(void); +void OS_SpinWait(u32 cycles); +void OS_WaitVBlankIntr(void); + +#endif //POKEDIAMOND_ARM9_OS_SYSTEM_H diff --git a/arm9/lib/NitroSDK/include/OS_tcm.h b/arm9/lib/NitroSDK/include/OS_tcm.h new file mode 100644 index 00000000..66f8ec59 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_tcm.h @@ -0,0 +1,12 @@ +// +// Created by red031000 on 2020-05-05. +// + +#ifndef POKEDIAMOND_OS_TCM_H +#define POKEDIAMOND_OS_TCM_H + +#include "consts.h" + +u32 OS_GetDTCMAddress(void); + +#endif //POKEDIAMOND_OS_TCM_H diff --git a/arm9/lib/NitroSDK/include/OS_terminate_proc.h b/arm9/lib/NitroSDK/include/OS_terminate_proc.h new file mode 100644 index 00000000..b4553fb4 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_terminate_proc.h @@ -0,0 +1,9 @@ +#ifndef POKEDIAMOND_ARM9_OS_TERMINATE_PROC_H +#define POKEDIAMOND_ARM9_OS_TERMINATE_PROC_H + +#include "nitro/types.h" + +void OS_Terminate(void); +void OS_Halt(void); + +#endif //POKEDIAMOND_ARM9_OS_TERMINATE_PROC_H diff --git a/arm9/lib/NitroSDK/include/OS_thread.h b/arm9/lib/NitroSDK/include/OS_thread.h new file mode 100644 index 00000000..e330e219 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_thread.h @@ -0,0 +1,30 @@ +#ifndef POKEDIAMOND_ARM9_OS_THREAD_H +#define POKEDIAMOND_ARM9_OS_THREAD_H + +#include "nitro/types.h" +#include "OS_context.h" +#include "nitro/OS_thread_shared.h" + +OSMutex *OSi_RemoveMutexLinkFromQueue(OSMutexQueue *queue); +void OS_InitThread(void); +BOOL OS_IsThreadAvailable(void); +void OS_CreateThread(OSThread *thread, void (*func) (void *), void *arg, void *stack, u32 stackSize, u32 prio); +void OS_ExitThread(void); +void OS_DestroyThread(OSThread *thread); +void OS_JoinThread(OSThread *thread); +BOOL OS_IsThreadTerminated(const OSThread *thread); +void OS_SleepThread(OSThreadQueue *queue); +void OS_WakeupThread(OSThreadQueue *queue); +void OS_WakeupThreadDirect(OSThread *thread); +OSThread *OS_SelectThread(void); +void OS_RescheduleThread(void); +void OS_YieldThread(void); +BOOL OS_SetThreadPriority(OSThread *thread, u32 prio); +u32 OS_GetThreadPriority(const OSThread *thread); +void OS_Sleep(u32 msec); +OSSwitchThreadCallback OS_SetSwitchThreadCallback(OSSwitchThreadCallback callback); +u32 OS_DisableScheduler(void); +u32 OS_EnableScheduler(void); +void OS_SetThreadDestructor(OSThread *thread, OSThreadDestructor dtor); + +#endif //POKEDIAMOND_ARM9_OS_THREAD_H diff --git a/arm9/lib/NitroSDK/include/OS_tick.h b/arm9/lib/NitroSDK/include/OS_tick.h new file mode 100644 index 00000000..e0b6ea39 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_tick.h @@ -0,0 +1,15 @@ +#ifndef POKEDIAMOND_ARM9_OS_TICK_H +#define POKEDIAMOND_ARM9_OS_TICK_H + +#include "consts.h" +#include "OS_timer.h" +#include "nitro/OS_tick_shared.h" + +#define OSi_TICK_TIMERCONTROL (REG_OS_TM0CNT_H_E_MASK | REG_OS_TM0CNT_H_I_MASK | OS_TIMER_PRESCALER_64) + +void OS_InitTick(void); +BOOL OS_IsTickAvailable(void); +OSTick OS_GetTick(void); +u16 OS_GetTickLo(void); + +#endif //POKEDIAMOND_ARM9_OS_TICK_H diff --git a/arm9/lib/NitroSDK/include/OS_timer.h b/arm9/lib/NitroSDK/include/OS_timer.h new file mode 100644 index 00000000..4a10041b --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_timer.h @@ -0,0 +1,9 @@ +#ifndef POKEDIAMOND_ARM9_OS_TIMER_H +#define POKEDIAMOND_ARM9_OS_TIMER_H + +#include "nitro/OS_timer_shared.h" +#include "nitro/types.h" + +void OSi_SetTimerReserved(s32 timerNum); + +#endif //POKEDIAMOND_ARM9_OS_TIMER_H diff --git a/arm9/lib/NitroSDK/include/OS_valarm.h b/arm9/lib/NitroSDK/include/OS_valarm.h new file mode 100644 index 00000000..b4850f9d --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_valarm.h @@ -0,0 +1,25 @@ +#ifndef POKEDIAMOND_OS_VALARM_H +#define POKEDIAMOND_OS_VALARM_H + +#include "nitro/types.h" +#include "OS_alarm.h" + +typedef struct OSiVAlarm OSVAlarm; +struct OSiVAlarm +{ + OSAlarmHandler handler; + void *arg; + u32 tag; + u32 frame; + s16 fire; + s16 delay; + OSVAlarm *prev; + OSVAlarm *next; + BOOL period; + BOOL finish; + BOOL canceled; +}; + +void OS_InitVAlarm(void); + +#endif //POKEDIAMOND_OS_VALARM_H diff --git a/arm9/lib/NitroSDK/include/OS_vramExclusive.h b/arm9/lib/NitroSDK/include/OS_vramExclusive.h new file mode 100644 index 00000000..d7c3ef92 --- /dev/null +++ b/arm9/lib/NitroSDK/include/OS_vramExclusive.h @@ -0,0 +1,10 @@ +#ifndef POKEDIAMOND_OS_VRAMEXCLUSIVE_H +#define POKEDIAMOND_OS_VRAMEXCLUSIVE_H + +#include "nitro/types.h" + +void OSi_InitVramExclusive(void); +BOOL OSi_TryLockVram(u16 bank, u16 lockId); +void OSi_UnlockVram(u16 bank, u16 lockId); + +#endif //POKEDIAMOND_OS_VRAMEXCLUSIVE_H diff --git a/arm9/lib/NitroSDK/include/PAD_pad.h b/arm9/lib/NitroSDK/include/PAD_pad.h new file mode 100644 index 00000000..f3de4198 --- /dev/null +++ b/arm9/lib/NitroSDK/include/PAD_pad.h @@ -0,0 +1,45 @@ +#ifndef NITRO_PAD_PAD_H_ +#define NITRO_PAD_PAD_H_ + +#include "registers.h" + +//================================================================================ +// BUTTONS + +//---- masked value +#define PAD_PLUS_KEY_MASK 0x00f0 // mask : cross keys +#define PAD_BUTTON_MASK 0x2f0f // mask : buttons +#define PAD_DEBUG_BUTTON_MASK 0x2000 // mask : debug button +#define PAD_ALL_MASK 0x2fff // mask : all buttons +#define PAD_RCNTPORT_MASK 0x2c00 // mask : factors ARM7 can read from RCNT register +#define PAD_KEYPORT_MASK 0x03ff // mask : factors ARM7/9 can read from KEY register + +#define PAD_DETECT_FOLD_MASK 0x8000 // mask : folding + +//---- button and key +#define PAD_BUTTON_A 0x0001 // A +#define PAD_BUTTON_B 0x0002 // B +#define PAD_BUTTON_SELECT 0x0004 // SELECT +#define PAD_BUTTON_START 0x0008 // START +#define PAD_KEY_RIGHT 0x0010 // RIGHT of cross key +#define PAD_KEY_LEFT 0x0020 // LEFT of cross key +#define PAD_KEY_UP 0x0040 // UP of cross key +#define PAD_KEY_DOWN 0x0080 // DOWN of cross key +#define PAD_BUTTON_R 0x0100 // R +#define PAD_BUTTON_L 0x0200 // L +#define PAD_BUTTON_X 0x0400 // X +#define PAD_BUTTON_Y 0x0800 // Y +#define PAD_BUTTON_DEBUG 0x2000 // Debug button + +static inline u16 PAD_Read(void) +{ + return (u16)(((reg_PAD_KEYINPUT | *(vu16 *)HW_BUTTON_XY_BUF) ^ + (PAD_PLUS_KEY_MASK | PAD_BUTTON_MASK)) & (PAD_PLUS_KEY_MASK | PAD_BUTTON_MASK)); +} + +static inline BOOL PAD_DetectFold(void) +{ + return (BOOL)((*(vu16 *)HW_BUTTON_XY_BUF & PAD_DETECT_FOLD_MASK) >> 15); +} + +#endif //NITRO_PAD_PAD_H_ diff --git a/arm9/lib/NitroSDK/include/PXI_fifo.h b/arm9/lib/NitroSDK/include/PXI_fifo.h new file mode 100644 index 00000000..b1ca33f3 --- /dev/null +++ b/arm9/lib/NitroSDK/include/PXI_fifo.h @@ -0,0 +1,36 @@ +#ifndef POKEDIAMOND_ARM9_PXI_FIFO_H +#define POKEDIAMOND_ARM9_PXI_FIFO_H + +#include "nitro/PXI_fifo_shared.h" +#include "nitro/types.h" + +typedef enum +{ + PXI_FIFO_SUCCESS = 0, + PXI_FIFO_FAIL_SEND_ERR = -1, + PXI_FIFO_FAIL_SEND_FULL = -2, + PXI_FIFO_FAIL_RECV_ERR = -3, + PXI_FIFO_FAIL_RECV_EMPTY = -4, + PXI_FIFO_NO_CALLBACK_ENTRY = -5 +} PXIFifoStatus; + +typedef void (*PXIFifoCallback) (PXIFifoTag tag, u32 data, BOOL err); + +typedef union +{ + struct + { + u32 tag:5; + u32 err:1; + u32 data:26; + } e; + u32 raw; +} PXIFifoMessage; + +void PXI_InitFifo(void); +void PXI_SetFifoRecvCallback(s32 fifotag, PXIFifoCallback callback); +BOOL PXI_IsCallbackReady(s32 fifotag, PXIProc proc); +s32 PXI_SendWordByFifo(s32 fifotag, u32 data, BOOL err); +void PXIi_HandlerRecvFifoNotEmpty(void); + +#endif //POKEDIAMOND_ARM9_PXI_FIFO_H diff --git a/arm9/lib/NitroSDK/include/PXI_init.h b/arm9/lib/NitroSDK/include/PXI_init.h new file mode 100644 index 00000000..5c330c9c --- /dev/null +++ b/arm9/lib/NitroSDK/include/PXI_init.h @@ -0,0 +1,6 @@ +#ifndef POKEDIAMOND_PXI_INIT_H +#define POKEDIAMOND_PXI_INIT_H + +void PXI_Init(void); + +#endif //POKEDIAMOND_PXI_INIT_H diff --git a/arm9/lib/NitroSDK/include/RTC_api.h b/arm9/lib/NitroSDK/include/RTC_api.h new file mode 100644 index 00000000..09efde7e --- /dev/null +++ b/arm9/lib/NitroSDK/include/RTC_api.h @@ -0,0 +1,111 @@ +#ifndef NITRO_RTC_API_H_ +#define NITRO_RTC_API_H_ + +typedef enum RTCAlarmChan +{ + RTC_ALARM_CHAN_1 = 0, + RTC_ALARM_CHAN_2, + RTC_ALARM_CHAN_MAX +} +RTCAlarmChan; + +// Alarm status definitions +typedef enum RTCAlarmStatus +{ + RTC_ALARM_STATUS_OFF = 0, + RTC_ALARM_STATUS_ON, + RTC_ALARM_STATUS_MAX +} +RTCAlarmStatus; + +#define RTC_ALARM_ENABLE_NONE 0x0000 +#define RTC_ALARM_ENABLE_WEEK 0x0001 +#define RTC_ALARM_ENABLE_HOUR 0x0002 +#define RTC_ALARM_ENABLE_MINUTE 0x0004 +#define RTC_ALARM_ENABLE_ALL ( RTC_ALARM_ENABLE_WEEK | RTC_ALARM_ENABLE_HOUR | RTC_ALARM_ENABLE_MINUTE ) + +typedef enum RTCWeek +{ + RTC_WEEK_SUNDAY = 0, + RTC_WEEK_MONDAY, + RTC_WEEK_TUESDAY, + RTC_WEEK_WEDNESDAY, + RTC_WEEK_THURSDAY, + RTC_WEEK_FRIDAY, + RTC_WEEK_SATURDAY, + RTC_WEEK_MAX +} +RTCWeek; + +typedef struct RTCDate +{ + u32 year; + u32 month; + u32 day; + RTCWeek week; +} +RTCDate; + +typedef struct RTCTime +{ + u32 hour; + u32 minute; + u32 second; +} +RTCTime; + +typedef struct RTCAlarmParam +{ + RTCWeek week; // Day of the week + u32 hour; // Hour ( 0 ~ 23 ) + u32 minute; // Minute ( 0 ~ 59 ) + u32 enable; // Alarm enable flag ( RTC_ALARM_ENABLE_* ) + +} +RTCAlarmParam; + +typedef enum RTCResult +{ + RTC_RESULT_SUCCESS = 0, + RTC_RESULT_BUSY, + RTC_RESULT_ILLEGAL_PARAMETER, + RTC_RESULT_SEND_ERROR, + RTC_RESULT_INVALID_COMMAND, + RTC_RESULT_ILLEGAL_STATUS, + RTC_RESULT_FATAL_ERROR, + RTC_RESULT_MAX +} +RTCResult; + +typedef void (*RTCCallback) (RTCResult result, void *arg); +typedef void (*RTCInterrupt) (void); + +void RTC_Init(void); +RTCResult RTC_GetDate(RTCDate *date); +RTCResult RTC_GetTime(RTCTime *time); +RTCResult RTC_GetDateTime(RTCDate *date, RTCTime *time); +RTCResult RTC_SetDate(const RTCDate *date); +RTCResult RTC_SetTime(const RTCTime *time); +RTCResult RTC_SetDateTime(const RTCDate *date, const RTCTime *time); +RTCResult RTC_GetAlarmStatus(RTCAlarmChan chan, RTCAlarmStatus *status); +RTCResult RTC_GetAlarmParam(RTCAlarmChan chan, RTCAlarmParam *param); +RTCResult RTC_SetAlarmStatus(RTCAlarmChan chan, const RTCAlarmStatus *status); +RTCResult RTC_SetAlarmParam(RTCAlarmChan chan, const RTCAlarmParam *param); +RTCResult RTC_GetDateAsync(RTCDate *date, RTCCallback callback, void *arg); +RTCResult RTC_GetTimeAsync(RTCTime *time, RTCCallback callback, void *arg); +RTCResult RTC_GetDateTimeAsync(RTCDate *date, RTCTime *time, RTCCallback callback, void *arg); +RTCResult RTC_SetDateAsync(const RTCDate *date, RTCCallback callback, void *arg); +RTCResult RTC_SetTimeAsync(const RTCTime *time, RTCCallback callback, void *arg); +RTCResult RTC_SetDateTimeAsync(const RTCDate *date, const RTCTime *time, RTCCallback callback, + void *arg); +RTCResult RTC_GetAlarmStatusAsync(RTCAlarmChan chan, RTCAlarmStatus *status, RTCCallback callback, + void *arg); +RTCResult RTC_GetAlarmParamAsync(RTCAlarmChan chan, RTCAlarmParam *param, RTCCallback callback, + void *arg); +void RTC_SetAlarmInterrupt(RTCInterrupt interrupt); +RTCResult RTC_SetAlarmStatusAsync(RTCAlarmChan chan, const RTCAlarmStatus *status, + RTCCallback callback, void *arg); +RTCResult RTC_SetAlarmParamAsync(RTCAlarmChan chan, const RTCAlarmParam *param, + RTCCallback callback, void *arg); + +#endif //NITRO_RTC_API_H_ diff --git a/arm9/lib/NitroSDK/include/RTC_convert.h b/arm9/lib/NitroSDK/include/RTC_convert.h new file mode 100644 index 00000000..a75928b9 --- /dev/null +++ b/arm9/lib/NitroSDK/include/RTC_convert.h @@ -0,0 +1,12 @@ +#ifndef NITRO_RTC_CONVERT_H_ +#define NITRO_RTC_CONVERT_H_ + +s32 RTC_ConvertDateToDay(const RTCDate * date); +s32 RTCi_ConvertTimeToSecond(const RTCTime * time); +s64 RTC_ConvertDateTimeToSecond(const RTCDate * date, const RTCTime * time); +void RTC_ConvertDayToDate(RTCDate * date, s32 day); +void RTCi_ConvertSecondToTime(RTCTime * time, s32 sec); +void RTC_ConvertSecondToDateTime(RTCDate * date, RTCTime * time, s64 sec); +RTCWeek RTC_GetDayOfWeek(RTCDate * date); + +#endif //NITRO_RTC_CONVERT_H_ diff --git a/arm9/lib/NitroSDK/include/RTC_internal.h b/arm9/lib/NitroSDK/include/RTC_internal.h new file mode 100644 index 00000000..440d8b95 --- /dev/null +++ b/arm9/lib/NitroSDK/include/RTC_internal.h @@ -0,0 +1,11 @@ +#ifndef NITRO_RTC_INTERNAL_H_ +#define NITRO_RTC_INTERNAL_H_ + +#include "nitro/types.h" + +BOOL RTCi_WriteRawStatus2Async(void); +BOOL RTCi_ReadRawTimeAsync(void); +BOOL RTCi_ReadRawDateAsync(void); +BOOL RTCi_ReadRawDateTimeAsync(void); + +#endif //NITRO_RTC_INTERNAL_H_ diff --git a/arm9/lib/NitroSDK/include/SND_alarm.h b/arm9/lib/NitroSDK/include/SND_alarm.h new file mode 100644 index 00000000..07b77f45 --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_alarm.h @@ -0,0 +1,14 @@ +#ifndef GUARD_SND_ALARM_H +#define GUARD_SND_ALARM_H + +#include "global.h" +#include "nitro/SND_alarm_shared.h" + +typedef void (*SNDAlarmCallback)(void *); + +void SND_AlarmInit(void); +void SNDi_IncAlarmId(u32 idx); +u8 SNDi_SetAlarmHandler(u32 idx, SNDAlarmCallback cb, void *data); +void SNDi_CallAlarmHandler(s32 idx); + +#endif diff --git a/arm9/lib/NitroSDK/include/SND_bank.h b/arm9/lib/NitroSDK/include/SND_bank.h new file mode 100644 index 00000000..b9000d57 --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_bank.h @@ -0,0 +1,95 @@ +#ifndef GUARD_SND_BANK_H +#define GUARD_SND_BANK_H + +#include "global.h" + +#include "SND_main.h" + +#define SND_INST_ILLEGAL 0 +#define SND_INST_PCM 1 +#define SND_INST_PSG 2 +#define SND_INST_NOISE 3 +#define SND_INST_DIRECTPCM 4 +#define SND_INST_DUMMY 5 +#define SND_INST_DRUM_TABLE 16 +#define SND_INST_KEY_SPLIT 17 + +#define SND_BANK_MAX_WAVEARC 4 +#define SND_INST_MAX_KEYSPLIT 8 + +#define SND_INST_OFFSET_TYPE(off) ((u8)off) +#define SND_INST_OFFSET_NORMAL(bank, off) ((struct SNDInstParam *)((u8 *)bank + (u32)(off >> 8))) +#define SND_INST_OFFSET_DRUMS(bank, off) ((struct SNDDrumSet *)((u8 *)bank + (u32)(off >> 8))) +#define SND_INST_OFFSET_KEYSPL(bank, off) ((struct SNDKeySplit *)((u8 *)bank + (u32)(off >> 8))) + +struct SNDWaveArc; + +struct SNDWaveArcLink { + struct SNDWaveArc *waveArc; // 0x0 + struct SNDWaveArcLink *waveArcLLnext; // 0x4 +}; // size = 0x8 + +struct SNDBankData { + struct SNDBinaryFileHeader fileHeader; // 0x00 + struct SNDBinaryBlockHeader blockHeader; // 0x10 + struct SNDWaveArcLink waveArcLinks[SND_BANK_MAX_WAVEARC]; // 0x18 + u32 instCount; // 0x38 + u32 instOffsets[]; // 0x3C +}; // size = 0x40 + +struct SNDWaveArc { + struct SNDBinaryFileHeader fileHeader; // 0x00 + struct SNDBinaryBlockHeader blockHeader; // 0x10 + struct SNDWaveArcLink *waveArcLLHead; // 0x18 + u8 unk_1C[28]; // 0x1C + u32 waveCount; // 0x38 + u32 waveOffsets[]; // 0x3C +}; // size = 0x3C + +struct SNDInstParam { + u16 wave[2]; // 0x0 + u8 rootKey; // 0x4 + u8 envAttack; // 0x5 + u8 envDecay; // 0x6 + u8 envSustain; // 0x7 + u8 envRelease; // 0x8 + u8 pan; // 0x9 +}; // size = 0xA + +struct SNDInstData { + u8 type; // 0x0 + u8 unk_1; // 0x1 + struct SNDInstParam param; // 0x2 +}; // size = 0xC + +struct SNDKeySplit { + u8 key[SND_INST_MAX_KEYSPLIT]; // 0x0 + struct SNDInstData instruments[]; // 0x8 +}; // size = 0x8 + +struct SNDDrumSet { + u8 minKey; + u8 maxKey; + struct SNDInstData instruments[]; +}; // size = 0x2 + +struct SNDInstPos { + u32 program; // 0x0 + u32 index; // 0x4 +}; // size = 0x8 + +struct SNDWaveData { + struct SNDWaveParam param; // 0x0 + u8 sampleData[]; // 0xC +}; // size = 0xC + +void SND_AssignWaveArc(struct SNDBankData *bankData, s32 index, struct SNDWaveArc *waveArc); +void SND_DestroyBank(struct SNDBankData *bankData); +void SND_DestroyWaveArc(struct SNDWaveArc *waveArc); +struct SNDInstPos SND_GetFirstInstDataPos(const struct SNDBankData *bankData); +BOOL SND_GetNextInstData(const struct SNDBankData *bankData, struct SNDInstData *instData, struct SNDInstPos *instPos); +u32 SND_GetWaveDataCount(const struct SNDWaveArc *waveArc); +void SND_SetWaveDataAddress(struct SNDWaveArc *waveArc, s32 index, const struct SNDWaveData *waveData); +const struct SNDWaveData *SND_GetWaveDataAddress(const struct SNDWaveArc *waveArc, s32 index); + +#endif // GUARD_SND_BANK_H diff --git a/arm9/lib/NitroSDK/include/SND_command.h b/arm9/lib/NitroSDK/include/SND_command.h new file mode 100644 index 00000000..ff392833 --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_command.h @@ -0,0 +1,67 @@ +#ifndef GUARD_SND_COMMAND_H +#define GUARD_SND_COMMAND_H + +#include "global.h" + +#define SND_CMD_COUNT 256 +#define SND_CMD_ARG_MAX 4 + +#define SND_CMD_FLAG_NOBLOCK 0x0 +#define SND_CMD_FLAG_BLOCK 0x1 +#define SND_CMD_FLAG_IMMEDIATE 0x2 + +#define SND_CMD_START_SEQ 0x00 +#define SND_CMD_STOP_SEQ 0x01 +#define SND_CMD_PREPARE_SEQ 0x02 +#define SND_CMD_START_PREPARED_SEQ 0x03 +#define SND_CMD_PAUSE_SEQ 0x04 +#define SND_CMD_SKIP_SEQ 0x05 +#define SND_CMD_PLAYER_PARAM 0x06 +#define SND_CMD_TRACK_PARAM 0x07 +#define SND_CMD_MUTE_TRACK 0x08 +#define SND_CMD_ALLOCATABLE_CHANNEL 0x09 +#define SND_CMD_PLAYER_LOCAL_VAR 0x0A +#define SND_CMD_PLAYER_GLOBAL_VAR 0x0B +#define SND_CMD_START_TIMER 0x0C +#define SND_CMD_STOP_TIMER 0x0D +#define SND_CMD_SETUP_CHANNEL_PCM 0x0E +#define SND_CMD_SETUP_CHANNEL_PSG 0x0F +#define SND_CMD_SETUP_CHANNEL_NOISE 0x10 +#define SND_CMD_SETUP_CAPTURE 0x11 +#define SND_CMD_SETUP_ALARM 0x12 +#define SND_CMD_CHANNEL_TIMER 0x13 +#define SND_CMD_CHANNEL_VOLUME 0x14 +#define SND_CMD_CHANNEL_PAN 0x15 +#define SND_CMD_SURROUND_DECAY 0x16 +#define SND_CMD_MASTER_VOLUME 0x17 +#define SND_CMD_MASTER_PAN 0x18 +#define SND_CMD_OUTPUT_SELECTOR 0x19 +#define SND_CMD_LOCK_CHANNEL 0x1A +#define SND_CMD_UNLOCK_CHANNEL 0x1B +#define SND_CMD_STOP_UNLOCKED_CHANNEL 0x1C +#define SND_CMD_SET_SHARED_WORK 0x1D +#define SND_CMD_INVALIDATE_SEQ 0x1E +#define SND_CMD_INVALIDATE_BANK 0x1F +#define SND_CMD_INVALIDATE_WAVE 0x20 +#define SND_CMD_READ_DRIVER_INFO 0x21 + +struct SNDCommand { + struct SNDCommand *llNext; // 0x0 + s32 id; // 0x4 + u32 arg[SND_CMD_ARG_MAX]; // 0x8 +}; // size = 0x18 + +void SND_CommandInit(void); +const struct SNDCommand *SND_RecvCommandReply(u32 flags); +struct SNDCommand *SND_AllocCommand(u32 flags); +void SND_PushCommand(struct SNDCommand *cmd); +BOOL SND_FlushCommand(u32 flags); +void SND_WaitForCommandProc(u32 tag); +void SND_WaitForFreeCommand(s32 count); +u32 SND_GetCurrentCommandTag(void); +BOOL SND_IsFinishedCommandTag(u32 tag); +s32 SND_CountFreeCommand(void); +s32 SND_CountReservedCommand(void); +s32 SND_CountWaitingCommand(void); + +#endif // GUARD_SND_COMMAND_H diff --git a/arm9/lib/NitroSDK/include/SND_interface.h b/arm9/lib/NitroSDK/include/SND_interface.h new file mode 100644 index 00000000..d0898f85 --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_interface.h @@ -0,0 +1,63 @@ +#ifndef GUARD_SND_INTERFACE_H +#define GUARD_SND_INTERFACE_H + +#include "global.h" +#include "SND_bank.h" +#include "SND_work.h" +#include "SND_alarm.h" + +void SND_StartSeq(s32 player, const void *seqBasePtr, u32 seqOffset, struct SNDBankData *bankData); +void SND_StopSeq(s32 player); +void SND_PrepareSeq(s32 player, const void *seqBasePtr, u32 seqOffset, struct SNDBankData *bankData); +void SND_StartPreparedSeq(s32 player); +void SND_PauseSeq(s32 player, BOOL flag); + +void SND_SetPlayerTempoRatio(s32 player, s32 ratio); +void SND_SetPlayerVolume(s32 player, s32 volume); +void SND_SetPlayerChannelPriority(s32 player, s32 prio); +void SND_SetPlayerLocalVariable(s32 player, s32 varNo, s16 var); +void SND_SetPlayerGlobalVariable(s32 varNo, s16 var); + +void SND_SetTrackVolume(s32 player, u32 trackBitMask, s32 volume); +void SND_SetTrackPitch(s32 player, u32 trackBitMask, s32 pitch); +void SND_SetTrackPan(s32 player, u32 trackBitMask, s32 pan); +void SND_SetTrackPanRange(s32 player, u32 trackBitMask, s32 panRange); +void SND_SetTrackModDepth(s32 player, u32 trackBitMask, s32 depth); +void SND_SetTrackModSpeed(s32 player, u32 trackBitMask, s32 speed); +void SND_SetTrackAllocatableChannel(s32 player, u32 trackBitMask, u32 chnBitMask); +void SND_SetTrackMute(s32 player, u32 trackBitMask, BOOL flag); + +void SND_StartTimer(u32 chnBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags); +void SND_StopTimer(u32 chnBitMask, u32 capBitMask, u32 alarmBitMask, u32 flags); + +void SND_SetupCapture(s32 capture, s32 format, void *bufferPtr, u32 length, BOOL loopFlag, s32 in, s32 out); +void SND_SetupAlarm(s32 alarm, u32 tick, u32 period, SNDAlarmCallback cb, void *userData); + +void SND_StopUnlockedChannel(u32 chnBitMask, u32 flags); +void SND_LockChannel(u32 chnBitMask, u32 flags); +void SND_UnlockChannel(u32 chnBitMask, u32 flags); + +void SND_SetChannelTimer(u32 chnBitMask, s32 timer); +void SND_SetChannelVolume(u32 chnBitMask, s32 volume, s32 chnDataShift); +void SND_SetChannelPan(u32 chnBitMask, s32 pan); +void SND_SetupChannelPcm(s32 chn, s32 waveFormat, const void *dataAddr, s32 loopMode, s32 loopStart, s32 dataLen, s32 volume, s32 chnDataShift, s32 timer, s32 pan); +void SND_SetupChannelPsg(s32 chn, s32 sndDuty, s32 volume, s32 chnDataShift, s32 timer, s32 pan); +void SND_SetupChannelNoise(s32 chn, s32 volume, s32 chnDataShift, s32 timer, s32 pan); + +void SND_InvalidateSeqData(const void *start, const void *end); +void SND_InvalidateBankData(const void *start, const void *end); +void SND_InvalidateWaveData(const void *start, const void *end); + +void SND_SetMasterVolume(s32 volume); +void SND_SetOutputSelector(s32 left, s32 right, s32 channel1, s32 channel3); +void SND_SetMasterPan(s32 pan); +void SND_ResetMasterPan(void); + +void SND_ReadDriverInfo(struct SNDDriverInfo *info); + +void SNDi_SetPlayerParam(s32 player, u32 offset, u32 data, s32 size); +void SNDi_SetTrackParam(s32 player, u32 trackBitMask, u32 offset, u32 data, s32 size); +void SNDi_SetSurroundDecay(s32 decay); +void SNDi_SkipSeq(s32 player, u32 tick); + +#endif // GUARD_SND_INTERFACE_H diff --git a/arm9/lib/NitroSDK/include/SND_main.h b/arm9/lib/NitroSDK/include/SND_main.h new file mode 100644 index 00000000..8fa9364e --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_main.h @@ -0,0 +1,26 @@ +#ifndef GUARD_SND_MAIN_H +#define GUARD_SND_MAIN_H + +#include "global.h" + +#include "nitro/SND_main_shared.h" + +void SNDi_UnlockMutex(void); +void SNDi_LockMutex(void); +void SND_Init(void); + +struct SNDBinaryFileHeader { + s8 signature[4]; // 0x0 + u16 byteOrder; // 0x4 + u16 version; // 0x6 + u32 fileSize; // 0x8 + u16 headerSize; // 0xC + u16 dataBlocks; // 0xE +}; // size = 0x10 + +typedef struct SNDBinaryBlockHeader { + u32 type; // 0x0 + u32 size; // 0x4 +} SNDBinaryBlockHeader; // size = 0x8 + +#endif // GUARD_SND_MAIN_H diff --git a/arm9/lib/NitroSDK/include/SND_util.h b/arm9/lib/NitroSDK/include/SND_util.h new file mode 100644 index 00000000..4137459a --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_util.h @@ -0,0 +1,14 @@ +#ifndef GUARD_SND_UTIL_H +#define GUARD_SND_UTIL_H + +#include "global.h" + +void SND_CalcTimer(void); +u16 SND_CalcChannelVolume(s32 x); + +extern const s16 SNDi_DecibelTable[0x80]; + +// not used in pokediamond +//extern const s16 SNDi_DecibelSquareTable[0x80]; + +#endif // GUARD_SND_UTIL_H diff --git a/arm9/lib/NitroSDK/include/SND_work.h b/arm9/lib/NitroSDK/include/SND_work.h new file mode 100644 index 00000000..a8a3d62b --- /dev/null +++ b/arm9/lib/NitroSDK/include/SND_work.h @@ -0,0 +1,68 @@ +#ifndef GUARD_SND_WORK_H +#define GUARD_SND_WORK_H + +#include "global.h" + +#include "SND_main.h" +#include "nitro/SND_work_shared.h" + +struct SNDDriverInfo { + struct SNDWork work; // 0x0000 + u32 channelControls[SND_CHANNEL_COUNT]; // 0x1180 + struct SNDWork *workPtr; // 0x11C0 + u32 lockedChannels; // 0x11C4 + u8 unk_XXX[24]; // 0x11C8 +}; // size = 0x11E0 + +struct SNDChannelInfo { + struct { + BOOL active : 1; + BOOL locked: 1; + } flags; // 0x0 + u16 volume; // 0x4 + u8 pan; // 0x6 + u8 unk_7; // 0x7 + s32 envStatus; // 0x8 +}; // size = 0xC + +struct SNDPlayerInfo { + struct { + BOOL active : 1; + BOOL paused : 1; + } flags; // 0x0 + u16 trackBitMask; // 0x4 + u16 tempo; // 0x6 + u8 volume; // 0x8 + u8 unk_9[3]; // 0x9 +}; // size = 0xC + +struct SNDTrackInfo { + u16 program; // 0x0 + u8 volume; // 0x2 + u8 expression; // 0x3 + + s8 pitchBend; // 0x4 + u8 bendRange; // 0x5 + u8 pan; // 0x6 + s8 transpose; // 0x7 + + u8 unk_8; // 0x8 + u8 chnCount; // 0x9 + u8 channel[SND_CHANNEL_COUNT]; // 0xA +}; // size = 0x1A + +u32 SND_GetPlayerStatus(void); +u16 SND_GetChannelStatus(void); +//u16 SND_GetCaptureStatus(void); +u32 SND_GetPlayerTickCounter(u32 playerId); +//s16 SND_GetPlayerLocalVariable(u32 playerId, u32 var); +//s16 SND_GetPlayerGlobalVariable(u32 var); +//BOOL SND_ReadChannelInfo(const SNDDriverInfo *driverInfo, s32 chnId, SNDChannelInfo *chnInfo); +//BOOL SND_ReadPlayerInfo(const SNDDriverInfo *driverInfo, s32 playerId, s32 trackId, SNDPlayerInfo *playerInfo); +//BOOL SND_ReadTrackInfo(const SNDDriverInfo *driverInfo s32 playerId, s32 trackId, SNDTrackInfo *trackInfo); +u32 SNDi_GetFinishedCommandTag(void); +void SNDi_InitSharedWork(struct SNDSharedWork *sw); + +extern struct SNDSharedWork *SNDi_SharedWork; + +#endif // GUARD_SND_WORK_H diff --git a/arm9/lib/NitroSDK/include/SPI_mic.h b/arm9/lib/NitroSDK/include/SPI_mic.h new file mode 100644 index 00000000..79588fe9 --- /dev/null +++ b/arm9/lib/NitroSDK/include/SPI_mic.h @@ -0,0 +1,6 @@ +#ifndef NITRO_SPI_MIC_H_ +#define NITRO_SPI_MIC_H_ + +void MIC_Init(void); + +#endif //NITRO_SPI_MIC_H_ diff --git a/arm9/lib/NitroSDK/include/SPI_pm.h b/arm9/lib/NitroSDK/include/SPI_pm.h new file mode 100644 index 00000000..95f94f24 --- /dev/null +++ b/arm9/lib/NitroSDK/include/SPI_pm.h @@ -0,0 +1,40 @@ +#ifndef NITRO_SPI_PM_H_ +#define NITRO_SPI_PM_H_ + +ENUMS_ALWAYS_INT_ON + +#define PM_TRIGGER_KEY (1 << 0) +#define PM_TRIGGER_RTC_ALARM (1 << 1) +#define PM_TRIGGER_COVER_OPEN (1 << 2) +#define PM_TRIGGER_CARD (1 << 3) +#define PM_TRIGGER_CARTRIDGE (1 << 4) +typedef u32 PMWakeUpTrigger; + +#define PM_PAD_LOGIC_OR (0 << REG_PAD_KEYCNT_LOGIC_SHIFT) +#define PM_PAD_LOGIC_AND (1 << REG_PAD_KEYCNT_LOGIC_SHIFT) +typedef u32 PMLogic; + +typedef enum +{ + PM_BACKLIGHT_OFF = 0, + PM_BACKLIGHT_ON = 1 +} PMBackLightSwitch; + +typedef enum +{ + PM_LCD_TOP = 0, + PM_LCD_BOTTOM = 1, + PM_LCD_ALL = 2 +} +PMLCDTarget; + +void PM_GetBackLight(PMBackLightSwitch * top, PMBackLightSwitch * bottom); +void PM_GoSleepMode(PMWakeUpTrigger trigger, PMLogic logic, u16 keyPattern); +u32 PM_SetBackLight(PMLCDTarget target, PMBackLightSwitch status); +u32 PM_ForceToPowerOff(void); +void PM_SetAmp(int gain); +void PM_SetAmpGain(int gain); + +ENUMS_ALWAYS_INT_RESET + +#endif //NITRO_SPI_PM_H_ diff --git a/arm9/lib/NitroSDK/include/WM.h b/arm9/lib/NitroSDK/include/WM.h new file mode 100644 index 00000000..ad287292 --- /dev/null +++ b/arm9/lib/NitroSDK/include/WM.h @@ -0,0 +1,61 @@ +#ifndef POKEDIAMOND_WM_H +#define POKEDIAMOND_WM_H + +#include "nitro/types.h" + +typedef struct WMDataSet +{ + u16 aidBitmap; + u16 receivedBitmap; + u16 data[508 / sizeof(u16)]; +} WMDataSet; + +typedef struct WMDataSharingInfo +{ + WMDataSet ds[4]; + u16 seqNum[4]; + u16 writeIndex; + u16 sendIndex; + u16 readIndex; + u16 aidBitmap; + u16 dataLength; + u16 stationNumber; + u16 dataSetLength; + u16 port; + u16 doubleMode; + u16 currentSeqNum; + u16 state; + u16 reserved[1]; +} WMDataSharingInfo; + +typedef WMDataSharingInfo WMKeySetBuf; + +typedef enum WMErrCode +{ + WM_ERRCODE_SUCCESS = 0, + WM_ERRCODE_FAILED = 1, + WM_ERRCODE_OPERATING = 2, + WM_ERRCODE_ILLEGAL_STATE = 3, + WM_ERRCODE_WM_DISABLE = 4, + WM_ERRCODE_NO_KEYSET = 5, + WM_ERRCODE_NO_DATASET = 5, + WM_ERRCODE_INVALID_PARAM = 6, + WM_ERRCODE_NO_CHILD = 7, + WM_ERRCODE_FIFO_ERROR = 8, + WM_ERRCODE_TIMEOUT = 9, + WM_ERRCODE_SEND_QUEUE_FULL = 10, + WM_ERRCODE_NO_ENTRY = 11, + WM_ERRCODE_OVER_MAX_ENTRY = 12, + WM_ERRCODE_INVALID_POLLBITMAP = 13, + WM_ERRCODE_NO_DATA = 14, + WM_ERRCODE_SEND_FAILED = 15, + + WM_ERRCODE_DCF_TEST, + WM_ERRCODE_WL_INVALID_PARAM, + WM_ERRCODE_WL_LENGTH_ERR, + + WM_ERRCODE_FLASH_ERROR, + WM_ERRCODE_MAX +} WMErrCode; + +#endif //POKEDIAMOND_WM_H diff --git a/arm9/lib/NitroSDK/include/WM_ks.h b/arm9/lib/NitroSDK/include/WM_ks.h new file mode 100644 index 00000000..0eeb6b1b --- /dev/null +++ b/arm9/lib/NitroSDK/include/WM_ks.h @@ -0,0 +1,9 @@ +#ifndef POKEDIAMOND_WM_KS_H +#define POKEDIAMOND_WM_KS_H + +#include "WM.h" + +WMErrCode WM_StartKeySharing(WMKeySetBuf *buf, u16 port); +WMErrCode WM_EndKeySharing(WMKeySetBuf *buf); + +#endif //POKEDIAMOND_WM_KS_H diff --git a/arm9/lib/NitroSDK/include/consts.h b/arm9/lib/NitroSDK/include/consts.h new file mode 100644 index 00000000..127339ca --- /dev/null +++ b/arm9/lib/NitroSDK/include/consts.h @@ -0,0 +1,63 @@ +#ifndef POKEDIAMOND_ARM9_CONSTS_H +#define POKEDIAMOND_ARM9_CONSTS_H + +#include "nitro/consts_shared.h" + +#define HW_C5_PERMIT_MASK 0xf + +#define HW_C5_PERMIT_RO 5 +#define HW_C5_PERMIT_RW 1 + +#define HW_C5_PR3_SFT 12 + +#define HW_C6_PR_4KB 0x16 +#define HW_C6_PR_8KB 0x18 +#define HW_C6_PR_16KB 0x1a +#define HW_C6_PR_32KB 0x1c +#define HW_C6_PR_64KB 0x1e +#define HW_C6_PR_128KB 0x20 +#define HW_C6_PR_256KB 0x22 +#define HW_C6_PR_512KB 0x24 +#define HW_C6_PR_1MB 0x26 +#define HW_C6_PR_2MB 0x28 +#define HW_C6_PR_4MB 0x2a +#define HW_C6_PR_8MB 0x2c +#define HW_C6_PR_16MB 0x2e +#define HW_C6_PR_32MB 0x30 +#define HW_C6_PR_64MB 0x32 +#define HW_C6_PR_128MB 0x34 +#define HW_C6_PR_256MB 0x36 +#define HW_C6_PR_512MB 0x38 +#define HW_C6_PR_1GB 0x3a +#define HW_C6_PR_2GB 0x3c +#define HW_C6_PR_4GB 0x3e + +#define HW_C6_PR_ENABLE 1 + +#define HW_C9_TCMR_16KB 0x0a +#define HW_C9_TCMR_32MB 0x20 + +#define HW_CACHE_LINE_SIZE 32 + +#define OSi_CONSOLE_NOT_DETECT 0xffffffff + +#define OS_CONSOLE_NITRO 0x80000000 +#define OS_CONSOLE_DEV_CARD 0x02000000 +#define OS_CONSOLE_SIZE_MASK 0x00000003 +#define OS_CONSOLE_SIZE_4MB 0x00000001 + +#define OSi_TCM_REGION_BASE_MASK 0xfffff000 + +#define OS_IE_V_BLANK (1UL << 0) +#define OS_IE_H_BLANK (1UL << 1) + +#define HW_CPU_CLOCK_ARM9 67027964 + +#define REG_PXI_SUBP_FIFO_CNT_E_MASK 0x8000 +#define REG_PXI_SUBP_FIFO_CNT_ERR_MASK 0x4000 +#define REG_PXI_SUBP_FIFO_CNT_RECV_RI_MASK 0x0400 +#define REG_PXI_SUBP_FIFO_CNT_RECV_EMP_MASK 0x0100 +#define REG_PXI_SUBP_FIFO_CNT_SEND_CL_MASK 0x0008 +#define REG_PXI_SUBP_FIFO_CNT_SEND_FULL_MASK 0x0002 + +#endif //POKEDIAMOND_ARM9_CONSTS_H diff --git a/arm9/lib/NitroSDK/include/custom_allocator.h b/arm9/lib/NitroSDK/include/custom_allocator.h new file mode 100644 index 00000000..0a42ae13 --- /dev/null +++ b/arm9/lib/NitroSDK/include/custom_allocator.h @@ -0,0 +1,13 @@ +#ifndef POKEDIAMOND_CUSTOM_ALLOCATOR_H +#define POKEDIAMOND_CUSTOM_ALLOCATOR_H + +#include "nitro/types.h" + +typedef void * (* AllocFunc)(u32 size); +typedef void (* FreeFunc)(void * ptr); + +void* CallCustomAllocator(u32 size); +void CallCustomDestructor(void * ptr); +void SetCustomAllocatorAndDestructor(AllocFunc allocator, FreeFunc destructor); + +#endif //POKEDIAMOND_CUSTOM_ALLOCATOR_H diff --git a/arm9/lib/NitroSDK/include/dgt.h b/arm9/lib/NitroSDK/include/dgt.h new file mode 100644 index 00000000..97916f1b --- /dev/null +++ b/arm9/lib/NitroSDK/include/dgt.h @@ -0,0 +1,37 @@ +#ifndef GUARD_DGT_H +#define GUARD_DGT_H + +#include "nitro/types.h" + +struct DGTHash1Context { + union { + struct { + unsigned long a, b, c, d; + }; + unsigned long state[4]; + }; + unsigned long long length; + union { + unsigned long buffer32[16]; + unsigned char buffer8[64]; + }; +}; + +struct DGTHash2Context { + unsigned long Intermediate_Hash[5]; + unsigned long Length_Low; + unsigned long Length_High; + int Message_Block_Index; + unsigned char Message_Block[64]; + int Computed; + int Corrupted; +}; + +void DGT_Hash1Reset(struct DGTHash1Context *context); +void DGT_Hash1SetSource(struct DGTHash1Context *context, u8 *input, u32 length); +void DGT_Hash1GetDigest_R(u8 *digest, struct DGTHash1Context *context); +void DGT_Hash2Reset(struct DGTHash2Context *context); +void DGT_Hash2SetSource(struct DGTHash2Context *context, u8 *input, u32 length); +void DGT_Hash2GetDigest(struct DGTHash2Context *context, u8 *digest); + +#endif diff --git a/arm9/lib/NitroSDK/include/fx.h b/arm9/lib/NitroSDK/include/fx.h new file mode 100644 index 00000000..bdf49037 --- /dev/null +++ b/arm9/lib/NitroSDK/include/fx.h @@ -0,0 +1,177 @@ +#ifndef GUARD_FX_H +#define GUARD_FX_H + +#include "nitro/types.h" + +typedef s16 fx16; +typedef s32 fx32; +typedef s64 fx64; +typedef s64 fx64c; + +#define FX16_INT_MASK 0xF000 +#define FX16_INT_ABS_MASK 0x7000 +#define FX16_FRAC_MASK 0x0FFF +#define FX16_INT_SHIFT 0xC + +#define FX32_INT_MASK 0xFFFFF000 +#define FX32_INT_ABS_MASK 0x7FFFF000 +#define FX32_FRAC_MASK 0x00000FFF +#define FX32_INT_SHIFT 0xC + +#define FX64_INT_MASK 0xFFFFFFFFFFFFF000 +#define FX64_INT_ABS_MASK 0x7FFFFFFFFFFFF000 +#define FX64_FRAC_MASK 0x0000000000000FFF +#define FX64_INT_SHIFT 0xC + +#define FX64C_INT_MASK 0xFFFFFFFF00000000 +#define FX64C_INT_ABS_MASK 0x7FFFFFFF00000000 +#define FX64C_FRAC_MASK 0x00000000FFFFFFFF +#define FX64C_INT_SHIFT 0x20 + +#define FX_INT(TYPE, x) (((x) & TYPE ## _INT_MASK) >> TYPE ## _INT_SHIFT) +#define FX_INT_ABS(TYPE, x) (((x) & TYPE ## _INT_ABS_MASK) >> TYPE ## _INT_SHIFT) +#define FX_FRAC(TYPE, x) ((x) & TYPE ## _FRAC_MASK) + +#define FX16_INT(x) FX_INT(FX16, x) +#define FX16_INT_ABS(x) FX_INT_ABS(FX16, x) +#define FX16_FRAC(x) FX_FRAC(FX16, x) + +#define FX32_INT(x) FX_INT(FX32, x) +#define FX32_INT_ABS(x) FX_INT_ABS(FX32, x) +#define FX32_FRAC(x) FX_FRAC(FX32, x) + +#define FX64_INT(x) FX_INT(FX64, x) +#define FX64_INT_ABS(x) FX_INT_ABS(FX64, x) +#define FX64_FRAC(x) FX_FRAC(FX64, x) + +#define FX64C_INT(x) FX_INT(FX64C, x) +#define FX64C_INT_ABS(x) FX_INT_ABS(FX64C, x) +#define FX64C_FRAC(x) FX_FRAC(FX64C, x) + +//TODO: clean up these macros +#define FX32_MUL_NO_ROUND(a, b) ((fx32)(((fx64)(a) * (b)) >> FX32_INT_SHIFT)) +#define FX32_MUL(a, b) ((fx32)((((fx64)(a) * (b) + (1 << (FX32_INT_SHIFT - 1))) >> FX32_INT_SHIFT))) +#define FX32_MUL_ADD_MUL(a, b, c, d) ((fx32)(((fx64)(a) * (b) + (fx64)c * d) >> FX32_INT_SHIFT)) +//the extra term here is for rounding +#define FX32_MUL_SUB_MUL(a, b, c, d) ((fx32)(((fx64)(a) * (b) - (fx64)c * d + (1 << (FX32_INT_SHIFT - 1))) >> FX32_INT_SHIFT)) + +#define FX_MUL_FX32_FX64C(a, b) ((fx32)((((a) * (b) + ((fx64)1 << (FX64C_INT_SHIFT - 1))) >> FX64C_INT_SHIFT))) + +#define FX_FX16_TO_F32(x) ((f32)((x) / (f32)(1 << FX16_SHIFT))) +#define FX_F32_TO_FX16(x) ((fx16)(((x) > 0) ? \ + (fx16)((x) * (1 << FX16_INT_SHIFT) + 0.5f ) : \ + (fx16)((x) * (1 << FX16_INT_SHIFT) - 0.5f ))) +#define FX_F32_TO_FX32(x) ((fx32)(((x) > 0) ? \ + (fx32)((x) * (1 << FX32_INT_SHIFT) + 0.5f ) : \ + (fx32)((x) * (1 << FX32_INT_SHIFT) - 0.5f ))) +#define FX16_CONST(x) FX_F32_TO_FX16(x) +#define FX32_CONST(x) FX_F32_TO_FX32(x) + +#define FX16_ONE ((fx16)0x1000) +#define FX32_ONE ((fx32)0x00001000L) + +struct Vecx32 +{ + fx32 x; + fx32 y; + fx32 z; +}; + +struct Vecx16 +{ + fx16 x; + fx16 y; + fx16 z; +}; + +//Matrices are indexed as [column][row] +struct Mtx44 +{ + fx32 _[16]; +}; + +struct Mtx43 +{ + fx32 _[12]; +}; + +struct Mtx33 +{ + fx32 _[9]; +}; + +struct Mtx22 +{ + fx32 _[4]; +}; + +//FX +void FX_Init(); +fx32 FX_Modf(fx32 x, fx32 *iptr); + +//Atan +u16 FX_Atan(fx32 x); +u16 FX_Atan2(fx32 x, fx32 y); + +//Vec +void VEC_Add(struct Vecx32 *x, struct Vecx32 *y, struct Vecx32 *dst); +void VEC_Subtract(struct Vecx32 *x, struct Vecx32 *y, struct Vecx32 *dst); +void VEC_Fx16Add(struct Vecx16 *x, struct Vecx16 *y, struct Vecx16 *dst); +fx32 VEC_DotProduct(struct Vecx32 *x, struct Vecx32 *y); +fx32 VEC_Fx16DotProduct(struct Vecx16 *a, struct Vecx16 *b); +void VEC_CrossProduct(struct Vecx32 *a, struct Vecx32 *b, struct Vecx32 *dst); +void VEC_Fx16CrossProduct(struct Vecx16 *a, struct Vecx16 *b, struct Vecx16 *dst); +fx32 VEC_Mag(struct Vecx32 *a); +void VEC_Normalize(struct Vecx32 *a, struct Vecx32 *dst); +void VEC_Fx16Normalize(struct Vecx16 *a, struct Vecx16 *dst); +void VEC_MultAdd(fx32 factor, struct Vecx32 *a, struct Vecx32 *b, struct Vecx32 *dst); + +//CP +fx32 FX_Div(fx32 numerator, fx32 denominator); +fx32 FX_Inv(fx32 x); +fx32 FX_Sqrt(fx32 x); +fx64 FX_GetDivResultFx64c(); +fx32 FX_GetDivResult(); +void FX_InvAsync(fx32 x); +fx32 FX_GetSqrtResult(); +void FX_DivAsync(fx32 numerator, fx32 denominator); +fx32 FX_DivS32(fx32 numerator, fx32 denominator); +fx32 FX_ModS32(fx32 num, fx32 mod); + +//Mtx +//The functions ending in underscores seem to be in assembly originally +//Mtx44 +void MTX_TransApply44(struct Mtx44 *mtx, struct Mtx44 *dst, fx32 x, fx32 y, fx32 z); +void MTX_Concat44(struct Mtx44 *a, struct Mtx44 *b, struct Mtx44 *c); +void MTX_Identity44_(struct Mtx44 *dst); +void MTX_Copy44To43_(struct Mtx44 *src, struct Mtx43 *dst); +void MTX_RotX44_(struct Mtx44 *mtx, fx32 sinphi, fx32 cosphi); +void MTX_RotY44_(struct Mtx44 *mtx, fx32 sinphi, fx32 cosphi); +void MTX_RotZ44_(struct Mtx44 *mtx, fx32 sinphi, fx32 cosphi); + +//Mtx43 +void MTX_ScaleApply43(struct Mtx43 *mtx, struct Mtx43 *dst, fx32 x, fx32 y, fx32 z); +fx32 MTX_Inverse43(struct Mtx43 *mtx, struct Mtx43 *inv); +void MTX_Concat43(struct Mtx43 *a, struct Mtx43 *b, struct Mtx43 *c); +void MTX_MultVec43(struct Vecx32 *vec, struct Mtx43 *mtx, struct Vecx32 *dst); +void MTX_Identity43_(struct Mtx43 *mtx); +void MTX_Copy43To44_(struct Mtx43 *src, struct Mtx44 *dst); +void MTX_Scale43_(struct Mtx43 *dst, fx32 x, fx32 y, fx32 z); +void MTX_RotX43_(struct Mtx43 *mtx, fx32 sinphi, fx32 cosphi); +void MTX_RotY43_(struct Mtx43 *mtx, fx32 sinphi, fx32 cosphi); + +//Mtx33 +void MTX_ScaleApply33(struct Mtx33 *mtx, struct Mtx33 *dst, fx32 x, fx32 y, fx32 z); +void MTX_Concat33(struct Mtx33 *a, struct Mtx33 *b, struct Mtx33 *c); +void MTX_MultVec33(struct Vecx32 *vec, struct Mtx33 *mtx, struct Vecx32 *dst); +void MTX_Identity33_(struct Mtx33 *mtx); +void MTX_RotX33_(struct Mtx33 *mtx, fx32 sinphi, fx32 cosphi); +void MTX_RotY33_(struct Mtx33 *mtx, fx32 sinphi, fx32 cosphi); +void MTX_RotZ33_(struct Mtx33 *mtx, fx32 sinphi, fx32 cosphi); + +//Mtx22 +void MTX_ScaleApply22(struct Mtx22 *mtx, struct Mtx22 *dst, fx32 x, fx32 y); +void MTX_Identity22_(struct Mtx22 *mtx); +void MTX_Rot22_(struct Mtx22 *mtx, fx32 sinphi, fx32 cosphi); + +#endif //GUARD_FX_H diff --git a/arm9/lib/NitroSDK/include/gx.h b/arm9/lib/NitroSDK/include/gx.h new file mode 100644 index 00000000..7e6606fa --- /dev/null +++ b/arm9/lib/NitroSDK/include/gx.h @@ -0,0 +1,234 @@ +#ifndef GUARD_GX_H +#define GUARD_GX_H + +#include "fx.h" +#include "MI_memory.h" +#include "MI_dma.h" +#include "OS_vramExclusive.h" +#include "registers.h" + +//temporary while other files aren't decompiled + +void GXi_NopClearFifo128_(void *); + +#include "GXcommon.h" +#include "GX_struct_2d.h" +#include "GX_g3.h" +#include "GX_g3_util.h" +#include "GX_g3x.h" +#include "GX_g3b.h" +#include "GX_asm.h" +#include "GX_vramcnt.h" +#include "GX_bgcnt.h" +#include "GX_load2d.h" +#include "GX_load3d.h" +#include "GX_g2.h" +#include "GX_state.h" +#include "GX_g3imm.h" +#include "GX_dma.h" + +typedef union +{ + u32 raw; + struct + { + u32 bgMode:3; + u32 bg0_2d3d:1; + u32 objMapChar:1; + u32 objMapBmp:2; + u32 blankScr:1; + u32 visiblePlane:5; + u32 visibleWnd:3; + u32 dispMode:4; + u32 extObjMapChar:2; + u32 extObjMapBmp:1; + u32 hBlankObjProc:1; + u32 bgCharOffset:3; + u32 bgScrOffset:3; + u32 bgExtPltt:1; + u32 objExtPltt:1; + }; +} +GXDispCnt; + +typedef union +{ + u32 raw; + struct + { + u32 bgMode:3; + u32 _reserve1:1; + u32 objMapChar:1; + u32 objMapBmp:2; + u32 blankScr:1; + u32 visiblePlane:5; + u32 visibleWnd:3; + u32 dispMode:1; + u32 _reserve2:3; + u32 extObjMapChar:2; + u32 _reserve3:1; + u32 hBlankObjProc:1; + u32 _reserve4:6; + u32 bgExtPltt:1; + u32 objExtPltt:1; + }; +} +GXSDispCnt; + +typedef enum +{ + GX_BGMODE_0 = 0, + GX_BGMODE_1 = 1, + GX_BGMODE_2 = 2, + GX_BGMODE_3 = 3, + GX_BGMODE_4 = 4, + GX_BGMODE_5 = 5, + GX_BGMODE_6 = 6 +} +GXBGMode; + +typedef enum +{ + GX_BG0_AS_2D = 0, + GX_BG0_AS_3D = 1 +} +GXBG0As; + +typedef enum +{ + GX_DISPMODE_GRAPHICS = 0x01, + GX_DISPMODE_VRAM_A = 0x02, + GX_DISPMODE_VRAM_B = 0x06, + GX_DISPMODE_VRAM_C = 0x0a, + GX_DISPMODE_VRAM_D = 0x0e, + GX_DISPMODE_MMEM = 0x03 +} +GXDispMode; + +typedef enum +{ + GX_PLANEMASK_NONE = 0x00, + GX_PLANEMASK_BG0 = 0x01, + GX_PLANEMASK_BG1 = 0x02, + GX_PLANEMASK_BG2 = 0x04, + GX_PLANEMASK_BG3 = 0x08, + GX_PLANEMASK_OBJ = 0x10 +} +GXPlaneMask; + +typedef enum +{ + GX_WNDMASK_NONE = 0x00, + GX_WNDMASK_W0 = 0x01, + GX_WNDMASK_W1 = 0x02, + GX_WNDMASK_OW = 0x04 +} +GXWndMask; + +typedef enum +{ + GX_BGCHAROFFSET_0x00000 = 0x00, + GX_BGCHAROFFSET_0x10000 = 0x01, + GX_BGCHAROFFSET_0x20000 = 0x02, + GX_BGCHAROFFSET_0x30000 = 0x03, + GX_BGCHAROFFSET_0x40000 = 0x04, + GX_BGCHAROFFSET_0x50000 = 0x05, + GX_BGCHAROFFSET_0x60000 = 0x06, + GX_BGCHAROFFSET_0x70000 = 0x07 +} +GXBGCharOffset; + +typedef enum +{ + GX_BGSCROFFSET_0x00000 = 0x00, + GX_BGSCROFFSET_0x10000 = 0x01, + GX_BGSCROFFSET_0x20000 = 0x02, + GX_BGSCROFFSET_0x30000 = 0x03, + GX_BGSCROFFSET_0x40000 = 0x04, + GX_BGSCROFFSET_0x50000 = 0x05, + GX_BGSCROFFSET_0x60000 = 0x06, + GX_BGSCROFFSET_0x70000 = 0x07 +} +GXBGScrOffset; + +typedef enum +{ + GX_DISP_SELECT_SUB_MAIN = 0, + GX_DISP_SELECT_MAIN_SUB = 1 +} +GXDispSelect; + +typedef enum +{ + GX_OBJVRAMMODE_CHAR_2D = (0 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (0 << REG_GX_DISPCNT_EXOBJ_SHIFT), + GX_OBJVRAMMODE_CHAR_1D_32K = + (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (0 << REG_GX_DISPCNT_EXOBJ_SHIFT), + GX_OBJVRAMMODE_CHAR_1D_64K = + (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (1 << REG_GX_DISPCNT_EXOBJ_SHIFT), + GX_OBJVRAMMODE_CHAR_1D_128K = + (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (2 << REG_GX_DISPCNT_EXOBJ_SHIFT), + GX_OBJVRAMMODE_CHAR_1D_256K = + (1 << REG_GX_DISPCNT_OBJMAP_SHIFT) | (3 << REG_GX_DISPCNT_EXOBJ_SHIFT) +} + GXOBJVRamModeChar; + +void GX_Init(); +u32 GX_HBlankIntr(u32 enable); +u32 GX_VBlankIntr(u32 enable); +void GX_DispOff(); +void GX_DispOn(); +void GX_SetGraphicsMode(GXDispMode dispMode, GXBGMode bgMode, GXBG0As bg0_2d3d); +void GXS_SetGraphicsMode(GXBGMode mode); +void GXx_SetMasterBrightness_(vu16 *dst, s32 brightness); + +static inline void GX_SetMasterBrightness(int brightness) +{ + GXx_SetMasterBrightness_(®_GX_MASTER_BRIGHT, brightness); +} + +static inline void GX_SetVisiblePlane(int plane) +{ + reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~REG_GX_DISPCNT_DISPLAY_MASK) | (plane << REG_GX_DISPCNT_DISPLAY_SHIFT)); +} + +static inline void GXS_SetVisiblePlane(int plane) +{ + reg_GXS_DB_DISPCNT = (u32)((reg_GXS_DB_DISPCNT & ~REG_GXS_DB_DISPCNT_DISPLAY_MASK) | (plane << REG_GXS_DB_DISPCNT_DISPLAY_SHIFT)); +} + +static inline void GXS_DispOn(void) +{ + reg_GXS_DB_DISPCNT |= REG_GXS_DB_DISPCNT_MODE_MASK; +} + +static inline void GX_SetDispSelect(GXDispSelect sel) +{ + reg_GX_POWCNT = (u16)((reg_GX_POWCNT & ~REG_GX_POWCNT_DSEL_MASK) | (sel << REG_GX_POWCNT_DSEL_SHIFT)); +} + +static inline void GX_SetBGScrOffset(GXBGScrOffset offset) +{ + reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~REG_GX_DISPCNT_BGSCREENOFFSET_MASK) | (offset << REG_GX_DISPCNT_BGSCREENOFFSET_SHIFT)); +} + +static inline void GX_SetBGCharOffset(GXBGCharOffset offset) +{ + reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~REG_GX_DISPCNT_BGCHAROFFSET_MASK) | (offset << REG_GX_DISPCNT_BGCHAROFFSET_SHIFT)); +} + +static inline void GX_SetVisibleWnd(int window) +{ + reg_GX_DISPCNT = (u32)((reg_GX_DISPCNT & ~(REG_GX_DISPCNT_W0_MASK | REG_GX_DISPCNT_W1_MASK | REG_GX_DISPCNT_OW_MASK)) | (window << REG_GX_DISPCNT_W0_SHIFT)); +} + +static inline void GXS_SetVisibleWnd(int window) +{ + reg_GXS_DB_DISPCNT = (u32)((reg_GXS_DB_DISPCNT & ~(REG_GXS_DB_DISPCNT_W0_MASK | REG_GXS_DB_DISPCNT_W1_MASK | REG_GXS_DB_DISPCNT_OW_MASK)) | (window << REG_GXS_DB_DISPCNT_W0_SHIFT)); +} + +static inline void GXS_SetOBJVRamModeChar(GXOBJVRamModeChar mode) +{ + reg_GXS_DB_DISPCNT = (u32)(reg_GXS_DB_DISPCNT & ~(REG_GXS_DB_DISPCNT_EXOBJ_CH_MASK | REG_GXS_DB_DISPCNT_OBJMAP_CH_MASK) | mode); +} + +#endif //GUARD_GX_H diff --git a/arm9/lib/NitroSDK/include/math.h b/arm9/lib/NitroSDK/include/math.h new file mode 100644 index 00000000..085aa24f --- /dev/null +++ b/arm9/lib/NitroSDK/include/math.h @@ -0,0 +1,9 @@ +#ifndef GUARD_MATH_H +#define GUARD_MATH_H + +#include "dgt.h" +#include "MATH_pop.h" +#include "MATH_crc.h" +#include "MATH_dgt.h" + +#endif diff --git a/arm9/lib/NitroSDK/include/mmap.h b/arm9/lib/NitroSDK/include/mmap.h new file mode 100644 index 00000000..69e9c696 --- /dev/null +++ b/arm9/lib/NitroSDK/include/mmap.h @@ -0,0 +1,102 @@ +#ifndef POKEDIAMOND_ARM9_MMAP_H +#define POKEDIAMOND_ARM9_MMAP_H + +#include "nitro/types.h" +#include "nitro/mmap_shared.h" + +extern u32 SDK_AUTOLOAD_DTCM_START[]; + +#define HW_MAIN_MEM_EX_SIZE 0x00800000 +#define HW_MAIN_MEM_DEBUGGER_OFFSET 0x00700000 + +#define HW_ITCM_IMAGE 0x01000000 +#define HW_ITCM 0x01FF8000 +#define HW_ITCM_SIZE 0x00008000 +#define HW_ITCM_END (HW_ITCM + HW_ITCM_SIZE) + +#define HW_IOREG 0x04000000 +#define HW_CTRDG_ROM 0x08000000 +#define HW_BIOS 0xffff0000 + +#define HW_DTCM ((u32)SDK_AUTOLOAD_DTCM_START) +#define HW_DTCM_SIZE 0x00004000 + +#define HW_DTCM_SYSRV (HW_DTCM + 0x00003fc0) +#define HW_INTR_CHECK_BUF (HW_DTCM_SYSRV + 0x38) +#define HW_EXCP_VECTOR_BUF (HW_DTCM_SYSRV + 0x1C) + + +#define HW_CARD_ROM_HEADER_SIZE 0x00000160 +#define HW_DOWNLOAD_PARAMETER_SIZE 0x00000020 + +#define HW_CHECK_DEBUGGER_SW 0x027ffc10 +#define HW_CARD_ROM_HEADER (HW_MAIN_MEM + 0x007ffa80) +#define HW_BOOT_CHECK_INFO_BUF (HW_MAIN_MEM + 0x007ffc00) +#define HW_RESET_PARAMETER_BUF (HW_MAIN_MEM + 0x007ffc20) +#define HW_ROM_BASE_OFFSET_BUF (HW_MAIN_MEM + 0x007ffc2c) +#define HW_CTRDG_MODULE_INFO_BUF (HW_MAIN_MEM + 0x007ffc30) +#define HW_ROM_HEADER_BUF (HW_MAIN_MEM + 0x007ffe00) // ROM registration area data buffer +#define HW_RED_RESERVED (HW_MAIN_MEM + 0x007ff800) // Some kind of reserved data for shared memory +#define HW_MAIN_MEM_EX_END (HW_MAIN_MEM + HW_MAIN_MEM_EX_SIZE) +#define HW_MAIN_MEM_SHARED (HW_MAIN_MEM_EX_END - HW_MAIN_MEM_SHARED_SIZE) +#define HW_DTCM_SVC_STACK_END (HW_DTCM + 0x00003fc0) +#define HW_DTCM_SVC_STACK (HW_DTCM_SVC_STACK_END - HW_SVC_STACK_SIZE) +#define HW_DTCM_IRQ_STACK_END (HW_DTCM_SVC_STACK) + +#define HW_MAIN_MEM_SUB (HW_MAIN_MEM_MAIN_END + 0x400000) + +#define HW_BIOS_EXCP_STACK_MAIN (HW_MAIN_MEM + 0x007ffd80) +#define HW_EXCP_VECTOR_MAIN (HW_MAIN_MEM + 0x007ffd9c) + +#define HW_PXI_SIGNAL_PARAM_ARM9 (HW_MAIN_MEM + 0x007fff80) + +#define HW_WM_RSSI_POOL (HW_MAIN_MEM + 0x007fff98) + +#define HW_COMPONENT_PARAM (HW_MAIN_MEM + 0x007fff9c) + +#define HW_LOCK_ID_FLAG_MAIN (HW_MAIN_MEM + 0x007fffb0) +#define HW_SHARED_LOCK_BUF (HW_MAIN_MEM + 0x007fffc0) +#define HW_CARD_LOCK_BUF (HW_MAIN_MEM + 0x007fffe0) + +#define OSi_MAIN_ARENA_HI_DEFAULT (HW_MAIN_MEM_MAIN_END) +#define OSi_MAINEX_ARENA_HI_DEFAULT (HW_MAIN_MEM + HW_MAIN_MEM_DEBUGGER_OFFSET) +#define HW_ITCM_ARENA_HI_DEFAULT (HW_ITCM + HW_ITCM_SIZE) +#define HW_SHARED_ARENA_HI_DEFAULT (HW_RED_RESERVED - HW_CARD_ROM_HEADER_SIZE - HW_DOWNLOAD_PARAMETER_SIZE) +#define HW_SHARED_ARENA_LO_DEFAULT (HW_MAIN_MEM_SHARED) +#define OSi_WRAM_MAIN_ARENA_HI_DEFAULT (HW_WRAM) +#define OSi_WRAM_MAIN_ARENA_LO_DEFAULT (HW_WRAM) + +#define HW_BG_PLTT 0x05000000 +#define HW_BG_PLTT_END 0x05000200 +#define HW_BG_PLTT_SIZE (HW_BG_PLTT_END-HW_BG_PLTT) +#define HW_OBJ_PLTT 0x05000200 +#define HW_OBJ_PLTT_END 0x05000400 +#define HW_OBJ_PLTT_SIZE (HW_OBJ_PLTT_END-HW_OBJ_PLTT) +#define HW_PLTT HW_BG_PLTT +#define HW_PLTT_END HW_OBJ_PLTT_END +#define HW_PLTT_SIZE (HW_PLTT_END-HW_PLTT) +#define HW_DB_BG_PLTT 0x05000400 +#define HW_DB_BG_PLTT_END 0x05000600 +#define HW_DB_BG_PLTT_SIZE (HW_DB_BG_PLTT_END-HW_DB_BG_PLTT) +#define HW_DB_OBJ_PLTT 0x05000600 +#define HW_DB_OBJ_PLTT_END 0x05000800 +#define HW_DB_OBJ_PLTT_SIZE (HW_DB_OBJ_PLTT_END-HW_DB_OBJ_PLTT) +#define HW_DB_PLTT HW_DB_BG_PLTT +#define HW_DB_PLTT_END HW_DB_OBJ_PLTT_END +#define HW_DB_PLTT_SIZE (HW_DB_PLTT_END-HW_DB_PLTT) +#define HW_LCDC_VRAM 0x6800000 +#define HW_LCDC_VRAM_END 0x68a4000 +#define HW_LCDC_VRAM_SIZE (HW_LCDC_VRAM_END - HW_LCDC_VRAM) +#define HW_OAM 0x07000000 +#define HW_OAM_END 0x07000400 +#define HW_OAM_SIZE (HW_OAM_END-HW_OAM) +#define HW_DB_OAM 0x07000400 +#define HW_DB_OAM_END 0x07000800 +#define HW_DB_OAM_SIZE (HW_DB_OAM_END-HW_DB_OAM) + +#define HW_CTRDG_RAM_END 0x0a010000 + +#define HW_DTCM_SYSRV_OFS_INTR_VECTOR 0x3c +#define HW_RESET_VECTOR 0xffff0000 + +#endif //POKEDIAMOND_ARM9_MMAP_H diff --git a/arm9/lib/NitroSDK/include/nitro.h b/arm9/lib/NitroSDK/include/nitro.h new file mode 100644 index 00000000..ea7503cc --- /dev/null +++ b/arm9/lib/NitroSDK/include/nitro.h @@ -0,0 +1,20 @@ +#ifndef POKEDIAMOND_NITRO_H +#define POKEDIAMOND_NITRO_H + +#ifdef __cplusplus +extern "C" { +#endif + +// Include all nitro files +#include "sections.h" +#include "misc.h" +#include "nitro/types.h" +#include "consts.h" +#include "OS_init.h" +#include "mmap.h" + +#ifdef __cplusplus +} +#endif + +#endif //POKEDIAMOND_NITRO_H diff --git a/arm9/lib/NitroSDK/include/registers.h b/arm9/lib/NitroSDK/include/registers.h new file mode 100644 index 00000000..b4fd8ce7 --- /dev/null +++ b/arm9/lib/NitroSDK/include/registers.h @@ -0,0 +1,1069 @@ +#ifndef POKEDIAMOND_ARM9_REGISTERS_H +#define POKEDIAMOND_ARM9_REGISTERS_H + +#include "nitro/types.h" +#include "nitro/registers_shared.h" + +#define reg_GX_DISPCNT (*(REGType32v *)0x4000000) +#define reg_GX_DISPSTAT (*(REGType16v *)0x4000004) +#define reg_GX_VCOUNT (*(REGType16v *)0x4000006) + +#define reg_G2_BG0CNT (*(REGType16v *)0x4000008) +#define reg_G2_BG1CNT (*(REGType16v *)0x400000a) +#define reg_G2_BG2CNT (*(REGType16v *)0x400000c) +#define reg_G2_BG3CNT (*(REGType16v *)0x400000e) +#define reg_G2_BG0OFS (*(REGType32v *)0x4000010) +#define reg_G2_BG0HOFS (*(REGType16v *)0x4000010) +#define reg_G2_BG0VOFS (*(REGType16v *)0x4000012) +#define reg_G2_BG1OFS (*(REGType32v *)0x4000014) +#define reg_G2_BG1HOFS (*(REGType16v *)0x4000014) +#define reg_G2_BG1VOFS (*(REGType16v *)0x4000016) +#define reg_G2_BG2OFS (*(REGType32v *)0x4000018) +#define reg_G2_BG2HOFS (*(REGType16v *)0x4000018) +#define reg_G2_BG2VOFS (*(REGType16v *)0x400001a) +#define reg_G2_BG3OFS (*(REGType32v *)0x400001c) +#define reg_G2_BG3HOFS (*(REGType16v *)0x400001c) +#define reg_G2_BG3VOFS (*(REGType16v *)0x400001e) +#define reg_G2_BG2PA (*(REGType16v *)0x4000020) +#define reg_G2_BG2PB (*(REGType16v *)0x4000022) +#define reg_G2_BG2PC (*(REGType16v *)0x4000024) +#define reg_G2_BG2PD (*(REGType16v *)0x4000026) +#define reg_G2_BG2X (*(REGType32v *)0x4000028) +#define reg_G2_BG2Y (*(REGType32v *)0x400002c) +#define reg_G2_BG3PA (*(REGType16v *)0x4000030) +#define reg_G2_BG3PB (*(REGType16v *)0x4000032) +#define reg_G2_BG3PC (*(REGType16v *)0x4000034) +#define reg_G2_BG3PD (*(REGType16v *)0x4000036) +#define reg_G2_BG3X (*(REGType32v *)0x4000038) +#define reg_G2_BG3Y (*(REGType32v *)0x400003c) +#define reg_G2_WIN0H (*(REGType16v *)0x4000040) +#define reg_G2_WIN1H (*(REGType16v *)0x4000042) +#define reg_G2_WIN0V (*(REGType16v *)0x4000044) +#define reg_G2_WIN1V (*(REGType16v *)0x4000046) +#define reg_G2_WININ (*(REGType16v *)0x4000048) +#define reg_G2_WINOUT (*(REGType16v *)0x400004a) +#define reg_G2_MOSAIC (*(REGType16v *)0x400004c) +#define reg_G2_BLDCNT (*(REGType16v *)0x4000050) +#define reg_G2_BLDALPHA (*(REGType16v *)0x4000052) +#define reg_G2_BLDY (*(REGType16v *)0x4000054) + +#define reg_G3X_DISP3DCNT (*(REGType16v *)0x4000060) + +#define reg_GX_DISPCAPCNT (*(REGType32v *)0x4000064) +#define reg_GX_DISP_MMEM_FIFO (*(REGType32v *)0x4000068) +#define reg_GX_DISP_MMEM_FIFO_L (*(REGType16v *)0x4000068) +#define reg_GX_DISP_MMEM_FIFO_H (*(REGType16v *)0x400006a) +#define reg_GX_MASTER_BRIGHT (*(REGType16v *)0x400006c) +#define reg_GX_TVOUTCNT (*(REGType16v *)0x4000070) + +#define reg_MI_DMA0SAD (*(REGType32v *)0x40000b0) +#define reg_MI_DMA0DAD (*(REGType32v *)0x40000b4) +#define reg_MI_DMA0CNT (*(REGType32v *)0x40000b8) +#define reg_MI_DMA1SAD (*(REGType32v *)0x40000bc) +#define reg_MI_DMA1DAD (*(REGType32v *)0x40000c0) +#define reg_MI_DMA1CNT (*(REGType32v *)0x40000c4) +#define reg_MI_DMA2SAD (*(REGType32v *)0x40000c8) +#define reg_MI_DMA2DAD (*(REGType32v *)0x40000cc) +#define reg_MI_DMA2CNT (*(REGType32v *)0x40000d0) +#define reg_MI_DMA3SAD (*(REGType32v *)0x40000d4) +#define reg_MI_DMA3DAD (*(REGType32v *)0x40000d8) +#define reg_MI_DMA3CNT (*(REGType32v *)0x40000dc) +#define reg_MI_DMA0_CLR_DATA (*(REGType32v *)0x40000e0) +#define reg_MI_DMA1_CLR_DATA (*(REGType32v *)0x40000e4) +#define reg_MI_DMA2_CLR_DATA (*(REGType32v *)0x40000e8) +#define reg_MI_DMA3_CLR_DATA (*(REGType32v *)0x40000ec) + +#define reg_EXI_SIODATA32 (*(REGType32v *)0x4000120) +#define reg_EXI_SIOCNT (*(REGType16v *)0x4000128) +#define reg_EXI_SIOSEL (*(REGType32v *)0x400012c) + +#define reg_PAD_KEYINPUT (*(REGType16v *)0x4000130) +#define reg_PAD_KEYCNT (*(REGType16v *)0x4000132) + +#define REG_SUBPINTF_ADDR 0x4000180 +#define reg_PXI_SUBPINTF (*(REGType16v *)REG_SUBPINTF_ADDR) +#define reg_PXI_SUBP_FIFO_CNT (*(REGType16v *)0x4000184) +#define reg_PXI_SEND_FIFO (*(REGType32v *)0x4000188) + +#define reg_MI_MCCNT0 (*(REGType16v *)0x40001a0) +#define reg_CARD_MASTERCNT (*(REGType8v *)0x40001a1) //? +#define reg_MI_MCD0 (*(REGType16v *)0x40001a2) +#define reg_MI_MCCNT1 (*(REGType32v *)0x40001a4) +#define reg_CARD_CNT (*(REGType32v *)0x40001a4) //? +#define reg_MI_MCCMD0 (*(REGType32v *)0x40001a8) +#define reg_CARD_CMD (*(REGType8v *)0x40001a8) //? +#define reg_MI_MCCMD1 (*(REGType32v *)0x40001ac) +#define reg_MI_EXMEMCNT (*(REGType16v *)0x4000204) + +#define reg_OS_PAUSE (*(REGType16v *)0x4000300) + +#define reg_GX_VRAMCNT (*(REGType32v *)0x4000240) +#define reg_GX_VRAMCNT_A (*(REGType8v *)0x4000240) +#define reg_GX_VRAMCNT_B (*(REGType8v *)0x4000241) +#define reg_GX_VRAMCNT_C (*(REGType8v *)0x4000242) +#define reg_GX_VRAMCNT_D (*(REGType8v *)0x4000243) +#define reg_GX_WVRAMCNT (*(REGType32v *)0x4000244) +#define reg_GX_VRAMCNT_E (*(REGType8v *)0x4000244) +#define reg_GX_VRAMCNT_F (*(REGType8v *)0x4000245) +#define reg_GX_VRAMCNT_G (*(REGType8v *)0x4000246) +#define reg_GX_VRAMCNT_WRAM (*(REGType8v *)0x4000247) +#define reg_GX_VRAM_HI_CNT (*(REGType16v *)0x4000248) +#define reg_GX_VRAMCNT_H (*(REGType8v *)0x4000248) +#define reg_GX_VRAMCNT_I (*(REGType8v *)0x4000249) + +#define reg_CP_DIVCNT (*(REGType16v *)0x4000280) + +#define REG_DIV_NUMER_ADDR 0x4000290 +#define reg_CP_DIV_NUMER (*(REGType64v *)REG_DIV_NUMER_ADDR) +#define reg_CP_DIV_NUMER_L (*(REGType32v *)REG_DIV_NUMER_ADDR) +#define reg_CP_DIV_NUMER_H (*(REGType32v *)0x4000294) +#define reg_CP_DIV_DENOM (*(REGType64v *)0x4000298) +#define reg_CP_DIV_DENOM_L (*(REGType32v *)0x4000298) +#define reg_CP_DIV_DENOM_H (*(REGType32v *)0x400029c) +#define reg_CP_DIV_RESULT (*(REGType64v *)0x40002A0) +#define reg_CP_DIV_RESULT_L (*(REGType32v *)0x40002A0) +#define reg_CP_DIV_RESULT_H (*(REGType32v *)0x40002A4) +#define reg_CP_DIVREM_RESULT (*(REGType64v *)0x40002A8) +#define reg_CP_DIVREM_RESULT_L (*(REGType32v *)0x40002A8) +#define reg_CP_DIVREM_RESULT_H (*(REGType32v *)0x40002Ac) +#define reg_CP_SQRTCNT (*(REGType16v *)0x40002B0) +#define reg_CP_SQRT_RESULT (*(REGType32v *)0x40002B4) +#define reg_CP_SQRT_PARAM (*(REGType64v *)0x40002B8) +#define reg_CP_SQRT_PARAM_L (*(REGType32v *)0x40002B8) +#define reg_CP_SQRT_PARAM_H (*(REGType32v *)0x40002Bc) + +#define reg_GX_POWCNT (*(REGType16v *)0x4000304) + +#define reg_G3X_RDLINES_COUNT (*(const REGType16v *)0x4000320) +#define reg_G3X_EDGE_COLOR_0 (*(REGType32v *)0x4000330) +#define reg_G3X_EDGE_COLOR_0_L (*(REGType16v *)0x4000330) +#define reg_G3X_EDGE_COLOR_0_H (*(REGType16v *)0x4000332) +#define reg_G3X_EDGE_COLOR_1 (*(REGType32v *)0x4000334) +#define reg_G3X_EDGE_COLOR_1_L (*(REGType16v *)0x4000334) +#define reg_G3X_EDGE_COLOR_1_H (*(REGType16v *)0x4000336) +#define reg_G3X_EDGE_COLOR_2 (*(REGType32v *)0x4000338) +#define reg_G3X_EDGE_COLOR_2_L (*(REGType16v *)0x4000338) +#define reg_G3X_EDGE_COLOR_2_H (*(REGType16v *)0x400033a) +#define reg_G3X_EDGE_COLOR_3 (*(REGType32v *)0x400033c) +#define reg_G3X_EDGE_COLOR_3_L (*(REGType16v *)0x400033c) +#define reg_G3X_EDGE_COLOR_3_H (*(REGType16v *)0x400033e) +#define reg_G3X_ALPHA_TEST_REF (*(REGType16v *)0x4000340) +#define reg_G3X_CLEAR_COLOR (*(REGType32v *)0x4000350) +#define reg_G3X_CLEAR_DEPTH (*(REGType16v *)0x4000354) +#define reg_G3X_CLRIMAGE_OFFSET (*(REGType16v *)0x4000356) +#define reg_G3X_FOG_COLOR (*(REGType32v *)0x4000358) +#define reg_G3X_FOG_OFFSET (*(REGType16v *)0x400035c) +#define reg_G3X_FOG_TABLE_0 (*(REGType32v *)0x4000360) +#define reg_G3X_FOG_TABLE_0_L (*(REGType16v *)0x4000360) +#define reg_G3X_FOG_TABLE_0_H (*(REGType16v *)0x4000362) +#define reg_G3X_FOG_TABLE_1 (*(REGType32v *)0x4000364) +#define reg_G3X_FOG_TABLE_1_L (*(REGType16v *)0x4000364) +#define reg_G3X_FOG_TABLE_1_H (*(REGType16v *)0x4000366) +#define reg_G3X_FOG_TABLE_2 (*(REGType32v *)0x4000368) +#define reg_G3X_FOG_TABLE_2_L (*(REGType16v *)0x4000368) +#define reg_G3X_FOG_TABLE_2_H (*(REGType16v *)0x400036a) +#define reg_G3X_FOG_TABLE_3 (*(REGType32v *)0x400036c) +#define reg_G3X_FOG_TABLE_3_L (*(REGType16v *)0x400036c) +#define reg_G3X_FOG_TABLE_3_H (*(REGType16v *)0x400036e) +#define reg_G3X_FOG_TABLE_4 (*(REGType32v *)0x4000370) +#define reg_G3X_FOG_TABLE_4_L (*(REGType16v *)0x4000370) +#define reg_G3X_FOG_TABLE_4_H (*(REGType16v *)0x4000372) +#define reg_G3X_FOG_TABLE_5 (*(REGType32v *)0x4000374) +#define reg_G3X_FOG_TABLE_5_L (*(REGType16v *)0x4000374) +#define reg_G3X_FOG_TABLE_5_H (*(REGType16v *)0x4000376) +#define reg_G3X_FOG_TABLE_6 (*(REGType32v *)0x4000378) +#define reg_G3X_FOG_TABLE_6_L (*(REGType16v *)0x4000378) +#define reg_G3X_FOG_TABLE_6_H (*(REGType16v *)0x400037a) +#define reg_G3X_FOG_TABLE_7 (*(REGType32v *)0x400037c) +#define reg_G3X_FOG_TABLE_7_L (*(REGType16v *)0x400037c) +#define reg_G3X_FOG_TABLE_7_H (*(REGType16v *)0x400037e) +#define reg_G3X_TOON_TABLE_0 (*(REGType32v *)0x4000380) +#define reg_G3X_TOON_TABLE_0_L (*(REGType16v *)0x4000380) +#define reg_G3X_TOON_TABLE_0_H (*(REGType16v *)0x4000382) +#define reg_G3X_TOON_TABLE_1 (*(REGType32v *)0x4000384) +#define reg_G3X_TOON_TABLE_1_L (*(REGType16v *)0x4000384) +#define reg_G3X_TOON_TABLE_1_H (*(REGType16v *)0x4000386) +#define reg_G3X_TOON_TABLE_2 (*(REGType32v *)0x4000388) +#define reg_G3X_TOON_TABLE_2_L (*(REGType16v *)0x4000388) +#define reg_G3X_TOON_TABLE_2_H (*(REGType16v *)0x400038a) +#define reg_G3X_TOON_TABLE_3 (*(REGType32v *)0x400038c) +#define reg_G3X_TOON_TABLE_3_L (*(REGType16v *)0x400038c) +#define reg_G3X_TOON_TABLE_3_H (*(REGType16v *)0x400038e) +#define reg_G3X_TOON_TABLE_4 (*(REGType32v *)0x4000390) +#define reg_G3X_TOON_TABLE_4_L (*(REGType16v *)0x4000390) +#define reg_G3X_TOON_TABLE_4_H (*(REGType16v *)0x4000392) +#define reg_G3X_TOON_TABLE_5 (*(REGType32v *)0x4000394) +#define reg_G3X_TOON_TABLE_5_L (*(REGType16v *)0x4000394) +#define reg_G3X_TOON_TABLE_5_H (*(REGType16v *)0x4000396) +#define reg_G3X_TOON_TABLE_7 (*(REGType32v *)0x400039c) +#define reg_G3X_TOON_TABLE_7_L (*(REGType16v *)0x400039c) +#define reg_G3X_TOON_TABLE_7_H (*(REGType16v *)0x400039e) +#define reg_G3X_TOON_TABLE_8 (*(REGType32v *)0x40003a0) +#define reg_G3X_TOON_TABLE_8_L (*(REGType16v *)0x40003a0) +#define reg_G3X_TOON_TABLE_8_H (*(REGType16v *)0x40003a2) +#define reg_G3X_TOON_TABLE_9 (*(REGType32v *)0x40003a4) +#define reg_G3X_TOON_TABLE_9_L (*(REGType16v *)0x40003a4) +#define reg_G3X_TOON_TABLE_9_H (*(REGType16v *)0x40003a6) +#define reg_G3X_TOON_TABLE_10 (*(REGType32v *)0x40003a8) +#define reg_G3X_TOON_TABLE_10_L (*(REGType16v *)0x40003a8) +#define reg_G3X_TOON_TABLE_10_H (*(REGType16v *)0x40003aa) +#define reg_G3X_TOON_TABLE_11 (*(REGType32v *)0x40003ac) +#define reg_G3X_TOON_TABLE_11_L (*(REGType16v *)0x40003ac) +#define reg_G3X_TOON_TABLE_11_H (*(REGType16v *)0x40003ae) +#define reg_G3X_TOON_TABLE_12 (*(REGType32v *)0x40003b0) +#define reg_G3X_TOON_TABLE_12_L (*(REGType16v *)0x40003b0) +#define reg_G3X_TOON_TABLE_12_H (*(REGType16v *)0x40003b2) +#define reg_G3X_TOON_TABLE_13 (*(REGType32v *)0x40003b4) +#define reg_G3X_TOON_TABLE_13_L (*(REGType16v *)0x40003b4) +#define reg_G3X_TOON_TABLE_13_H (*(REGType16v *)0x40003b6) +#define reg_G3X_TOON_TABLE_14 (*(REGType32v *)0x40003b8) +#define reg_G3X_TOON_TABLE_14_L (*(REGType16v *)0x40003b8) +#define reg_G3X_TOON_TABLE_14_H (*(REGType16v *)0x40003ba) +#define reg_G3X_TOON_TABLE_15 (*(REGType32v *)0x40003bc) +#define reg_G3X_TOON_TABLE_15_L (*(REGType16v *)0x40003bc) +#define reg_G3X_TOON_TABLE_15_H (*(REGType16v *)0x40003be) +#define reg_G3X_GXFIFO (*(REGType32v *)0x4000400) + +#define reg_G3_MTX_MODE (*(REGType32v *)0x4000440) +#define reg_G3_MTX_PUSH (*(REGType32v *)0x4000444) +#define reg_G3_MTX_POP (*(REGType32v *)0x4000448) +#define reg_G3_MTX_STORE (*(REGType32v *)0x400044c) +#define reg_G3_MTX_RESTORE (*(REGType32v *)0x4000450) +#define reg_G3_MTX_IDENTITY (*(REGType32v *)0x4000454) +#define reg_G3_MTX_LOAD_4x4 (*(REGType32v *)0x4000458) +#define reg_G3_MTX_LOAD_4x3 (*(REGType32v *)0x400045c) +#define reg_G3_MTX_MULT_4x4 (*(REGType32v *)0x4000460) +#define reg_G3_MTX_MULT_4x3 (*(REGType32v *)0x4000464) +#define reg_G3_MTX_MULT_3x3 (*(REGType32v *)0x4000468) +#define reg_G3_MTX_SCALE (*(REGType32v *)0x400046c) +#define reg_G3_MTX_TRANS (*(REGType32v *)0x4000470) +#define reg_G3_COLOR (*(REGType32v *)0x4000480) +#define reg_G3_NORMAL (*(REGType32v *)0x4000484) +#define reg_G3_TEXCOORD (*(REGType32v *)0x4000488) +#define reg_G3_VTX_16 (*(REGType32v *)0x400048c) +#define reg_G3_VTX_10 (*(REGType32v *)0x4000490) +#define reg_G3_VTX_XY (*(REGType32v *)0x4000494) +#define reg_G3_VTX_XZ (*(REGType32v *)0x4000498) +#define reg_G3_VTX_YZ (*(REGType32v *)0x400049c) +#define reg_G3_VTX_DIFF (*(REGType32v *)0x40004a0) +#define reg_G3_POLYGON_ATTR (*(REGType32v *)0x40004a4) +#define reg_G3_TEXIMAGE_PARAM (*(REGType32v *)0x40004a8) +#define reg_G3_TEXPLTT_BASE (*(REGType32v *)0x40004ac) +#define reg_G3_DIF_AMB (*(REGType32v *)0x40004c0) +#define reg_G3_SPE_EMI (*(REGType32v *)0x40004c4) +#define reg_G3_LIGHT_VECTOR (*(REGType32v *)0x40004c8) +#define reg_G3_LIGHT_COLOR (*(REGType32v *)0x40004cc) +#define reg_G3_SHININESS (*(REGType32v *)0x40004d0) +#define reg_G3_BEGIN_VTXS (*(REGType32v *)0x4000500) +#define reg_G3_END_VTXS (*(REGType32v *)0x4000504) +#define reg_G3_SWAP_BUFFERS (*(REGType32v *)0x4000540) +#define reg_G3_VIEWPORT (*(REGType32v *)0x4000580) +#define reg_G3_BOX_TEST (*(REGType32v *)0x40005c0) +#define reg_G3_POS_TEST (*(REGType32v *)0x40005c4) +#define reg_G3_VEC_TEST (*(REGType32v *)0x40005c8) + +#define reg_G3X_GXSTAT (*(REGType32v *)0x4000600) +#define reg_G3X_LISTRAM_COUNT (*(REGType16v *)0x4000604) +#define reg_G3X_VTXRAM_COUNT (*(REGType16v *)0x4000606) +#define reg_G3X_DISP_1DOT_DEPTH (*(REGType16v *)0x4000610) +#define reg_G3X_POS_RESULT_X (*(const REGType32v *)0x4000620) +#define reg_G3X_POS_RESULT_Y (*(const REGType32v *)0x4000624) +#define reg_G3X_POS_RESULT_Z (*(const REGType32v *)0x4000628) +#define reg_G3X_POS_RESULT_W (*(const REGType32v *)0x400062c) +#define reg_G3X_VEC_RESULT_X (*(const REGType16v *)0x4000630) +#define reg_G3X_VEC_RESULT_Y (*(const REGType16v *)0x4000632) +#define reg_G3X_VEC_RESULT_Z (*(const REGType16v *)0x4000634) +#define reg_G3X_CLIPMTX_RESULT_0 (*(const REGType32v *)0x4000640) +#define reg_G3X_CLIPMTX_RESULT_1 (*(const REGType32v *)0x4000644) +#define reg_G3X_CLIPMTX_RESULT_2 (*(const REGType32v *)0x4000648) +#define reg_G3X_CLIPMTX_RESULT_3 (*(const REGType32v *)0x400064c) +#define reg_G3X_CLIPMTX_RESULT_4 (*(const REGType32v *)0x4000650) +#define reg_G3X_CLIPMTX_RESULT_5 (*(const REGType32v *)0x4000654) +#define reg_G3X_CLIPMTX_RESULT_6 (*(const REGType32v *)0x4000658) +#define reg_G3X_CLIPMTX_RESULT_7 (*(const REGType32v *)0x400065c) +#define reg_G3X_CLIPMTX_RESULT_8 (*(const REGType32v *)0x4000660) +#define reg_G3X_CLIPMTX_RESULT_9 (*(const REGType32v *)0x4000664) +#define reg_G3X_CLIPMTX_RESULT_10 (*(const REGType32v *)0x4000668) +#define reg_G3X_CLIPMTX_RESULT_11 (*(const REGType32v *)0x400066c) +#define reg_G3X_CLIPMTX_RESULT_12 (*(const REGType32v *)0x4000670) +#define reg_G3X_CLIPMTX_RESULT_13 (*(const REGType32v *)0x4000674) +#define reg_G3X_CLIPMTX_RESULT_14 (*(const REGType32v *)0x4000678) +#define reg_G3X_CLIPMTX_RESULT_15 (*(const REGType32v *)0x400067c) +#define reg_G3X_VECMTX_RESULT_0 (*(const REGType32v *)0x4000680) +#define reg_G3X_VECMTX_RESULT_1 (*(const REGType32v *)0x4000684) +#define reg_G3X_VECMTX_RESULT_2 (*(const REGType32v *)0x4000688) +#define reg_G3X_VECMTX_RESULT_3 (*(const REGType32v *)0x400068c) +#define reg_G3X_VECMTX_RESULT_4 (*(const REGType32v *)0x4000690) +#define reg_G3X_VECMTX_RESULT_5 (*(const REGType32v *)0x4000694) +#define reg_G3X_VECMTX_RESULT_6 (*(const REGType32v *)0x4000698) +#define reg_G3X_VECMTX_RESULT_7 (*(const REGType32v *)0x400069c) +#define reg_G3X_VECMTX_RESULT_8 (*(const REGType32v *)0x40006a0) + +#define reg_GXS_DB_DISPCNT (*(REGType32v *)0x4001000) + +#define reg_G2S_DB_BG0CNT (*(REGType16v *)0x4001008) +#define reg_G2S_DB_BG1CNT (*(REGType16v *)0x400100a) +#define reg_G2S_DB_BG2CNT (*(REGType16v *)0x400100c) +#define reg_G2S_DB_BG3CNT (*(REGType16v *)0x400100e) +#define reg_G2S_DB_BG0OFS (*(REGType32v *)0x4001010) +#define reg_G2S_DB_BG0HOFS (*(REGType16v *)0x4001010) +#define reg_G2S_DB_BG0VOFS (*(REGType16v *)0x4001012) +#define reg_G2S_DB_BG1OFS (*(REGType32v *)0x4001014) +#define reg_G2S_DB_BG1HOFS (*(REGType16v *)0x4001014) +#define reg_G2S_DB_BG1VOFS (*(REGType16v *)0x4001016) +#define reg_G2S_DB_BG2OFS (*(REGType32v *)0x4001018) +#define reg_G2S_DB_BG2HOFS (*(REGType16v *)0x4001018) +#define reg_G2S_DB_BG2VOFS (*(REGType16v *)0x400101a) +#define reg_G2S_DB_BG3OFS (*(REGType32v *)0x400101c) +#define reg_G2S_DB_BG3HOFS (*(REGType16v *)0x400101c) +#define reg_G2S_DB_BG3VOFS (*(REGType16v *)0x400101e) +#define reg_G2S_DB_BG2PA (*(REGType16v *)0x4001020) +#define reg_G2S_DB_BG2PB (*(REGType16v *)0x4001022) +#define reg_G2S_DB_BG2PC (*(REGType16v *)0x4001024) +#define reg_G2S_DB_BG2PD (*(REGType16v *)0x4001026) +#define reg_G2S_DB_BG2X (*(REGType32v *)0x4001028) +#define reg_G2S_DB_BG2Y (*(REGType32v *)0x400102c) +#define reg_G2S_DB_BG3PA (*(REGType16v *)0x4001030) +#define reg_G2S_DB_BG3PB (*(REGType16v *)0x4001032) +#define reg_G2S_DB_BG3PC (*(REGType16v *)0x4001034) +#define reg_G2S_DB_BG3PD (*(REGType16v *)0x4001036) +#define reg_G2S_DB_BG3X (*(REGType32v *)0x4001038) +#define reg_G2S_DB_BG3Y (*(REGType32v *)0x400103c) +#define reg_G2S_DB_WIN0H (*(REGType16v *)0x4001040) +#define reg_G2S_DB_WIN1H (*(REGType16v *)0x4001042) +#define reg_G2S_DB_WIN0V (*(REGType16v *)0x4001044) +#define reg_G2S_DB_WIN1V (*(REGType16v *)0x4001046) +#define reg_G2S_DB_WININ (*(REGType16v *)0x4001048) +#define reg_G2S_DB_WINOUT (*(REGType16v *)0x400104a) +#define reg_G2S_DB_MOSAIC (*(REGType16v *)0x400104c) +#define reg_G2S_DB_BLDCNT (*(REGType16v *)0x4001050) +#define reg_G2S_DB_BLDALPHA (*(REGType16v *)0x4001052) +#define reg_G2S_DB_BLDY (*(REGType16v *)0x4001054) + +#define reg_GXS_DB_MASTER_BRIGHT (*(REGType16v *)0x400106c) + +#define reg_PXI_RECV_FIFO (*(REGType32v *)0x4100000) + +#define reg_MI_MCD1 (*(REGType32v *)0x4100010) +#define reg_CARD_DATA (*(REGType32v *)0x4100010) //? + +#define REG_OS_IE_VE_SHIFT 2 +#define REG_OS_IE_T0_SHIFT 3 +#define REG_OS_IE_T1_SHIFT 4 +#define REG_OS_IE_T2_SHIFT 5 +#define REG_OS_IE_T3_SHIFT 6 +#define REG_OS_IE_IFN_SHIFT 18 +#define REG_OS_IE_MC_SHIFT 19 + +#define REG_PAD_KEYINPUT_L_SHIFT 9 +#define REG_PAD_KEYINPUT_L_SIZE 1 +#define REG_PAD_KEYINPUT_L_MASK 0x0200 + +#define REG_PAD_KEYINPUT_R_SHIFT 8 +#define REG_PAD_KEYINPUT_R_SIZE 1 +#define REG_PAD_KEYINPUT_R_MASK 0x0100 + +#define REG_PAD_KEYINPUT_DOWN_SHIFT 7 +#define REG_PAD_KEYINPUT_DOWN_SIZE 1 +#define REG_PAD_KEYINPUT_DOWN_MASK 0x0080 + +#define REG_PAD_KEYINPUT_UP_SHIFT 6 +#define REG_PAD_KEYINPUT_UP_SIZE 1 +#define REG_PAD_KEYINPUT_UP_MASK 0x0040 + +#define REG_PAD_KEYINPUT_LEFT_SHIFT 5 +#define REG_PAD_KEYINPUT_LEFT_SIZE 1 +#define REG_PAD_KEYINPUT_LEFT_MASK 0x0020 + +#define REG_PAD_KEYINPUT_RIGHT_SHIFT 4 +#define REG_PAD_KEYINPUT_RIGHT_SIZE 1 +#define REG_PAD_KEYINPUT_RIGHT_MASK 0x0010 + +#define REG_PAD_KEYINPUT_START_SHIFT 3 +#define REG_PAD_KEYINPUT_START_SIZE 1 +#define REG_PAD_KEYINPUT_START_MASK 0x0008 + +#define REG_PAD_KEYINPUT_SEL_SHIFT 2 +#define REG_PAD_KEYINPUT_SEL_SIZE 1 +#define REG_PAD_KEYINPUT_SEL_MASK 0x0004 + +#define REG_PAD_KEYINPUT_B_SHIFT 1 +#define REG_PAD_KEYINPUT_B_SIZE 1 +#define REG_PAD_KEYINPUT_B_MASK 0x0002 + +#define REG_PAD_KEYINPUT_A_SHIFT 0 +#define REG_PAD_KEYINPUT_A_SIZE 1 +#define REG_PAD_KEYINPUT_A_MASK 0x0001 + +#ifndef SDK_ASM +#define REG_PAD_KEYINPUT_FIELD( l, r, down, up, left, right, start, sel, b, a ) \ + (u16)( \ + ((u32)(l) << REG_PAD_KEYINPUT_L_SHIFT) | \ + ((u32)(r) << REG_PAD_KEYINPUT_R_SHIFT) | \ + ((u32)(down) << REG_PAD_KEYINPUT_DOWN_SHIFT) | \ + ((u32)(up) << REG_PAD_KEYINPUT_UP_SHIFT) | \ + ((u32)(left) << REG_PAD_KEYINPUT_LEFT_SHIFT) | \ + ((u32)(right) << REG_PAD_KEYINPUT_RIGHT_SHIFT) | \ + ((u32)(start) << REG_PAD_KEYINPUT_START_SHIFT) | \ + ((u32)(sel) << REG_PAD_KEYINPUT_SEL_SHIFT) | \ + ((u32)(b) << REG_PAD_KEYINPUT_B_SHIFT) | \ + ((u32)(a) << REG_PAD_KEYINPUT_A_SHIFT)) +#endif + +#define REG_PAD_KEYCNT_LOGIC_SHIFT 15 +#define REG_PAD_KEYCNT_LOGIC_SIZE 1 +#define REG_PAD_KEYCNT_LOGIC_MASK 0x8000 + +#define REG_PAD_KEYCNT_INTR_SHIFT 14 +#define REG_PAD_KEYCNT_INTR_SIZE 1 +#define REG_PAD_KEYCNT_INTR_MASK 0x4000 + +#define REG_PAD_KEYCNT_L_SHIFT 9 +#define REG_PAD_KEYCNT_L_SIZE 1 +#define REG_PAD_KEYCNT_L_MASK 0x0200 + +#define REG_PAD_KEYCNT_R_SHIFT 8 +#define REG_PAD_KEYCNT_R_SIZE 1 +#define REG_PAD_KEYCNT_R_MASK 0x0100 + +#define REG_PAD_KEYCNT_DOWN_SHIFT 7 +#define REG_PAD_KEYCNT_DOWN_SIZE 1 +#define REG_PAD_KEYCNT_DOWN_MASK 0x0080 + +#define REG_PAD_KEYCNT_UP_SHIFT 6 +#define REG_PAD_KEYCNT_UP_SIZE 1 +#define REG_PAD_KEYCNT_UP_MASK 0x0040 + +#define REG_PAD_KEYCNT_LEFT_SHIFT 5 +#define REG_PAD_KEYCNT_LEFT_SIZE 1 +#define REG_PAD_KEYCNT_LEFT_MASK 0x0020 + +#define REG_PAD_KEYCNT_RIGHT_SHIFT 4 +#define REG_PAD_KEYCNT_RIGHT_SIZE 1 +#define REG_PAD_KEYCNT_RIGHT_MASK 0x0010 + +#define REG_PAD_KEYCNT_START_SHIFT 3 +#define REG_PAD_KEYCNT_START_SIZE 1 +#define REG_PAD_KEYCNT_START_MASK 0x0008 + +#define REG_PAD_KEYCNT_SEL_SHIFT 2 +#define REG_PAD_KEYCNT_SEL_SIZE 1 +#define REG_PAD_KEYCNT_SEL_MASK 0x0004 + +#define REG_PAD_KEYCNT_B_SHIFT 1 +#define REG_PAD_KEYCNT_B_SIZE 1 +#define REG_PAD_KEYCNT_B_MASK 0x0002 + +#define REG_PAD_KEYCNT_A_SHIFT 0 +#define REG_PAD_KEYCNT_A_SIZE 1 +#define REG_PAD_KEYCNT_A_MASK 0x0001 + +#define REG_G2_WINOUT_OBJWININ_SHIFT 8 +#define REG_G2_WINOUT_OBJWININ_SIZE 6 +#define REG_G2_WINOUT_OBJWININ_MASK 0x3f00 + +#define REG_G2_WINOUT_WINOUT_SHIFT 0 +#define REG_G2_WINOUT_WINOUT_SIZE 6 +#define REG_G2_WINOUT_WINOUT_MASK 0x003f + +#define REG_G2_WINOUT_FIELD( objwinin, winout ) \ + (u16)( \ + ((u32)(objwinin) << REG_G2_WINOUT_OBJWININ_SHIFT) | \ + ((u32)(winout) << REG_G2_WINOUT_WINOUT_SHIFT)) + +#ifndef SDK_ASM +#define REG_PAD_KEYCNT_FIELD( logic, intr, l, r, down, up, left, right, start, sel, b, a ) \ + (u16)( \ + ((u32)(logic) << REG_PAD_KEYCNT_LOGIC_SHIFT) | \ + ((u32)(intr) << REG_PAD_KEYCNT_INTR_SHIFT) | \ + ((u32)(l) << REG_PAD_KEYCNT_L_SHIFT) | \ + ((u32)(r) << REG_PAD_KEYCNT_R_SHIFT) | \ + ((u32)(down) << REG_PAD_KEYCNT_DOWN_SHIFT) | \ + ((u32)(up) << REG_PAD_KEYCNT_UP_SHIFT) | \ + ((u32)(left) << REG_PAD_KEYCNT_LEFT_SHIFT) | \ + ((u32)(right) << REG_PAD_KEYCNT_RIGHT_SHIFT) | \ + ((u32)(start) << REG_PAD_KEYCNT_START_SHIFT) | \ + ((u32)(sel) << REG_PAD_KEYCNT_SEL_SHIFT) | \ + ((u32)(b) << REG_PAD_KEYCNT_B_SHIFT) | \ + ((u32)(a) << REG_PAD_KEYCNT_A_SHIFT)) +#endif + +#define REG_GX_POWCNT_GE_SHIFT 3 +#define REG_GX_POWCNT_GE_SIZE 1 +#define REG_GX_POWCNT_GE_MASK 0x0008 + +#define REG_GX_POWCNT_RE_SHIFT 2 +#define REG_GX_POWCNT_RE_SIZE 1 +#define REG_GX_POWCNT_RE_MASK 0x0004 + +#define REG_GX_POWCNT_E2DG_SHIFT 1 +#define REG_GX_POWCNT_E2DG_SIZE 1 +#define REG_GX_POWCNT_E2DG_MASK 0x0002 + +#define REG_GX_POWCNT_LCD_SHIFT 0 +#define REG_GX_POWCNT_LCD_SIZE 1 +#define REG_GX_POWCNT_LCD_MASK 0x0001 + +#define REG_GX_POWCNT_LCDB_SHIFT 8 +#define REG_GX_POWCNT_LCDB_SIZE 1 +#define REG_GX_POWCNT_LCDB_MASK 0x0100 + +#define REG_GX_POWCNT_E2DGB_SHIFT 9 +#define REG_GX_POWCNT_E2DGB_SIZE 1 +#define REG_GX_POWCNT_E2DGB_MASK 0x0200 + +#define REG_GX_POWCNT_DSEL_SHIFT 15 +#define REG_GX_POWCNT_DSEL_SIZE 1 +#define REG_GX_POWCNT_DSEL_MASK 0x8000 + +// GX_DISPCNT +#define REG_GX_DISPCNT_O_SHIFT 31 +#define REG_GX_DISPCNT_O_SIZE 1 +#define REG_GX_DISPCNT_O_MASK 0x80000000 + +#define REG_GX_DISPCNT_BG_SHIFT 30 +#define REG_GX_DISPCNT_BG_SIZE 1 +#define REG_GX_DISPCNT_BG_MASK 0x40000000 + +#define REG_GX_DISPCNT_BGSCREENOFFSET_SHIFT 27 +#define REG_GX_DISPCNT_BGSCREENOFFSET_SIZE 3 +#define REG_GX_DISPCNT_BGSCREENOFFSET_MASK 0x38000000 + +#define REG_GX_DISPCNT_BGCHAROFFSET_SHIFT 24 +#define REG_GX_DISPCNT_BGCHAROFFSET_SIZE 3 +#define REG_GX_DISPCNT_BGCHAROFFSET_MASK 0x07000000 + +#define REG_GX_DISPCNT_OH_SHIFT 23 +#define REG_GX_DISPCNT_OH_SIZE 1 +#define REG_GX_DISPCNT_OH_MASK 0x00800000 + +#define REG_GX_DISPCNT_EXOBJ_SHIFT 20 +#define REG_GX_DISPCNT_EXOBJ_SIZE 3 +#define REG_GX_DISPCNT_EXOBJ_MASK 0x00700000 + +#define REG_GX_DISPCNT_VRAM_SHIFT 18 +#define REG_GX_DISPCNT_VRAM_SIZE 2 +#define REG_GX_DISPCNT_VRAM_MASK 0x000c0000 + +#define REG_GX_DISPCNT_MODE_SHIFT 16 +#define REG_GX_DISPCNT_MODE_SIZE 2 +#define REG_GX_DISPCNT_MODE_MASK 0x00030000 + +#define REG_GX_DISPCNT_OW_SHIFT 15 +#define REG_GX_DISPCNT_OW_SIZE 1 +#define REG_GX_DISPCNT_OW_MASK 0x00008000 + +#define REG_GX_DISPCNT_W1_SHIFT 14 +#define REG_GX_DISPCNT_W1_SIZE 1 +#define REG_GX_DISPCNT_W1_MASK 0x00004000 + +#define REG_GX_DISPCNT_W0_SHIFT 13 +#define REG_GX_DISPCNT_W0_SIZE 1 +#define REG_GX_DISPCNT_W0_MASK 0x00002000 + +#define REG_GX_DISPCNT_DISPLAY_SHIFT 8 +#define REG_GX_DISPCNT_DISPLAY_SIZE 5 +#define REG_GX_DISPCNT_DISPLAY_MASK 0x00001f00 + +#define REG_GX_DISPCNT_BLANK_SHIFT 7 +#define REG_GX_DISPCNT_BLANK_SIZE 1 +#define REG_GX_DISPCNT_BLANK_MASK 0x00000080 + +#define REG_GX_DISPCNT_OBJMAP_SHIFT 4 +#define REG_GX_DISPCNT_OBJMAP_SIZE 3 +#define REG_GX_DISPCNT_OBJMAP_MASK 0x00000070 + +#define REG_GX_DISPCNT_BG02D3D_SHIFT 3 +#define REG_GX_DISPCNT_BG02D3D_SIZE 1 +#define REG_GX_DISPCNT_BG02D3D_MASK 0x00000008 + +#define REG_GX_DISPCNT_BGMODE_SHIFT 0 +#define REG_GX_DISPCNT_BGMODE_SIZE 3 +#define REG_GX_DISPCNT_BGMODE_MASK 0x00000007 + +#define REG_GX_DISPCNT_OBJMAP_CH_SHIFT 4 +#define REG_GX_DISPCNT_OBJMAP_CH_SIZE 1 +#define REG_GX_DISPCNT_OBJMAP_CH_MASK 0x00000010 + +#define REG_GX_DISPCNT_OBJMAP_BM_SHIFT 5 +#define REG_GX_DISPCNT_OBJMAP_BM_SIZE 2 +#define REG_GX_DISPCNT_OBJMAP_BM_MASK 0x00000060 + +#define REG_GX_DISPCNT_EXOBJ_CH_SHIFT 20 +#define REG_GX_DISPCNT_EXOBJ_CH_SIZE 2 +#define REG_GX_DISPCNT_EXOBJ_CH_MASK 0x00300000 + +#define REG_GX_DISPCNT_EXOBJ_BM_SHIFT 22 +#define REG_GX_DISPCNT_EXOBJ_BM_SIZE 1 +#define REG_GX_DISPCNT_EXOBJ_BM_MASK 0x00400000 + +// GXS_DB_DISPCNT +#define REG_GXS_DB_DISPCNT_O_SHIFT 31 +#define REG_GXS_DB_DISPCNT_O_SIZE 1 +#define REG_GXS_DB_DISPCNT_O_MASK 0x80000000 + +#define REG_GXS_DB_DISPCNT_BG_SHIFT 30 +#define REG_GXS_DB_DISPCNT_BG_SIZE 1 +#define REG_GXS_DB_DISPCNT_BG_MASK 0x40000000 + +#define REG_GXS_DB_DISPCNT_OH_SHIFT 23 +#define REG_GXS_DB_DISPCNT_OH_SIZE 1 +#define REG_GXS_DB_DISPCNT_OH_MASK 0x00800000 + +#define REG_GXS_DB_DISPCNT_EXOBJ_SHIFT 20 +#define REG_GXS_DB_DISPCNT_EXOBJ_SIZE 2 +#define REG_GXS_DB_DISPCNT_EXOBJ_MASK 0x00300000 + +#define REG_GXS_DB_DISPCNT_MODE_SHIFT 16 +#define REG_GXS_DB_DISPCNT_MODE_SIZE 1 +#define REG_GXS_DB_DISPCNT_MODE_MASK 0x00010000 + +#define REG_GXS_DB_DISPCNT_OW_SHIFT 15 +#define REG_GXS_DB_DISPCNT_OW_SIZE 1 +#define REG_GXS_DB_DISPCNT_OW_MASK 0x00008000 + +#define REG_GXS_DB_DISPCNT_W1_SHIFT 14 +#define REG_GXS_DB_DISPCNT_W1_SIZE 1 +#define REG_GXS_DB_DISPCNT_W1_MASK 0x00004000 + +#define REG_GXS_DB_DISPCNT_W0_SHIFT 13 +#define REG_GXS_DB_DISPCNT_W0_SIZE 1 +#define REG_GXS_DB_DISPCNT_W0_MASK 0x00002000 + +#define REG_GXS_DB_DISPCNT_DISPLAY_SHIFT 8 +#define REG_GXS_DB_DISPCNT_DISPLAY_SIZE 5 +#define REG_GXS_DB_DISPCNT_DISPLAY_MASK 0x00001f00 + +#define REG_GXS_DB_DISPCNT_BLANK_SHIFT 7 +#define REG_GXS_DB_DISPCNT_BLANK_SIZE 1 +#define REG_GXS_DB_DISPCNT_BLANK_MASK 0x00000080 + +#define REG_GXS_DB_DISPCNT_OBJMAP_SHIFT 4 +#define REG_GXS_DB_DISPCNT_OBJMAP_SIZE 3 +#define REG_GXS_DB_DISPCNT_OBJMAP_MASK 0x00000070 + +#define REG_GXS_DB_DISPCNT_BGMODE_SHIFT 0 +#define REG_GXS_DB_DISPCNT_BGMODE_SIZE 3 +#define REG_GXS_DB_DISPCNT_BGMODE_MASK 0x00000007 + +#define REG_GXS_DB_DISPCNT_OBJMAP_CH_SHIFT 4 +#define REG_GXS_DB_DISPCNT_OBJMAP_CH_SIZE 1 +#define REG_GXS_DB_DISPCNT_OBJMAP_CH_MASK 0x00000010 + +#define REG_GXS_DB_DISPCNT_OBJMAP_BM_SHIFT 5 +#define REG_GXS_DB_DISPCNT_OBJMAP_BM_SIZE 2 +#define REG_GXS_DB_DISPCNT_OBJMAP_BM_MASK 0x00000060 + +#define REG_GXS_DB_DISPCNT_EXOBJ_CH_SHIFT 20 +#define REG_GXS_DB_DISPCNT_EXOBJ_CH_SIZE 2 +#define REG_GXS_DB_DISPCNT_EXOBJ_CH_MASK 0x00300000 + +// MASTER BRIGHT +#define REG_GX_MASTER_BRIGHT_E_MOD_SHIFT 14 +#define REG_GX_MASTER_BRIGHT_E_MOD_SIZE 2 +#define REG_GX_MASTER_BRIGHT_E_MOD_MASK 0xc000 + +#define REG_GX_MASTER_BRIGHT_E_VALUE_SHIFT 0 +#define REG_GX_MASTER_BRIGHT_E_VALUE_SIZE 5 +#define REG_GX_MASTER_BRIGHT_E_VALUE_MASK 0x001f + +// DISPSTAT +#define REG_GX_DISPSTAT_VCOUNTER_SHIFT 7 +#define REG_GX_DISPSTAT_VCOUNTER_SIZE 9 +#define REG_GX_DISPSTAT_VCOUNTER_MASK 0xff80 + +#define REG_GX_DISPSTAT_VQI_SHIFT 5 +#define REG_GX_DISPSTAT_VQI_SIZE 1 +#define REG_GX_DISPSTAT_VQI_MASK 0x0020 + +#define REG_GX_DISPSTAT_HBI_SHIFT 4 +#define REG_GX_DISPSTAT_HBI_SIZE 1 +#define REG_GX_DISPSTAT_HBI_MASK 0x0010 + +#define REG_GX_DISPSTAT_VBI_SHIFT 3 +#define REG_GX_DISPSTAT_VBI_SIZE 1 +#define REG_GX_DISPSTAT_VBI_MASK 0x0008 + +#define REG_GX_DISPSTAT_LYC_SHIFT 2 +#define REG_GX_DISPSTAT_LYC_SIZE 1 +#define REG_GX_DISPSTAT_LYC_MASK 0x0004 + +#define REG_GX_DISPSTAT_HBLK_SHIFT 1 +#define REG_GX_DISPSTAT_HBLK_SIZE 1 +#define REG_GX_DISPSTAT_HBLK_MASK 0x0002 + +#define REG_GX_DISPSTAT_VBLK_SHIFT 0 +#define REG_GX_DISPSTAT_VBLK_SIZE 1 +#define REG_GX_DISPSTAT_VBLK_MASK 0x0001 + +// G2_BG0CNT +#define REG_G2_BG0CNT_SCREENSIZE_SHIFT 14 +#define REG_G2_BG0CNT_SCREENSIZE_SIZE 2 +#define REG_G2_BG0CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2_BG0CNT_BGPLTTSLOT_SHIFT 13 +#define REG_G2_BG0CNT_BGPLTTSLOT_SIZE 1 +#define REG_G2_BG0CNT_BGPLTTSLOT_MASK 0x2000 + +#define REG_G2_BG0CNT_SCREENBASE_SHIFT 8 +#define REG_G2_BG0CNT_SCREENBASE_SIZE 5 +#define REG_G2_BG0CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2_BG0CNT_COLORMODE_SHIFT 7 +#define REG_G2_BG0CNT_COLORMODE_SIZE 1 +#define REG_G2_BG0CNT_COLORMODE_MASK 0x0080 + +#define REG_G2_BG0CNT_MOSAIC_SHIFT 6 +#define REG_G2_BG0CNT_MOSAIC_SIZE 1 +#define REG_G2_BG0CNT_MOSAIC_MASK 0x0040 + +#define REG_G2_BG0CNT_CHARBASE_SHIFT 2 +#define REG_G2_BG0CNT_CHARBASE_SIZE 4 +#define REG_G2_BG0CNT_CHARBASE_MASK 0x003c + +#define REG_G2_BG0CNT_PRIORITY_SHIFT 0 +#define REG_G2_BG0CNT_PRIORITY_SIZE 2 +#define REG_G2_BG0CNT_PRIORITY_MASK 0x0003 + +// G2_BG1CNT +#define REG_G2_BG1CNT_SCREENSIZE_SHIFT 14 +#define REG_G2_BG1CNT_SCREENSIZE_SIZE 2 +#define REG_G2_BG1CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2_BG1CNT_BGPLTTSLOT_SHIFT 13 +#define REG_G2_BG1CNT_BGPLTTSLOT_SIZE 1 +#define REG_G2_BG1CNT_BGPLTTSLOT_MASK 0x2000 + +#define REG_G2_BG1CNT_SCREENBASE_SHIFT 8 +#define REG_G2_BG1CNT_SCREENBASE_SIZE 5 +#define REG_G2_BG1CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2_BG1CNT_COLORMODE_SHIFT 7 +#define REG_G2_BG1CNT_COLORMODE_SIZE 1 +#define REG_G2_BG1CNT_COLORMODE_MASK 0x0080 + +#define REG_G2_BG1CNT_MOSAIC_SHIFT 6 +#define REG_G2_BG1CNT_MOSAIC_SIZE 1 +#define REG_G2_BG1CNT_MOSAIC_MASK 0x0040 + +#define REG_G2_BG1CNT_CHARBASE_SHIFT 2 +#define REG_G2_BG1CNT_CHARBASE_SIZE 4 +#define REG_G2_BG1CNT_CHARBASE_MASK 0x003c + +#define REG_G2_BG1CNT_PRIORITY_SHIFT 0 +#define REG_G2_BG1CNT_PRIORITY_SIZE 2 +#define REG_G2_BG1CNT_PRIORITY_MASK 0x0003 + +// G2_BG2CNT +#define REG_G2_BG2CNT_SCREENSIZE_SHIFT 14 +#define REG_G2_BG2CNT_SCREENSIZE_SIZE 2 +#define REG_G2_BG2CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2_BG2CNT_AREAOVER_SHIFT 13 +#define REG_G2_BG2CNT_AREAOVER_SIZE 1 +#define REG_G2_BG2CNT_AREAOVER_MASK 0x2000 + +#define REG_G2_BG2CNT_SCREENBASE_SHIFT 8 +#define REG_G2_BG2CNT_SCREENBASE_SIZE 5 +#define REG_G2_BG2CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2_BG2CNT_COLORMODE_SHIFT 7 +#define REG_G2_BG2CNT_COLORMODE_SIZE 1 +#define REG_G2_BG2CNT_COLORMODE_MASK 0x0080 + +#define REG_G2_BG2CNT_MOSAIC_SHIFT 6 +#define REG_G2_BG2CNT_MOSAIC_SIZE 1 +#define REG_G2_BG2CNT_MOSAIC_MASK 0x0040 + +#define REG_G2_BG2CNT_CHARBASE_SHIFT 2 +#define REG_G2_BG2CNT_CHARBASE_SIZE 4 +#define REG_G2_BG2CNT_CHARBASE_MASK 0x003c + +#define REG_G2_BG2CNT_PRIORITY_SHIFT 0 +#define REG_G2_BG2CNT_PRIORITY_SIZE 2 +#define REG_G2_BG2CNT_PRIORITY_MASK 0x0003 + +// G2_BG3CNT +#define REG_G2_BG3CNT_SCREENSIZE_SHIFT 14 +#define REG_G2_BG3CNT_SCREENSIZE_SIZE 2 +#define REG_G2_BG3CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2_BG3CNT_AREAOVER_SHIFT 13 +#define REG_G2_BG3CNT_AREAOVER_SIZE 1 +#define REG_G2_BG3CNT_AREAOVER_MASK 0x2000 + +#define REG_G2_BG3CNT_SCREENBASE_SHIFT 8 +#define REG_G2_BG3CNT_SCREENBASE_SIZE 5 +#define REG_G2_BG3CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2_BG3CNT_COLORMODE_SHIFT 7 +#define REG_G2_BG3CNT_COLORMODE_SIZE 1 +#define REG_G2_BG3CNT_COLORMODE_MASK 0x0080 + +#define REG_G2_BG3CNT_MOSAIC_SHIFT 6 +#define REG_G2_BG3CNT_MOSAIC_SIZE 1 +#define REG_G2_BG3CNT_MOSAIC_MASK 0x0040 + +#define REG_G2_BG3CNT_CHARBASE_SHIFT 2 +#define REG_G2_BG3CNT_CHARBASE_SIZE 4 +#define REG_G2_BG3CNT_CHARBASE_MASK 0x003c + +#define REG_G2_BG3CNT_PRIORITY_SHIFT 0 +#define REG_G2_BG3CNT_PRIORITY_SIZE 2 +#define REG_G2_BG3CNT_PRIORITY_MASK 0x0003 + +// G2S_DB_BG0CNT +#define REG_G2S_DB_BG0CNT_SCREENSIZE_SHIFT 14 +#define REG_G2S_DB_BG0CNT_SCREENSIZE_SIZE 2 +#define REG_G2S_DB_BG0CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2S_DB_BG0CNT_BGPLTTSLOT_SHIFT 13 +#define REG_G2S_DB_BG0CNT_BGPLTTSLOT_SIZE 1 +#define REG_G2S_DB_BG0CNT_BGPLTTSLOT_MASK 0x2000 + +#define REG_G2S_DB_BG0CNT_SCREENBASE_SHIFT 8 +#define REG_G2S_DB_BG0CNT_SCREENBASE_SIZE 5 +#define REG_G2S_DB_BG0CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2S_DB_BG0CNT_COLORMODE_SHIFT 7 +#define REG_G2S_DB_BG0CNT_COLORMODE_SIZE 1 +#define REG_G2S_DB_BG0CNT_COLORMODE_MASK 0x0080 + +#define REG_G2S_DB_BG0CNT_MOSAIC_SHIFT 6 +#define REG_G2S_DB_BG0CNT_MOSAIC_SIZE 1 +#define REG_G2S_DB_BG0CNT_MOSAIC_MASK 0x0040 + +#define REG_G2S_DB_BG0CNT_CHARBASE_SHIFT 2 +#define REG_G2S_DB_BG0CNT_CHARBASE_SIZE 4 +#define REG_G2S_DB_BG0CNT_CHARBASE_MASK 0x003c + +#define REG_G2S_DB_BG0CNT_PRIORITY_SHIFT 0 +#define REG_G2S_DB_BG0CNT_PRIORITY_SIZE 2 +#define REG_G2S_DB_BG0CNT_PRIORITY_MASK 0x0003 + +// G2S_DB_BG1CNT +#define REG_G2S_DB_BG1CNT_SCREENSIZE_SHIFT 14 +#define REG_G2S_DB_BG1CNT_SCREENSIZE_SIZE 2 +#define REG_G2S_DB_BG1CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2S_DB_BG1CNT_BGPLTTSLOT_SHIFT 13 +#define REG_G2S_DB_BG1CNT_BGPLTTSLOT_SIZE 1 +#define REG_G2S_DB_BG1CNT_BGPLTTSLOT_MASK 0x2000 + +#define REG_G2S_DB_BG1CNT_SCREENBASE_SHIFT 8 +#define REG_G2S_DB_BG1CNT_SCREENBASE_SIZE 5 +#define REG_G2S_DB_BG1CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2S_DB_BG1CNT_COLORMODE_SHIFT 7 +#define REG_G2S_DB_BG1CNT_COLORMODE_SIZE 1 +#define REG_G2S_DB_BG1CNT_COLORMODE_MASK 0x0080 + +#define REG_G2S_DB_BG1CNT_MOSAIC_SHIFT 6 +#define REG_G2S_DB_BG1CNT_MOSAIC_SIZE 1 +#define REG_G2S_DB_BG1CNT_MOSAIC_MASK 0x0040 + +#define REG_G2S_DB_BG1CNT_CHARBASE_SHIFT 2 +#define REG_G2S_DB_BG1CNT_CHARBASE_SIZE 4 +#define REG_G2S_DB_BG1CNT_CHARBASE_MASK 0x003c + +#define REG_G2S_DB_BG1CNT_PRIORITY_SHIFT 0 +#define REG_G2S_DB_BG1CNT_PRIORITY_SIZE 2 +#define REG_G2S_DB_BG1CNT_PRIORITY_MASK 0x0003 + +// G2S_DB_BG2CNT +#define REG_G2S_DB_BG2CNT_SCREENSIZE_SHIFT 14 +#define REG_G2S_DB_BG2CNT_SCREENSIZE_SIZE 2 +#define REG_G2S_DB_BG2CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2S_DB_BG2CNT_AREAOVER_SHIFT 13 +#define REG_G2S_DB_BG2CNT_AREAOVER_SIZE 1 +#define REG_G2S_DB_BG2CNT_AREAOVER_MASK 0x2000 + +#define REG_G2S_DB_BG2CNT_SCREENBASE_SHIFT 8 +#define REG_G2S_DB_BG2CNT_SCREENBASE_SIZE 5 +#define REG_G2S_DB_BG2CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2S_DB_BG2CNT_COLORMODE_SHIFT 7 +#define REG_G2S_DB_BG2CNT_COLORMODE_SIZE 1 +#define REG_G2S_DB_BG2CNT_COLORMODE_MASK 0x0080 + +#define REG_G2S_DB_BG2CNT_MOSAIC_SHIFT 6 +#define REG_G2S_DB_BG2CNT_MOSAIC_SIZE 1 +#define REG_G2S_DB_BG2CNT_MOSAIC_MASK 0x0040 + +#define REG_G2S_DB_BG2CNT_CHARBASE_SHIFT 2 +#define REG_G2S_DB_BG2CNT_CHARBASE_SIZE 4 +#define REG_G2S_DB_BG2CNT_CHARBASE_MASK 0x003c + +#define REG_G2S_DB_BG2CNT_PRIORITY_SHIFT 0 +#define REG_G2S_DB_BG2CNT_PRIORITY_SIZE 2 +#define REG_G2S_DB_BG2CNT_PRIORITY_MASK 0x0003 + +// G2S_DB_BG3CNT +#define REG_G2S_DB_BG3CNT_SCREENSIZE_SHIFT 14 +#define REG_G2S_DB_BG3CNT_SCREENSIZE_SIZE 2 +#define REG_G2S_DB_BG3CNT_SCREENSIZE_MASK 0xc000 + +#define REG_G2S_DB_BG3CNT_AREAOVER_SHIFT 13 +#define REG_G2S_DB_BG3CNT_AREAOVER_SIZE 1 +#define REG_G2S_DB_BG3CNT_AREAOVER_MASK 0x2000 + +#define REG_G2S_DB_BG3CNT_SCREENBASE_SHIFT 8 +#define REG_G2S_DB_BG3CNT_SCREENBASE_SIZE 5 +#define REG_G2S_DB_BG3CNT_SCREENBASE_MASK 0x1f00 + +#define REG_G2S_DB_BG3CNT_COLORMODE_SHIFT 7 +#define REG_G2S_DB_BG3CNT_COLORMODE_SIZE 1 +#define REG_G2S_DB_BG3CNT_COLORMODE_MASK 0x0080 + +#define REG_G2S_DB_BG3CNT_MOSAIC_SHIFT 6 +#define REG_G2S_DB_BG3CNT_MOSAIC_SIZE 1 +#define REG_G2S_DB_BG3CNT_MOSAIC_MASK 0x0040 + +#define REG_G2S_DB_BG3CNT_CHARBASE_SHIFT 2 +#define REG_G2S_DB_BG3CNT_CHARBASE_SIZE 4 +#define REG_G2S_DB_BG3CNT_CHARBASE_MASK 0x003c + +#define REG_G2S_DB_BG3CNT_PRIORITY_SHIFT 0 +#define REG_G2S_DB_BG3CNT_PRIORITY_SIZE 2 +#define REG_G2S_DB_BG3CNT_PRIORITY_MASK 0x0003 + +// G2_BG0OFS +#define REG_G2_BG0OFS_VOFFSET_SHIFT 16 +#define REG_G2_BG0OFS_VOFFSET_SIZE 9 +#define REG_G2_BG0OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2_BG0OFS_HOFFSET_SHIFT 0 +#define REG_G2_BG0OFS_HOFFSET_SIZE 9 +#define REG_G2_BG0OFS_HOFFSET_MASK 0x000001ff + +// G2_BG1OFS +#define REG_G2_BG1OFS_VOFFSET_SHIFT 16 +#define REG_G2_BG1OFS_VOFFSET_SIZE 9 +#define REG_G2_BG1OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2_BG1OFS_HOFFSET_SHIFT 0 +#define REG_G2_BG1OFS_HOFFSET_SIZE 9 +#define REG_G2_BG1OFS_HOFFSET_MASK 0x000001ff + +// G2_BG2OFS +#define REG_G2_BG2OFS_VOFFSET_SHIFT 16 +#define REG_G2_BG2OFS_VOFFSET_SIZE 9 +#define REG_G2_BG2OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2_BG2OFS_HOFFSET_SHIFT 0 +#define REG_G2_BG2OFS_HOFFSET_SIZE 9 +#define REG_G2_BG2OFS_HOFFSET_MASK 0x000001ff + +// G2_BG3OFS +#define REG_G2_BG3OFS_VOFFSET_SHIFT 16 +#define REG_G2_BG3OFS_VOFFSET_SIZE 9 +#define REG_G2_BG3OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2_BG3OFS_HOFFSET_SHIFT 0 +#define REG_G2_BG3OFS_HOFFSET_SIZE 9 +#define REG_G2_BG3OFS_HOFFSET_MASK 0x000001ff + +// G2S_DB_BG0OFS +#define REG_G2S_DB_BG0OFS_VOFFSET_SHIFT 16 +#define REG_G2S_DB_BG0OFS_VOFFSET_SIZE 9 +#define REG_G2S_DB_BG0OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2S_DB_BG0OFS_HOFFSET_SHIFT 0 +#define REG_G2S_DB_BG0OFS_HOFFSET_SIZE 9 +#define REG_G2S_DB_BG0OFS_HOFFSET_MASK 0x000001ff + +// G2S_DB_BG1OFS +#define REG_G2S_DB_BG1OFS_VOFFSET_SHIFT 16 +#define REG_G2S_DB_BG1OFS_VOFFSET_SIZE 9 +#define REG_G2S_DB_BG1OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2S_DB_BG1OFS_HOFFSET_SHIFT 0 +#define REG_G2S_DB_BG1OFS_HOFFSET_SIZE 9 +#define REG_G2S_DB_BG1OFS_HOFFSET_MASK 0x000001ff + +// G2S_DB_BG2OFS +#define REG_G2S_DB_BG2OFS_VOFFSET_SHIFT 16 +#define REG_G2S_DB_BG2OFS_VOFFSET_SIZE 9 +#define REG_G2S_DB_BG2OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2S_DB_BG2OFS_HOFFSET_SHIFT 0 +#define REG_G2S_DB_BG2OFS_HOFFSET_SIZE 9 +#define REG_G2S_DB_BG2OFS_HOFFSET_MASK 0x000001ff + +// G2S_DB_BG3OFS +#define REG_G2S_DB_BG3OFS_VOFFSET_SHIFT 16 +#define REG_G2S_DB_BG3OFS_VOFFSET_SIZE 9 +#define REG_G2S_DB_BG3OFS_VOFFSET_MASK 0x01ff0000 + +#define REG_G2S_DB_BG3OFS_HOFFSET_SHIFT 0 +#define REG_G2S_DB_BG3OFS_HOFFSET_SIZE 9 +#define REG_G2S_DB_BG3OFS_HOFFSET_MASK 0x000001ff + +// Timer control + +#define REG_OS_TM0CNT_L_TIMER0CNT_SHIFT 0 +#define REG_OS_TM0CNT_L_TIMER0CNT_SIZE 16 +#define REG_OS_TM0CNT_L_TIMER0CNT_MASK 0xffff + +#define REG_OS_TM0CNT_H_E_SHIFT 7 +#define REG_OS_TM0CNT_H_E_SIZE 1 +#define REG_OS_TM0CNT_H_E_MASK 0x0080 + +#define REG_OS_TM0CNT_H_I_SHIFT 6 +#define REG_OS_TM0CNT_H_I_SIZE 1 +#define REG_OS_TM0CNT_H_I_MASK 0x0040 + +#define REG_OS_TM0CNT_H_PS_SHIFT 0 +#define REG_OS_TM0CNT_H_PS_SIZE 2 +#define REG_OS_TM0CNT_H_PS_MASK 0x0003 + +#define REG_OS_TM1CNT_L_TIMER0CNT_SHIFT 0 +#define REG_OS_TM1CNT_L_TIMER0CNT_SIZE 16 +#define REG_OS_TM1CNT_L_TIMER0CNT_MASK 0xffff + +#define REG_OS_TM1CNT_H_E_SHIFT 7 +#define REG_OS_TM1CNT_H_E_SIZE 1 +#define REG_OS_TM1CNT_H_E_MASK 0x0080 + +#define REG_OS_TM1CNT_H_I_SHIFT 6 +#define REG_OS_TM1CNT_H_I_SIZE 1 +#define REG_OS_TM1CNT_H_I_MASK 0x0040 + +#define REG_OS_TM1CNT_H_PS_SHIFT 0 +#define REG_OS_TM1CNT_H_PS_SIZE 2 +#define REG_OS_TM1CNT_H_PS_MASK 0x0003 + +#define REG_OS_TM2CNT_L_TIMER0CNT_SHIFT 0 +#define REG_OS_TM2CNT_L_TIMER0CNT_SIZE 16 +#define REG_OS_TM2CNT_L_TIMER0CNT_MASK 0xffff + +#define REG_OS_TM2CNT_H_E_SHIFT 7 +#define REG_OS_TM2CNT_H_E_SIZE 1 +#define REG_OS_TM2CNT_H_E_MASK 0x0080 + +#define REG_OS_TM2CNT_H_I_SHIFT 6 +#define REG_OS_TM2CNT_H_I_SIZE 1 +#define REG_OS_TM2CNT_H_I_MASK 0x0040 + +#define REG_OS_TM2CNT_H_PS_SHIFT 0 +#define REG_OS_TM2CNT_H_PS_SIZE 2 +#define REG_OS_TM2CNT_H_PS_MASK 0x0003 + +#define REG_OS_TM3CNT_L_TIMER0CNT_SHIFT 0 +#define REG_OS_TM3CNT_L_TIMER0CNT_SIZE 16 +#define REG_OS_TM3CNT_L_TIMER0CNT_MASK 0xffff + +#define REG_OS_TM3CNT_H_E_SHIFT 7 +#define REG_OS_TM3CNT_H_E_SIZE 1 +#define REG_OS_TM3CNT_H_E_MASK 0x0080 + +#define REG_OS_TM3CNT_H_I_SHIFT 6 +#define REG_OS_TM3CNT_H_I_SIZE 1 +#define REG_OS_TM3CNT_H_I_MASK 0x0040 + +#define REG_OS_TM3CNT_H_PS_SHIFT 0 +#define REG_OS_TM3CNT_H_PS_SIZE 2 +#define REG_OS_TM3CNT_H_PS_MASK 0x0003 + +#endif //POKEDIAMOND_ARM9_REGISTERS_H diff --git a/arm9/lib/NitroSDK/include/syscall.h b/arm9/lib/NitroSDK/include/syscall.h new file mode 100644 index 00000000..8e7962df --- /dev/null +++ b/arm9/lib/NitroSDK/include/syscall.h @@ -0,0 +1,19 @@ +#ifndef POKEDIAMOND_ARM9_SYSCALL_H +#define POKEDIAMOND_ARM9_SYSCALL_H + +#include "consts.h" +#include "MI_dma.h" + +void SVC_CpuSet(const void *srcp, void *destp, u32 dmaCntData); + +#define SVC_CpuClear( data, destp, size, bit ) \ +do{ \ + vu##bit tmp = (vu##bit )(data); \ + SVC_CpuSet((u8 *)&(tmp), (u8 *)(destp), ( \ + MI_DMA_SRC_FIX | \ + MI_DMA_##bit##BIT_BUS | ((size)/((bit)/8) & 0x1fffff))); \ +} while(0) + +void SVC_WaitByLoop(u32 ct); + +#endif //POKEDIAMOND_ARM9_SYSCALL_H diff --git a/arm9/lib/NitroSDK/include/systemWork.h b/arm9/lib/NitroSDK/include/systemWork.h new file mode 100644 index 00000000..1e3ba46b --- /dev/null +++ b/arm9/lib/NitroSDK/include/systemWork.h @@ -0,0 +1,6 @@ +#ifndef POKEDIAMOND_ARM9_SYSTEMWORK_H +#define POKEDIAMOND_ARM9_SYSTEMWORK_H + +#include "nitro/OS_systemWork_shared.h" + +#endif //POKEDIAMOND_ARM9_SYSTEMWORK_H diff --git a/arm9/lib/NitroSDK/include/tp.h b/arm9/lib/NitroSDK/include/tp.h new file mode 100644 index 00000000..dc762f10 --- /dev/null +++ b/arm9/lib/NitroSDK/include/tp.h @@ -0,0 +1,45 @@ +#ifndef NITRO_TP_H_ +#define NITRO_TP_H_ + +#define TP_TOUCH_OFF 0 // Not being touched +#define TP_TOUCH_ON 1 // Being touched + +#define TP_VALIDITY_VALID 0 // Valid +#define TP_VALIDITY_INVALID_X 1 // Data with invalid X coordinate +#define TP_VALIDITY_INVALID_Y 2 // Data with invalid Y coordinate +#define TP_VALIDITY_INVALID_XY (TP_VALIDITY_INVALID_X | TP_VALIDITY_INVALID_Y) // Data with invalid X and Y coordinates + +// Touch panel input structure +typedef struct +{ + u16 x; // x coordinate ( 0 - 4095 ) + u16 y; // y coordinate ( 0 - 4095 ) + u16 touch; // Touch yes/no + u16 validity; // Valid yes/no +} +TPData; + +typedef struct NvTpData +{ + s16 x0; // X origin coordinate + s16 y0; // Y origin coordinate + s16 xDotSize; // X dot size + s16 yDotSize; // Y dot size +} +TPCalibrateParam; + +void TP_Init(void); +void TP_SetCalibrateParam(const TPCalibrateParam *param); +BOOL TP_GetUserInfo(TPCalibrateParam *calibrate); +void TP_RequestSamplingAsync(void); +u32 TP_WaitRawResult(TPData *result); +void TP_GetLatestRawPointInAuto(TPData *result); +void TP_GetCalibratedPoint(TPData *disp, const TPData *raw); + +static inline u32 TP_RequestRawSampling(TPData *result) +{ + TP_RequestSamplingAsync(); + return TP_WaitRawResult(result); +} + +#endif //NITRO_TP_H_ diff --git a/arm9/lib/NitroSDK/include/userInfo.h b/arm9/lib/NitroSDK/include/userInfo.h new file mode 100644 index 00000000..690dcf54 --- /dev/null +++ b/arm9/lib/NitroSDK/include/userInfo.h @@ -0,0 +1,92 @@ +#ifndef POKEDIAMOND_USERINFO_H +#define POKEDIAMOND_USERINFO_H + +typedef struct NVRAMConfigDate +{ + u8 month; //0x00 + u8 day; //0x01 +} NVRAMConfigDate; //0x02 + +typedef struct NVRAMConfigNickname +{ + u16 str[10]; //0x00 + u8 length; //0x14 + u8 rsv; //0x15 +} NVRAMConfigNickname; //0x16 + +typedef struct NVRAMConfigComment +{ + u16 str[26]; //0x00 + u8 length; //0x34 + u8 rsv; //0x35 +} NVRAMConfigComment; //0x36 + +typedef struct NVRAMConfigOwnerInfo +{ + u8 favouriteColour:4; //0x00 (0-3) + u8 rsv:4; //0x00 (4-7) + NVRAMConfigDate birthday; //0x01 + u8 pad; //0x03 + NVRAMConfigNickname nickname; //0x04 + NVRAMConfigComment comment; //0x1a +} NVRAMConfigOwnerInfo; //0x50 + +typedef struct NVRAMConfigAlarm +{ + u8 hour; //0x00 + u8 minute; //0x01 + u8 second; //0x02 + u8 pad; //0x03 + u16 enableWeek:7; //0x04 (0-6) + u16 alarmOn:1; //0x04 (7) + u16 rsv:8; //0x04 (8-15) +} NVRAMConfigAlarm; //0x06 + +typedef struct NVRAMConfigTpCalibData +{ + u16 raw_x1; //0x00 + u16 raw_y1; //0x02 + u8 dx1; //0x04 + u8 dy1; //0x05 + u16 raw_x2; //0x06 + u16 raw_y2; //0x08 + u8 dx2; //0x0a + u8 dy2; //0x0b +} NVRAMConfigTpCalibData; //0x0c + +typedef struct NVRAMConfigOption +{ + u16 language:3; //0x00 (0-2) + u16 agbLcd:1; //0x00 (3) + u16 detectPullOutCardFlag:1; //0x00 (4) + u16 detectPullOutCtrdgFlag:1; //0x00 (5) + u16 autoBootFlag:1; //0x00 (6) + u16 rsv:4; //0x00 (7-10) + u16 input_favouriteColour:1; //0x00 (11) + u16 input_tp:1; //0x00 (12) + u16 input_language:1; //0x00 (13) + u16 input_rtc:1; //0x00 (14) + u16 input_nickname:1; //0x00 (15) + u8 timeZone; //0x02 + u8 rtcClockAdjust; //0x03 + s64 rtcOffset; //0x04 +} NVRAMConfigOption; //0x0c + +typedef struct NVRAMConfigData +{ + u8 version; //0x00 + u8 pad; //0x01 + NVRAMConfigOwnerInfo owner; //0x02 + NVRAMConfigAlarm alarm; //0x52 + NVRAMConfigTpCalibData tp; //0x58 + NVRAMConfigOption option; //0x64 +} NVRAMConfigData; //0x70 + +typedef struct NVRAMConfig +{ + NVRAMConfigData ncd; //0x00 + u16 saveCount; //0x70 + u16 crc16; //0x72 +} NVRAMConfig; //0x74 + +#endif //POKEDIAMOND_USERINFO_H |