MGislv/ooot
1
0
Fork 0
mirror of https://github.com/blawar/ooot.git synced 2024-06-30 16:29:55 +00:00
Code Releases Wiki Activity

cleaned up hw registers

Browse Source
This commit is contained in:
Blake Warner 2022-03-01 09:28:38 -05:00
parent 376097e725
commit 34815c9c15
71 changed files with 59 additions and 1928 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
include/ultra64/rcp.h
View File

@ -1,104 +1,49 @@
#ifndef ULTRA64_RCP_H
#define ULTRA64_RCP_H
uintptr_t& hw_reg(u32 reg);
//#define HW_REG(reg, type) *(type*)((reg) | 0xA0000000)
#define HW_REG(reg, type) hw_reg(reg)
struct HardwareRegisters
{
uintptr_t SP_MEM_ADDR_REG = 0; // = 0x04040000;
uintptr_t SP_DRAM_ADDR_REG = 0; // = 0x04040004;
uintptr_t SP_RD_LEN_REG = 0; // = 0x04040008;
uintptr_t SP_WR_LEN_REG = 0; // = 0x0404000C;
uintptr_t SP_STATUS_REG = 0; // = 0x04040010;
uintptr_t SP_PC_REG = 0; // = 0x04080000;
const u32 AI_DRAM_ADDR_REG = 0x04500000;
const u32 AI_LEN_REG = 0x04500004;
const u32 AI_CONTROL_REG = 0x04500008;
const u32 AI_STATUS_REG = 0x0450000C;
const u32 AI_DACRATE_REG = 0x04500010;
const u32 AI_BITRATE_REG = 0x04500014;
uintptr_t MI_INIT_MODE_REG = 0; // = 0x04300000;
uintptr_t MI_VERSION_REG = 0; // = 0x04300004;
uintptr_t MI_INTR_REG = 0; // = 0x04300008;
uintptr_t MI_INTR_MASK_REG = 0; // = 0x0430000C;
uintptr_t VI_STATUS_REG = 0; // = 0x04400000;
uintptr_t VI_ORIGIN_REG = 0; // = 0x04400004;
uintptr_t VI_WIDTH_REG = 0; // = 0x04400008;
uintptr_t VI_INTR_REG = 0; // = 0x0440000C;
uintptr_t VI_CURRENT_REG = 0; // = 0x04400010;
uintptr_t VI_BURST_REG = 0; // = 0x04400014;
uintptr_t VI_V_SYNC_REG = 0; // = 0x04400018; // VI vertical sync
uintptr_t VI_H_SYNC_REG = 0; // = 0x0440001C; // VI horizontal sync
uintptr_t VI_LEAP_REG = 0; // = 0x04400020; // VI horizontal sync leap
uintptr_t VI_H_START_REG = 0; // = 0x04400024; // VI horizontal video
uintptr_t VI_V_START_REG = 0; // = 0x04400028; // VI vertical video
uintptr_t VI_V_BURST_REG = 0; // = 0x0440002C; // VI vertical burst
uintptr_t VI_X_SCALE_REG = 0; // = 0x04400030; // VI x-scale
uintptr_t VI_Y_SCALE_REG = 0; // = 0x04400034; // VI y-scale
uintptr_t AI_DRAM_ADDR_REG = 0; // = 0x04500000;
uintptr_t AI_LEN_REG = 0; // = 0x04500004;
uintptr_t AI_CONTROL_REG = 0; // = 0x04500008;
intptr_t AI_STATUS_REG = 0; // = 0x0450000C;
uintptr_t AI_DACRATE_REG = 0; // = 0x04500010;
uintptr_t AI_BITRATE_REG = 0; // = 0x04500014;
};
extern HardwareRegisters hw_regs;
#define AI_STATUS_AI_FULL (1 << 31)
#define AI_STATUS_AI_BUSY (1 << 30)
const u32 VI_STATUS_REG = 0x04400000;
#define VI_CONTROL_REG VI_STATUS_REG
const u32 VI_ORIGIN_REG = 0x04400004;
#define VI_DRAM_ADDR_REG VI_ORIGIN_REG
const u32 VI_WIDTH_REG = 0x04400008;
#define VI_H_WIDTH_REG VI_WIDTH_REG
const u32 VI_INTR_REG = 0x0440000C;
#define VI_V_INTER_REG VI_H_WIDTH_REG
const u32 VI_CURRENT_REG = 0x04400010;
#define VI_V_CURRENT_LINE_REG VI_CURRENT_REG
const u32 VI_BURST_REG = 0x04400014;
#define VI_TIMING_REG VI_BURST_REG
const u32 VI_V_SYNC_REG = 0x04400018; //VI vertical sync
const u32 VI_H_SYNC_REG = 0x0440001C; //VI horizontal sync
const u32 VI_LEAP_REG = 0x04400020; //VI horizontal sync leap
#define VI_H_SYNC_LEAP_REG VI_LEAP_REG
const u32 VI_H_START_REG = 0x04400024; //VI horizontal video
#define VI_H_VIDEO_REG VI_H_START_REG
const u32 VI_V_START_REG = 0x04400028; //VI vertical video
#define VI_V_VIDEO_REG VI_V_START_REG
const u32 VI_V_BURST_REG = 0x0440002C; //VI vertical burst
const u32 VI_X_SCALE_REG = 0x04400030; //VI x-scale
const u32 VI_Y_SCALE_REG = 0x04400034; //VI y-scale
#define SP_IMEM_START 0x04001000
#define SP_DMEM_START 0x04000000
const u32 SP_MEM_ADDR_REG = 0x04040000;
const u32 SP_DRAM_ADDR_REG = 0x04040004;
const u32 SP_RD_LEN_REG = 0x04040008;
const u32 SP_WR_LEN_REG = 0x0404000C;
const u32 SP_STATUS_REG = 0x04040010;
const u32 SP_PC_REG = 0x04080000;
const u32 PI_DRAM_ADDR_REG = 0x04600000; //PI DRAM address
const u32 PI_CART_ADDR_REG = 0x04600004; //PI pbus (cartridge) address
const u32 PI_RD_LEN_REG = 0x04600008; //PI read length
const u32 PI_WR_LEN_REG = 0x0460000C; //PI write length
const u32 PI_STATUS_REG = 0x04600010; //PI status
const u32 PI_BSD_DOM1_LAT_REG = 0x04600014; //PI dom1 latency
const u32 PI_DOMAIN1_REG = 0x04600014;
const u32 PI_BSD_DOM1_PWD_REG = 0x04600018; //PI dom1 pulse width
const u32 PI_BSD_DOM1_PGS_REG = 0x0460001C; //PI dom1 page size
const u32 PI_BSD_DOM1_RLS_REG = 0x04600020; //PI dom1 release
const u32 PI_BSD_DOM2_LAT_REG = 0x04600024; //PI dom2 latency
const u32 PI_DOMAIN2_REG = 0x04600024;
const u32 PI_BSD_DOM2_PWD_REG = 0x04600028; //PI dom2 pulse width
const u32 PI_BSD_DOM2_PGS_REG = 0x0460002C; //PI dom2 page size
const u32 PI_BSD_DOM2_RLS_REG = 0x04600030; //PI dom2 release
#define PI_STATUS_BUSY 0x1
#define PI_STATUS_IOBUSY 0x2
@ -107,14 +52,6 @@ const u32 PI_BSD_DOM2_RLS_REG = 0x04600030; //PI dom2 release
#define PI_STATUS_RESET_CONTROLLER 0x1
#define PI_STATUS_CLEAR_INTR 0x2
const u32 SI_DRAM_ADDR_REG = 0x04800000;
const u32 SI_PIF_ADDR_RD64B_REG = 0x04800004;
const u32 SI_PIF_ADDR_WR64B_REG = 0x04800010;
const u32 SI_STATUS_REG = 0x04800018;
#define SI_STATUS_DMA_BUSY 0x1
#define SI_STATUS_IO_READ_BUSY 0x2
@ -123,16 +60,6 @@ const u32 SI_STATUS_REG = 0x04800018;
#define PIF_RAM_START 0x1FC007C0
const u32 MI_INIT_MODE_REG = 0x04300000;
#define MI_MODE_REG MI_INIT_MODE_REG
const u32 MI_VERSION_REG = 0x04300004;
const u32 MI_INTR_REG = 0x04300008;
const u32 MI_INTR_MASK_REG = 0x0430000C;
#define VI_NTSC_CLOCK 48681812 /* Hz = 48.681812 MHz */
#define VI_PAL_CLOCK 49656530 /* Hz = 49.656530 MHz */
#define VI_MPAL_CLOCK 48628316 /* Hz = 48.628316 MHz */

26
src/code/audioMgr.cpp
View File

@ -49,7 +49,7 @@ void audio_int()
*AudioInfo.MI_INTR_REG |= MI_INTR_AI;
*/
/*
uint32_t mi_intr_reg = HW_REG(MI_INTR_REG, u32), status_register;
uint32_t mi_intr_reg = hw_regs.MI_INTR_REG, status_register;
mi_intr_reg &= ~MI_INTR_AI;
mi_intr_reg |= (m_AudioIntrReg & MI_INTR_AI);
@ -64,8 +64,8 @@ void audio_int()
{
FAKE_CAUSE_REGISTER &= ~CAUSE_IP2;
}
HW_REG(MI_INTR_REG, u32) = mi_intr_reg;
status_register = HW_REG(AI_STATUS_REG, u32);
hw_regs.MI_INTR_REG = mi_intr_reg;
status_register = hw_regs.AI_STATUS_REG;
if((status_register & STATUS_IE) == 0)
{
@ -135,18 +135,18 @@ void azi_init()
AUDIO_INFO Audio_Info;
memset(&Audio_Info, 0, sizeof(Audio_Info));
HW_REG(AI_CONTROL_REG, u32) = 1;
HW_REG(AI_DACRATE_REG, u32) = 0x3FFF;
HW_REG(AI_BITRATE_REG, u32) = 0xF;
hw_regs.AI_CONTROL_REG = 1;
hw_regs.AI_DACRATE_REG = 0x3FFF;
hw_regs.AI_BITRATE_REG = 0xF;
Audio_Info.hwnd = GetActiveWindow();
Audio_Info.AI_DRAM_ADDR_REG = &HW_REG(AI_DRAM_ADDR_REG, u32);
Audio_Info.AI_LEN_REG = &HW_REG(AI_LEN_REG, u32);
Audio_Info.AI_CONTROL_REG = &HW_REG(AI_CONTROL_REG, u32);
Audio_Info.AI_STATUS_REG = &HW_REG(AI_STATUS_REG, u32);
Audio_Info.AI_DACRATE_REG = &HW_REG(AI_DACRATE_REG, u32);
Audio_Info.AI_BITRATE_REG = &HW_REG(AI_BITRATE_REG, u32);
Audio_Info.MI_INTR_REG = &HW_REG(MI_INTR_REG, u32);
Audio_Info.AI_DRAM_ADDR_REG = &hw_regs.AI_DRAM_ADDR_REG;
Audio_Info.AI_LEN_REG = &hw_regs.AI_LEN_REG;
Audio_Info.AI_CONTROL_REG = &hw_regs.AI_CONTROL_REG;
Audio_Info.AI_STATUS_REG = (u32*)&hw_regs.AI_STATUS_REG;
Audio_Info.AI_DACRATE_REG = &hw_regs.AI_DACRATE_REG;
Audio_Info.AI_BITRATE_REG = &hw_regs.AI_BITRATE_REG;
Audio_Info.MI_INTR_REG = &hw_regs.MI_INTR_REG;
Audio_Info.CheckInterrupts = audio_int;
InitiateAudio(Audio_Info);

5
src/code/graph.cpp
View File

@ -275,11 +275,6 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
Fault_RemoveClient(&sGraphUcodeFaultClient);
}
if (HREG(81) < 0) {
LogUtils_LogHexDump((void*)&HW_REG(SP_MEM_ADDR_REG, u32), 0x20);
LogUtils_LogHexDump((void*)&DPC_START_REG, 0x20);
}
if (HREG(81) < 0) {
HREG(81) = 0;
}

9
src/libultra/io/aigetlen.cpp
View File

@ -1,9 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_AIGETLEN_C
#include "global.h"
#include "regs.h"
#include "ultra64/rcp.h"
#include "def/aigetlen.h"
u32 osAiGetLength(void) {
return HW_REG(AI_LEN_REG, u32);
}

23
src/libultra/io/aisetfreq.cpp
View File

@ -1,23 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_AISETFREQ_C
#include "global.h"
#include "def/aisetfreq.h"
#include "def/initialize.h"
s32 osAiSetFrequency(u32 frequency) {
u8 bitrate;
f32 dacRateF = ((f32)osViClock / frequency) + 0.5f;
u32 dacRate = dacRateF;
if (dacRate < 132) {
return -1;
}
bitrate = (dacRate / 66);
if (bitrate > 16) {
bitrate = 16;
}
HW_REG(AI_DACRATE_REG, u32) = dacRate - 1;
HW_REG(AI_BITRATE_REG, u32) = bitrate - 1;
return osViClock / (s32)dacRate;
}

7
src/libultra/io/aisetnextbuf.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_AISETNEXTBUF_C
#include "global.h"
#include "def/aisetnextbuf.h"
s32 osAiSetNextBuffer(void* buf, u32 size) {
return 0;
}

69
src/libultra/io/cartrominit.cpp
View File

@ -1,69 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CARTROMINIT_C
#include "global.h"
#include "regs.h"
#include "ultra64/rcp.h"
#include "ultra64/pi.h"
#include "def/cartrominit.h"
#include "def/piacs.h"
#include "def/pimgr.h"
OSPiHandle __CartRomHandle;
OSPiHandle* osCartRomInit(void) {
register u32 a;
register s32 status;
register u32 prevInt;
register u32 lastLatency;
register u32 lastPageSize;
register u32 lastRelDuration;
register u32 lastPulse;
static u32 D_8000AF10 = 1;
__osPiGetAccess();
if (!D_8000AF10) {
__osPiRelAccess();
return &__CartRomHandle;
}
D_8000AF10 = 0;
__CartRomHandle.type = DEVICE_TYPE_CART;
__CartRomHandle.baseAddress = 0xB0000000;
__CartRomHandle.domain = PI_DOMAIN1;
__CartRomHandle.speed = 0;
bzero(&__CartRomHandle.transferInfo, sizeof(__OSTranxInfo));
while (status = HW_REG(PI_STATUS_REG, u32), status & (PI_STATUS_BUSY | PI_STATUS_IOBUSY)) {
;
}
lastLatency = HW_REG(PI_BSD_DOM1_LAT_REG, u32);
lastPageSize = HW_REG(PI_BSD_DOM1_PGS_REG, u32);
lastRelDuration = HW_REG(PI_BSD_DOM1_RLS_REG, u32);
lastPulse = HW_REG(PI_BSD_DOM1_PWD_REG, u32);
HW_REG(PI_BSD_DOM1_LAT_REG, u32) = 0xFF;
HW_REG(PI_BSD_DOM1_PGS_REG, u32) = 0;
HW_REG(PI_BSD_DOM1_RLS_REG, u32) = 3;
HW_REG(PI_BSD_DOM1_PWD_REG, u32) = 0xFF;
a = HW_REG(__CartRomHandle.baseAddress, u32);
__CartRomHandle.latency = a & 0xFF;
__CartRomHandle.pageSize = (a >> 0x10) & 0xF;
__CartRomHandle.relDuration = (a >> 0x14) & 0xF;
__CartRomHandle.pulse = (a >> 8) & 0xFF;
HW_REG(PI_BSD_DOM1_LAT_REG, u32) = lastLatency;
HW_REG(PI_BSD_DOM1_PGS_REG, u32) = lastPageSize;
HW_REG(PI_BSD_DOM1_RLS_REG, u32) = lastRelDuration;
HW_REG(PI_BSD_DOM1_PWD_REG, u32) = lastPulse;
prevInt = __osDisableInt();
//__CartRomHandle.next = __osPiTable;
//__osPiTable = &__CartRomHandle;
__osRestoreInt(prevInt);
__osPiRelAccess();
return &__CartRomHandle;
}

36
src/libultra/io/contpfs.cpp
View File

@ -1,36 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTPFS_C
#include "ultra64.h"
#include "global.h"
#include "def/contpfs.h"
#include "def/pfsreadwritefile.h"
s32 __osPfsInodeCacheChannel = -1;
u8 __osPfsInodeCacheBank = 250;
u16 __osSumcalc(u8* ptr, s32 length) {
return 0xFFFF;
}
s32 __osIdCheckSum(u16* ptr, u16* checkSum, u16* idSum) {
return 0;
}
s32 __osRepairPackId(OSPfs* pfs, __OSPackId* badid, __OSPackId* newid) {
return 0;
}
s32 __osCheckPackId(OSPfs* pfs, __OSPackId* check) {
return 0;
}
s32 __osGetId(OSPfs* pfs) {
return 0;
}
s32 __osCheckId(OSPfs* pfs) {
return 0;
}
s32 __osPfsRWInode(OSPfs* pfs, __OSInode* inode, u8 flag, u8 bank) {
return 0;
}

19
src/libultra/io/contquery.cpp
View File

@ -1,19 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTQUERY_C
#include "global.h"
#include "def/contquery.h"
/**
* osContStartQuery:
* Starts to read the values for SI device status and type which are connected to the controller port and joyport
* connector.
*/
s32 osContStartQuery(struct OSMesgQueue* mq) {
return 0;
}
/**
* osContGetQuery:
* Returns the values from osContStartQuery to status. Both functions must be paired for use.
*/
void osContGetQuery(struct OSContStatus* data) {
}

11
src/libultra/io/contramread.cpp
View File

@ -1,11 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTRAMREAD_C
#include "global.h"
#include "def/contramread.h"
#define BLOCKSIZE 32
s32 __osPfsLastChannel = -1;
s32 __osContRamRead(struct OSMesgQueue* ctrlrqueue, s32 channel, u16 addr, u8* data) {
return 0;
}

8
src/libultra/io/contramwrite.cpp
View File

@ -1,8 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTRAMWRITE_C
#include "ultra64.h"
#include "global.h"
#include "def/contramwrite.h"
s32 __osContRamWrite(OSMesgQueue* mq, s32 channel, u16 address, u8* buffer, s32 force) {
return 0;
}

12
src/libultra/io/contreaddata.cpp
View File

@ -1,12 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTREADDATA_C
#include "global.h"
s32 osContStartReadData(struct OSMesgQueue* mq) {
return 0;
}
void osContGetReadData(struct OSContPad* contData) {
}
void __osPackReadData(void) {
}

27
src/libultra/io/controller.cpp
View File

@ -1,27 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTROLLER_C
#include "global.h"
#include "ultra64/controller.h"
#include "ultra64/time.h"
#include "def/controller.h"
OSPifRam __osPifInternalBuff;
u8 __osContLastPoll;
u8 __osMaxControllers; // always 4
OSTimer __osEepromTimer;
OSMesgQueue __osEepromTimerMsgQ;
OSMesg __osEepromTimerMsg;
u32 gOSContInitialized = 0;
#define HALF_SECOND OS_USEC_TO_CYCLES(500000)
s32 osContInit(OSMesgQueue* mq, u8* ctlBitfield, OSContStatus* status) {
return 0;
}
void __osContGetInitData(u8* ctlBitfield, OSContStatus* status) {
}
void __osPackRequestData(u8 poll) {
}

13
src/libultra/io/contsetch.cpp
View File

@ -1,13 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CONTSETCH_C
#include "ultra64.h"
#include "global.h"
#include "def/contsetch.h"
/*
* s32 osContSetCh(u8 ch)
* This function specifies the number of devices for the functions to access when those functions access to multiple
* direct SI devices.
*/
s32 osContSetCh(u8 ch) {
return 0;
}

64
src/libultra/io/crc.cpp
View File

@ -1,64 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_CRC_C
#include "global.h"
#include "def/crc.h"
// Valid addr up to 0x7FF
// It's the address of a block of 0x20 bytes in the mempak
// So that means the whole mempak has a 16-bit address space
u8 __osContAddressCrc(u16 addr) {
u32 addr32 = addr;
u32 ret = 0;
u32 bit;
s32 i;
for (bit = 0x400; bit; bit >>= 1) {
ret <<= 1;
if (addr32 & bit) {
if (ret & 0x20) {
ret ^= 0x14;
} else {
++ret;
}
} else if (ret & 0x20) {
ret ^= 0x15;
}
}
for (i = 0; i < 5; ++i) {
ret <<= 1;
if (ret & 0x20) {
ret ^= 0x15;
}
}
return ret & 0x1F;
}
u8 __osContDataCrc(u8* data) {
s32 ret = 0;
u32 bit;
u32 byte;
for (byte = 0x20; byte; --byte, ++data) {
for (bit = 0x80; bit; bit >>= 1) {
ret <<= 1;
if ((*data & bit) != 0) {
if ((ret & 0x100) != 0) {
ret ^= 0x84;
} else {
++ret;
}
} else if (ret & 0x100) {
ret ^= 0x85;
}
}
}
do {
ret <<= 1;
if (ret & 0x100) {
ret ^= 0x85;
}
++byte;
} while (byte < 8U);
return ret;
}

107
src/libultra/io/devmgr.cpp
View File

@ -1,107 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_DEVMGR_C
#include "global.h"
#include "ultra64/internal.h"
#include "ultra64/rcp.h"
#include "def/devmgr.h"
#include "def/epirawread.h"
#include "def/epirawwrite.h"
#include "def/recvmesg.h"
#include "def/resetglobalintmask.h"
#include "def/setglobalintmask.h"
#include "def/yieldthread.h"
void __osDevMgrMain(void* arg) {
OSIoMesg* ioMesg;
OSMesg sp70;
OSMesg sp6C;
OSMgrArgs* arg0 = (OSMgrArgs*)arg;
__OSTranxInfo* transfer;
__OSBlockInfo* block;
s32 phi_s2;
s32 phi_s0;
u32 sp54;
ioMesg = NULL;
while (true) {
osRecvMesg(arg0->cmdQueue, (OSMesg)&ioMesg, OS_MESG_BLOCK);
if ((ioMesg->piHandle != NULL) && (ioMesg->piHandle->type == DEVICE_TYPE_64DD) &&
((ioMesg->piHandle->transferInfo.cmdType == 0) || (ioMesg->piHandle->transferInfo.cmdType == 1))) {
transfer = &ioMesg->piHandle->transferInfo;
block = &transfer->block[transfer->blockNum];
transfer->sectorNum = -1;
if (transfer->transferMode != 3) {
block->dramAddr = (void*)((uintptr_t)block->dramAddr - block->sectorSize);
}
phi_s2 = ((transfer->transferMode == 2) && (ioMesg->piHandle->transferInfo.cmdType == 0)) ? 1 : 0;
osRecvMesg(arg0->acccessQueue, &sp6C, OS_MESG_BLOCK);
__osResetGlobalIntMask(0x00100401);
__osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow | 0x80000000);
while (true) {
osRecvMesg(arg0->eventQueue, &sp70, OS_MESG_BLOCK);
transfer = &ioMesg->piHandle->transferInfo;
block = &transfer->block[transfer->blockNum];
if (block->errStatus == 0x1D) {
__osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow | 0x10000000);
__osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow);
__osEPiRawReadIo(ioMesg->piHandle, 0x05000508, &sp54);
if (sp54 & 0x02000000) {
__osEPiRawWriteIo(ioMesg->piHandle, 0x05000510, transfer->bmCtlShadow | 0x1000000);
}
block->errStatus = 4;
HW_REG(PI_STATUS_REG, u32) = PI_STATUS_CLEAR_INTR;
__osSetGlobalIntMask(0x00100C01);
}
osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK);
if ((phi_s2 != 1) || (ioMesg->piHandle->transferInfo.block[0].errStatus != 0)) {
break;
}
phi_s2 = 0;
}
osSendMesg(arg0->acccessQueue, 0, OS_MESG_NOBLOCK);
if (ioMesg->piHandle->transferInfo.blockNum == 1) {
osYieldThread();
}
} else {
switch (ioMesg->hdr.type) {
case OS_MESG_TYPE_DMAREAD:
osRecvMesg(arg0->acccessQueue, &sp6C, OS_MESG_BLOCK);
phi_s0 = arg0->piDmaCallback(OS_READ, ioMesg->devAddr, ioMesg->dramAddr, ioMesg->size);
break;
case OS_MESG_TYPE_DMAWRITE:
osRecvMesg(arg0->acccessQueue, &sp6C, OS_MESG_BLOCK);
phi_s0 = arg0->piDmaCallback(OS_WRITE, ioMesg->devAddr, ioMesg->dramAddr, ioMesg->size);
break;
case OS_MESG_TYPE_EDMAREAD:
osRecvMesg(arg0->acccessQueue, &sp6C, OS_MESG_BLOCK);
phi_s0 = arg0->epiDmaCallback(ioMesg->piHandle, OS_READ, ioMesg->devAddr, ioMesg->dramAddr,
ioMesg->size);
break;
case OS_MESG_TYPE_EDMAWRITE:
osRecvMesg(arg0->acccessQueue, &sp6C, OS_MESG_BLOCK);
phi_s0 = arg0->epiDmaCallback(ioMesg->piHandle, OS_WRITE, ioMesg->devAddr, ioMesg->dramAddr,
ioMesg->size);
break;
case OS_MESG_TYPE_LOOPBACK:
osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK);
phi_s0 = -1;
break;
default:
phi_s0 = -1;
break;
}
if (phi_s0 == 0) {
osRecvMesg(arg0->eventQueue, &sp70, OS_MESG_BLOCK);
osSendMesg(ioMesg->hdr.retQueue, ioMesg, OS_MESG_NOBLOCK);
osSendMesg(arg0->acccessQueue, NULL, OS_MESG_NOBLOCK);
}
}
}
}

7
src/libultra/io/dpgetstat.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_DPGETSTAT_C
#include "global.h"
#include "def/dpgetstat.h"
u32 osDpGetStatus(void) {
return 0;
}

6
src/libultra/io/dpsetstat.cpp
View File

@ -1,6 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_DPSETSTAT_C
#include "global.h"
#include "def/dpsetstat.h"
void osDpSetStatus(u32 status) {
}

9
src/libultra/io/driverominit.cpp
View File

@ -1,9 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_DRIVEROMINIT_C
#include "global.h"
#include "def/driverominit.h"
struct OSPiHandle* osDriveRomInit(void) {
return NULL;
}

8
src/libultra/io/epidma.cpp
View File

@ -1,8 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_EPIDMA_C
#include "global.h"
#include "ultra64/internal.h"
#include "def/epidma.h"
s32 osEPiStartDma(OSPiHandle* handle, OSIoMesg* mb, s32 direction) {
return 0;
}

7
src/libultra/io/epirawdma.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_EPIRAWDMA_C
#include "global.h"
#include "def/epirawdma.h"
s32 __osEPiRawStartDma(struct OSPiHandle* handle, s32 direction, u32 cartAddr, void* dramAddr, size_t size) {
return 0;
}

7
src/libultra/io/epirawread.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_EPIRAWREAD_C
#include "global.h"
#include "def/epirawread.h"
s32 __osEPiRawReadIo(struct OSPiHandle* handle, u32 devAddr, u32* data) {
return 0;
}

7
src/libultra/io/epiwrite.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_EPIWRITE_C
#include "global.h"
#include "def/epiwrite.h"
s32 osEPiWriteIo(struct OSPiHandle* handle, u32 devAddr, u32 data) {
return 0;
}

17
src/libultra/io/motor.cpp
View File

@ -1,17 +0,0 @@
#include "global.h"
#define BANK_ADDR 0x400
#define MOTOR_ID 0x80
//OSPifRam osPifBuffers[MAXCONTROLLERS];
s32 __osMotorAccess(struct OSPfs* pfs, u32 vibrate) {
return 0;
}
void _MakeMotorData(s32 channel, struct OSPifRam* buf) {
}
s32 osMotorInit(struct OSMesgQueue* ctrlrqueue, struct OSPfs* pfs, s32 channel) {
return 0; // "Recognized rumble pak"
}

145
src/libultra/io/pfsallocatefile.cpp
View File

@ -1,145 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSALLOCATEFILE_C
#include "ultra64.h"
#include "global.h"
#include "ultra64/pfs.h"
#include "def/contpfs.h"
#include "def/contramwrite.h"
#include "def/pfsallocatefile.h"
#include "def/pfsfindfile.h"
#include "def/pfsfreeblocks.h"
s32 osPfsAllocateFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName, s32 fileSize, s32* fileNo) {
s32 startPage;
s32 decleared;
s32 prevPage;
s32 oldPrevPage = 0;
s32 ret = 0;
s32 fileSizeInPages;
__OSInode inode;
__OSInode backupInode;
__OSDir dir;
u8 bank;
u8 prevBank = 0;
s32 firsttime = 0;
s32 bytes;
__OSInodeUnit fpage;
if ((companyCode == 0) || (gameCode == 0)) {
return PFS_ERR_INVALID;
}
fileSizeInPages = (fileSize + PFS_PAGE_SIZE - 1) / PFS_PAGE_SIZE;
if (((ret = osPfsFindFile(pfs, companyCode, gameCode, gameName, extName, fileNo)) != 0) &&
(ret != PFS_ERR_INVALID)) {
return ret;
}
if (*fileNo != -1) {
return PFS_ERR_EXIST;
}
ret = osPfsFreeBlocks(pfs, &bytes);
if (fileSize > bytes) {
return PFS_DATA_FULL;
}
if (fileSizeInPages == 0) {
return (PFS_ERR_INVALID);
}
if (((ret = osPfsFindFile(pfs, 0, 0, 0, 0, fileNo)) != 0) && (ret != PFS_ERR_INVALID)) {
return ret;
}
if (*fileNo == -1) {
return PFS_DIR_FULL;
}
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
return ret;
}
ret = __osPfsDeclearPage(pfs, &inode, fileSizeInPages, &startPage, bank, &decleared, &prevPage);
if (ret) {
return ret;
}
if (startPage != -1) { /* There is free space */
if (firsttime == 0) {
fpage.inode_t.page = (u8)startPage;
fpage.inode_t.bank = bank;
} else { /* Writing previous bank inode */
backupInode.inodePage[oldPrevPage].inode_t.bank = bank;
backupInode.inodePage[oldPrevPage].inode_t.page = (u8)startPage;
if ((ret = __osPfsRWInode(pfs, &backupInode, PFS_WRITE, prevBank)) != 0) {
return ret;
}
}
if (fileSizeInPages > decleared) {
bcopy(&inode, &backupInode, sizeof(__OSInode));
oldPrevPage = prevPage;
prevBank = bank;
fileSizeInPages -= decleared;
firsttime++;
} else {
fileSizeInPages = 0;
if ((ret = __osPfsRWInode(pfs, &inode, PFS_WRITE, bank)) != 0) {
return ret;
}
break;
}
}
}
if ((fileSizeInPages > 0) || (startPage == -1)) {
return PFS_ERR_INCONSISTENT;
}
dir.start_page = fpage;
dir.company_code = companyCode;
dir.game_code = gameCode;
dir.data_sum = 0;
bcopy(gameName, dir.game_name, PFS_FILE_NAME_LEN);
bcopy(extName, dir.ext_name, PFS_FILE_EXT_LEN);
return __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + *fileNo, (u8*)&dir, 0);
}
s32 __osPfsDeclearPage(OSPfs* pfs, __OSInode* inode, s32 fileSizeInPages, s32* startPage, u8 bank, s32* decleared,
s32* finalPage) {
s32 j;
s32 spage, prevPage;
s32 ret = 0;
s32 offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
for (j = offset; j < PFS_INODE_SIZE_PER_PAGE; j++) {
if (inode->inodePage[j].ipage == PFS_PAGE_NOT_USED) {
break;
}
}
if (j == PFS_INODE_SIZE_PER_PAGE) {
*startPage = -1;
return ret;
}
spage = j;
*decleared = 1;
prevPage = j;
j++;
while ((fileSizeInPages > *decleared) && (j < PFS_INODE_SIZE_PER_PAGE)) {
if (inode->inodePage[j].ipage == PFS_PAGE_NOT_USED) {
inode->inodePage[prevPage].inode_t.bank = (u8)bank;
inode->inodePage[prevPage].inode_t.page = (u8)j;
prevPage = j;
(*decleared)++;
}
j++;
}
*startPage = spage;
if ((j == (PFS_INODE_SIZE_PER_PAGE)) && (fileSizeInPages > *decleared)) {
*finalPage = prevPage;
} else {
inode->inodePage[prevPage].ipage = PFS_EOF;
*finalPage = 0;
}
return ret;
}

199
src/libultra/io/pfschecker.cpp
View File

@ -1,199 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSCHECKER_C
#include "ultra64.h"
#include "global.h"
#include "ultra64/pfs.h"
#include "def/contpfs.h"
#include "def/contramread.h"
#include "def/contramwrite.h"
#include "def/pfschecker.h"
#include "def/pfsselectbank.h"
#define CHECK_IPAGE(p) \
(((p).ipage >= pfs->inodeStartPage) && ((p).inode_t.bank < pfs->banks) && ((p).inode_t.page >= 0x01) && \
((p).inode_t.page < 0x80))
s32 osPfsChecker(OSPfs* pfs) {
s32 j;
s32 ret;
__OSInodeUnit next;
__OSInode checkedInode;
__OSInode tempInode;
__OSDir tempDir;
__OSInodeUnit nextNodeInFile[16];
__OSInodeCache cache;
s32 fixed = 0;
u8 bank, prevBank = 254;
s32 cc, cl;
s32 offset;
ret = __osCheckId(pfs);
if (ret == PFS_ERR_NEW_PACK) {
ret = __osGetId(pfs);
}
if (ret) {
return ret;
}
if ((ret = func_80105788(pfs, &cache)) != 0) {
return ret;
}
for (j = 0; j < pfs->dir_size; j++) {
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + j, (u8*)&tempDir)) != 0) {
return ret;
}
if ((tempDir.company_code != 0) || (tempDir.game_code != 0)) {
if ((tempDir.company_code == 0) || (tempDir.game_code == 0)) {
cc = -1;
} else {
next = tempDir.start_page;
cl = cc = 0;
bank = 255;
while (CHECK_IPAGE(next)) {
if (bank != next.inode_t.bank) {
bank = next.inode_t.bank;
if (prevBank != bank) {
ret = __osPfsRWInode(pfs, &tempInode, PFS_READ, bank);
prevBank = bank;
}
if ((ret != 0) && (ret != PFS_ERR_INCONSISTENT)) {
return ret;
}
}
if ((cc = func_80105A60(pfs, next, &cache) - cl) != 0) {
break;
}
cl = 1;
next = tempInode.inodePage[next.inode_t.page];
}
}
if ((cc != 0) || (next.ipage != PFS_EOF)) {
bzero(&tempDir, sizeof(__OSDir));
if (pfs->activebank != 0) {
if ((ret = __osPfsSelectBank(pfs, 0)) != 0) {
return ret;
}
}
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + j, (u8*)&tempDir, 0)) != 0) {
return ret;
}
fixed++;
}
}
}
for (j = 0; j < pfs->dir_size; j++) {
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + j, (u8*)&tempDir)) != 0) {
return ret;
}
if ((tempDir.company_code != 0) && (tempDir.game_code != 0) &&
(tempDir.start_page.ipage >= (u16)pfs->inodeStartPage)) { // cast required
nextNodeInFile[j].ipage = tempDir.start_page.ipage;
} else {
nextNodeInFile[j].ipage = 0;
}
}
for (bank = 0; bank < pfs->banks; bank++) {
ret = __osPfsRWInode(pfs, &tempInode, PFS_READ, bank);
if ((ret != 0) && (ret != PFS_ERR_INCONSISTENT)) {
return (ret);
}
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
for (j = 0; j < offset; j++) {
checkedInode.inodePage[j].ipage = tempInode.inodePage[j].ipage;
}
for (; j < PFS_INODE_SIZE_PER_PAGE; j++) {
checkedInode.inodePage[j].ipage = PFS_PAGE_NOT_USED;
}
for (j = 0; j < pfs->dir_size; j++) {
while (nextNodeInFile[j].inode_t.bank == bank &&
nextNodeInFile[j].ipage >= (u16)pfs->inodeStartPage) { // cast required
u8 val;
val = nextNodeInFile[j].inode_t.page;
nextNodeInFile[j] = checkedInode.inodePage[val] = tempInode.inodePage[val];
}
}
if ((ret = __osPfsRWInode(pfs, &checkedInode, PFS_WRITE, bank)) != 0) {
return ret;
}
}
if (fixed != 0) {
pfs->status |= PFS_CORRUPTED;
} else {
pfs->status &= ~PFS_CORRUPTED;
}
return 0;
}
// Original name: corrupted_init (probably needs better name)
s32 func_80105788(OSPfs* pfs, __OSInodeCache* cache) {
s32 i;
s32 n;
s32 offset;
u8 bank;
__OSInodeUnit tpage;
__OSInode tempInode;
s32 ret;
for (i = 0; i < PFS_INODE_DIST_MAP; i++) {
cache->map[i] = 0;
}
cache->bank = 255;
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
ret = __osPfsRWInode(pfs, &tempInode, PFS_READ, bank);
if ((ret != 0) && (ret != PFS_ERR_INCONSISTENT)) {
return ret;
}
for (i = offset; i < PFS_INODE_SIZE_PER_PAGE; i++) {
tpage = tempInode.inodePage[i];
if ((tpage.ipage >= pfs->inodeStartPage) && (tpage.inode_t.bank != bank)) {
n = ((tpage.inode_t.page & 0x7F) / PFS_SECTOR_SIZE) +
PFS_SECTOR_PER_BANK * (tpage.inode_t.bank % PFS_BANK_LAPPED_BY);
cache->map[n] |= (1 << (bank % PFS_BANK_LAPPED_BY));
}
}
}
return 0;
}
// original name: corrupted (probably needs a better name)
s32 func_80105A60(OSPfs* pfs, __OSInodeUnit fpage, __OSInodeCache* cache) {
s32 j;
s32 n;
s32 hit = 0;
u8 bank;
s32 offset;
s32 ret = 0;
n = (fpage.inode_t.page / PFS_SECTOR_SIZE) + PFS_SECTOR_PER_BANK * (fpage.inode_t.bank % PFS_BANK_LAPPED_BY);
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
if ((bank == fpage.inode_t.bank) || (cache->map[n] & (1 << (bank % PFS_BANK_LAPPED_BY))) != 0) {
if (bank != cache->bank) {
ret = __osPfsRWInode(pfs, &(cache->inode), PFS_READ, bank);
if (ret && (ret != PFS_ERR_INCONSISTENT)) {
return ret;
}
cache->bank = bank;
}
for (j = offset; ((hit < 2) && (j < PFS_INODE_SIZE_PER_PAGE)); j++) {
if (cache->inode.inodePage[j].ipage == fpage.ipage) {
hit++;
}
}
if (hit >= 2) {
return 2;
}
}
}
return hit;
}

78
src/libultra/io/pfsdeletefile.cpp
View File

@ -1,78 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSDELETEFILE_C
#include "ultra64/pfs.h"
#include "global.h"
#include "def/contpfs.h"
#include "def/contramread.h"
#include "def/contramwrite.h"
#include "def/pfsdeletefile.h"
#include "def/pfsfindfile.h"
#include "def/pfsselectbank.h"
s32 osPfsDeleteFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName) {
s32 file_no;
s32 ret;
__OSInode inode;
__OSDir dir;
__OSInodeUnit last_page;
u8 startpage;
u8 bank;
if ((companyCode == 0) || (gameCode == 0)) {
return PFS_ERR_INVALID;
}
if ((ret = osPfsFindFile(pfs, companyCode, gameCode, gameName, extName, &file_no)) != 0) {
return ret;
}
if ((pfs->activebank != 0) && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
return ret;
}
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + file_no, (u8*)&dir)) != 0) {
return ret;
}
startpage = dir.start_page.inode_t.page;
for (bank = dir.start_page.inode_t.bank; bank < pfs->banks;) {
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
return ret;
}
if ((ret = __osPfsReleasePages(pfs, &inode, startpage, bank, &last_page)) != 0) {
return ret;
}
if ((ret = __osPfsRWInode(pfs, &inode, PFS_WRITE, bank)) != 0) {
return ret;
}
if (last_page.ipage == PFS_EOF) {
break;
}
bank = last_page.inode_t.bank;
startpage = last_page.inode_t.page;
}
if (bank >= pfs->banks) {
return PFS_ERR_INCONSISTENT;
}
bzero(&dir, sizeof(__OSDir));
ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + file_no, (u8*)&dir, 0);
return ret;
}
s32 __osPfsReleasePages(OSPfs* pfs, __OSInode* inode, u8 initialPage, u8 bank, __OSInodeUnit* finalPage) {
__OSInodeUnit next;
__OSInodeUnit prev;
s32 ret = 0;
next.ipage = (u16)((bank << 8) + initialPage);
do {
prev = next;
next = inode->inodePage[next.inode_t.page];
inode->inodePage[prev.inode_t.page].ipage = PFS_PAGE_NOT_USED;
} while (next.ipage >= pfs->inodeStartPage && next.inode_t.bank == bank);
*finalPage = next;
return ret;
}

64
src/libultra/io/pfsfilestate.cpp
View File

@ -1,64 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSFILESTATE_C
#include "ultra64.h"
#include "global.h"
#include "def/contpfs.h"
#include "def/contramread.h"
#include "def/pfsfilestate.h"
#include "def/pfsgetstatus.h"
#include "def/pfsselectbank.h"
s32 osPfsFileState(OSPfs* pfs, s32 fileNo, OSPfsState* state) {
s32 ret;
s32 pages;
__OSInode inode;
__OSDir dir;
__OSInodeUnit page;
u8 bank;
if (fileNo >= pfs->dir_size || fileNo < 0) {
return PFS_ERR_INVALID;
}
if (!(pfs->status & PFS_INITIALIZED)) {
return PFS_ERR_INVALID;
}
if ((ret = __osCheckId(pfs)) != 0) {
return ret;
}
if (pfs->activebank != 0 && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
return ret;
}
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + fileNo, (u8*)&dir)) != 0) {
return ret;
}
if (dir.company_code == 0 || dir.game_code == 0) {
return PFS_ERR_INVALID;
}
page = dir.start_page;
pages = 0;
bank = 0xFF;
while (true) {
if (page.ipage < pfs->inodeStartPage) {
break;
}
if (page.inode_t.bank != bank) {
bank = page.inode_t.bank;
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
return ret;
}
}
pages++;
page = inode.inodePage[page.inode_t.page];
}
if (page.ipage != PFS_EOF) {
return PFS_ERR_INCONSISTENT;
}
state->file_size = pages * PFS_ONE_PAGE * BLOCKSIZE;
state->company_code = dir.company_code;
state->game_code = dir.game_code;
bcopy(&dir.game_name, state->game_name, PFS_FILE_NAME_LEN);
bcopy(&dir.ext_name, state->ext_name, PFS_FILE_EXT_LEN);
return __osPfsGetStatus(pfs->queue, pfs->channel);
}

58
src/libultra/io/pfsfindfile.cpp
View File

@ -1,58 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSFINDFILE_C
#include "ultra64.h"
#include "global.h"
#include "def/contpfs.h"
#include "def/contramread.h"
#include "def/pfsfindfile.h"
#include "def/pfsgetstatus.h"
s32 osPfsFindFile(OSPfs* pfs, u16 companyCode, u32 gameCode, u8* gameName, u8* extName, s32* fileNo) {
s32 j;
s32 i;
__OSDir dir;
s32 ret = 0;
s32 err;
if (!(pfs->status & PFS_INITIALIZED)) {
return PFS_ERR_INVALID;
}
if ((ret = __osCheckId(pfs)) != 0) {
return ret;
}
for (j = 0; j < pfs->dir_size; j++) {
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + j, (u8*)&dir)) != 0) {
return ret;
}
if ((ret = __osPfsGetStatus(pfs->queue, pfs->channel)) != 0) {
return ret;
}
if ((dir.company_code == companyCode) && (dir.game_code == gameCode)) {
err = 0;
if (gameName != 0) {
for (i = 0; i < PFS_FILE_NAME_LEN; i++) {
if (dir.game_name[i] != gameName[i]) {
err = 1;
break;
}
}
}
if ((extName != 0) && (err == 0)) {
for (i = 0; i < PFS_FILE_EXT_LEN; i++) {
if (dir.ext_name[i] != extName[i]) {
err = 1;
break;
}
}
}
if (err == 0) {
*fileNo = j;
return ret;
}
}
}
*fileNo = -1;
return PFS_ERR_INVALID;
}

38
src/libultra/io/pfsfreeblocks.cpp
View File

@ -1,38 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSFREEBLOCKS_C
#include "ultra64.h"
#include "global.h"
#include "ultra64/pfs.h"
#include "def/contpfs.h"
#include "def/pfsfreeblocks.h"
s32 osPfsFreeBlocks(OSPfs* pfs, s32* leftoverBytes) {
s32 j;
s32 pages = 0;
__OSInode inode;
s32 ret = 0;
u8 bank;
s32 offset;
if (!(pfs->status & PFS_INITIALIZED)) {
return (PFS_ERR_INVALID);
}
if ((ret = __osCheckId(pfs)) != 0) {
return ret;
}
for (bank = PFS_ID_BANK_256K; bank < pfs->banks; bank++) {
if ((ret = __osPfsRWInode(pfs, &inode, PFS_READ, bank)) != 0) {
return ret;
}
offset = ((bank > PFS_ID_BANK_256K) ? 1 : pfs->inodeStartPage);
for (j = offset; j < PFS_INODE_SIZE_PER_PAGE; j++) {
if (inode.inodePage[j].ipage == PFS_PAGE_NOT_USED) {
pages++;
}
}
}
*leftoverBytes = pages * PFS_ONE_PAGE * BLOCKSIZE;
return 0;
}

16
src/libultra/io/pfsgetstatus.cpp
View File

@ -1,16 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSGETSTATUS_C
#include "ultra64.h"
#include "global.h"
#include "def/pfsgetstatus.h"
OSPifRam gPifMempakBuf;
s32 __osPfsGetStatus(OSMesgQueue* queue, s32 channel) {
return 0;
}
void __osPfsRequestOneChannel(s32 channel, u8 poll) {
}
void __osPfsGetOneChannelData(s32 channel, OSContStatus* contData) {
}

12
src/libultra/io/pfsinitpak.cpp
View File

@ -1,12 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSINITPAK_C
#include "ultra64.h"
#include "global.h"
#include "def/pfsinitpak.h"
s32 osPfsInitPak(OSMesgQueue* queue, OSPfs* pfs, s32 channel) {
return 0;
}
s32 __osPfsCheckRamArea(OSPfs* pfs) {
return 0;
}

14
src/libultra/io/pfsisplug.cpp
View File

@ -1,14 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSISPLUG_C
#include "ultra64.h"
#include "global.h"
#include "def/pfsisplug.h"
s32 osPfsIsPlug(OSMesgQueue* mq, u8* pattern) {
return 0;
}
void __osPfsRequestData(u8 poll) {
}
void __osPfsGetInitData(u8* pattern, OSContStatus* contData) {
}

133
src/libultra/io/pfsreadwritefile.cpp
View File

@ -1,133 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSREADWRITEFILE_C
#include "ultra64.h"
#include "global.h"
#include "def/contpfs.h"
#include "def/contramread.h"
#include "def/contramwrite.h"
#include "def/pfsgetstatus.h"
#include "def/pfsreadwritefile.h"
#include "def/pfsselectbank.h"
#define CHECK_IPAGE(p, pfs) \
(((p).ipage >= (pfs).inodeStartPage) && ((p).inode_t.bank < (pfs).banks) && ((p).inode_t.page >= 0x01) && \
((p).inode_t.page < 0x80))
__OSInode __osPfsInodeCache;
s32 __osPfsGetNextPage(OSPfs* pfs, u8* bank, __OSInode* inode, __OSInodeUnit* page) {
s32 ret;
if (page->inode_t.bank != *bank) {
*bank = page->inode_t.bank;
if ((ret = __osPfsRWInode(pfs, inode, PFS_READ, *bank)) != 0) {
return ret;
}
}
*page = inode->inodePage[page->inode_t.page];
if (!CHECK_IPAGE(*page, *pfs)) {
if (page->ipage == PFS_EOF) {
return PFS_ERR_INVALID;
}
return PFS_ERR_INCONSISTENT;
}
return 0;
}
s32 osPfsReadWriteFile(OSPfs* pfs, s32 fileNo, u8 flag, s32 offset, s32 size, u8* data) {
s32 ret;
__OSDir dir;
__OSInode inode;
__OSInodeUnit curPage;
s32 curBlock;
s32 blockSize;
u8* buffer;
u8 bank;
u16 blockno;
if ((fileNo >= pfs->dir_size) || (fileNo < 0)) {
return PFS_ERR_INVALID;
}
if ((size <= 0) || ((size % BLOCKSIZE) != 0)) {
return PFS_ERR_INVALID;
}
if ((offset < 0) || ((offset % BLOCKSIZE) != 0)) {
return PFS_ERR_INVALID;
}
if (!(pfs->status & PFS_INITIALIZED)) {
return PFS_ERR_INVALID;
}
if (__osCheckId(pfs) == PFS_ERR_NEW_PACK) {
return PFS_ERR_NEW_PACK;
}
if (pfs->activebank != 0 && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
return ret;
}
if ((ret = __osContRamRead(pfs->queue, pfs->channel, pfs->dir_table + fileNo, (u8*)&dir)) != 0) {
return ret;
}
if ((dir.company_code == 0) || (dir.game_code == 0)) {
return PFS_ERR_INVALID;
}
if (!CHECK_IPAGE(dir.start_page, *pfs)) {
if (dir.start_page.ipage == PFS_EOF) {
return PFS_ERR_INVALID;
}
return PFS_ERR_INCONSISTENT;
}
if ((flag == PFS_READ) && ((dir.status & PFS_WRITTEN) == 0)) {
return PFS_ERR_BAD_DATA;
}
bank = 255;
curBlock = offset / BLOCKSIZE;
curPage = dir.start_page;
while (curBlock >= 8) {
if ((ret = __osPfsGetNextPage(pfs, &bank, &inode, &curPage)) != 0) {
return ret;
}
curBlock -= 8;
}
blockSize = size / BLOCKSIZE;
buffer = data;
while (blockSize > 0) {
if (curBlock == 8) {
if ((ret = __osPfsGetNextPage(pfs, &bank, &inode, &curPage)) != 0) {
return ret;
}
curBlock = 0;
}
if (pfs->activebank != curPage.inode_t.bank && (ret = __osPfsSelectBank(pfs, curPage.inode_t.bank)) != 0) {
return ret;
}
blockno = curPage.inode_t.page * PFS_ONE_PAGE + curBlock;
if (flag == PFS_READ) {
ret = __osContRamRead(pfs->queue, pfs->channel, blockno, buffer);
} else {
ret = __osContRamWrite(pfs->queue, pfs->channel, blockno, buffer, 0);
}
if (ret != 0) {
return ret;
}
buffer += BLOCKSIZE;
curBlock++;
blockSize--;
}
if (flag == PFS_WRITE && !(dir.status & PFS_WRITTEN)) {
dir.status |= PFS_WRITTEN;
if (pfs->activebank != 0 && (ret = __osPfsSelectBank(pfs, 0)) != 0) {
return ret;
}
if ((ret = __osContRamWrite(pfs->queue, pfs->channel, pfs->dir_table + fileNo, (u8*)&dir, 0)) != 0) {
return ret;
}
}
return __osPfsGetStatus(pfs->queue, pfs->channel);
}

21
src/libultra/io/pfsselectbank.cpp
View File

@ -1,21 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PFSSELECTBANK_C
#include "ultra64/pfs.h"
#include "global.h"
#include "def/contramwrite.h"
#include "def/pfsselectbank.h"
s32 __osPfsSelectBank(OSPfs* pfs, u8 bank) {
u8 temp[BLOCKSIZE];
s32 i;
s32 ret = 0;
for (i = 0; i < BLOCKSIZE; i++) {
temp[i] = bank;
}
ret = __osContRamWrite(pfs->queue, pfs->channel, 0x8000 / BLOCKSIZE, temp, 0);
if (ret == 0) {
pfs->activebank = bank;
}
return ret;
}

17
src/libultra/io/piacs.cpp
View File

@ -1,17 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PIACS_C
#include "global.h"
#include "def/piacs.h"
u32 __osPiAccessQueueEnabled = 0;
//OSMesg piAccessBuf;
//OSMesgQueue __osPiAccessQueue;
void __osPiCreateAccessQueue(void) {
}
void __osPiGetAccess(void) {
}
void __osPiRelAccess(void) {
}

12
src/libultra/io/pigetcmdq.cpp
View File

@ -1,12 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PIGETCMDQ_C
#include "global.h"
#include "ultra64/internal.h"
#include "def/pigetcmdq.h"
OSMesgQueue* osPiGetCmdQueue(void) {
if (!__osPiDevMgr.initialized) {
return NULL;
}
return __osPiDevMgr.cmdQueue;
}

23
src/libultra/io/pimgr.cpp
View File

@ -1,23 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PIMGR_C
#include "global.h"
#include "ultra64/internal.h"
#include "def/pimgr.h"
OSMgrArgs __osPiDevMgr = { 0 };
OSPiHandle __Dom1SpeedParam;
OSPiHandle __Dom2SpeedParam;
OSThread piThread;
u8 piStackThread[0x1000];
OSMesgQueue piEventQueue;
OSMesg piEventBuf[2];
OSThread __osThreadSave;
OSPiHandle* __osPiTable = NULL;
OSPiHandle* __osCurrentHandle[] = {
&__Dom1SpeedParam,
&__Dom2SpeedParam,
};
void osCreatePiManager(OSPri pri, OSMesgQueue* cmdQ, OSMesg* cmdBuf, s32 cmdMsgCnt) {
}

9
src/libultra/io/pirawdma.cpp
View File

@ -1,9 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_PIRAWDMA_C
#include "global.h"
#include "regs.h"
#include "ultra64/rcp.h"
#include "def/pirawdma.h"
s32 __osPiRawStartDma(s32 dir, u32 cartAddr, void* dramAddr, size_t size) {
return 0;
}

6
src/libultra/io/si.cpp
View File

@ -1,6 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SI_C
#include "global.h"
#include "def/si.h"
s32 __osSiDeviceBusy(void) {
}

12
src/libultra/io/siacs.cpp
View File

@ -1,12 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SIACS_C
#include "global.h"
#include "def/siacs.h"
void __osSiCreateAccessQueue(void) {
}
void __osSiGetAccess(void) {
}
void __osSiRelAccess(void) {
}

7
src/libultra/io/sirawdma.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SIRAWDMA_C
#include "global.h"
#include "def/sirawdma.h"
s32 __osSiRawStartDma(s32 dir, void* addr) {
return 0;
}

7
src/libultra/io/sirawread.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SIRAWREAD_C
#include "global.h"
#include "def/sirawread.h"
s32 __osSiRawReadIo(void* devAddr, u32* dst) {
return 0;
}

7
src/libultra/io/sirawwrite.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SIRAWWRITE_C
#include "global.h"
#include "def/sirawwrite.h"
s32 __osSiRawWriteIo(void* devAddr, u32 val) {
return 0;
}

14
src/libultra/io/sp.cpp
View File

@ -1,14 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SP_C
#include "global.h"
#include "ultra64/rcp.h"
#include "ultra64/rsp.h"
#include "def/sp.h"
u32 __osSpDeviceBusy(void) {
register u32 status = HW_REG(SP_STATUS_REG, u32);
if (status & (SP_STATUS_DMA_BUSY | SP_STATUS_DMA_FULL | SP_STATUS_IO_FULL)) {
return 1;
}
return 0;
}

8
src/libultra/io/spgetstat.cpp
View File

@ -1,8 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SPGETSTAT_C
#include "global.h"
#include "ultra64/rcp.h"
#include "def/spgetstat.h"
u32 __osSpGetStatus(void) {
return HW_REG(SP_STATUS_REG, u32);
}

7
src/libultra/io/sprawdma.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SPRAWDMA_C
#include "global.h"
#include "def/sprawdma.h"
s32 __osSpRawStartDma(s32 direction, void* devAddr, void* dramAddr, u32 size) {
return 0;
}

7
src/libultra/io/spsetpc.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SPSETPC_C
#include "global.h"
#include "def/spsetpc.h"
s32 __osSpSetPc(void* pc) {
return 0;
}

8
src/libultra/io/spsetstat.cpp
View File

@ -1,8 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SPSETSTAT_C
#include "global.h"
#include "ultra64/rcp.h"
#include "def/spsetstat.h"
void __osSpSetStatus(u32 status) {
HW_REG(SP_STATUS_REG, u32) = status;
}

14
src/libultra/io/sptask.cpp
View File

@ -1,14 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SPTASK_C
#include "global.h"
#include "sched.h"
#include "def/sptask.h"
OSTask* _VirtualToPhysicalTask(OSTask* intp) {
return NULL;
}
void osSpTaskLoad(OSTask* intp) {
}
void osSpTaskStartGo(OSTask* tp) {
}

6
src/libultra/io/sptaskyield.cpp
View File

@ -1,6 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_SPTASKYIELD_C
#include "global.h"
#include "def/sptaskyield.h"
void osSpTaskYield(void) {
}

5
src/libultra/io/sptaskyielded.cpp
View File

@ -1,5 +0,0 @@
#include "global.h"
u32 osSpTaskYielded(struct OSTask* task) {
return 0;
}

46
src/libultra/io/vi.cpp
View File

@ -1,46 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VI_C
#include "global.h"
#include "ultra64/vi.h"
#include "regs.h"
#include "ultra64/rcp.h"
#include "def/vi.h"
#include "def/vimodempallan1.h"
#include "def/vimodentsclan1.h"
#include "def/vimodepallan1.h"
#include "def/viswapcontext.h"
extern u32 osTvType;
extern OSViMode osViModePalLan1;
extern OSViMode osViModeNtscLan1;
extern OSViMode osViModeMpalLan1;
extern OSViMode osViModeFpalLan1;
OSViContext vi[2] = { 0 };
OSViContext* __osViCurr = &vi[0];
OSViContext* __osViNext = &vi[1];
void __osViInit(void) {
bzero(vi, sizeof(vi));
__osViCurr = &vi[0];
__osViNext = &vi[1];
__osViNext->retraceCount = 1;
__osViCurr->retraceCount = 1;
__osViNext->buffer = (void*)0x80000000;
__osViCurr->buffer = (void*)0x80000000;
if (osTvType == OS_TV_PAL) {
__osViNext->modep = &osViModePalLan1;
} else if (osTvType == OS_TV_MPAL) {
__osViNext->modep = &osViModeMpalLan1;
} else {
__osViNext->modep = &osViModeNtscLan1;
}
__osViNext->state = 0x20;
__osViNext->features = __osViNext->modep->comRegs.ctrl;
HW_REG(VI_CONTROL_REG, u32) = 0;
__osViSwapContext();
}

16
src/libultra/io/viblack.cpp
View File

@ -1,16 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIBLACK_C
#include "global.h"
#include "def/vi.h"
#include "def/viblack.h"
// TODO: name magic constants
void osViBlack(u8 active) {
register u32 prevInt = __osDisableInt();
if (active) {
__osViNext->state |= 0x20;
} else {
__osViNext->state &= ~0x20;
}
__osRestoreInt(prevInt);
}

6
src/libultra/io/viextend.cpp
View File

@ -1,6 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIEXTEND_C
#include "global.h"
#include "def/viextend.h"
void osViExtendVStart(u32 arg0) {
}

6
src/libultra/io/vigetcurrcontext.cpp
View File

@ -1,6 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIGETCURRCONTEXT_C
#include "global.h"
struct OSViContext* __osViGetCurrentContext(void) {
return NULL;
}

7
src/libultra/io/vigetcurrframebuf.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIGETCURRFRAMEBUF_C
#include "global.h"
#include "def/vigetcurrframebuf.h"
u32* osViGetCurrentFramebuffer(void) {
return 0;
}

7
src/libultra/io/vigetnextframebuf.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIGETNEXTFRAMEBUF_C
#include "global.h"
#include "def/vigetnextframebuf.h"
void* osViGetNextFramebuffer(void) {
return NULL;
}

18
src/libultra/io/vimgr.cpp
View File

@ -1,18 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIMGR_C
#include "global.h"
#include "ultra64/internal.h"
#include "def/vimgr.h"
OSThread viThread;
u8 viThreadStack[0x1000];
OSMesgQueue viEventQueue;
OSMesg viEventBuf[6];
OSIoMesg viRetraceMsg;
OSIoMesg viCounterMsg;
OSMgrArgs __osViDevMgr = { 0 };
u32 __additional_scanline = 0;
void viMgrMain(void*);
void viMgrMain(void* vargs) {
}

35
src/libultra/io/vimodefpallan1.cpp
View File

@ -1,35 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIMODEFPALLAN1_C
#include "global.h"
#include "ultra64/vi.h"
#include "def/vimodefpallan1.h"
OSViMode osViModeFpalLan1 = {
0x2C, // type
{
// comRegs
0x311E, // ctrl
SCREEN_WIDTH, // width
0x4541E3A, // burst
0x271, // vSync
0x170C69, // hSync
0xC6F0C6D, // leap
0x800300, // hStart
0x200, // xScale
0 // vCurrent
},
{ // fldRegs
{
0x280, // origin
0x400, // yScale
0x2F0269, // vStart
0x9026B, // vBurst
2, // vIntr
},
{
0x280, // origin
0x400, // yScale
0x2F0269, // vStart
0x9026B, // vBurst
2 // vIntr
} },
};

37
src/libultra/io/vimodempallan1.cpp
View File

@ -1,37 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIMODEMPALLAN1_C
#include "global.h"
#include "ultra64/vi.h"
#include "def/vimodempallan1.h"
OSViMode osViModeMpalLan1 = {
0x1E, // type
{
// comRegs
0x311E, // ctrl
SCREEN_WIDTH, // width
0x4651E39, // burst
0x20D, // vSync
0x40C11, // hSync
0xC190C1A, // leap
0x6C02EC, // hStart
0x200, // xScale
0, // vCurrent
},
{ // fldRegs
{
// [0]
0x280, // origin
0x400, // yScale
0x2501FF, // vStart
0xE0204, // vBurst
2, // vIntr
},
{
// [1]
0x280, // origin
0x400, // yScale
0x2501FF, // vStart
0xE0204, // vBurst
2, // vIntr
} },
};

37
src/libultra/io/vimodentsclan1.cpp
View File

@ -1,37 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIMODENTSCLAN1_C
#include "global.h"
#include "ultra64/vi.h"
#include "def/vimodentsclan1.h"
OSViMode osViModeNtscLan1 = {
2, // type
{
// comRegs
0x311E, // ctrl
SCREEN_WIDTH, // width
0x3E52239, // burst
0x20D, // vSync
0xC15, // hSync
0xC150C15, // leap
0x6C02EC, // hStart
0x200, // xScale
0, // vCurrent
},
{ // fldRegs
{
// [0]
0x280, // origin
0x400, // yScale
0x2501FF, // vStart
0xE0204, // vBurst
2, // vIntr
},
{
// [1]
0x280, // origin
0x400, // yScale
0x2501FF, // vStart
0xE0204, // vBurst
2, // vIntr
} },
};

35
src/libultra/io/vimodepallan1.cpp
View File

@ -1,35 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VIMODEPALLAN1_C
#include "global.h"
#include "ultra64/vi.h"
#include "def/vimodepallan1.h"
OSViMode osViModePalLan1 = {
0x10, // type
{
// comRegs
0x311E, // ctrl
SCREEN_WIDTH, // width
0x4541E3A, // burst
0x271, // vSync
0x170C69, // hSync
0xC6F0C6D, // leap
0x800300, // hStart
0x200, // xScale
0 // vCurrent
},
{ // fldRegs
{
0x280, // origin
0x400, // yScale
0x5F0239, // vStart
0x9026B, // vBurst
2, // vIntr
},
{
0x280, // origin
0x400, // yScale
0x5F0239, // vStart
0x9026B, // vBurst
2 // vIntr
} },
};

16
src/libultra/io/visetevent.cpp
View File

@ -1,16 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISETEVENT_C
#include "global.h"
#include "def/vi.h"
#include "def/visetevent.h"
extern OSViContext* __osViNext;
void osViSetEvent(OSMesgQueue* mq, OSMesg msg, u32 retraceCount) {
register u32 prevInt = __osDisableInt();
__osViNext->mq = mq;
__osViNext->msg = msg;
__osViNext->retraceCount = retraceCount;
__osRestoreInt(prevInt);
}

14
src/libultra/io/visetmode.cpp
View File

@ -1,14 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISETMODE_C
#include "global.h"
#include "def/vi.h"
#include "def/visetmode.h"
void osViSetMode(OSViMode* mode) {
register u32 prevInt = __osDisableInt();
__osViNext->modep = mode;
__osViNext->state = 1;
__osViNext->features = __osViNext->modep->comRegs.ctrl;
__osRestoreInt(prevInt);
}

41
src/libultra/io/visetspecial.cpp
View File

@ -1,41 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISETSPECIAL_C
#include "global.h"
#include "def/vi.h"
#include "def/visetspecial.h"
void osViSetSpecialFeatures(u32 func) {
register u32 prevInt = __osDisableInt();
if (func & OS_VI_GAMMA_ON) {
__osViNext->features |= OS_VI_GAMMA;
}
if (func & OS_VI_GAMMA_OFF) {
__osViNext->features &= ~OS_VI_GAMMA;
}
if (func & OS_VI_GAMMA_DITHER_ON) {
__osViNext->features |= OS_VI_GAMMA_DITHER;
}
if (func & OS_VI_GAMMA_DITHER_OFF) {
__osViNext->features &= ~OS_VI_GAMMA_DITHER;
}
if (func & OS_VI_DIVOT_ON) {
__osViNext->features |= OS_VI_DIVOT;
}
if (func & OS_VI_DIVOT_OFF) {
__osViNext->features &= ~OS_VI_DIVOT;
}
if (func & OS_VI_DITHER_FILTER_ON) {
__osViNext->features |= OS_VI_DITHER_FILTER;
__osViNext->features &= ~(OS_VI_UNK200 | OS_VI_UNK100);
}
if (func & OS_VI_DITHER_FILTER_OFF) {
__osViNext->features &= ~OS_VI_DITHER_FILTER;
__osViNext->features |= __osViNext->modep->comRegs.ctrl & (OS_VI_UNK200 | OS_VI_UNK100);
}
__osViNext->state |= 8;
__osRestoreInt(prevInt);
}

7
src/libultra/io/visetxscale.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISETXSCALE_C
#include "global.h"
#include "def/visetxscale.h"
void osViSetXScale(f32 scale) {
scale = 0.0;
}

7
src/libultra/io/visetyscale.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISETYSCALE_C
#include "global.h"
#include "def/visetyscale.h"
void osViSetYScale(f32 scale) {
scale = 0.0;
}

13
src/libultra/io/viswapbuf.cpp
View File

@ -1,13 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISWAPBUF_C
#include "global.h"
#include "def/vi.h"
#include "def/viswapbuf.h"
void osViSwapBuffer(void* vaddr) {
u32 prevInt = __osDisableInt();
__osViNext->buffer = vaddr;
__osViNext->state |= 0x10; // TODO: figure out what this flag means
__osRestoreInt(prevInt);
}

7
src/libultra/io/viswapcontext.cpp
View File

@ -1,7 +0,0 @@
#define INTERNAL_SRC_LIBULTRA_IO_VISWAPCONTEXT_C
#include "global.h"
#include "ultra64/rcp.h"
#include "def/viswapcontext.h"
void __osViSwapContext(void) {
}

32
src/port/ultra_reimplementation.cpp
View File

@ -16,6 +16,8 @@
#include <chrono>
#include "../../AziAudio/AziAudio/AudioSpec.h"
HardwareRegisters hw_regs;
extern u32 osTvType;
extern OSViMode osViModePalLan1;
@ -450,7 +452,7 @@ s32 osAiSetNextBuffer(void* buf, u32 size)
}
// Originally a call to __osAiDeviceBusy
status = HW_REG(AI_STATUS_REG, s32);
status = hw_regs.AI_STATUS_REG;
if(status & AI_STATUS_AI_FULL)
{
return -1;
@ -458,8 +460,8 @@ s32 osAiSetNextBuffer(void* buf, u32 size)
// OS_K0_TO_PHYSICAL replaces osVirtualToPhysical, this replacement
// assumes that only KSEG0 addresses are given
HW_REG(AI_DRAM_ADDR_REG, u32) = bufAdjusted;
HW_REG(AI_LEN_REG, u32) = size;
hw_regs.AI_DRAM_ADDR_REG = bufAdjusted;
hw_regs.AI_LEN_REG = size;
AiLenChanged();
return 0;
}
@ -469,7 +471,7 @@ extern s32 osViClock;
u32 osAiGetLength()
{
AiReadLength();
return HW_REG(AI_LEN_REG, u32);
return hw_regs.AI_LEN_REG;
}
s32 osAiSetFrequency(u32 frequency)
@ -490,30 +492,12 @@ s32 osAiSetFrequency(u32 frequency)
bitrate = 16;
}
HW_REG(AI_DACRATE_REG, u32) = dacRate - 1;
HW_REG(AI_BITRATE_REG, u32) = bitrate - 1;
hw_regs.AI_DACRATE_REG = dacRate - 1;
hw_regs.AI_BITRATE_REG = bitrate - 1;
AiDacrateChanged(SYSTEM_NTSC);
return osViClock / (s32)dacRate;
}
#include <unordered_map>
static std::unordered_map<u32, uintptr_t> gRegisterMap;
uintptr_t& hw_reg(u32 reg)
{
if(reg == AI_DACRATE_REG || reg == AI_BITRATE_REG || reg == AI_LEN_REG)
{
int x = 0;
}
if(gRegisterMap.size() == 0)
{
gRegisterMap.reserve(64);
}
return gRegisterMap[reg];
}
void osCreateMesgQueue(OSMesgQueue* mq, OSMesg* msg, s32 count)
{
mq->mtqueue = NULL;