From a436d79177fc54927d14cc2114802dee74176a6b Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Tue, 24 Dec 2019 04:25:49 +0800 Subject: partially sync with knizz's documentation --- src/trade.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/trade.c b/src/trade.c index 2f48928ec..10ed51d69 100644 --- a/src/trade.c +++ b/src/trade.c @@ -2765,10 +2765,10 @@ static bool32 IsDeoxysOrMewUntradable(u16 species, bool8 isObedientBitSet) int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct a0, struct UnkLinkRfuStruct_02022B14Substruct a1, u16 species1, u16 species2, u8 type, u16 species3, u8 isObedientBitSet) { - u8 r9 = a0.unk_01_0; - u8 r4 = a0.unk_00_7; - u8 r10 = a1.unk_01_0; - u8 r0 = a1.unk_00_7; + u8 r9 = a0.hasNationalDex; + u8 r4 = a0.isChampion; + u8 r10 = a1.hasNationalDex; + u8 r0 = a1.isChampion; u8 r1 = a1.unk_01_2; u8 r2; @@ -2845,7 +2845,7 @@ int GetUnionRoomTradeMessageId(struct UnkLinkRfuStruct_02022B14Substruct a0, str int CanRegisterMonForTradingBoard(struct UnkLinkRfuStruct_02022B14Substruct a0, u16 species, u16 a2, u8 a3) { - u8 canTradeEggAndNational = a0.unk_01_0; + u8 canTradeEggAndNational = a0.hasNationalDex; if (IsDeoxysOrMewUntradable(a2, a3)) { -- cgit v1.2.3 From 8f1a8972c19f5cd2522c9e7982bd330ac05305e9 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Fri, 27 Dec 2019 05:17:41 +0800 Subject: librfu_stwi Co-authored-by: Max Thomas --- src/librfu_stwi.c | 645 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 645 insertions(+) create mode 100644 src/librfu_stwi.c (limited to 'src') diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c new file mode 100644 index 000000000..fe8a4ef76 --- /dev/null +++ b/src/librfu_stwi.c @@ -0,0 +1,645 @@ +#include "global.h" +#include "librfu.h" + +static void STWI_intr_timer(void); +static u16 STWI_init(u8 request); +static s32 STWI_start_Command(void); +static void STWI_set_timer(u8 unk); +static void STWI_stop_timer(void); +static s32 STWI_restart_Command(void); +static s32 STWI_reset_ClockCounter(void); + +void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, bool8 copyInterruptToRam) +{ + // If we're copying our interrupt into RAM, DMA it to block1 and use + // block2 for our RfuStruct, otherwise block1 holds the RfuStruct. + // interrupt usually is a pointer to gIntrTable[1] + if (copyInterruptToRam == TRUE) + { + *interrupt = (IntrFunc)interruptStruct->block1; + DmaCopy16(3, &IntrSIO32, interruptStruct->block1, sizeof(interruptStruct->block1)); + gRfuState = &interruptStruct->block2; + } + else + { + *interrupt = IntrSIO32; + gRfuState = (struct RfuStruct *)interruptStruct->block1; + } + gRfuState->rxPacket = &interruptStruct->rxPacketAlloc; + gRfuState->txPacket = &interruptStruct->txPacketAlloc; + gRfuState->msMode = 1; + gRfuState->state = 0; + gRfuState->reqLength = 0; + gRfuState->reqNext = 0; + gRfuState->ackLength = 0; + gRfuState->ackNext = 0; + gRfuState->ackActiveCommand = 0; + gRfuState->timerState = 0; + gRfuState->timerActive = 0; + gRfuState->error = 0; + gRfuState->recoveryCount = 0; + gRfuState->unk_2c = 0; + REG_RCNT = 0x100; // TODO: mystery bit? + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + STWI_init_Callback_M(); + STWI_init_Callback_S(); + IntrEnable(INTR_FLAG_SERIAL); +} + +void STWI_init_timer(IntrFunc *interrupt, s32 timerSelect) +{ + *interrupt = STWI_intr_timer; + gRfuState->timerSelect = timerSelect; + IntrEnable(INTR_FLAG_TIMER0 << gRfuState->timerSelect); +} + +void AgbRFU_SoftReset(void) +{ + vu16 *timerL; + vu16 *timerH; + + REG_RCNT = 0x8000; + REG_RCNT = 0x80A0; // all these bits are undocumented + timerL = ®_TMCNT_L(gRfuState->timerSelect); + timerH = ®_TMCNT_H(gRfuState->timerSelect); + *timerH = 0; + *timerL = 0; + *timerH = 0x83; + while (*timerL <= 0x11) + REG_RCNT = 0x80A2; + *timerH = 3; + REG_RCNT = 0x80A0; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + gRfuState->state = 0; + gRfuState->reqLength = 0; + gRfuState->reqNext = 0; + gRfuState->reqActiveCommand = 0; + gRfuState->ackLength = 0; + gRfuState->ackNext = 0; + gRfuState->ackActiveCommand = 0; + gRfuState->timerState = 0; + gRfuState->timerActive = 0; + gRfuState->error = 0; + gRfuState->msMode = 1; + gRfuState->recoveryCount = 0; + gRfuState->unk_2c = 0; +} + +void STWI_set_MS_mode(u8 mode) +{ + gRfuState->msMode = mode; +} + +u16 STWI_read_status(u8 index) +{ + switch (index) + { + case 0: + return gRfuState->error; + case 1: + return gRfuState->msMode; + case 2: + return gRfuState->state; + case 3: + return gRfuState->reqActiveCommand; + default: + return 0xFFFF; + } +} + +void STWI_init_Callback_M(void) +{ + STWI_set_Callback_M(NULL); +} + +void STWI_init_Callback_S(void) +{ + STWI_set_Callback_S(NULL); +} + +void STWI_set_Callback_M(void (*callbackM)()) +{ + gRfuState->callbackM = callbackM; +} + +void STWI_set_Callback_S(void (*callbackS)()) +{ + gRfuState->callbackS = callbackS; +} + +void STWI_set_Callback_ID(u32 id) +{ + gRfuState->callbackId = id; +} + +u16 STWI_poll_CommandEnd(void) +{ + while (gRfuState->unk_2c == TRUE) + ; + return gRfuState->error; +} + +void STWI_send_ResetREQ(void) +{ + if (!STWI_init(RFU_RESET)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_LinkStatusREQ(void) +{ + if (!STWI_init(RFU_LINK_STATUS)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_VersionStatusREQ(void) +{ + if (!STWI_init(RFU_VERSION_STATUS)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SystemStatusREQ(void) +{ + if (!STWI_init(RFU_SYSTEM_STATUS)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SlotStatusREQ(void) +{ + if (!STWI_init(RFU_SLOT_STATUS)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_ConfigStatusREQ(void) +{ + if (!STWI_init(RFU_CONFIG_STATUS)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_GameConfigREQ(u8 *unk1, u8 *data) +{ + u8 *packetBytes; + s32 i; + + if (!STWI_init(RFU_GAME_CONFIG)) + { + gRfuState->reqLength = 6; + // TODO: what is unk1 + packetBytes = gRfuState->txPacket->rfuPacket8.data; + packetBytes += sizeof(u32); + *(u16 *)packetBytes = *(u16 *)unk1; + packetBytes += sizeof(u16); + unk1 += sizeof(u16); + for (i = 0; i < 14; ++i) + { + *packetBytes = *unk1; + ++packetBytes; + ++unk1; + } + for (i = 0; i < 8; ++i) + { + *packetBytes = *data; + ++packetBytes; + ++data; + } + STWI_start_Command(); + } +} + +void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3) +{ + if (!STWI_init(RFU_SYSTEM_CONFIG)) + { + u8 *packetBytes; + + gRfuState->reqLength = 1; + packetBytes = gRfuState->txPacket->rfuPacket8.data; + packetBytes += sizeof(u32); + *packetBytes++ = unk3; + *packetBytes++ = unk2; + *(u16*)packetBytes = unk1; + STWI_start_Command(); + } +} + +void STWI_send_SC_StartREQ(void) +{ + if (!STWI_init(RFU_SC_START)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SC_PollingREQ(void) +{ + if (!STWI_init(RFU_SC_POLLING)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SC_EndREQ(void) +{ + if (!STWI_init(RFU_SC_END)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SP_StartREQ(void) +{ + if (!STWI_init(RFU_SP_START)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SP_PollingREQ(void) +{ + if (!STWI_init(RFU_SP_POLLING)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_SP_EndREQ(void) +{ + if (!STWI_init(RFU_SP_END)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_CP_StartREQ(u16 unk1) +{ + if (!STWI_init(RFU_CP_START)) + { + gRfuState->reqLength = 1; + gRfuState->txPacket->rfuPacket32.data[0] = unk1; + STWI_start_Command(); + } +} + +void STWI_send_CP_PollingREQ(void) +{ + if (!STWI_init(RFU_CP_POLLING)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_CP_EndREQ(void) +{ + if (!STWI_init(RFU_CP_END)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_DataTxREQ(const void *in, u8 size) +{ + if (!STWI_init(RFU_DATA_TX)) + { + u8 reqLength = (size / sizeof(u32)); + if (size & (sizeof(u32) - 1)) + reqLength += 1; + gRfuState->reqLength = reqLength; + CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->reqLength * sizeof(u32)); + STWI_start_Command(); + } +} + +void STWI_send_DataTxAndChangeREQ(const void *in, u8 size) +{ + if (!STWI_init(RFU_DATA_TX_AND_CHANGE)) + { + u8 reqLength = (size / sizeof(u32)); + if (size & (sizeof(u32) - 1)) + reqLength += 1; + gRfuState->reqLength = reqLength; + CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->reqLength * sizeof(u32)); + STWI_start_Command(); + } +} + +void STWI_send_DataRxREQ(void) +{ + if (!STWI_init(RFU_DATA_RX)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_MS_ChangeREQ(void) +{ + if (!STWI_init(RFU_MS_CHANGE)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_DataReadyAndChangeREQ(u8 unk) +{ + if (!STWI_init(RFU_DATA_READY_AND_CHANGE)) + { + if (!unk) + { + gRfuState->reqLength = 0; + } + else + { + u8 *packetBytes; + + gRfuState->reqLength = 1; + packetBytes = gRfuState->txPacket->rfuPacket8.data; + packetBytes += sizeof(u32); + *packetBytes++ = unk; + *packetBytes++ = 0; + *packetBytes++ = 0; + *packetBytes = 0; + } + STWI_start_Command(); + } +} + +void STWI_send_DisconnectedAndChangeREQ(u8 unk0, u8 unk1) +{ + if (!STWI_init(RFU_DISCONNECTED_AND_CHANGE)) + { + u8 *packetBytes; + + gRfuState->reqLength = 1; + packetBytes = gRfuState->txPacket->rfuPacket8.data; + packetBytes += sizeof(u32); + *packetBytes++ = unk0; + *packetBytes++ = unk1; + *packetBytes++ = 0; + *packetBytes = 0; + STWI_start_Command(); + } +} + +void STWI_send_ResumeRetransmitAndChangeREQ(void) +{ + if (!STWI_init(RFU_RESUME_RETRANSMIT_AND_CHANGE)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_DisconnectREQ(u8 unk) +{ + if (!STWI_init(RFU_DISCONNECT)) + { + gRfuState->reqLength = 1; + gRfuState->txPacket->rfuPacket32.data[0] = unk; + STWI_start_Command(); + } +} + +void STWI_send_TestModeREQ(u8 unk0, u8 unk1) +{ + if (!STWI_init(RFU_TEST_MODE)) + { + gRfuState->reqLength = 1; + gRfuState->txPacket->rfuPacket32.data[0] = unk0 | (unk1 << 8); + STWI_start_Command(); + } +} + +void STWI_send_CPR_StartREQ(u16 unk0, u16 unk1, u8 unk2) +{ + u32 *packetData; + u32 arg1; + + if (!STWI_init(RFU_CPR_START)) + { + gRfuState->reqLength = 2; + arg1 = unk1 | (unk0 << 16); + packetData = gRfuState->txPacket->rfuPacket32.data; + packetData[0] = arg1; + packetData[1] = unk2; + STWI_start_Command(); + } +} + +void STWI_send_CPR_PollingREQ(void) +{ + if (!STWI_init(RFU_CPR_POLLING)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_CPR_EndREQ(void) +{ + if (!STWI_init(RFU_CPR_END)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +void STWI_send_StopModeREQ(void) +{ + if (!STWI_init(RFU_STOP_MODE)) + { + gRfuState->reqLength = 0; + STWI_start_Command(); + } +} + +static void STWI_intr_timer(void) +{ + switch (gRfuState->timerState) + { + // TODO: Make an enum for these + case 2: + gRfuState->timerActive = 1; + STWI_set_timer(50); + break; + case 1: + case 4: + STWI_stop_timer(); + STWI_restart_Command(); + break; + case 3: + gRfuState->timerActive = 1; + STWI_stop_timer(); + STWI_reset_ClockCounter(); + if (gRfuState->callbackM) + gRfuState->callbackM(255, 0); + break; + } +} + +static void STWI_set_timer(u8 unk) +{ + vu16 *timerL; + vu16 *timerH; + + timerL = ®_TMCNT_L(gRfuState->timerSelect); + timerH = ®_TMCNT_H(gRfuState->timerSelect); + REG_IME = 0; + switch (unk) + { + case 50: + *timerL = 0xFCCB; + gRfuState->timerState = 1; + break; + case 80: + *timerL = 0xFAE0; + gRfuState->timerState = 2; + break; + case 100: + *timerL = 0xF996; + gRfuState->timerState = 3; + break; + case 130: + *timerL = 0xF7AD; + gRfuState->timerState = 4; + break; + } + *timerH = TIMER_ENABLE | TIMER_INTR_ENABLE | TIMER_1024CLK; + REG_IF = INTR_FLAG_TIMER0 << gRfuState->timerSelect; + REG_IME = 1; +} + +static void STWI_stop_timer(void) +{ + gRfuState->timerState = 0; + REG_TMCNT_L(gRfuState->timerSelect) = 0; + REG_TMCNT_H(gRfuState->timerSelect) = 0; +} + +static u16 STWI_init(u8 request) +{ + if (!REG_IME) + { + gRfuState->error = 6; + if (gRfuState->callbackM) + gRfuState->callbackM(request, gRfuState->error); + return TRUE; + } + else if (gRfuState->unk_2c == TRUE) + { + gRfuState->error = 2; + gRfuState->unk_2c = FALSE; + if (gRfuState->callbackM) + gRfuState->callbackM(request, gRfuState->error); + return TRUE; + } + else if(!gRfuState->msMode) + { + gRfuState->error = 4; + if (gRfuState->callbackM) + gRfuState->callbackM(request, gRfuState->error, gRfuState); + return TRUE; + } + else + { + gRfuState->unk_2c = TRUE; + gRfuState->reqActiveCommand = request; + gRfuState->state = 0; + gRfuState->reqLength = 0; + gRfuState->reqNext = 0; + gRfuState->ackLength = 0; + gRfuState->ackNext = 0; + gRfuState->ackActiveCommand = 0; + gRfuState->timerState = 0; + gRfuState->timerActive = 0; + gRfuState->error = 0; + gRfuState->recoveryCount = 0; + REG_RCNT = 0x100; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + return FALSE; + } +} + +static s32 STWI_start_Command(void) +{ + u16 imeTemp; + + // equivalent to gRfuState->txPacket->rfuPacket32.command, + // but the cast here is required to avoid register issue + *(u32 *)gRfuState->txPacket->rfuPacket8.data = 0x99660000 | (gRfuState->reqLength << 8) | gRfuState->reqActiveCommand; + REG_SIODATA32 = gRfuState->txPacket->rfuPacket32.command; + gRfuState->state = 0; + gRfuState->reqNext = 1; + imeTemp = REG_IME; + REG_IME = 0; + REG_IE |= (INTR_FLAG_TIMER0 << gRfuState->timerSelect); + REG_IE |= INTR_FLAG_SERIAL; + REG_IME = imeTemp; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_MULTI_BUSY | SIO_115200_BPS; + return 0; +} + +static s32 STWI_restart_Command(void) +{ + if (gRfuState->recoveryCount <= 1) + { + ++gRfuState->recoveryCount; + STWI_start_Command(); + } + else + { + if (gRfuState->reqActiveCommand == RFU_MS_CHANGE || gRfuState->reqActiveCommand == RFU_DATA_TX_AND_CHANGE || gRfuState->reqActiveCommand == RFU_UNK35 || gRfuState->reqActiveCommand == RFU_RESUME_RETRANSMIT_AND_CHANGE) + { + gRfuState->error = 1; + gRfuState->unk_2c = 0; + if (gRfuState->callbackM) + gRfuState->callbackM(gRfuState->reqActiveCommand, gRfuState->error); + } + else + { + gRfuState->error = 1; + gRfuState->unk_2c = 0; + if (gRfuState->callbackM) + gRfuState->callbackM(gRfuState->reqActiveCommand, gRfuState->error); + gRfuState->state = 4; // TODO: what's 4 + } + } + return 0; +} + +static s32 STWI_reset_ClockCounter(void) +{ + gRfuState->state = 5; // TODO: what is 5 + gRfuState->reqLength = 0; + gRfuState->reqNext = 0; + REG_SIODATA32 = (1 << 31); + REG_SIOCNT = 0; + REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; + REG_SIOCNT = (SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS) + 0x7F; + return 0; +} -- cgit v1.2.3 From 973cb394b23002acde7d7ea19abc754019dd106c Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Sun, 29 Dec 2019 06:24:26 +0800 Subject: librfu through 0x81E13F0 --- src/agb_flash.c | 2 +- src/librfu_rfu.c | 736 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/librfu_stwi.c | 21 +- 3 files changed, 748 insertions(+), 11 deletions(-) create mode 100644 src/librfu_rfu.c (limited to 'src') diff --git a/src/agb_flash.c b/src/agb_flash.c index 5b171abcb..7eb4ae737 100644 --- a/src/agb_flash.c +++ b/src/agb_flash.c @@ -74,7 +74,7 @@ u16 SetFlashTimerIntr(u8 timerNum, void (**intrFunc)(void)) return 1; sTimerNum = timerNum; - sTimerReg = ®_TMCNT(sTimerNum); + sTimerReg = ®_TMCNT_L(sTimerNum); *intrFunc = FlashTimerIntr; return 0; } diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c new file mode 100644 index 000000000..96f4e9519 --- /dev/null +++ b/src/librfu_rfu.c @@ -0,0 +1,736 @@ +#include "global.h" +#include "librfu.h" + +void rfu_CB_defaultCallback(u8, u16); +void rfu_CB_reset(u8, u16); +void rfu_CB_configGameData(u8, u16); +void rfu_CB_stopMode(u8, u16); +void rfu_CB_startSearchChild(u8, u16); +void rfu_CB_pollAndEndSearchChild(u8, u16); +void rfu_CB_startSearchParent(u8, u16); +void rfu_CB_pollSearchParent(u8, u16); +void rfu_CB_pollConnectParent(u8, u16); +void rfu_CB_pollConnectParent(u8, u16); +s32 sub_81E349C(u8); +void rfu_enableREQCallback(bool8); +void rfu_STC_readChildList(void); +void rfu_STC_readParentCandidateList(void); +void rfu_STC_REQ_callback(u8, u16); +void rfu_STC_removeLinkData(u8, u8); +void rfu_STC_fastCopy(u8 **a1, u8 **a2, s32 a3); +void rfu_STC_clearLinkStatus(u8); +void rfu_NI_checkCommFailCounter(void); + +extern const char _Str_RFU_MBOOT[]; + +struct RfuStruct *gRfuState; +ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[4]; +struct RfuSlotStatusNI *gRfuSlotStatusNI[4]; +struct RfuLinkStatus *gRfuLinkStatus; +struct RfuStatic *gRfuStatic; +struct RfuFixed *gRfuFixed; +ALIGNED(8) struct Unk_3007470 gUnknown_3007470; + +u16 rfu_initializeAPI(struct Unk_3001190 *unk0, u16 unk1, IntrFunc *interrupt, bool8 copyInterruptToRam) +{ + u16 i; + u16 *dst; + const u16 *src; + u16 r3; + + // is in EWRAM? + if (((u32)unk0 & 0xF000000) == 0x2000000 && copyInterruptToRam) + return 2; + // is not 4-byte aligned? + if ((u32)unk0 & 3) + return 2; + // Nintendo pls, just use a ternary for once + if (copyInterruptToRam) + { + // An assert/debug print may have existed before, ie + // printf("%s %u < %u", "somefile.c:12345", unk1, num) + // to push this into r3? + r3 = 0xe64; + if (unk1 < r3) + return 1; + } + if (!copyInterruptToRam) + { + r3 = 0x504; // same as above, this should be r3 not r0 + if (unk1 < r3) + return 1; + } + gRfuLinkStatus = &unk0->linkStatus; + gRfuStatic = &unk0->static_; + gRfuFixed = &unk0->fixed; + gRfuSlotStatusNI[0] = &unk0->NI[0]; + gRfuSlotStatusUNI[0] = &unk0->UNI[0]; + for (i = 1; i < NELEMS(gRfuSlotStatusNI); ++i) + { + gRfuSlotStatusNI[i] = &gRfuSlotStatusNI[i - 1][1]; + gRfuSlotStatusUNI[i] = &gRfuSlotStatusUNI[i - 1][1]; + } + // TODO: Is it possible to fix the following 2 statements? + // It's equivalent to: + // gRfuFixed->STWIBuffer = &unk0->intr; + // STWI_init_all(&unk0->intr, interrupt, copyInterruptToRam); + gRfuFixed->STWIBuffer = (struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1]; + STWI_init_all((struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1], interrupt, copyInterruptToRam); + rfu_STC_clearAPIVariables(); + for (i = 0; i < NELEMS(gRfuSlotStatusNI); ++i) + { + gRfuSlotStatusNI[i]->recvBuffer = 0; + gRfuSlotStatusNI[i]->recvBufferSize = 0; + gRfuSlotStatusUNI[i]->recvBuffer = 0; + gRfuSlotStatusUNI[i]->recvBufferSize = 0; + } + src = (const u16 *)((u32)&rfu_STC_fastCopy & ~1); + dst = gRfuFixed->fastCopyBuffer; + // rfu_REQ_changeMasterSlave is the function next to rfu_STC_fastCopy + for (r3 = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16), --r3; r3 != 0xFFFF; --r3) + *dst++ = *src++; + gRfuFixed->fastCopyPtr = (u8 *)gRfuFixed->fastCopyBuffer + 1; + return 0; +} + +void rfu_STC_clearAPIVariables(void) +{ + u16 IMEBackup = REG_IME; + u8 i, r4; + + REG_IME = 0; + r4 = gRfuStatic->flags; + CpuFill16(0, gRfuStatic, sizeof(struct RfuStatic)); + gRfuStatic->flags = r4 & 8; + CpuFill16(0, gRfuLinkStatus, sizeof(struct RfuLinkStatus)); + gRfuLinkStatus->watchInterval = 4; + gRfuStatic->nowWatchInterval = 0; + gRfuLinkStatus->connMode = 0xFF; + rfu_clearAllSlot(); + gRfuStatic->SCStartFlag = 0; + for (i = 0; i < NELEMS(gRfuStatic->cidBak); ++i) + gRfuStatic->cidBak[i] = 0; + REG_IME = IMEBackup; +} + +void rfu_REQ_PARENT_resumeRetransmitAndChange(void) +{ + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_ResumeRetransmitAndChangeREQ(); +} + +u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) +{ + struct RfuIntrStruct *buf; + *ackFlag = 0; + if (gRfuLinkStatus->connMode != 1) + return 0x300; + buf = rfu_getSTWIRecvBuffer(); + switch (buf->rxPacketAlloc.rfuPacket8.data[0]) + { + case 40: + case 54: + if (buf->rxPacketAlloc.rfuPacket8.data[1] == 0) + *ackFlag = gRfuLinkStatus->connSlotFlag; + else + *ackFlag = buf->rxPacketAlloc.rfuPacket8.data[4]; + return 0; + default: + return 0x10; + } +} + +void rfu_setTimerInterrupt(u8 which, IntrFunc *intr) +{ + STWI_init_timer(intr, which); +} + +struct RfuIntrStruct *rfu_getSTWIRecvBuffer(void) +{ + return gRfuFixed->STWIBuffer; +} + +void rfu_setMSCCallback(void (*callback)(u16)) +{ + STWI_set_Callback_S(callback); +} + +void rfu_setREQCallback(void (*callback)(u16, u16)) +{ + gRfuFixed->reqCallback = callback; + rfu_enableREQCallback(callback != NULL); +} + +void rfu_enableREQCallback(bool8 enable) +{ + if (enable) + gRfuStatic->flags |= 8; + else + gRfuStatic->flags &= 0xF7; +} + +void rfu_STC_REQ_callback(u8 r5, u16 reqResult) +{ + STWI_set_Callback_M(rfu_CB_defaultCallback); + gRfuStatic->reqResult = reqResult; + if (gRfuStatic->flags & 8) + gRfuFixed->reqCallback(r5, reqResult); +} + +void rfu_CB_defaultCallback(u8 r0, u16 reqResult) +{ + s32 r5; + u8 i; + + if (r0 == 0xFF) + { + if (gRfuStatic->flags & 8) + gRfuFixed->reqCallback(r0, reqResult); + r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + for (i = 0; i < 4; ++i) + if ((r5 >> i) & 1) + rfu_STC_removeLinkData(i, 1); + gRfuLinkStatus->connMode = 0xFF; + } +} + +u16 rfu_waitREQComplete(void) +{ + STWI_poll_CommandEnd(); + return gRfuStatic->reqResult; +} + +void rfu_REQ_RFUStatus(void) +{ + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_SystemStatusREQ(); +} + +u32 rfu_getRFUStatus(u8 *status) +{ + if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] != 0x93) + return 0x10; + if (STWI_poll_CommandEnd() == 0) + *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7]; + else + *status = 0xFF; + return 0; +} + +s32 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) +{ + const char *s1 = _Str_RFU_MBOOT; + char *s2 = (char *)0x30000F0; + u16 checksum; + u16 *r2; + u8 i; + + while (*s1 != '\0') + if (*s1++ != *s2++) + return 1; + r2 = (u16 *)0x3000000; + checksum = 0; + for (i = 0; i < 90; ++i) + checksum += *r2++; + if (checksum != *(u16 *)0x30000FA) + return 1; + CpuCopy16((u16 *)0x3000000, gRfuLinkStatus, sizeof(struct RfuLinkStatus)); + gRfuStatic->flags |= 0x80; + return 0; +} + +void rfu_REQ_stopMode(void) +{ + vu32 *timerReg; + + if (REG_IME == 0) + { + rfu_STC_REQ_callback(61, 6); + gRfuState->error = 6; + } + else + { + AgbRFU_SoftReset(); + rfu_STC_clearAPIVariables(); + if (sub_81E349C(8) == 0x8001) + { + timerReg = ®_TMCNT(gRfuState->timerSelect); + *timerReg = 0; + *timerReg = (TIMER_ENABLE | TIMER_1024CLK) << 16; + while (*timerReg << 16 < 262 << 16) + ; + *timerReg = 0; + STWI_set_Callback_M(rfu_CB_stopMode); + STWI_send_StopModeREQ(); + } + else + { + REG_SIOCNT = SIO_MULTI_MODE; + rfu_STC_REQ_callback(61, 0); + } + } +} + +void rfu_CB_stopMode(u8 a1, u16 reqResult) +{ + if (reqResult == 0) + REG_SIOCNT = SIO_MULTI_MODE; + rfu_STC_REQ_callback(a1, reqResult); +} + +s32 rfu_REQBN_softReset_and_checkID(void) +{ + s32 r2; + + if (REG_IME == 0) + return -1; + AgbRFU_SoftReset(); + rfu_STC_clearAPIVariables(); + if ((r2 = sub_81E349C(30)) == 0) + REG_SIOCNT = SIO_MULTI_MODE; + return r2; +} + +void rfu_REQ_reset(void) +{ + STWI_set_Callback_M(rfu_CB_reset); + STWI_send_ResetREQ(); +} + +void rfu_CB_reset(u8 a1, u16 reqResult) +{ + if (reqResult == 0) + rfu_STC_clearAPIVariables(); + rfu_STC_REQ_callback(a1, reqResult); +} + +void rfu_REQ_configSystem(u16 r4, u8 r5, u8 r6) +{ + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_SystemConfigREQ((r4 & 3) | 0x3C, r5, r6); + if (r6 == 0) + { + gRfuStatic->unk_1a = 1; + } + else + { + u16 IMEBackup = REG_IME; + + REG_IME = 0; + gRfuStatic->unk_1a = Div(600, r6); + REG_IME = IMEBackup; + } +} + +void rfu_REQ_configGameData(u8 r6, u16 r2, const u8 *r4, const u8 *r7) +{ + u8 sp[16]; + u8 i; + u8 r3; + const u8 *r5 = r4; + const u8 *r1; + + sp[0] = r2; + sp[1] = r2 >> 8; + if (r6 != 0) + sp[1] = (r2 >> 8) | 0x80; + for (i = 2; i < 15; ++i) + sp[i] = *r4++; + r3 = 0; + r1 = r7; + for (i = 0; i < 8; ++i) + { + r3 += *r1++; + r3 += *r5++; + } + sp[15] = ~r3; + if (r6 != 0) + sp[14] = 0; + STWI_set_Callback_M(rfu_CB_configGameData); + STWI_send_GameConfigREQ(sp, r7); +} + +void rfu_CB_configGameData(u8 ip, u16 r7) +{ + s32 r2, r3; + u8 *r4; + u8 i; + u8 *r1; + + if (r7 == 0) + { + r1 = gRfuState->txPacket->rfuPacket8.data; + r2 = gRfuLinkStatus->my.serialNum = r1[4]; + gRfuLinkStatus->my.serialNum = (r1[5] << 8) | r2; + r4 = &r1[6]; + if (gRfuLinkStatus->my.serialNum & 0x8000) + { + gRfuLinkStatus->my.serialNum = gRfuLinkStatus->my.serialNum ^ 0x8000; + gRfuLinkStatus->my.multibootFlag = 1; + } + else + { + gRfuLinkStatus->my.multibootFlag = 0; + } + for (i = 0; i < NELEMS(gRfuLinkStatus->my.gname) - 2; ++i) + gRfuLinkStatus->my.gname[i] = *r4++; + ++r4; + for (i = 0; i < NELEMS(gRfuLinkStatus->my.uname) - 1; ++i) + gRfuLinkStatus->my.uname[i] = *r4++; + } + rfu_STC_REQ_callback(ip, r7); +} + +void rfu_REQ_startSearchChild(void) +{ + u16 r1; + + STWI_set_Callback_M(rfu_CB_defaultCallback); + STWI_send_SystemStatusREQ(); + r1 = STWI_poll_CommandEnd(); + if (r1 == 0) + { + if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) + rfu_STC_clearLinkStatus(1); + } + else + { + rfu_STC_REQ_callback(25, r1); + } + STWI_set_Callback_M(rfu_CB_startSearchChild); + STWI_send_SC_StartREQ(); +} + +void rfu_CB_startSearchChild(u8 r3, u16 reqResult) +{ + if (reqResult == 0) + gRfuStatic->SCStartFlag = 1; + rfu_STC_REQ_callback(r3, reqResult); +} + +void rfu_STC_clearLinkStatus(u8 r4) +{ + u8 i; + + rfu_clearAllSlot(); + if (r4 != 0) + { + CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); + gRfuLinkStatus->findParentCount = 0; + } + for (i = 0; i < NELEMS(gRfuLinkStatus->strength); ++i) + gRfuLinkStatus->strength[i] = 0; + gRfuLinkStatus->connCount = 0; + gRfuLinkStatus->connSlotFlag = 0; + gRfuLinkStatus->linkLossSlotFlag = 0; + gRfuLinkStatus->getNameFlag = 0; +} + +void rfu_REQ_pollSearchChild(void) +{ + STWI_set_Callback_M(rfu_CB_pollAndEndSearchChild); + STWI_send_SC_PollingREQ(); +} + +void rfu_REQ_endSearchChild(void) +{ + STWI_set_Callback_M(rfu_CB_pollAndEndSearchChild); + STWI_send_SC_EndREQ(); +} + +void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) +{ + if (reqResult == 0) + rfu_STC_readChildList(); + if (r4 == 26) + { + if (gRfuLinkStatus->my.id == 0) + { + STWI_set_Callback_M(rfu_CB_defaultCallback); + STWI_send_SystemStatusREQ(); + if (STWI_poll_CommandEnd() == 0) + gRfuLinkStatus->my.id = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; + } + } + else if (r4 == 27) + { + if (gRfuLinkStatus->connMode == 255) + gRfuLinkStatus->my.id = 0; + gRfuStatic->SCStartFlag = 0; + } + rfu_STC_REQ_callback(r4, reqResult); +} + +void rfu_STC_readChildList(void) +{ + u32 r5; + u8 r8 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]; + u8 *r4; + u8 i; + u8 sp[4]; + u8 r2; + + if (r8 != 0) + { + r5 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; + STWI_set_Callback_M(rfu_CB_defaultCallback); + STWI_send_LinkStatusREQ(); + if (STWI_poll_CommandEnd() == 0) + { + r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + for (i = 0; i < NELEMS(sp); ++i) + sp[i] = *r4++; + } + gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = r5; + } + for (r4 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + r8 != 0; + r4 += 4) + { + r2 = r4[2]; + if (r2 < 4 && !((gRfuLinkStatus->connSlotFlag >> r2) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> r2) & 1)) + { + if (sp[r2] != 0) + ++gRfuStatic->lsFixedCount[r2]; + if (gRfuStatic->lsFixedCount[r2] >= 4) + { + gRfuStatic->lsFixedCount[r2] = 0; + gRfuLinkStatus->strength[r2] = 0xFF; + gRfuLinkStatus->connSlotFlag |= 1 << r2; + ++gRfuLinkStatus->connCount; + gRfuLinkStatus->partner[r2].id = *(u16 *)r4; + gRfuLinkStatus->partner[r2].slot = r2; + gRfuLinkStatus->connMode = 1; + gRfuStatic->flags &= 0x7F; + gRfuStatic->cidBak[r2] = gRfuLinkStatus->partner[r2].id; + } + } + --r8; + } +} + +void rfu_REQ_startSearchParent(void) +{ + STWI_set_Callback_M(rfu_CB_startSearchParent); + STWI_send_SP_StartREQ(); +} + +void rfu_CB_startSearchParent(u8 r5, u16 reqResult) +{ + if (reqResult == 0) + rfu_STC_clearLinkStatus(0); + rfu_STC_REQ_callback(r5, reqResult); +} + +void rfu_REQ_pollSearchParent(void) +{ + STWI_set_Callback_M(rfu_CB_pollSearchParent); + STWI_send_SP_PollingREQ(); +} + +void rfu_CB_pollSearchParent(u8 r5, u16 reqResult) +{ + if (reqResult == 0) + rfu_STC_readParentCandidateList(); + rfu_STC_REQ_callback(r5, reqResult); +} + +void rfu_REQ_endSearchParent(void) +{ + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_SP_EndREQ(); +} + +void rfu_STC_readParentCandidateList(void) +{ + u8 r7, r6, r5, r4, r3; + u8 *r1, *r2; + struct RfuTgtData *r4_; + + CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); + r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0]; + r7 = r2[1]; + r2 += 4; + gRfuLinkStatus->findParentCount = 0; + for (r6 = 0; r6 < 4 && r7 != 0; ++r6) + { + r7 -= 7; + r1 = r2 + 6; + r2 += 19; + r5 = ~*r2; + ++r2; + r4 = 0; + for (r3 = 0; r3 < 8; ++r3) + { + r4 += *r2++; + r4 += *r1++; + } + if (r4 == r5) + { + r2 -= 28; + r4_ = &gRfuLinkStatus->partner[gRfuLinkStatus->findParentCount]; + r4_->id = *(u16 *)r2; + r2 += 2; + r4_->slot = *r2; + r2 += 2; + r4_->serialNum = *(u16 *)r2 & 0x7FFF; + if (*(u16 *)r2 & 0x8000) + r4_->multibootFlag = 1; + else + r4_->multibootFlag = 0; + r2 += 2; + for (r3 = 0; r3 < NELEMS(r4_->gname) - 2; ++r3) + r4_->gname[r3] = *r2++; + ++r2; + for (r3 = 0; r3 < NELEMS(r4_->uname) - 1; ++r3) + r4_->uname[r3] = *r2++; + ++gRfuLinkStatus->findParentCount; + } + } +} + +void rfu_REQ_startConnectParent(u16 r4) +{ + u16 r3 = 0; + u8 i; + for (i = 0; i < NELEMS(gRfuLinkStatus->partner) && gRfuLinkStatus->partner[i].id != r4; ++i) + ; + if (i == 4) + r3 = 256; + if (r3 == 0) + { + gRfuStatic->tryPid = r4; + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_CP_StartREQ(r4); + } + else + { + rfu_STC_REQ_callback(31, r3); + } +} + +void rfu_REQ_pollConnectParent(void) +{ + STWI_set_Callback_M(rfu_CB_pollConnectParent); + STWI_send_CP_PollingREQ(); +} + +void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) +{ + u16 id; + u8 slot; + u8 r2, r5; + struct RfuTgtData *r9; + struct RfuTgtData sp; + + if (sp28 == 0) + { + id = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; + slot = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[6]; + if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) + { + r2 = 1 << slot; + if (!(r2 & gRfuLinkStatus->connSlotFlag)) + { + gRfuLinkStatus->connSlotFlag |= r2; + gRfuLinkStatus->linkLossSlotFlag &= ~r2; + gRfuLinkStatus->my.id = id; + ++gRfuLinkStatus->connCount; + gRfuLinkStatus->connMode = 0; + gRfuStatic->flags |= 0x80; + for (r5 = 0; r5 < NELEMS(gRfuLinkStatus->partner); ++r5) + { + if (gRfuLinkStatus->partner[r5].id == gRfuStatic->tryPid) + { + if (gRfuLinkStatus->findParentCount != 0) + { + r9 = &sp; + CpuCopy16(&gRfuLinkStatus->partner[r5], &sp, sizeof(struct RfuTgtData)); + CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); + gRfuLinkStatus->findParentCount = 0; + } + else + { + r9 = &gRfuLinkStatus->partner[r5]; + } + break; + } + } + if (r5 < 4) + { + CpuCopy16(r9, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData)); + gRfuLinkStatus->partner[slot].slot = slot; + } + } + } + } + rfu_STC_REQ_callback(sp24, sp28); +} + +u16 rfu_getConnectParentStatus(u8 *status, u8 *r1) +{ + u8 r0, *r2; + + *status = 0xFF; + r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; + r0 = r2[0] + 96; + if (r0 <= 1) + { + r2 += 6; + *r1 = r2[0]; + *status = r2[1]; + return 0; + } + return 0x10; +} + +void rfu_REQ_endConnectParent(void) +{ + STWI_set_Callback_M(rfu_CB_pollConnectParent); + STWI_send_CP_EndREQ(); + if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[6] < 4) + gRfuStatic->linkEmergencyFlag[gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[6]] = 0; +} + +u16 rfu_syncVBlank(void) +{ + u8 r3, r4; + s32 r5; + + rfu_NI_checkCommFailCounter(); + if (gRfuLinkStatus->connMode == 0xFF) + return 0; + if (gRfuStatic->nowWatchInterval != 0) + --gRfuStatic->nowWatchInterval; + r3 = rfu_getMasterSlave(); + if (!(gRfuStatic->flags & 2)) + { + if (r3 == 0) + { + gRfuStatic->flags |= 4; + gRfuStatic->watchdogTimer = 360; + } + } + else if (r3 != 0) + { + gRfuStatic->flags &= 0xFB; + } + if (r3 != 0) + gRfuStatic->flags &= 0xFD; + else + gRfuStatic->flags |= 2; + if (!(gRfuStatic->flags & 4)) + return 0; + if (gRfuStatic->watchdogTimer == 0) + { + gRfuStatic->flags &= 0xFB; + r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + for (r4 = 0; r4 < 4; ++r4) + if ((r5 >> r4) & 1) + rfu_STC_removeLinkData(r4, 1); + gRfuLinkStatus->connMode = 0xFF; + return 1; + } + --gRfuStatic->watchdogTimer; + return 0; +} diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c index fe8a4ef76..c8df0ccfa 100644 --- a/src/librfu_stwi.c +++ b/src/librfu_stwi.c @@ -64,7 +64,7 @@ void AgbRFU_SoftReset(void) timerH = ®_TMCNT_H(gRfuState->timerSelect); *timerH = 0; *timerL = 0; - *timerH = 0x83; + *timerH = TIMER_ENABLE | TIMER_1024CLK; while (*timerL <= 0x11) REG_RCNT = 0x80A2; *timerH = 3; @@ -117,12 +117,13 @@ void STWI_init_Callback_S(void) STWI_set_Callback_S(NULL); } -void STWI_set_Callback_M(void (*callbackM)()) +// The callback can take 2 or 3 arguments. +void STWI_set_Callback_M(void *callbackM) { gRfuState->callbackM = callbackM; } -void STWI_set_Callback_S(void (*callbackS)()) +void STWI_set_Callback_S(void (*callbackS)(u16)) { gRfuState->callbackS = callbackS; } @@ -193,7 +194,7 @@ void STWI_send_ConfigStatusREQ(void) } } -void STWI_send_GameConfigREQ(u8 *unk1, u8 *data) +void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data) { u8 *packetBytes; s32 i; @@ -496,7 +497,7 @@ static void STWI_intr_timer(void) gRfuState->timerActive = 1; STWI_stop_timer(); STWI_reset_ClockCounter(); - if (gRfuState->callbackM) + if (gRfuState->callbackM != NULL) gRfuState->callbackM(255, 0); break; } @@ -546,7 +547,7 @@ static u16 STWI_init(u8 request) if (!REG_IME) { gRfuState->error = 6; - if (gRfuState->callbackM) + if (gRfuState->callbackM != NULL) gRfuState->callbackM(request, gRfuState->error); return TRUE; } @@ -554,14 +555,14 @@ static u16 STWI_init(u8 request) { gRfuState->error = 2; gRfuState->unk_2c = FALSE; - if (gRfuState->callbackM) + if (gRfuState->callbackM != NULL) gRfuState->callbackM(request, gRfuState->error); return TRUE; } else if(!gRfuState->msMode) { gRfuState->error = 4; - if (gRfuState->callbackM) + if (gRfuState->callbackM != NULL) gRfuState->callbackM(request, gRfuState->error, gRfuState); return TRUE; } @@ -617,14 +618,14 @@ static s32 STWI_restart_Command(void) { gRfuState->error = 1; gRfuState->unk_2c = 0; - if (gRfuState->callbackM) + if (gRfuState->callbackM != NULL) gRfuState->callbackM(gRfuState->reqActiveCommand, gRfuState->error); } else { gRfuState->error = 1; gRfuState->unk_2c = 0; - if (gRfuState->callbackM) + if (gRfuState->callbackM != NULL) gRfuState->callbackM(gRfuState->reqActiveCommand, gRfuState->error); gRfuState->state = 4; // TODO: what's 4 } -- cgit v1.2.3 From 6cbce0b9668c0fd7e902397e96f9a488b1d6f5a8 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Tue, 31 Dec 2019 06:42:18 +0800 Subject: librfu through 0x81E2C40 --- src/librfu_rfu.c | 1095 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1093 insertions(+), 2 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 96f4e9519..3bfa3b601 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -11,17 +11,31 @@ void rfu_CB_startSearchParent(u8, u16); void rfu_CB_pollSearchParent(u8, u16); void rfu_CB_pollConnectParent(u8, u16); void rfu_CB_pollConnectParent(u8, u16); +void rfu_CB_disconnect(u8, u16); +void rfu_CB_CHILD_pollConnectRecovery(u8, u16); +void rfu_CB_sendData(UNUSED u8, u16); +void rfu_CB_sendData2(UNUSED u8, u16); +void rfu_CB_sendData3(u8, u16); +void rfu_CB_recvData(u8, u16); s32 sub_81E349C(u8); void rfu_enableREQCallback(bool8); void rfu_STC_readChildList(void); void rfu_STC_readParentCandidateList(void); void rfu_STC_REQ_callback(u8, u16); void rfu_STC_removeLinkData(u8, u8); -void rfu_STC_fastCopy(u8 **a1, u8 **a2, s32 a3); +void rfu_STC_fastCopy(const u8 **, u8 **, s32); void rfu_STC_clearLinkStatus(u8); void rfu_NI_checkCommFailCounter(void); +u16 rfu_STC_setSendData_org(u8, u8, u8, const void *, u32); +void rfu_constructSendLLFrame(void); +u16 rfu_STC_NI_constructLLSF(u8, u8 **, struct NIComm *); +u16 rfu_STC_UNI_constructLLSF(u8, u8 **); +void rfu_STC_PARENT_analyzeRecvPacket(void); +void rfu_STC_CHILD_analyzeRecvPacket(void); +u16 rfu_STC_analyzeLLSF(u8, u8 *, u16); extern const char _Str_RFU_MBOOT[]; +extern const u8 _Str_RfuHeader[]; struct RfuStruct *gRfuState; ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[4]; @@ -89,7 +103,7 @@ u16 rfu_initializeAPI(struct Unk_3001190 *unk0, u16 unk1, IntrFunc *interrupt, b // rfu_REQ_changeMasterSlave is the function next to rfu_STC_fastCopy for (r3 = ((void *)rfu_REQ_changeMasterSlave - (void *)rfu_STC_fastCopy) / sizeof(u16), --r3; r3 != 0xFFFF; --r3) *dst++ = *src++; - gRfuFixed->fastCopyPtr = (u8 *)gRfuFixed->fastCopyBuffer + 1; + gRfuFixed->fastCopyPtr = (void *)gRfuFixed->fastCopyBuffer + 1; return 0; } @@ -734,3 +748,1080 @@ u16 rfu_syncVBlank(void) --gRfuStatic->watchdogTimer; return 0; } + +s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) +{ + u8 sp08 = 0; + u8 sp0C = 0; + u8 i; + s32 sp10, sp14; + u8 *r2; + u8 r9, r6, r3, r1, r0; + + *r8 = 0; + *sp00 = 0; + *sp04 = 0; + if (gRfuLinkStatus->connMode == 0xFF || gRfuState->msMode == 0) + return 0; + if (gRfuStatic->flags & 4) + gRfuStatic->watchdogTimer = 360; + if (gRfuStatic->nowWatchInterval == 0) + { + gRfuStatic->nowWatchInterval = gRfuLinkStatus->watchInterval; + sp08 = 1; + } + if ((u8)r5 == 41) + { + u8 *r1 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; + + *r8 = r1[4]; + *sp00 = r1[5]; + if (*sp00 == 1) + *r8 = gRfuLinkStatus->connSlotFlag; + sp08 = 2; + } + else + { + if (r5 == 310) + { + r6 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5]; + r6 ^= gRfuLinkStatus->connSlotFlag; + *r8 = r6 & gRfuLinkStatus->connSlotFlag; + *sp00 = 1; + for (i = 0; i < NELEMS(gRfuLinkStatus->strength); ++i) + { + if ((*r8 >> i) & 1) + { + gRfuLinkStatus->strength[i] = 0; + rfu_STC_removeLinkData(i, 0); + } + } + } + if (sp08 == 0) + return 0; + } + sp10 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command; + sp14 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0]; + STWI_set_Callback_M(rfu_CB_defaultCallback); + STWI_send_LinkStatusREQ(); + sp0C = STWI_poll_CommandEnd(); + if (sp0C == 0) + { + r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + for (i = 0; i < NELEMS(gRfuLinkStatus->strength); ++i) + gRfuLinkStatus->strength[i] = *r2++; + r9 = 0; + i = 0; + } + else + { + rfu_STC_REQ_callback(17, sp0C); + return sp0C; + } + for (; i < 4; ++i) + { + r6 = 1 << i; + if (sp0C == 0) + { + if (sp08 == 1 && (gRfuLinkStatus->connSlotFlag & r6)) + { + if (gRfuLinkStatus->strength[i] == 0) + { + if (gRfuLinkStatus->connMode == 1) + { + ++gRfuStatic->linkEmergencyFlag[i]; + if (gRfuStatic->linkEmergencyFlag[i] > 3) + { + *r8 |= r6; + *sp00 = sp08; // why not directly use 1? + } + } + else + { + STWI_send_SystemStatusREQ(); + if (STWI_poll_CommandEnd() == 0) + { + if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) + { + *r8 |= r6; + *sp00 = sp08; + } + else + { + if (++gRfuStatic->linkEmergencyFlag[i] > gRfuStatic->unk_1a) + { + gRfuStatic->linkEmergencyFlag[i] = 0; + STWI_send_DisconnectREQ(gRfuLinkStatus->connSlotFlag); + STWI_poll_CommandEnd(); + *r8 |= r6; + *sp00 = sp08; // why not directly use 1? + } + } + } + } + } + else + { + gRfuStatic->linkEmergencyFlag[i] = sp0C; // why not directly use 0? + } + } + if (gRfuLinkStatus->connMode == 1 && gRfuLinkStatus->strength[i] != 0) + { + if (r6 & gRfuLinkStatus->linkLossSlotFlag) + { + if (gRfuLinkStatus->strength[i] > 10) + { + *sp04 |= r6; + gRfuLinkStatus->connSlotFlag |= r6; + gRfuLinkStatus->linkLossSlotFlag &= ~r6; + ++gRfuLinkStatus->connCount; + gRfuStatic->linkEmergencyFlag[i] = 0; + } + else + { + gRfuLinkStatus->strength[i] = 0; + } + } + else + { + if (!((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & r6)) + { + STWI_send_SlotStatusREQ(); + STWI_poll_CommandEnd(); + r2 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; + r3 = r2[1] - 1; + for (r2 += 8; r3 != 0; r2 += 4, --r3) + { + u16 r4 = *(u16 *)r2; + + if (r2[2] == i && r4 == gRfuStatic->cidBak[i]) + { + r9 |= 1 << i; + break; + } + } + } + } + } + } + r1 = gRfuLinkStatus->connSlotFlag; + r0 = *r8; + r0 &= r1; + if (r6 & r0) + rfu_STC_removeLinkData(i, 0); + } + if (r9 != 0) + { + STWI_send_DisconnectREQ(r9); + STWI_poll_CommandEnd(); + } + // equivalent to: + // gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.command = sp10; + *(u32 *)gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data = sp10; + gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] = sp14; + return 0; +} + +void rfu_STC_removeLinkData(u8 r7, u8 r12) +{ + u8 r5 = 1 << r7; + s32 r6; + + if ((gRfuLinkStatus->connSlotFlag & r5) && gRfuLinkStatus->connCount != 0) + --gRfuLinkStatus->connCount; + gRfuLinkStatus->connSlotFlag &= r6 = ~r5; + gRfuLinkStatus->linkLossSlotFlag |= r5; + if ((*(u32 *)gRfuLinkStatus & 0xFF00FF) == 0) + gRfuLinkStatus->connMode = 0xFF; + if (r12 != 0) + { + CpuFill16(0, &gRfuLinkStatus->partner[r7], sizeof(struct RfuTgtData)); + gRfuLinkStatus->linkLossSlotFlag &= r6; + gRfuLinkStatus->getNameFlag &= r6; + gRfuLinkStatus->strength[r7] = 0; + } +} + +void rfu_REQ_disconnect(u8 who) +{ + u16 r1; + + if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & who) + { + gRfuStatic->recoveryBmSlot = who; + if (gRfuLinkStatus->connMode == 0xFF && gRfuStatic->flags & 0x80) + { + if (gRfuLinkStatus->linkLossSlotFlag & who) + rfu_CB_disconnect(48, 0); + } + else if (gRfuStatic->SCStartFlag + && (STWI_set_Callback_M(rfu_CB_defaultCallback), + STWI_send_SC_EndREQ(), + (r1 = STWI_poll_CommandEnd()) != 0)) + { + rfu_STC_REQ_callback(27, r1); + } + else + { + STWI_set_Callback_M(rfu_CB_disconnect); + STWI_send_DisconnectREQ(who); + } + } +} + +void rfu_CB_disconnect(u8 r6, u16 r5) +{ + u8 r4, r0; + + if (r5 == 3 && gRfuLinkStatus->connMode == 0) + { + STWI_set_Callback_M(rfu_CB_defaultCallback); + STWI_send_SystemStatusREQ(); + if (STWI_poll_CommandEnd() == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) + r5 = 0; + } + gRfuStatic->recoveryBmSlot &= gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; + gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8] = gRfuStatic->recoveryBmSlot; + if (r5 == 0) + { + for (r4 = 0; r4 < 4; ++r4) + { + r0 = 1 << r4; + if (r0 & gRfuStatic->recoveryBmSlot) + rfu_STC_removeLinkData(r4, 1); + } + } + if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) == 0) + gRfuLinkStatus->connMode = 0xFF; + rfu_STC_REQ_callback(r6, r5); + if (gRfuStatic->SCStartFlag) + { + STWI_set_Callback_M(rfu_CB_defaultCallback); + STWI_send_SC_StartREQ(); + r5 = STWI_poll_CommandEnd(); + if (r5 != 0) + rfu_STC_REQ_callback(25, r5); + } +} + +void rfu_REQ_CHILD_startConnectRecovery(u8 r5) +{ + u8 i; + + gRfuStatic->recoveryBmSlot = r5; + for (i = 0; i < 4 && !((r5 >> i) & 1); ++i) + ; + STWI_set_Callback_M(rfu_STC_REQ_callback); + // if i == 4, gRfuLinkStatus->partner[i].id becomes gRfuLinkStatus->my.id + STWI_send_CPR_StartREQ(gRfuLinkStatus->partner[i].id, gRfuLinkStatus->my.id, r5); +} + +void rfu_REQ_CHILD_pollConnectRecovery(void) +{ + STWI_set_Callback_M(rfu_CB_CHILD_pollConnectRecovery); + STWI_send_CPR_PollingREQ(); +} + +void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7) +{ + u8 r3, r4; + struct RfuLinkStatus *r2; + + if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot) + { + gRfuLinkStatus->connMode = 0; + for (r4 = 0; r4 < NELEMS(gRfuStatic->linkEmergencyFlag); ++r4) + { + r3 = 1 << r4; + r2 = gRfuLinkStatus; // ??? + if (gRfuStatic->recoveryBmSlot & r3 & r2->linkLossSlotFlag) + { + gRfuLinkStatus->connSlotFlag |= r3; + gRfuLinkStatus->linkLossSlotFlag &= ~r3; + ++gRfuLinkStatus->connCount; + gRfuStatic->linkEmergencyFlag[r4] = 0; + } + } + gRfuStatic->recoveryBmSlot = 0; + } + rfu_STC_REQ_callback(r8, r7); +} + +u16 rfu_CHILD_getConnectRecoveryStatus(u8 *status) +{ + u8 r0; + + *status = 0xFF; + r0 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] + 77; + if (r0 <= 1) + { + *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; + return 0; + } + return 0x10; +} + +void rfu_REQ_CHILD_endConnectRecovery(void) +{ + STWI_set_Callback_M(rfu_CB_CHILD_pollConnectRecovery); + STWI_send_CPR_EndREQ(); +} + +void rfu_STC_fastCopy(const u8 **src_p, u8 **dst_p, s32 size) +{ + const u8 *src = *src_p; + u8 *dst = *dst_p; + s32 i; + + for (i = size - 1; i != -1; --i) + *dst++ = *src++; + *src_p = src; + *dst_p = dst; +} + +void rfu_REQ_changeMasterSlave(void) +{ + if (STWI_read_status(1) == 1) + { + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_MS_ChangeREQ(); + } + else + { + rfu_STC_REQ_callback(39, 0); + } +} + +bool8 rfu_getMasterSlave(void) +{ + bool8 r2 = STWI_read_status(1); + + if (r2 == 1) + { + if (gRfuState->unk_2c) + { + if (gRfuState->reqActiveCommand == 39 + || gRfuState->reqActiveCommand == 37 + || gRfuState->reqActiveCommand == 55) + r2 = 0; + } + } + return r2; +} + +void rfu_clearAllSlot(void) +{ + u16 i; + u16 IMEBackup = REG_IME; + + REG_IME = 0; + for (i = 0; i < NELEMS(gRfuSlotStatusNI); ++i) + { + CpuFill16(0, gRfuSlotStatusNI[i], sizeof(gRfuSlotStatusNI[i]->sub)); + CpuFill16(0, gRfuSlotStatusUNI[i], sizeof(gRfuSlotStatusUNI[i]->sub)); + gRfuLinkStatus->remainLLFrameSizeChild[i] = 16; + } + gRfuLinkStatus->remainLLFrameSizeParent = 87; + gRfuLinkStatus->sendSlotNIFlag = 0; + gRfuLinkStatus->recvSlotNIFlag = 0; + gRfuLinkStatus->sendSlotUNIFlag = 0; + gRfuStatic->recvRenewalFlag = 0; + REG_IME = IMEBackup; +} + +void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4) +{ + + if (!(gRfuStatic->flags & 0x80)) + { + if (r3 == 0) + gRfuLinkStatus->remainLLFrameSizeParent += r4->payloadSize; + gRfuLinkStatus->remainLLFrameSizeParent += 3; + } + else + { + if (r3 == 0) + gRfuLinkStatus->remainLLFrameSizeChild[r5] += r4->payloadSize; + gRfuLinkStatus->remainLLFrameSizeChild[r5] += 2; + } +} + +s32 rfu_clearSlot(u8 r8, u8 r7) +{ + u16 r10, r3, r1; + struct NIComm *r4; + + if (r7 > 3) + return 0x400; + if ((r8 & 0xF) == 0) + return 0x600; + r10 = REG_IME; + REG_IME = 0; + if (r8 & 0xC) + { + for (r3 = 0; r3 < 2; ++r3) + { + r4 = NULL; + if (r3 == 0) + { + if (r8 & 4) + { + r4 = &gRfuSlotStatusNI[r7]->sub.send; + gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlotOrg; + } + } + else + { + if (r8 & 8) + { + r4 = &gRfuSlotStatusNI[r7]->sub.recv; + gRfuLinkStatus->recvSlotNIFlag &= ~(1 << r7); + } + } + if (r4 != NULL) + { + if (r4->state & 0x8000) + { + rfu_STC_releaseFrame(r7, r3, r4); + for (r1 = 0; r1 < 4; ++r1) + if ((r4->bmSlotOrg >> r1) & 1) + r4->failCounter = 0; + } + CpuFill16(0, r4, sizeof(struct NIComm)); + } + } + } + if (r8 & 1) + { + struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7]; + + if (r3->sub.send.state & 0x8000) + { + if (!(gRfuStatic->flags & 0x80)) + gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->sub.send.payloadSize; + else + gRfuLinkStatus->remainLLFrameSizeChild[r7] += 2 + (u8)r3->sub.send.payloadSize; + gRfuLinkStatus->sendSlotUNIFlag &= ~r3->sub.send.bmSlot; + } + CpuFill16(0, &r3->sub.send, sizeof(struct UNISend)); + } + if (r8 & 2) + { + CpuFill16(0, &gRfuSlotStatusUNI[r7]->sub.recv, sizeof(struct UNIRecv)); + } + REG_IME = r10; + return 0; +} + +s32 rfu_setRecvBuffer(u8 r3, u8 r4, void *r5, size_t r6) +{ + if (r4 > 3) + return 0x400; + if (r3 & 0x20) + { + gRfuSlotStatusNI[r4]->recvBuffer = r5; + gRfuSlotStatusNI[r4]->recvBufferSize = r6; + } + else if (!(r3 & 0x10)) + { + return 0x600; + } + else + { + gRfuSlotStatusUNI[r4]->recvBuffer = r5; + gRfuSlotStatusUNI[r4]->recvBufferSize = r6; + } + return 0; +} + +s32 rfu_NI_setSendData(u8 a1, u8 a2, const void *a3, u32 a4) +{ + return rfu_STC_setSendData_org(32, a1, a2, a3, a4); +} + +s32 rfu_UNI_setSendData(u8 flag, const void *ptr, u8 size) +{ + u8 r0; + + if (gRfuLinkStatus->connMode == 1) + r0 = size + 3; + else + r0 = size + 2; + return rfu_STC_setSendData_org(16, flag, r0, ptr, 0); +} + +s32 rfu_NI_CHILD_setSendGameName(u8 a1, u8 a2) +{ + return rfu_STC_setSendData_org(64, 1 << a1, a2, &gRfuLinkStatus->my.serialNum, 26); +} + +u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp28) +{ + u8 r2, r0; + u8 r4; + u8 *r9; + u8 r5; + u8 i; + u16 sp04; + struct RfuSlotStatusUNI *r1; + struct RfuSlotStatusNI *r12; + + if (gRfuLinkStatus->connMode == 0xFF) + return 0x301; + if (!(r3 & 0xF)) + return 0x400; + if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & r3) != r3) + return 0x401; + if (r6 & 0x10) + r0 = gRfuLinkStatus->sendSlotUNIFlag; + else + r0 = gRfuLinkStatus->sendSlotNIFlag; + if (r0 & r3) + return 0x402; + for (r2 = 0; r2 < 4 && !((r3 >> r2) & 1); ++r2) + ; + if (gRfuLinkStatus->connMode == 1) + r9 = &gRfuLinkStatus->remainLLFrameSizeParent; + else if (gRfuLinkStatus->connMode == 0) + r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2]; + r4 = _Str_RfuHeader[16 * gRfuLinkStatus->connMode]; + if (r8 > *r9 || r8 <= r4) + return 0x500; + sp04 = REG_IME; + REG_IME = 0; + r5 = r6 & 0x20; + if (r5 || r6 == 0x40) + { + u8 *r1; // a hack to swap instructions + + r12 = gRfuSlotStatusNI[r2]; + r1 = NULL; + r12->sub.send.errorCode = 0; + *r12->sub.send.nowP = r1 = &r12->sub.send.dataType; + r12->sub.send.remainSize = 7; + r12->sub.send.bmSlotOrg = r3; + r12->sub.send.bmSlot = r3; + r12->sub.send.payloadSize = r8 - r4; + if (r5 != 0) + *r1 = 0; + else + *r1 = 1; + r12->sub.send.dataSize = sp28; + r12->sub.send.src = sp00; + r12->sub.send.ack = 0; + r12->sub.send.phase = 0; + #ifndef NONMATCHING // to fix r2, r3, r4, r5 register roulette + asm("":::"r2"); + #endif + for (i = 0; i < NELEMS(r12->sub.send.recvAckFlag); ++i) + { + r12->sub.send.recvAckFlag[i] = 0; + r12->sub.send.n[i] = 1; + } + for (r2 = 0; r2 < NELEMS(gRfuSlotStatusNI); ++r2) + if ((r3 >> r2) & 1) + gRfuSlotStatusNI[r2]->sub.send.failCounter = 0; + gRfuLinkStatus->sendSlotNIFlag |= r3; + *r9 -= r8; + r12->sub.send.state = 0x8021; + } + else if (r6 & 0x10) + { + r1 = gRfuSlotStatusUNI[r2]; + r1->sub.send.bmSlot = r3; + r1->sub.send.src = sp00; + r1->sub.send.payloadSize = r8 - r4; + *r9 -= r8; + r1->sub.send.state = 0x8024; + gRfuLinkStatus->sendSlotUNIFlag |= r3; + } + REG_IME = sp04; + return 0; +} + +s32 rfu_changeSendTarget(u8 r3, u8 r7, u8 r6) +{ + struct RfuSlotStatusNI *r5; + u16 r8; + u8 r2; + + if (r7 >= NELEMS(gRfuSlotStatusNI)) + return 0x400; + if (r3 == 0x20) + { + r5 = gRfuSlotStatusNI[r7]; + if ((r5->sub.send.state & 0x8000) + && (r5->sub.send.state & 0x20)) + { + r3 = r6 ^ r5->sub.send.bmSlot; + + if (!(r3 & r6)) + { + if (r3) + { + r8 = REG_IME; + REG_IME = 0; + for (r2 = 0; r2 < NELEMS(gRfuSlotStatusNI); ++r2) + { + if ((r3 >> r2) & 1) + gRfuSlotStatusNI[r2]->sub.send.failCounter = 0; + } + gRfuLinkStatus->sendSlotNIFlag &= ~r3; + r5->sub.send.bmSlot = r6; + if ((r6 << 24) == 0) // The shift doesn't make any sense. + { + rfu_STC_releaseFrame(r7, 0, &r5->sub.send); + r5->sub.send.state = 39; + } + REG_IME = r8; + } + } + else + { + return 0x404; + } + } + else + { + return 0x403; + } + } + else + { + if (r3 == 16) + { + s32 r3; + + if (gRfuSlotStatusUNI[r7]->sub.send.state != 0x8024) + return 0x403; + for (r3 = 0, r2 = 0; r2 < NELEMS(gRfuSlotStatusUNI); ++r2) + if (r2 != r7) + r3 |= gRfuSlotStatusUNI[r2]->sub.send.bmSlot; + if (r6 & r3) + return 0x404; + r8 = REG_IME; + REG_IME = 0; + gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[r7]->sub.send.bmSlot; + gRfuLinkStatus->sendSlotUNIFlag |= r6; + gRfuSlotStatusUNI[r7]->sub.send.bmSlot = r6; + REG_IME = r8; + } + else + { + return 0x600; + } + } + return 0; +} + +s32 rfu_NI_stopReceivingData(u8 who) +{ +#ifndef NONMATCHING // r4, r5 register swap + register struct NIComm *r5 asm("r5"); +#else + struct NIComm *r5; +#endif + u16 r4, r1; + + if (who > 3) + return 0x400; + r5 = &gRfuSlotStatusNI[who]->sub.recv; + r4 = REG_IME; + REG_IME = 0; + if (gRfuSlotStatusNI[who]->sub.recv.state & 0x8000) + { + if (gRfuSlotStatusNI[who]->sub.recv.state == 0x8043) + gRfuSlotStatusNI[who]->sub.recv.state = 72; + else + gRfuSlotStatusNI[who]->sub.recv.state = 71; + gRfuLinkStatus->recvSlotNIFlag &= ~(1 << who); + rfu_STC_releaseFrame(who, 1, r5); + } + REG_IME = r4; + return 0; +} + +s32 rfu_UNI_changeAndReadySendData(u8 r3, const void *r7, u8 r5) +{ + struct UNISend *r4; + u8 *r6; + u16 r1; + u8 r3_; + + if (r3 >= 4) + return 0x400; + r4 = &gRfuSlotStatusUNI[r3]->sub.send; + if (r4->state != 0x8024) + return 0x403; + if (gRfuLinkStatus->connMode == 1) + { + r6 = &gRfuLinkStatus->remainLLFrameSizeParent; + r3_ = gRfuLinkStatus->remainLLFrameSizeParent + (u8)r4->payloadSize; + } + else + { + r6 = &gRfuLinkStatus->remainLLFrameSizeChild[r3]; + r3_ = gRfuLinkStatus->remainLLFrameSizeChild[r3] + (u8)r4->payloadSize; + } + if (r3_ < r5) + return 0x500; + r1 = REG_IME; + REG_IME = 0; + r4->src = r7; + *r6 = r3_ - r5; + r4->payloadSize = r5; + r4->dataReadyFlag = 1; + REG_IME = r1; + return 0; +} + +void rfu_UNI_readySendData(u8 a1) +{ + if (a1 < NELEMS(gRfuSlotStatusUNI)) + { + if (gRfuSlotStatusUNI[a1]->sub.send.state == 0x8024) + gRfuSlotStatusUNI[a1]->sub.send.dataReadyFlag = 1; + } +} + +void rfu_UNI_clearRecvNewDataFlag(u8 a1) +{ + if (a1 < NELEMS(gRfuSlotStatusUNI)) + gRfuSlotStatusUNI[a1]->sub.recv.newDataFlag = 0; +} + +void rfu_REQ_sendData(u8 r5) +{ + if (gRfuLinkStatus->connMode != 0xFF) + { + if (gRfuLinkStatus->connMode == 1 + && !(gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag)) + { + if (gRfuStatic->commExistFlag) + { + gRfuStatic->emberCount = 16; + gRfuStatic->nullFrameCount = 0; + } + if (gRfuStatic->emberCount) + --gRfuStatic->emberCount; + else + ++gRfuStatic->nullFrameCount; + if (gRfuStatic->emberCount + || !(gRfuStatic->nullFrameCount & 0xF)) + { + gRfuFixed->LLFBuffer[0] = 1; + gRfuFixed->LLFBuffer[4] = 0xFF; + STWI_set_Callback_M(rfu_CB_sendData3); + if (r5 == 0) + STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, 1); + else + STWI_send_DataTxAndChangeREQ(gRfuFixed->LLFBuffer, 1); + return; + } + } + else + { + if (!gRfuLinkStatus->LLFReadyFlag) + rfu_constructSendLLFrame(); + if (gRfuLinkStatus->LLFReadyFlag) + { + STWI_set_Callback_M(rfu_CB_sendData); + if (r5 != 0) + { + STWI_send_DataTxAndChangeREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); + return; + } + STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); + } + } + if (r5 != 0) + { + if (gRfuLinkStatus->connMode == 1) + { + if (gRfuState->callbackS != NULL) + gRfuState->callbackS(39); + } + else + { + STWI_set_Callback_M(rfu_CB_sendData2); + STWI_send_MS_ChangeREQ(); + } + } + } +} + +void rfu_CB_sendData(UNUSED u8 r0, u16 r7) +{ + u8 r6; + struct NIComm *r4; + + if (r7 == 0) + { + for (r6 = 0; r6 < NELEMS(gRfuSlotStatusNI); ++r6) + { + if (gRfuSlotStatusUNI[r6]->sub.send.dataReadyFlag) + gRfuSlotStatusUNI[r6]->sub.send.dataReadyFlag = 0; + r4 = &gRfuSlotStatusNI[r6]->sub.send; + if (r4->state == 0x8020) + { + rfu_STC_releaseFrame(r6, 0, r4); + gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlot; + if (r4->dataType == 1) + gRfuLinkStatus->getNameFlag |= 1 << r6; + r4->state = 38; + } + } + } + gRfuLinkStatus->LLFReadyFlag = 0; + rfu_STC_REQ_callback(36, r7); +} + +void rfu_CB_sendData2(UNUSED u8 r0, u16 r1) +{ + rfu_STC_REQ_callback(36, r1); +} + +void rfu_CB_sendData3(u8 r0, u16 r1) +{ + if (r1 != 0) + rfu_STC_REQ_callback(36, r1); + else if (r0 == 0xFF) + rfu_STC_REQ_callback(0xFF, 0); +} + +void rfu_constructSendLLFrame(void) +{ + u32 r8, r5; + u8 r6; + u8 *sp00; + struct RfuSlotStatusNI *r2; + + if (gRfuLinkStatus->connMode != 0xFF + && gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag) + { + gRfuLinkStatus->LLFReadyFlag = 0; + r8 = 0; + sp00 = (u8 *)&gRfuFixed->LLFBuffer[1]; + for (r6 = 0; r6 < NELEMS(gRfuSlotStatusUNI); ++r6) + { + r5 = 0; + if (gRfuSlotStatusNI[r6]->sub.send.state & 0x8000) + r5 = rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->sub.send); + if (gRfuSlotStatusNI[r6]->sub.recv.state & 0x8000) + r5 += rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->sub.recv); + if (gRfuSlotStatusUNI[r6]->sub.send.state == 0x8024) + r5 += rfu_STC_UNI_constructLLSF(r6, &sp00); + if (r5 != 0) + { + if (gRfuLinkStatus->connMode == 1) + r8 += r5; + else + r8 |= r5 << (5 * r6 + 8); + } + } + if (r8 != 0) + { + while ((u32)sp00 & 3) + *sp00++ = 0; + gRfuFixed->LLFBuffer[0] = r8; + if (gRfuLinkStatus->connMode == 0) + { + u8 *r0 = sp00 - offsetof(struct RfuFixed, LLFBuffer[1]); + + // Does the volatile qualifier make sense? + // It's the same as: + // asm("":::"memory"); + r8 = r0 - *(u8 *volatile *)&gRfuFixed; + } + } + gRfuStatic->totalPacketSize = r8; + } +} + +u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) +{ + u16 r5; + u32 sp00; + u8 i; + u8 *r2; + const u8 *r8 = &_Str_RfuHeader[16 * gRfuLinkStatus->connMode]; + + if (r4->state == 0x8022) + { + while (r4->nowP[r4->phase] >= (const u8 *)r4->src + r4->dataSize) + { + ++r4->phase; + if (r4->phase == 4) + r4->phase = 0; + } + } + if (r4->state & 0x40) + { + r5 = 0; + } + else if (r4->state == 0x8022) + { + if (r4->nowP[r4->phase] + r4->payloadSize > (const u8 *)r4->src + r4->dataSize) + r5 = (const u8 *)r4->src + r4->dataSize - r4->nowP[r4->phase]; + else + r5 = r4->payloadSize; + } + else + { + if (r4->remainSize >= r4->payloadSize) + r5 = r4->payloadSize; + else + r5 = r4->remainSize; + } + sp00 = (r4->state & 0xF) << r8[3] + | r4->ack << r8[4] + | r4->phase << r8[5] + | r4->n[r4->phase] << r8[6] + | r5; + if (gRfuLinkStatus->connMode == 1) + sp00 |= r4->bmSlot << 18; + r2 = (u8 *)&sp00; + for (i = 0; i < *r8; ++i) + *(*r12)++ = *r2++; + if (r5 != 0) + { + const u8 *sp04 = r4->nowP[r4->phase]; + + gRfuFixed->fastCopyPtr(&sp04, r12, r5); + } + if (r4->state == 0x8022) + { + ++r4->phase; + if (r4->phase == 4) + r4->phase = 0; + } + if (gRfuLinkStatus->connMode == 1) + gRfuLinkStatus->LLFReadyFlag = 1; + else + gRfuLinkStatus->LLFReadyFlag |= 1 << r10; + return r5 + *r8; +} + +u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) +{ + const u8 *r5; + const u8 *sp04; + u32 sp00; + u8 *r2; + u8 i; + struct UNISend *r4 = &gRfuSlotStatusUNI[r8]->sub.send; + + if (!r4->dataReadyFlag || !r4->bmSlot) + return 0; + r5 = &_Str_RfuHeader[16 * gRfuLinkStatus->connMode]; + sp00 = (r4->state & 0xF) << r5[3] + | r4->payloadSize; + if (gRfuLinkStatus->connMode == 1) + sp00 |= r4->bmSlot << 18; + r2 = (u8 *)&sp00; + for (i = 0; i < *r5; ++i) + *(*r6)++ = *r2++; + sp04 = r4->src; + gRfuFixed->fastCopyPtr(&sp04, r6, r4->payloadSize); + if (gRfuLinkStatus->connMode == 1) + gRfuLinkStatus->LLFReadyFlag = 16; + else + gRfuLinkStatus->LLFReadyFlag |= 16 << r8; + return *r5 + r4->payloadSize; +} + +void rfu_REQ_recvData(void) +{ + if (gRfuLinkStatus->connMode != 0xFF) + { + gRfuStatic->commExistFlag = gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag; + gRfuStatic->recvErrorFlag = 0; + STWI_set_Callback_M(rfu_CB_recvData); + STWI_send_DataRxREQ(); + } +} + +void rfu_CB_recvData(u8 r9, u16 r7) +{ + u8 r6; + struct RfuSlotStatusNI *r4; + struct NIComm *r5; + + if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]) + { + gRfuStatic->NIEndRecvFlag = 0; + if (gRfuLinkStatus->connMode == 1) + rfu_STC_PARENT_analyzeRecvPacket(); + else + rfu_STC_CHILD_analyzeRecvPacket(); + for (r6 = 0; r6 < NELEMS(gRfuSlotStatusNI); ++r6) + { + r4 = gRfuSlotStatusNI[r6]; + if (r4->sub.recv.state == 0x8043 && !((gRfuStatic->NIEndRecvFlag >> r6) & 1)) + { + r5 = &r4->sub.recv; + if (r5->dataType == 1) + gRfuLinkStatus->getNameFlag |= 1 << r6; + rfu_STC_releaseFrame(r6, 1, r5); + gRfuLinkStatus->recvSlotNIFlag &= ~r5->bmSlot; + r4->sub.recv.state = 70; + } + } + if ( gRfuStatic->recvErrorFlag ) + r7 = gRfuStatic->recvErrorFlag | 0x700; + } + rfu_STC_REQ_callback(r9, r7); +} + +void rfu_STC_PARENT_analyzeRecvPacket(void) +{ + u32 r3; + u8 r5; + u8 sp[4]; + u8 *r6; + + r3 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket32.data[0] >> 8; + for (r5 = 0; r5 < NELEMS(sp); ++r5) + { + sp[r5] = r3 & 0x1F; + r3 >>= 5; + if (sp[r5] == 0) + gRfuStatic->NIEndRecvFlag |= 1 << r5; + } + r6 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8]; + for (r5 = 0; r5 < NELEMS(sp); ++r5) + { + if (sp[r5]) + { + u8 *r4 = &sp[r5]; + + do + { + u8 r0 = rfu_STC_analyzeLLSF(r5, r6, *r4); + + r6 += r0; + *r4 -= r0; + } while (!(*r4 & 0x80) && (*r4)); + } + } +} + +void rfu_STC_CHILD_analyzeRecvPacket(void) +{ + u16 r4; + u8 *r5; + u16 r0; + + r4 = *(u16 *)&gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] & 0x7F; + r5 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8]; + if (r4 == 0) + gRfuStatic->NIEndRecvFlag = 15; + do + { + if (r4 == 0) + break; + r0 = rfu_STC_analyzeLLSF(0, r5, r4); + r5 += r0; + r4 -= r0; + } while (!(r4 & 0x8000)); +} -- cgit v1.2.3 From 5bf8d1c62d6907b44d92f75f4402c4a0dee28a2c Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Wed, 1 Jan 2020 21:46:36 +0800 Subject: fix rfu_STC_analyzeLLSF Co-authored-by: Normmatt --- src/librfu_rfu.c | 175 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 160 insertions(+), 15 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 3bfa3b601..e53aade49 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1,6 +1,35 @@ #include "global.h" #include "librfu.h" +struct RfuHeader +{ + u8 unk00; + u8 unk01; + u8 unk02; + u8 unk03; + u8 unk04; + u8 unk05; + u8 unk06; + u8 unk07; + u8 unk08; + u8 unk09; + u8 unk0A; + u8 unk0B; + u8 unk0C; + u16 unk0E; +}; + +struct RfuTest +{ + u8 unk00; + u8 unk01; + u8 unk02; + u8 unk03; + u8 unk04; + u8 unk05; + u16 unk06; +}; + void rfu_CB_defaultCallback(u8, u16); void rfu_CB_reset(u8, u16); void rfu_CB_configGameData(u8, u16); @@ -19,6 +48,7 @@ void rfu_CB_sendData3(u8, u16); void rfu_CB_recvData(u8, u16); s32 sub_81E349C(u8); void rfu_enableREQCallback(bool8); +void rfu_STC_clearAPIVariables(void); void rfu_STC_readChildList(void); void rfu_STC_readParentCandidateList(void); void rfu_STC_REQ_callback(u8, u16); @@ -32,10 +62,13 @@ u16 rfu_STC_NI_constructLLSF(u8, u8 **, struct NIComm *); u16 rfu_STC_UNI_constructLLSF(u8, u8 **); void rfu_STC_PARENT_analyzeRecvPacket(void); void rfu_STC_CHILD_analyzeRecvPacket(void); -u16 rfu_STC_analyzeLLSF(u8, u8 *, u16); +u16 rfu_STC_analyzeLLSF(u8, const u8 *, u16); +void rfu_STC_UNI_receive(u8, const struct RfuTest *, const u8 *); +void rfu_STC_NI_receive_Receiver(u8, const struct RfuTest *, const u8 *); +void rfu_STC_NI_receive_Sender(u8, u8, const struct RfuTest *, UNUSED const u8 *); extern const char _Str_RFU_MBOOT[]; -extern const u8 _Str_RfuHeader[]; +extern const struct RfuHeader _Str_RfuHeader[2]; struct RfuStruct *gRfuState; ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[4]; @@ -1284,7 +1317,7 @@ u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp28) r9 = &gRfuLinkStatus->remainLLFrameSizeParent; else if (gRfuLinkStatus->connMode == 0) r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2]; - r4 = _Str_RfuHeader[16 * gRfuLinkStatus->connMode]; + r4 = _Str_RfuHeader[gRfuLinkStatus->connMode].unk00; if (r8 > *r9 || r8 <= r4) return 0x500; sp04 = REG_IME; @@ -1644,7 +1677,7 @@ u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) u32 sp00; u8 i; u8 *r2; - const u8 *r8 = &_Str_RfuHeader[16 * gRfuLinkStatus->connMode]; + const struct RfuHeader *r8 = &_Str_RfuHeader[gRfuLinkStatus->connMode]; if (r4->state == 0x8022) { @@ -1673,15 +1706,15 @@ u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) else r5 = r4->remainSize; } - sp00 = (r4->state & 0xF) << r8[3] - | r4->ack << r8[4] - | r4->phase << r8[5] - | r4->n[r4->phase] << r8[6] + sp00 = (r4->state & 0xF) << r8->unk03 + | r4->ack << r8->unk04 + | r4->phase << r8->unk05 + | r4->n[r4->phase] << r8->unk06 | r5; if (gRfuLinkStatus->connMode == 1) sp00 |= r4->bmSlot << 18; r2 = (u8 *)&sp00; - for (i = 0; i < *r8; ++i) + for (i = 0; i < r8->unk00; ++i) *(*r12)++ = *r2++; if (r5 != 0) { @@ -1699,12 +1732,12 @@ u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) gRfuLinkStatus->LLFReadyFlag = 1; else gRfuLinkStatus->LLFReadyFlag |= 1 << r10; - return r5 + *r8; + return r5 + r8->unk00; } u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) { - const u8 *r5; + const struct RfuHeader *r5; const u8 *sp04; u32 sp00; u8 *r2; @@ -1713,13 +1746,13 @@ u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) if (!r4->dataReadyFlag || !r4->bmSlot) return 0; - r5 = &_Str_RfuHeader[16 * gRfuLinkStatus->connMode]; - sp00 = (r4->state & 0xF) << r5[3] + r5 = &_Str_RfuHeader[gRfuLinkStatus->connMode]; + sp00 = (r4->state & 0xF) << r5->unk03 | r4->payloadSize; if (gRfuLinkStatus->connMode == 1) sp00 |= r4->bmSlot << 18; r2 = (u8 *)&sp00; - for (i = 0; i < *r5; ++i) + for (i = 0; i < r5->unk00; ++i) *(*r6)++ = *r2++; sp04 = r4->src; gRfuFixed->fastCopyPtr(&sp04, r6, r4->payloadSize); @@ -1727,7 +1760,7 @@ u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) gRfuLinkStatus->LLFReadyFlag = 16; else gRfuLinkStatus->LLFReadyFlag |= 16 << r8; - return *r5 + r4->payloadSize; + return r5->unk00 + r4->payloadSize; } void rfu_REQ_recvData(void) @@ -1825,3 +1858,115 @@ void rfu_STC_CHILD_analyzeRecvPacket(void) r4 -= r0; } while (!(r4 & 0x8000)); } + +u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) +{ + struct RfuTest sp00; + const struct RfuHeader *r6; + u32 r5; + u8 r4; + u32 r0; + u16 r10; + + r6 = &_Str_RfuHeader[~gRfuLinkStatus->connMode & 1]; + if (r3 < r6->unk00) + return r3; + r5 = 0; + for (r4 = 0; r4 < r6->unk00; ++r4) + r5 |= *r7++ << 8 * r4; + sp00.unk00 = (r5 >> r6->unk01) & r6->unk07; + sp00.unk01 = (r5 >> r6->unk02) & r6->unk08; + sp00.unk02 = (r5 >> r6->unk03) & r6->unk09; + sp00.unk03 = (r5 >> r6->unk04) & r6->unk0A; + sp00.unk04 = (r5 >> r6->unk05) & r6->unk0B; + sp00.unk05 = (r5 >> r6->unk06) & r6->unk0C; + sp00.unk06 = (r5 & r6->unk0E) & r5; + r10 = sp00.unk06 + r6->unk00; + if (sp00.unk00 == 0) + { + if (gRfuLinkStatus->connMode == 1) + { + if ((gRfuLinkStatus->connSlotFlag >> r12) & 1) + { + if (sp00.unk02 == 4) + { + rfu_STC_UNI_receive(r12, &sp00, r7); + } + else if (sp00.unk03 == 0) + { + rfu_STC_NI_receive_Receiver(r12, &sp00, r7); + } + else + { + for (r4 = 0; r4 < NELEMS(gRfuSlotStatusNI); ++r4) + if (((gRfuSlotStatusNI[r4]->sub.send.bmSlot >> r12) & 1) + && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1)) + break; + if (r4 <= 3) + rfu_STC_NI_receive_Sender(r4, r12, &sp00, r7); + } + } + } + else + { + s32 r5 = gRfuLinkStatus->connSlotFlag & sp00.unk01; + + if (r5) + { + for (r4 = 0; r4 < 4; ++r4) + { + if ((r5 >> r4) & 1) + { + if (sp00.unk02 == 4) + rfu_STC_UNI_receive(r4, &sp00, r7); + else if (sp00.unk03 == 0) + rfu_STC_NI_receive_Receiver(r4, &sp00, r7); + else if ((gRfuLinkStatus->sendSlotNIFlag >> r4) & 1) + rfu_STC_NI_receive_Sender(r4, r4, &sp00, r7); + } + } + } + } + } + return r10; +} + +void rfu_STC_UNI_receive(u8 r7, const struct RfuTest *r6, const u8 *sp00) +{ + u8 *sp04; + u32 r2; + struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7]; + struct UNIRecv *r5 = &r3->sub.recv; + + r5->errorCode = 0; + if (gRfuSlotStatusUNI[r7]->recvBufferSize < r6->unk06) + { + r3->sub.recv.state = 73; + r5->errorCode = 0x701; + } + else + { + if (r5->dataBlockFlag) + { + if (r5->newDataFlag) + { + r5->errorCode = 0x709; + goto _081E2F0E; + } + } + else + { + if (r5->newDataFlag) + r5->errorCode = 0x708; + } + r5->state = 0x8042; + r2 = r5->dataSize = r6->unk06; + sp04 = gRfuSlotStatusUNI[r7]->recvBuffer; + gRfuFixed->fastCopyPtr(&sp00, &sp04, r2); + r5->newDataFlag = 1; + r5->state = 0; + } +_081E2F0E: + if (r5->errorCode) + gRfuStatic->recvErrorFlag |= 16 << r7; +} -- cgit v1.2.3 From 1fda78fd0a1b0235ec0ee2db85e5ebbfa9fc50b5 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Thu, 2 Jan 2020 06:19:23 +0800 Subject: k.o. librfu_rfu --- src/librfu_rfu.c | 552 ++++++++++++++++++++++++++++++++++++++++++++++-------- src/librfu_stwi.c | 4 +- 2 files changed, 478 insertions(+), 78 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index e53aade49..140aa353e 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -19,7 +19,7 @@ struct RfuHeader u16 unk0E; }; -struct RfuTest +struct RfuLocalStruct { u8 unk00; u8 unk01; @@ -30,45 +30,51 @@ struct RfuTest u16 unk06; }; -void rfu_CB_defaultCallback(u8, u16); -void rfu_CB_reset(u8, u16); -void rfu_CB_configGameData(u8, u16); -void rfu_CB_stopMode(u8, u16); -void rfu_CB_startSearchChild(u8, u16); -void rfu_CB_pollAndEndSearchChild(u8, u16); -void rfu_CB_startSearchParent(u8, u16); -void rfu_CB_pollSearchParent(u8, u16); -void rfu_CB_pollConnectParent(u8, u16); -void rfu_CB_pollConnectParent(u8, u16); -void rfu_CB_disconnect(u8, u16); -void rfu_CB_CHILD_pollConnectRecovery(u8, u16); -void rfu_CB_sendData(UNUSED u8, u16); -void rfu_CB_sendData2(UNUSED u8, u16); -void rfu_CB_sendData3(u8, u16); -void rfu_CB_recvData(u8, u16); -s32 sub_81E349C(u8); -void rfu_enableREQCallback(bool8); -void rfu_STC_clearAPIVariables(void); -void rfu_STC_readChildList(void); -void rfu_STC_readParentCandidateList(void); -void rfu_STC_REQ_callback(u8, u16); -void rfu_STC_removeLinkData(u8, u8); -void rfu_STC_fastCopy(const u8 **, u8 **, s32); -void rfu_STC_clearLinkStatus(u8); -void rfu_NI_checkCommFailCounter(void); -u16 rfu_STC_setSendData_org(u8, u8, u8, const void *, u32); -void rfu_constructSendLLFrame(void); -u16 rfu_STC_NI_constructLLSF(u8, u8 **, struct NIComm *); -u16 rfu_STC_UNI_constructLLSF(u8, u8 **); -void rfu_STC_PARENT_analyzeRecvPacket(void); -void rfu_STC_CHILD_analyzeRecvPacket(void); -u16 rfu_STC_analyzeLLSF(u8, const u8 *, u16); -void rfu_STC_UNI_receive(u8, const struct RfuTest *, const u8 *); -void rfu_STC_NI_receive_Receiver(u8, const struct RfuTest *, const u8 *); -void rfu_STC_NI_receive_Sender(u8, u8, const struct RfuTest *, UNUSED const u8 *); +static void rfu_CB_defaultCallback(u8, u16); +static void rfu_CB_reset(u8, u16); +static void rfu_CB_configGameData(u8, u16); +static void rfu_CB_stopMode(u8, u16); +static void rfu_CB_startSearchChild(u8, u16); +static void rfu_CB_pollAndEndSearchChild(u8, u16); +static void rfu_CB_startSearchParent(u8, u16); +static void rfu_CB_pollSearchParent(u8, u16); +static void rfu_CB_pollConnectParent(u8, u16); +static void rfu_CB_pollConnectParent(u8, u16); +static void rfu_CB_disconnect(u8, u16); +static void rfu_CB_CHILD_pollConnectRecovery(u8, u16); +static void rfu_CB_sendData(UNUSED u8, u16); +static void rfu_CB_sendData2(UNUSED u8, u16); +static void rfu_CB_sendData3(u8, u16); +static void rfu_CB_recvData(u8, u16); +static s32 sub_81E349C(u8); +static void sub_81E36B8(void); +static void sub_81E3550(void); +static s32 sub_81E35C4(void); +static void rfu_enableREQCallback(bool8); +static void rfu_STC_clearAPIVariables(void); +static void rfu_STC_readChildList(void); +static void rfu_STC_readParentCandidateList(void); +static void rfu_STC_REQ_callback(u8, u16); +static void rfu_STC_removeLinkData(u8, u8); +static void rfu_STC_fastCopy(const u8 **, u8 **, s32); +static void rfu_STC_clearLinkStatus(u8); +static void rfu_NI_checkCommFailCounter(void); +static u16 rfu_STC_setSendData_org(u8, u8, u8, const void *, u32); +static void rfu_constructSendLLFrame(void); +static u16 rfu_STC_NI_constructLLSF(u8, u8 **, struct NIComm *); +static u16 rfu_STC_UNI_constructLLSF(u8, u8 **); +static void rfu_STC_PARENT_analyzeRecvPacket(void); +static void rfu_STC_CHILD_analyzeRecvPacket(void); +static u16 rfu_STC_analyzeLLSF(u8, const u8 *, u16); +static void rfu_STC_UNI_receive(u8, const struct RfuLocalStruct *, const u8 *); +static void rfu_STC_NI_receive_Receiver(u8, const struct RfuLocalStruct *, const u8 *); +static void rfu_STC_NI_receive_Sender(u8, u8, const struct RfuLocalStruct *, UNUSED const u8 *); +static void rfu_STC_NI_initSlot_asRecvDataEntity(u8, struct NIComm *); +static void rfu_STC_NI_initSlot_asRecvControllData(u8, struct NIComm *); extern const char _Str_RFU_MBOOT[]; extern const struct RfuHeader _Str_RfuHeader[2]; +extern const u16 _Str_Sio32ID[]; struct RfuStruct *gRfuState; ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[4]; @@ -91,7 +97,6 @@ u16 rfu_initializeAPI(struct Unk_3001190 *unk0, u16 unk1, IntrFunc *interrupt, b // is not 4-byte aligned? if ((u32)unk0 & 3) return 2; - // Nintendo pls, just use a ternary for once if (copyInterruptToRam) { // An assert/debug print may have existed before, ie @@ -140,7 +145,7 @@ u16 rfu_initializeAPI(struct Unk_3001190 *unk0, u16 unk1, IntrFunc *interrupt, b return 0; } -void rfu_STC_clearAPIVariables(void) +static void rfu_STC_clearAPIVariables(void) { u16 IMEBackup = REG_IME; u8 i, r4; @@ -169,6 +174,7 @@ void rfu_REQ_PARENT_resumeRetransmitAndChange(void) u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) { struct RfuIntrStruct *buf; + *ackFlag = 0; if (gRfuLinkStatus->connMode != 1) return 0x300; @@ -208,7 +214,7 @@ void rfu_setREQCallback(void (*callback)(u16, u16)) rfu_enableREQCallback(callback != NULL); } -void rfu_enableREQCallback(bool8 enable) +static void rfu_enableREQCallback(bool8 enable) { if (enable) gRfuStatic->flags |= 8; @@ -216,7 +222,7 @@ void rfu_enableREQCallback(bool8 enable) gRfuStatic->flags &= 0xF7; } -void rfu_STC_REQ_callback(u8 r5, u16 reqResult) +static void rfu_STC_REQ_callback(u8 r5, u16 reqResult) { STWI_set_Callback_M(rfu_CB_defaultCallback); gRfuStatic->reqResult = reqResult; @@ -224,7 +230,7 @@ void rfu_STC_REQ_callback(u8 r5, u16 reqResult) gRfuFixed->reqCallback(r5, reqResult); } -void rfu_CB_defaultCallback(u8 r0, u16 reqResult) +static void rfu_CB_defaultCallback(u8 r0, u16 reqResult) { s32 r5; u8 i; @@ -264,7 +270,7 @@ u32 rfu_getRFUStatus(u8 *status) return 0; } -s32 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) +static s32 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) { const char *s1 = _Str_RFU_MBOOT; char *s2 = (char *)0x30000F0; @@ -318,7 +324,7 @@ void rfu_REQ_stopMode(void) } } -void rfu_CB_stopMode(u8 a1, u16 reqResult) +static void rfu_CB_stopMode(u8 a1, u16 reqResult) { if (reqResult == 0) REG_SIOCNT = SIO_MULTI_MODE; @@ -344,7 +350,7 @@ void rfu_REQ_reset(void) STWI_send_ResetREQ(); } -void rfu_CB_reset(u8 a1, u16 reqResult) +static void rfu_CB_reset(u8 a1, u16 reqResult) { if (reqResult == 0) rfu_STC_clearAPIVariables(); @@ -397,7 +403,7 @@ void rfu_REQ_configGameData(u8 r6, u16 r2, const u8 *r4, const u8 *r7) STWI_send_GameConfigREQ(sp, r7); } -void rfu_CB_configGameData(u8 ip, u16 r7) +static void rfu_CB_configGameData(u8 ip, u16 r7) { s32 r2, r3; u8 *r4; @@ -448,14 +454,14 @@ void rfu_REQ_startSearchChild(void) STWI_send_SC_StartREQ(); } -void rfu_CB_startSearchChild(u8 r3, u16 reqResult) +static void rfu_CB_startSearchChild(u8 r3, u16 reqResult) { if (reqResult == 0) gRfuStatic->SCStartFlag = 1; rfu_STC_REQ_callback(r3, reqResult); } -void rfu_STC_clearLinkStatus(u8 r4) +static void rfu_STC_clearLinkStatus(u8 r4) { u8 i; @@ -485,7 +491,7 @@ void rfu_REQ_endSearchChild(void) STWI_send_SC_EndREQ(); } -void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) +static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) { if (reqResult == 0) rfu_STC_readChildList(); @@ -508,7 +514,7 @@ void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) rfu_STC_REQ_callback(r4, reqResult); } -void rfu_STC_readChildList(void) +static void rfu_STC_readChildList(void) { u32 r5; u8 r8 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]; @@ -562,7 +568,7 @@ void rfu_REQ_startSearchParent(void) STWI_send_SP_StartREQ(); } -void rfu_CB_startSearchParent(u8 r5, u16 reqResult) +static void rfu_CB_startSearchParent(u8 r5, u16 reqResult) { if (reqResult == 0) rfu_STC_clearLinkStatus(0); @@ -575,7 +581,7 @@ void rfu_REQ_pollSearchParent(void) STWI_send_SP_PollingREQ(); } -void rfu_CB_pollSearchParent(u8 r5, u16 reqResult) +static void rfu_CB_pollSearchParent(u8 r5, u16 reqResult) { if (reqResult == 0) rfu_STC_readParentCandidateList(); @@ -588,7 +594,7 @@ void rfu_REQ_endSearchParent(void) STWI_send_SP_EndREQ(); } -void rfu_STC_readParentCandidateList(void) +static void rfu_STC_readParentCandidateList(void) { u8 r7, r6, r5, r4, r3; u8 *r1, *r2; @@ -662,7 +668,7 @@ void rfu_REQ_pollConnectParent(void) STWI_send_CP_PollingREQ(); } -void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) +static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) { u16 id; u8 slot; @@ -955,7 +961,7 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) return 0; } -void rfu_STC_removeLinkData(u8 r7, u8 r12) +static void rfu_STC_removeLinkData(u8 r7, u8 r12) { u8 r5 = 1 << r7; s32 r6; @@ -1002,7 +1008,7 @@ void rfu_REQ_disconnect(u8 who) } } -void rfu_CB_disconnect(u8 r6, u16 r5) +static void rfu_CB_disconnect(u8 r6, u16 r5) { u8 r4, r0; @@ -1055,7 +1061,7 @@ void rfu_REQ_CHILD_pollConnectRecovery(void) STWI_send_CPR_PollingREQ(); } -void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7) +static void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7) { u8 r3, r4; struct RfuLinkStatus *r2; @@ -1100,7 +1106,7 @@ void rfu_REQ_CHILD_endConnectRecovery(void) STWI_send_CPR_EndREQ(); } -void rfu_STC_fastCopy(const u8 **src_p, u8 **dst_p, s32 size) +static void rfu_STC_fastCopy(const u8 **src_p, u8 **dst_p, s32 size) { const u8 *src = *src_p; u8 *dst = *dst_p; @@ -1162,7 +1168,7 @@ void rfu_clearAllSlot(void) REG_IME = IMEBackup; } -void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4) +static void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4) { if (!(gRfuStatic->flags & 0x80)) @@ -1288,7 +1294,7 @@ s32 rfu_NI_CHILD_setSendGameName(u8 a1, u8 a2) return rfu_STC_setSendData_org(64, 1 << a1, a2, &gRfuLinkStatus->my.serialNum, 26); } -u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp28) +static u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp28) { u8 r2, r0; u8 r4; @@ -1401,7 +1407,7 @@ s32 rfu_changeSendTarget(u8 r3, u8 r7, u8 r6) } gRfuLinkStatus->sendSlotNIFlag &= ~r3; r5->sub.send.bmSlot = r6; - if ((r6 << 24) == 0) // The shift doesn't make any sense. + if (r5->sub.send.bmSlot == 0) { rfu_STC_releaseFrame(r7, 0, &r5->sub.send); r5->sub.send.state = 39; @@ -1583,7 +1589,7 @@ void rfu_REQ_sendData(u8 r5) } } -void rfu_CB_sendData(UNUSED u8 r0, u16 r7) +static void rfu_CB_sendData(UNUSED u8 r0, u16 r7) { u8 r6; struct NIComm *r4; @@ -1609,12 +1615,12 @@ void rfu_CB_sendData(UNUSED u8 r0, u16 r7) rfu_STC_REQ_callback(36, r7); } -void rfu_CB_sendData2(UNUSED u8 r0, u16 r1) +static void rfu_CB_sendData2(UNUSED u8 r0, u16 r1) { rfu_STC_REQ_callback(36, r1); } -void rfu_CB_sendData3(u8 r0, u16 r1) +static void rfu_CB_sendData3(u8 r0, u16 r1) { if (r1 != 0) rfu_STC_REQ_callback(36, r1); @@ -1622,7 +1628,7 @@ void rfu_CB_sendData3(u8 r0, u16 r1) rfu_STC_REQ_callback(0xFF, 0); } -void rfu_constructSendLLFrame(void) +static void rfu_constructSendLLFrame(void) { u32 r8, r5; u8 r6; @@ -1671,7 +1677,7 @@ void rfu_constructSendLLFrame(void) } } -u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) +static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) { u16 r5; u32 sp00; @@ -1701,7 +1707,7 @@ u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) } else { - if (r4->remainSize >= r4->payloadSize) + if ((u32)r4->remainSize >= r4->payloadSize) r5 = r4->payloadSize; else r5 = r4->remainSize; @@ -1735,7 +1741,7 @@ u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) return r5 + r8->unk00; } -u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) +static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) { const struct RfuHeader *r5; const u8 *sp04; @@ -1774,7 +1780,7 @@ void rfu_REQ_recvData(void) } } -void rfu_CB_recvData(u8 r9, u16 r7) +static void rfu_CB_recvData(u8 r9, u16 r7) { u8 r6; struct RfuSlotStatusNI *r4; @@ -1800,13 +1806,13 @@ void rfu_CB_recvData(u8 r9, u16 r7) r4->sub.recv.state = 70; } } - if ( gRfuStatic->recvErrorFlag ) + if (gRfuStatic->recvErrorFlag) r7 = gRfuStatic->recvErrorFlag | 0x700; } rfu_STC_REQ_callback(r9, r7); } -void rfu_STC_PARENT_analyzeRecvPacket(void) +static void rfu_STC_PARENT_analyzeRecvPacket(void) { u32 r3; u8 r5; @@ -1839,7 +1845,7 @@ void rfu_STC_PARENT_analyzeRecvPacket(void) } } -void rfu_STC_CHILD_analyzeRecvPacket(void) +static void rfu_STC_CHILD_analyzeRecvPacket(void) { u16 r4; u8 *r5; @@ -1859,9 +1865,9 @@ void rfu_STC_CHILD_analyzeRecvPacket(void) } while (!(r4 & 0x8000)); } -u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) +static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) { - struct RfuTest sp00; + struct RfuLocalStruct sp00; const struct RfuHeader *r6; u32 r5; u8 r4; @@ -1900,7 +1906,7 @@ u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) { for (r4 = 0; r4 < NELEMS(gRfuSlotStatusNI); ++r4) if (((gRfuSlotStatusNI[r4]->sub.send.bmSlot >> r12) & 1) - && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1)) + && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1)) break; if (r4 <= 3) rfu_STC_NI_receive_Sender(r4, r12, &sp00, r7); @@ -1931,7 +1937,7 @@ u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) return r10; } -void rfu_STC_UNI_receive(u8 r7, const struct RfuTest *r6, const u8 *sp00) +static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 *sp00) { u8 *sp04; u32 r2; @@ -1970,3 +1976,397 @@ _081E2F0E: if (r5->errorCode) gRfuStatic->recvErrorFlag |= 16 << r7; } + +static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct *r6, const u8 *r3) +{ + struct NIComm *r12 = &gRfuSlotStatusNI[r0]->sub.send; + u16 r9 = r12->state; + u8 sp00 = r12->n[r6->unk04]; + u8 *r8; + u8 r4; + u16 r2; + + if ((r6->unk02 == 2 && r9 == 0x8022) + || (r6->unk02 == 1 && r9 == 0x8021) + || (r6->unk02 == 3 && r9 == 0x8023)) + { + if (r12->n[r6->unk04] == r6->unk05) + r12->recvAckFlag[r6->unk04] |= 1 << r10; + } + if ((r12->recvAckFlag[r6->unk04] & r12->bmSlot) == r12->bmSlot) + { + r12->n[r6->unk04] = (r12->n[r6->unk04] + 1) & 3; + r12->recvAckFlag[r6->unk04] = 0; + if ((u16)(r12->state + ~0x8020) <= 1) + { + if (r12->state == 0x8021) + r12->nowP[r6->unk04] += r12->payloadSize; + else + r12->nowP[r6->unk04] += r12->payloadSize << 2; + r12->remainSize -= r12->payloadSize; + if (r12->remainSize != 0) + if (r12->remainSize >= 0) + goto _081E30AE; + // Above is a hack to avoid optimization over comparison. + // rfu_STC_NI_constructLLSF uses this field as u32. + // It's equivalent to the following condition: + // if (r12->remainSize == 0 || r12->remainSize < 0) + { + r12->phase = 0; + if (r12->state == 0x8021) + { + for (r4 = 0; r4 < NELEMS(r12->n); ++r4) + { + r12->n[r4] = 1; + r12->nowP[r4] = r12->src + r12->payloadSize * r4; + } + r12->remainSize = r12->dataSize; + r12->state = 0x8022; + } + else + { + r12->n[0] = 0; + r12->remainSize = 0; + r12->state = 0x8023; + } + } + _081E30AE: + } + else if (r12->state == 0x8023) + { + r12->state = 0x8020; + } + } + if (r12->state != r9 + || r12->n[r6->unk04] != sp00 + || (r12->recvAckFlag[r6->unk04] >> r10) & 1) + { + r2 = REG_IME; + REG_IME = 0; + gRfuStatic->recvRenewalFlag |= 16 << r10; + gRfuSlotStatusNI[r10]->sub.send.failCounter = 0; + REG_IME = r2; + } +} + +static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, const u8 *sp00) +{ + u16 r2; + u32 r7 = 0; + struct RfuSlotStatusNI *r4 = gRfuSlotStatusNI[r8]; + struct NIComm *r5 = &r4->sub.recv; + u16 r9 = r4->sub.recv.state; + u8 r10 = r4->sub.recv.n[r6->unk04]; + + if (r6->unk02 == 3) + { + gRfuStatic->NIEndRecvFlag |= 1 << r8; + if (r4->sub.recv.state == 0x8042) + { + r4->sub.recv.phase = 0; + r4->sub.recv.n[0] = 0; + r4->sub.recv.state = 0x8043; + } + } + else if (r6->unk02 == 2) + { + if (r9 == 0x8041 && !r5->remainSize) + rfu_STC_NI_initSlot_asRecvDataEntity(r8, r5); + if (r5->state == 0x8042) + r7 = 1; + } + else if (r6->unk02 == 1) + { + if (r9 == 0x8041) + { + r7 = 1; + } + else + { + rfu_STC_NI_initSlot_asRecvControllData(r8, r5); + if (r4->sub.recv.state != 0x8041) + return; + r7 = 1; + } + } + if (r7 != 0) + { + if (r6->unk05 == ((r5->n[r6->unk04] + 1) & 3)) + { + gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->nowP[r6->unk04], r6->unk06); + if (r5->state == 0x8042) + r5->nowP[r6->unk04] += 3 * r5->payloadSize; + r5->remainSize -= r6->unk06; + r5->n[r6->unk04] = r6->unk05; + } + } + if (r5->errorCode == 0) + { + r5->phase = r6->unk04; + if (r5->state != r9 || r5->n[r6->unk04] != r10 || r5->n[r6->unk04] == r6->unk05) + { + r2 = REG_IME; + REG_IME = 0; + gRfuStatic->recvRenewalFlag |= 1 << r8; + r5->failCounter = 0; + REG_IME = r2; + } + } +} + +static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) +{ + u8 *r1; + u32 r5; + u8 r6; + + if (gRfuLinkStatus->connMode == 1) + { + r5 = 3; + r1 = &gRfuLinkStatus->remainLLFrameSizeParent; + } + else + { + r5 = 2; + r1 = &gRfuLinkStatus->remainLLFrameSizeChild[r4]; + } + r6 = 1 << r4; + if (r2->state == 0) + { + if (*r1 < r5) + { + r2->state = 73; + r2->errorCode = 0x702; + gRfuStatic->recvErrorFlag |= r6; + } + else + { + r2->errorCode = 0; + *r1 -= r5; + r2->nowP[0] = &r2->dataType; + r2->remainSize = 7; + r2->ack = 1; + r2->payloadSize = 0; + r2->bmSlot = r6; + r2->state = 0x8041; + gRfuLinkStatus->recvSlotNIFlag |= r6; + } + } +} + +static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4) +{ + u8 r1, r3; + + if (r4->dataType == 1) + { + r4->nowP[0] = (void *)&gRfuLinkStatus->partner[r5].serialNum; + } + else + { + if (r4->dataSize > gRfuSlotStatusNI[r5]->recvBufferSize) + { + r1 = 1 << r5; + gRfuStatic->recvErrorFlag |= r1; + gRfuLinkStatus->recvSlotNIFlag &= ~r1; + r4->errorCode = 0x701; + r4->state = 71; + rfu_STC_releaseFrame(r5, 1, r4); + return; + } + r4->nowP[0] = gRfuSlotStatusNI[r5]->recvBuffer; + } + for (r3 = 0; r3 < 4; ++r3) + { + r4->n[r3] = 0; + r4->nowP[r3] = &r4->nowP[0][r4->payloadSize * r3]; + } + r4->remainSize = r4->dataSize; + r4->state = 0x8042; +} + +static void rfu_NI_checkCommFailCounter(void) +{ + u16 r12; + u32 r7; + u8 r2, r3; + + if (gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag) + { + r12 = REG_IME; + REG_IME = 0; + r7 = gRfuStatic->recvRenewalFlag >> 4; + for (r3 = 0; r3 < NELEMS(gRfuSlotStatusNI); ++r3) + { + r2 = 1 << r3; + if (gRfuLinkStatus->sendSlotNIFlag & r2 + && !(gRfuStatic->recvRenewalFlag & r2)) + ++gRfuSlotStatusNI[r3]->sub.send.failCounter; + if (gRfuLinkStatus->recvSlotNIFlag & r2 + && !(r7 & r2)) + ++gRfuSlotStatusNI[r3]->sub.recv.failCounter; + } + gRfuStatic->recvRenewalFlag = 0; + REG_IME = r12; + } +} + +void rfu_REQ_noise(void) +{ + STWI_set_Callback_M(rfu_STC_REQ_callback); + STWI_send_TestModeREQ(1, 0); +} + +static s32 sub_81E349C(u8 r5) +{ + u16 r8; + vu16 *r4; + s32 r6; + + if (REG_IME == 0) + return -1; + r8 = REG_IE; + gRfuState->state = 10; + STWI_set_CallbackUnk(sub_81E36B8); + sub_81E3550(); + r4 = ®_TMCNT_L(gRfuState->timerSelect); + r5 *= 8; + while (--r5 != 0xFF) + { + r6 = sub_81E35C4(); + if (r6 != 0) + break; + r4[1] = 0; + r4[0] = 0; + r4[1] = TIMER_1024CLK | TIMER_ENABLE; + while (r4[0] < 32) + ; + r4[1] = 0; + r4[0] = 0; + } + REG_IME = 0; + REG_IE = r8; + REG_IME = 1; + gRfuState->state = 0; + STWI_set_CallbackUnk(NULL); + return r6; +} + +static void sub_81E3550(void) +{ + REG_IME = 0; + REG_IE &= ~((8 << gRfuState->timerSelect) | INTR_FLAG_SERIAL); + REG_IME = 1; + REG_RCNT = 0; + REG_SIOCNT = SIO_32BIT_MODE; + REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; + CpuFill32(0, &gUnknown_3007470, sizeof(struct Unk_3007470)); + REG_IF = INTR_FLAG_SERIAL; +} + +static s32 sub_81E35C4(void) +{ + u8 r12; + + switch (r12 = gUnknown_3007470.unk1) + { + case 0: + gUnknown_3007470.unk0 = 1; + REG_SIOCNT |= SIO_38400_BPS; + REG_IME = r12; + REG_IE |= INTR_FLAG_SERIAL; + REG_IME = 1; + gUnknown_3007470.unk1 = 1; + *(vu8 *)®_SIOCNT |= SIO_ENABLE; + break; + case 1: + if (gUnknown_3007470.unkA == 0) + { + if (gUnknown_3007470.unk0 == 1) + { + if (gUnknown_3007470.unk2 == 0) + { + REG_IME = gUnknown_3007470.unk2; + REG_SIOCNT |= SIO_ENABLE; + REG_IME = r12; + } + } + else if (gUnknown_3007470.unk4 != 0x8001 && !gUnknown_3007470.unk2) + { + REG_IME = gUnknown_3007470.unk2; + REG_IE &= ~INTR_FLAG_SERIAL; + REG_IME = r12; + REG_SIOCNT = gUnknown_3007470.unk2; + REG_SIOCNT = SIO_32BIT_MODE; + REG_IF = INTR_FLAG_SERIAL; + REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; + REG_IME = gUnknown_3007470.unk2; + REG_IE |= INTR_FLAG_SERIAL; + REG_IME = r12; + } + break; + } + else + { + gUnknown_3007470.unk1 = 2; + // fallthrough + } + default: + return gUnknown_3007470.unkA; + } + return 0; +} + +static void sub_81E36B8(void) +{ + u32 r5; + u16 r0; +#ifndef NONMATCHING + register u32 r1 asm("a2"); + register u16 r0_ asm("a1"); +#else + u32 r1; + u16 r0_; +#endif + + r5 = REG_SIODATA32; + if (gUnknown_3007470.unk0 != 1) + REG_SIOCNT |= SIO_ENABLE; + r1 = 16 * gUnknown_3007470.unk0; // to handle side effect of inline asm + r1 = (r5 << r1) >> 16; + r5 = (r5 << 16 * (1 - gUnknown_3007470.unk0)) >> 16; + if (gUnknown_3007470.unkA == 0) + { + if (r1 == gUnknown_3007470.unk6) + { + if (gUnknown_3007470.unk2 > 3) + { + gUnknown_3007470.unkA = r5; + } + else if (r1 == (u16)~gUnknown_3007470.unk4) + { + r0_ = ~gUnknown_3007470.unk6; + if (r5 == r0_) + ++gUnknown_3007470.unk2; + } + } + else + { + gUnknown_3007470.unk2 = gUnknown_3007470.unkA; + } + } + if (gUnknown_3007470.unk2 < 4) + gUnknown_3007470.unk4 = *(gUnknown_3007470.unk2 + _Str_Sio32ID); + else + gUnknown_3007470.unk4 = 0x8001; + gUnknown_3007470.unk6 = ~r5; + REG_SIODATA32 = (gUnknown_3007470.unk4 << 16 * (1 - gUnknown_3007470.unk0)) + + (gUnknown_3007470.unk6 << 16 * gUnknown_3007470.unk0); + if (gUnknown_3007470.unk0 == 1 && (gUnknown_3007470.unk2 || r5 == 0x494E)) + { + for (r0 = 0; r0 < 600; ++r0) + ; + if (gUnknown_3007470.unkA == 0) + REG_SIOCNT |= SIO_ENABLE; + } +} diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c index c8df0ccfa..c6c3441ec 100644 --- a/src/librfu_stwi.c +++ b/src/librfu_stwi.c @@ -128,9 +128,9 @@ void STWI_set_Callback_S(void (*callbackS)(u16)) gRfuState->callbackS = callbackS; } -void STWI_set_Callback_ID(u32 id) +void STWI_set_CallbackUnk(void (*func)(void)) { - gRfuState->callbackId = id; + gRfuState->unk_20 = func; } u16 STWI_poll_CommandEnd(void) -- cgit v1.2.3 From a7ec7175f1eadf79ab6cb4efbde1b9694535806f Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Tue, 7 Jan 2020 12:09:18 +0800 Subject: resolve a fake match --- src/librfu_rfu.c | 13 +++++-------- src/librfu_stwi.c | 2 +- 2 files changed, 6 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 140aa353e..6a4fee158 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1455,17 +1455,14 @@ s32 rfu_changeSendTarget(u8 r3, u8 r7, u8 r6) s32 rfu_NI_stopReceivingData(u8 who) { -#ifndef NONMATCHING // r4, r5 register swap - register struct NIComm *r5 asm("r5"); -#else struct NIComm *r5; -#endif u16 r4, r1; if (who > 3) return 0x400; r5 = &gRfuSlotStatusNI[who]->sub.recv; r4 = REG_IME; + ++r4; --r4; // fix r4, r5 register swap REG_IME = 0; if (gRfuSlotStatusNI[who]->sub.recv.state & 0x8000) { @@ -2227,7 +2224,7 @@ static s32 sub_81E349C(u8 r5) return -1; r8 = REG_IE; gRfuState->state = 10; - STWI_set_CallbackUnk(sub_81E36B8); + STWI_set_Callback_ID(sub_81E36B8); sub_81E3550(); r4 = ®_TMCNT_L(gRfuState->timerSelect); r5 *= 8; @@ -2248,7 +2245,7 @@ static s32 sub_81E349C(u8 r5) REG_IE = r8; REG_IME = 1; gRfuState->state = 0; - STWI_set_CallbackUnk(NULL); + STWI_set_Callback_ID(NULL); return r6; } @@ -2322,8 +2319,8 @@ static void sub_81E36B8(void) u32 r5; u16 r0; #ifndef NONMATCHING - register u32 r1 asm("a2"); - register u16 r0_ asm("a1"); + register u32 r1 asm("r1"); + register u16 r0_ asm("r0"); #else u32 r1; u16 r0_; diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c index c6c3441ec..8e27c04d8 100644 --- a/src/librfu_stwi.c +++ b/src/librfu_stwi.c @@ -128,7 +128,7 @@ void STWI_set_Callback_S(void (*callbackS)(u16)) gRfuState->callbackS = callbackS; } -void STWI_set_CallbackUnk(void (*func)(void)) +void STWI_set_Callback_ID(void (*func)(void)) // name in SDK, but is actually setting a function pointer { gRfuState->unk_20 = func; } -- cgit v1.2.3 From f12c1edf3f626fd608b837c125514768f264dc2c Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Fri, 10 Jan 2020 02:13:35 +0800 Subject: update documentation & func types --- src/librfu_rfu.c | 787 +++++++++++++++++++++-------------------------------- src/librfu_s32id.c | 163 +++++++++++ src/librfu_stwi.c | 67 +++-- 3 files changed, 509 insertions(+), 508 deletions(-) create mode 100644 src/librfu_s32id.c (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 6a4fee158..7e4e26fad 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1,4 +1,3 @@ -#include "global.h" #include "librfu.h" struct RfuHeader @@ -46,10 +45,6 @@ static void rfu_CB_sendData(UNUSED u8, u16); static void rfu_CB_sendData2(UNUSED u8, u16); static void rfu_CB_sendData3(u8, u16); static void rfu_CB_recvData(u8, u16); -static s32 sub_81E349C(u8); -static void sub_81E36B8(void); -static void sub_81E3550(void); -static s32 sub_81E35C4(void); static void rfu_enableREQCallback(bool8); static void rfu_STC_clearAPIVariables(void); static void rfu_STC_readChildList(void); @@ -74,17 +69,15 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8, struct NIComm *); extern const char _Str_RFU_MBOOT[]; extern const struct RfuHeader _Str_RfuHeader[2]; -extern const u16 _Str_Sio32ID[]; -struct RfuStruct *gRfuState; -ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[4]; -struct RfuSlotStatusNI *gRfuSlotStatusNI[4]; +struct STWIStatus *gRfuState; +ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[RFU_CHILD_MAX]; +struct RfuSlotStatusNI *gRfuSlotStatusNI[RFU_CHILD_MAX]; struct RfuLinkStatus *gRfuLinkStatus; struct RfuStatic *gRfuStatic; struct RfuFixed *gRfuFixed; -ALIGNED(8) struct Unk_3007470 gUnknown_3007470; -u16 rfu_initializeAPI(struct Unk_3001190 *unk0, u16 unk1, IntrFunc *interrupt, bool8 copyInterruptToRam) +u16 rfu_initializeAPI(struct RfuStructsBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam) { u16 i; u16 *dst; @@ -92,44 +85,44 @@ u16 rfu_initializeAPI(struct Unk_3001190 *unk0, u16 unk1, IntrFunc *interrupt, b u16 r3; // is in EWRAM? - if (((u32)unk0 & 0xF000000) == 0x2000000 && copyInterruptToRam) + if (((u32)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam) return 2; // is not 4-byte aligned? - if ((u32)unk0 & 3) + if ((u32)APIBuffer & 3) return 2; if (copyInterruptToRam) { // An assert/debug print may have existed before, ie - // printf("%s %u < %u", "somefile.c:12345", unk1, num) + // printf("%s %u < %u", "somefile.c:12345", buffByteSize, num) // to push this into r3? r3 = 0xe64; - if (unk1 < r3) + if (buffByteSize < r3) return 1; } if (!copyInterruptToRam) { r3 = 0x504; // same as above, this should be r3 not r0 - if (unk1 < r3) + if (buffByteSize < r3) return 1; } - gRfuLinkStatus = &unk0->linkStatus; - gRfuStatic = &unk0->static_; - gRfuFixed = &unk0->fixed; - gRfuSlotStatusNI[0] = &unk0->NI[0]; - gRfuSlotStatusUNI[0] = &unk0->UNI[0]; - for (i = 1; i < NELEMS(gRfuSlotStatusNI); ++i) + gRfuLinkStatus = &APIBuffer->linkStatus; + gRfuStatic = &APIBuffer->static_; + gRfuFixed = &APIBuffer->fixed; + gRfuSlotStatusNI[0] = &APIBuffer->NI[0]; + gRfuSlotStatusUNI[0] = &APIBuffer->UNI[0]; + for (i = 1; i < RFU_CHILD_MAX; ++i) { gRfuSlotStatusNI[i] = &gRfuSlotStatusNI[i - 1][1]; gRfuSlotStatusUNI[i] = &gRfuSlotStatusUNI[i - 1][1]; } // TODO: Is it possible to fix the following 2 statements? // It's equivalent to: - // gRfuFixed->STWIBuffer = &unk0->intr; - // STWI_init_all(&unk0->intr, interrupt, copyInterruptToRam); + // gRfuFixed->STWIBuffer = &APIBuffer->intr; + // STWI_init_all(&APIBuffer->intr, sioIntrTable_p, copyInterruptToRam); gRfuFixed->STWIBuffer = (struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1]; - STWI_init_all((struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1], interrupt, copyInterruptToRam); + STWI_init_all((struct RfuIntrStruct *)&gRfuSlotStatusUNI[3][1], sioIntrTable_p, copyInterruptToRam); rfu_STC_clearAPIVariables(); - for (i = 0; i < NELEMS(gRfuSlotStatusNI); ++i) + for (i = 0; i < RFU_CHILD_MAX; ++i) { gRfuSlotStatusNI[i]->recvBuffer = 0; gRfuSlotStatusNI[i]->recvBufferSize = 0; @@ -157,7 +150,7 @@ static void rfu_STC_clearAPIVariables(void) CpuFill16(0, gRfuLinkStatus, sizeof(struct RfuLinkStatus)); gRfuLinkStatus->watchInterval = 4; gRfuStatic->nowWatchInterval = 0; - gRfuLinkStatus->connMode = 0xFF; + gRfuLinkStatus->parentChild = 0xFF; rfu_clearAllSlot(); gRfuStatic->SCStartFlag = 0; for (i = 0; i < NELEMS(gRfuStatic->cidBak); ++i) @@ -176,7 +169,7 @@ u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) struct RfuIntrStruct *buf; *ackFlag = 0; - if (gRfuLinkStatus->connMode != 1) + if (gRfuLinkStatus->parentChild != 1) return 0x300; buf = rfu_getSTWIRecvBuffer(); switch (buf->rxPacketAlloc.rfuPacket8.data[0]) @@ -193,9 +186,9 @@ u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) } } -void rfu_setTimerInterrupt(u8 which, IntrFunc *intr) +void rfu_setTimerInterrupt(u8 timerNo, IntrFunc *timerIntrTable_p) { - STWI_init_timer(intr, which); + STWI_init_timer(timerIntrTable_p, timerNo); } struct RfuIntrStruct *rfu_getSTWIRecvBuffer(void) @@ -203,12 +196,12 @@ struct RfuIntrStruct *rfu_getSTWIRecvBuffer(void) return gRfuFixed->STWIBuffer; } -void rfu_setMSCCallback(void (*callback)(u16)) +void rfu_setMSCCallback(void (*callback)(u16 reqCommandId)) { STWI_set_Callback_S(callback); } -void rfu_setREQCallback(void (*callback)(u16, u16)) +void rfu_setREQCallback(void (*callback)(u16 reqCommandId, u16 reqResult)) { gRfuFixed->reqCallback = callback; rfu_enableREQCallback(callback != NULL); @@ -243,7 +236,7 @@ static void rfu_CB_defaultCallback(u8 r0, u16 reqResult) for (i = 0; i < 4; ++i) if ((r5 >> i) & 1) rfu_STC_removeLinkData(i, 1); - gRfuLinkStatus->connMode = 0xFF; + gRfuLinkStatus->parentChild = 0xFF; } } @@ -259,18 +252,18 @@ void rfu_REQ_RFUStatus(void) STWI_send_SystemStatusREQ(); } -u32 rfu_getRFUStatus(u8 *status) +u16 rfu_getRFUStatus(u8 *rfuState) { if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] != 0x93) return 0x10; if (STWI_poll_CommandEnd() == 0) - *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7]; + *rfuState = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7]; else - *status = 0xFF; + *rfuState = 0xFF; return 0; } -static s32 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) +u16 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) { const char *s1 = _Str_RFU_MBOOT; char *s2 = (char *)0x30000F0; @@ -305,7 +298,7 @@ void rfu_REQ_stopMode(void) { AgbRFU_SoftReset(); rfu_STC_clearAPIVariables(); - if (sub_81E349C(8) == 0x8001) + if (AgbRFU_checkID(8) == 0x8001) { timerReg = ®_TMCNT(gRfuState->timerSelect); *timerReg = 0; @@ -331,7 +324,7 @@ static void rfu_CB_stopMode(u8 a1, u16 reqResult) rfu_STC_REQ_callback(a1, reqResult); } -s32 rfu_REQBN_softReset_and_checkID(void) +u32 rfu_REQBN_softReset_and_checkID(void) { s32 r2; @@ -339,7 +332,7 @@ s32 rfu_REQBN_softReset_and_checkID(void) return -1; AgbRFU_SoftReset(); rfu_STC_clearAPIVariables(); - if ((r2 = sub_81E349C(30)) == 0) + if ((r2 = AgbRFU_checkID(30)) == 0) REG_SIOCNT = SIO_MULTI_MODE; return r2; } @@ -357,11 +350,11 @@ static void rfu_CB_reset(u8 a1, u16 reqResult) rfu_STC_REQ_callback(a1, reqResult); } -void rfu_REQ_configSystem(u16 r4, u8 r5, u8 r6) +void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer) { STWI_set_Callback_M(rfu_STC_REQ_callback); - STWI_send_SystemConfigREQ((r4 & 3) | 0x3C, r5, r6); - if (r6 == 0) + STWI_send_SystemConfigREQ((availSlotFlag & 3) | 0x3C, maxMFrame, mcTimer); + if (mcTimer == 0) { gRfuStatic->unk_1a = 1; } @@ -370,37 +363,37 @@ void rfu_REQ_configSystem(u16 r4, u8 r5, u8 r6) u16 IMEBackup = REG_IME; REG_IME = 0; - gRfuStatic->unk_1a = Div(600, r6); + gRfuStatic->unk_1a = Div(600, mcTimer); REG_IME = IMEBackup; } } -void rfu_REQ_configGameData(u8 r6, u16 r2, const u8 *r4, const u8 *r7) +void rfu_REQ_configGameData(u8 mbootFlag, u16 serialNo, const u8 *gname, const u8 *uname) { u8 sp[16]; u8 i; u8 r3; - const u8 *r5 = r4; - const u8 *r1; + const u8 *gnameBackup = gname; + const u8 *unameBackup; - sp[0] = r2; - sp[1] = r2 >> 8; - if (r6 != 0) - sp[1] = (r2 >> 8) | 0x80; + sp[0] = serialNo; + sp[1] = serialNo >> 8; + if (mbootFlag != 0) + sp[1] = (serialNo >> 8) | 0x80; for (i = 2; i < 15; ++i) - sp[i] = *r4++; + sp[i] = *gname++; r3 = 0; - r1 = r7; + unameBackup = uname; for (i = 0; i < 8; ++i) { - r3 += *r1++; - r3 += *r5++; + r3 += *unameBackup++; + r3 += *gnameBackup++; } sp[15] = ~r3; - if (r6 != 0) + if (mbootFlag != 0) sp[14] = 0; STWI_set_Callback_M(rfu_CB_configGameData); - STWI_send_GameConfigREQ(sp, r7); + STWI_send_GameConfigREQ(sp, uname); } static void rfu_CB_configGameData(u8 ip, u16 r7) @@ -413,22 +406,22 @@ static void rfu_CB_configGameData(u8 ip, u16 r7) if (r7 == 0) { r1 = gRfuState->txPacket->rfuPacket8.data; - r2 = gRfuLinkStatus->my.serialNum = r1[4]; - gRfuLinkStatus->my.serialNum = (r1[5] << 8) | r2; + r2 = gRfuLinkStatus->my.serialNo = r1[4]; + gRfuLinkStatus->my.serialNo = (r1[5] << 8) | r2; r4 = &r1[6]; - if (gRfuLinkStatus->my.serialNum & 0x8000) + if (gRfuLinkStatus->my.serialNo & 0x8000) { - gRfuLinkStatus->my.serialNum = gRfuLinkStatus->my.serialNum ^ 0x8000; - gRfuLinkStatus->my.multibootFlag = 1; + gRfuLinkStatus->my.serialNo = gRfuLinkStatus->my.serialNo ^ 0x8000; + gRfuLinkStatus->my.mbootFlag = 1; } else { - gRfuLinkStatus->my.multibootFlag = 0; + gRfuLinkStatus->my.mbootFlag = 0; } - for (i = 0; i < NELEMS(gRfuLinkStatus->my.gname) - 2; ++i) + for (i = 0; i < RFU_GAME_NAME_LENGTH; ++i) gRfuLinkStatus->my.gname[i] = *r4++; ++r4; - for (i = 0; i < NELEMS(gRfuLinkStatus->my.uname) - 1; ++i) + for (i = 0; i < RFU_USER_NAME_LENGTH; ++i) gRfuLinkStatus->my.uname[i] = *r4++; } rfu_STC_REQ_callback(ip, r7); @@ -471,7 +464,7 @@ static void rfu_STC_clearLinkStatus(u8 r4) CpuFill16(0, gRfuLinkStatus->partner, sizeof(gRfuLinkStatus->partner)); gRfuLinkStatus->findParentCount = 0; } - for (i = 0; i < NELEMS(gRfuLinkStatus->strength); ++i) + for (i = 0; i < RFU_CHILD_MAX; ++i) gRfuLinkStatus->strength[i] = 0; gRfuLinkStatus->connCount = 0; gRfuLinkStatus->connSlotFlag = 0; @@ -507,7 +500,7 @@ static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) } else if (r4 == 27) { - if (gRfuLinkStatus->connMode == 255) + if (gRfuLinkStatus->parentChild == 255) gRfuLinkStatus->my.id = 0; gRfuStatic->SCStartFlag = 0; } @@ -553,7 +546,7 @@ static void rfu_STC_readChildList(void) ++gRfuLinkStatus->connCount; gRfuLinkStatus->partner[r2].id = *(u16 *)r4; gRfuLinkStatus->partner[r2].slot = r2; - gRfuLinkStatus->connMode = 1; + gRfuLinkStatus->parentChild = 1; gRfuStatic->flags &= 0x7F; gRfuStatic->cidBak[r2] = gRfuLinkStatus->partner[r2].id; } @@ -626,35 +619,35 @@ static void rfu_STC_readParentCandidateList(void) r2 += 2; r4_->slot = *r2; r2 += 2; - r4_->serialNum = *(u16 *)r2 & 0x7FFF; + r4_->serialNo = *(u16 *)r2 & 0x7FFF; if (*(u16 *)r2 & 0x8000) - r4_->multibootFlag = 1; + r4_->mbootFlag = 1; else - r4_->multibootFlag = 0; + r4_->mbootFlag = 0; r2 += 2; - for (r3 = 0; r3 < NELEMS(r4_->gname) - 2; ++r3) + for (r3 = 0; r3 < RFU_GAME_NAME_LENGTH; ++r3) r4_->gname[r3] = *r2++; ++r2; - for (r3 = 0; r3 < NELEMS(r4_->uname) - 1; ++r3) + for (r3 = 0; r3 < RFU_USER_NAME_LENGTH; ++r3) r4_->uname[r3] = *r2++; ++gRfuLinkStatus->findParentCount; } } } -void rfu_REQ_startConnectParent(u16 r4) +void rfu_REQ_startConnectParent(u16 pid) { u16 r3 = 0; u8 i; - for (i = 0; i < NELEMS(gRfuLinkStatus->partner) && gRfuLinkStatus->partner[i].id != r4; ++i) + for (i = 0; i < RFU_CHILD_MAX && gRfuLinkStatus->partner[i].id != pid; ++i) ; if (i == 4) r3 = 256; if (r3 == 0) { - gRfuStatic->tryPid = r4; + gRfuStatic->tryPid = pid; STWI_set_Callback_M(rfu_STC_REQ_callback); - STWI_send_CP_StartREQ(r4); + STWI_send_CP_StartREQ(pid); } else { @@ -689,9 +682,9 @@ static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) gRfuLinkStatus->linkLossSlotFlag &= ~r2; gRfuLinkStatus->my.id = id; ++gRfuLinkStatus->connCount; - gRfuLinkStatus->connMode = 0; + gRfuLinkStatus->parentChild = 0; gRfuStatic->flags |= 0x80; - for (r5 = 0; r5 < NELEMS(gRfuLinkStatus->partner); ++r5) + for (r5 = 0; r5 < RFU_CHILD_MAX; ++r5) { if (gRfuLinkStatus->partner[r5].id == gRfuStatic->tryPid) { @@ -720,7 +713,7 @@ static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) rfu_STC_REQ_callback(sp24, sp28); } -u16 rfu_getConnectParentStatus(u8 *status, u8 *r1) +u16 rfu_getConnectParentStatus(u8 *status, u8 *connectSlotNo) { u8 r0, *r2; @@ -730,7 +723,7 @@ u16 rfu_getConnectParentStatus(u8 *status, u8 *r1) if (r0 <= 1) { r2 += 6; - *r1 = r2[0]; + *connectSlotNo = r2[0]; *status = r2[1]; return 0; } @@ -751,7 +744,7 @@ u16 rfu_syncVBlank(void) s32 r5; rfu_NI_checkCommFailCounter(); - if (gRfuLinkStatus->connMode == 0xFF) + if (gRfuLinkStatus->parentChild == 0xFF) return 0; if (gRfuStatic->nowWatchInterval != 0) --gRfuStatic->nowWatchInterval; @@ -781,26 +774,26 @@ u16 rfu_syncVBlank(void) for (r4 = 0; r4 < 4; ++r4) if ((r5 >> r4) & 1) rfu_STC_removeLinkData(r4, 1); - gRfuLinkStatus->connMode = 0xFF; + gRfuLinkStatus->parentChild = 0xFF; return 1; } --gRfuStatic->watchdogTimer; return 0; } -s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) +u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason, u8 *parentBmLinkRecoverySlot) { u8 sp08 = 0; u8 sp0C = 0; u8 i; s32 sp10, sp14; u8 *r2; - u8 r9, r6, r3, r1, r0; + u8 r9, r6, r3, connSlotFlag, r0; - *r8 = 0; - *sp00 = 0; - *sp04 = 0; - if (gRfuLinkStatus->connMode == 0xFF || gRfuState->msMode == 0) + *bmLinkLossSlot = 0; + *linkLossReason = 0; + *parentBmLinkRecoverySlot = 0; + if (gRfuLinkStatus->parentChild == 0xFF || gRfuState->msMode == 0) return 0; if (gRfuStatic->flags & 4) gRfuStatic->watchdogTimer = 360; @@ -809,27 +802,27 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) gRfuStatic->nowWatchInterval = gRfuLinkStatus->watchInterval; sp08 = 1; } - if ((u8)r5 == 41) + if ((u8)reqCommandId == 41) { u8 *r1 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data; - *r8 = r1[4]; - *sp00 = r1[5]; - if (*sp00 == 1) - *r8 = gRfuLinkStatus->connSlotFlag; + *bmLinkLossSlot = r1[4]; + *linkLossReason = r1[5]; + if (*linkLossReason == 1) + *bmLinkLossSlot = gRfuLinkStatus->connSlotFlag; sp08 = 2; } else { - if (r5 == 310) + if (reqCommandId == 310) { r6 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5]; r6 ^= gRfuLinkStatus->connSlotFlag; - *r8 = r6 & gRfuLinkStatus->connSlotFlag; - *sp00 = 1; - for (i = 0; i < NELEMS(gRfuLinkStatus->strength); ++i) + *bmLinkLossSlot = r6 & gRfuLinkStatus->connSlotFlag; + *linkLossReason = 1; + for (i = 0; i < RFU_CHILD_MAX; ++i) { - if ((*r8 >> i) & 1) + if ((*bmLinkLossSlot >> i) & 1) { gRfuLinkStatus->strength[i] = 0; rfu_STC_removeLinkData(i, 0); @@ -847,7 +840,7 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) if (sp0C == 0) { r2 = &gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; - for (i = 0; i < NELEMS(gRfuLinkStatus->strength); ++i) + for (i = 0; i < RFU_CHILD_MAX; ++i) gRfuLinkStatus->strength[i] = *r2++; r9 = 0; i = 0; @@ -866,13 +859,13 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) { if (gRfuLinkStatus->strength[i] == 0) { - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) { ++gRfuStatic->linkEmergencyFlag[i]; if (gRfuStatic->linkEmergencyFlag[i] > 3) { - *r8 |= r6; - *sp00 = sp08; // why not directly use 1? + *bmLinkLossSlot |= r6; + *linkLossReason = sp08; // why not directly use 1? } } else @@ -882,8 +875,8 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) { if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) { - *r8 |= r6; - *sp00 = sp08; + *bmLinkLossSlot |= r6; + *linkLossReason = sp08; } else { @@ -892,8 +885,8 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) gRfuStatic->linkEmergencyFlag[i] = 0; STWI_send_DisconnectREQ(gRfuLinkStatus->connSlotFlag); STWI_poll_CommandEnd(); - *r8 |= r6; - *sp00 = sp08; // why not directly use 1? + *bmLinkLossSlot |= r6; + *linkLossReason = sp08; // why not directly use 1? } } } @@ -904,13 +897,13 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) gRfuStatic->linkEmergencyFlag[i] = sp0C; // why not directly use 0? } } - if (gRfuLinkStatus->connMode == 1 && gRfuLinkStatus->strength[i] != 0) + if (gRfuLinkStatus->parentChild == 1 && gRfuLinkStatus->strength[i] != 0) { if (r6 & gRfuLinkStatus->linkLossSlotFlag) { if (gRfuLinkStatus->strength[i] > 10) { - *sp04 |= r6; + *parentBmLinkRecoverySlot |= r6; gRfuLinkStatus->connSlotFlag |= r6; gRfuLinkStatus->linkLossSlotFlag &= ~r6; ++gRfuLinkStatus->connCount; @@ -943,9 +936,9 @@ s32 rfu_REQBN_watchLink(u16 r5, u8 *r8, u8 *sp00, u8 *sp04) } } } - r1 = gRfuLinkStatus->connSlotFlag; - r0 = *r8; - r0 &= r1; + connSlotFlag = gRfuLinkStatus->connSlotFlag; + r0 = *bmLinkLossSlot; + r0 &= connSlotFlag; if (r6 & r0) rfu_STC_removeLinkData(i, 0); } @@ -971,7 +964,7 @@ static void rfu_STC_removeLinkData(u8 r7, u8 r12) gRfuLinkStatus->connSlotFlag &= r6 = ~r5; gRfuLinkStatus->linkLossSlotFlag |= r5; if ((*(u32 *)gRfuLinkStatus & 0xFF00FF) == 0) - gRfuLinkStatus->connMode = 0xFF; + gRfuLinkStatus->parentChild = 0xFF; if (r12 != 0) { CpuFill16(0, &gRfuLinkStatus->partner[r7], sizeof(struct RfuTgtData)); @@ -981,16 +974,16 @@ static void rfu_STC_removeLinkData(u8 r7, u8 r12) } } -void rfu_REQ_disconnect(u8 who) +void rfu_REQ_disconnect(u8 bmDisconnectSlot) { u16 r1; - if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & who) + if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmDisconnectSlot) { - gRfuStatic->recoveryBmSlot = who; - if (gRfuLinkStatus->connMode == 0xFF && gRfuStatic->flags & 0x80) + gRfuStatic->recoveryBmSlot = bmDisconnectSlot; + if (gRfuLinkStatus->parentChild == 0xFF && gRfuStatic->flags & 0x80) { - if (gRfuLinkStatus->linkLossSlotFlag & who) + if (gRfuLinkStatus->linkLossSlotFlag & bmDisconnectSlot) rfu_CB_disconnect(48, 0); } else if (gRfuStatic->SCStartFlag @@ -1003,7 +996,7 @@ void rfu_REQ_disconnect(u8 who) else { STWI_set_Callback_M(rfu_CB_disconnect); - STWI_send_DisconnectREQ(who); + STWI_send_DisconnectREQ(bmDisconnectSlot); } } } @@ -1012,7 +1005,7 @@ static void rfu_CB_disconnect(u8 r6, u16 r5) { u8 r4, r0; - if (r5 == 3 && gRfuLinkStatus->connMode == 0) + if (r5 == 3 && gRfuLinkStatus->parentChild == 0) { STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_SystemStatusREQ(); @@ -1031,7 +1024,7 @@ static void rfu_CB_disconnect(u8 r6, u16 r5) } } if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) == 0) - gRfuLinkStatus->connMode = 0xFF; + gRfuLinkStatus->parentChild = 0xFF; rfu_STC_REQ_callback(r6, r5); if (gRfuStatic->SCStartFlag) { @@ -1043,16 +1036,16 @@ static void rfu_CB_disconnect(u8 r6, u16 r5) } } -void rfu_REQ_CHILD_startConnectRecovery(u8 r5) +void rfu_REQ_CHILD_startConnectRecovery(u8 bmRecoverySlot) { u8 i; - gRfuStatic->recoveryBmSlot = r5; - for (i = 0; i < 4 && !((r5 >> i) & 1); ++i) + gRfuStatic->recoveryBmSlot = bmRecoverySlot; + for (i = 0; i < 4 && !((bmRecoverySlot >> i) & 1); ++i) ; STWI_set_Callback_M(rfu_STC_REQ_callback); // if i == 4, gRfuLinkStatus->partner[i].id becomes gRfuLinkStatus->my.id - STWI_send_CPR_StartREQ(gRfuLinkStatus->partner[i].id, gRfuLinkStatus->my.id, r5); + STWI_send_CPR_StartREQ(gRfuLinkStatus->partner[i].id, gRfuLinkStatus->my.id, bmRecoverySlot); } void rfu_REQ_CHILD_pollConnectRecovery(void) @@ -1068,7 +1061,7 @@ static void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7) if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot) { - gRfuLinkStatus->connMode = 0; + gRfuLinkStatus->parentChild = 0; for (r4 = 0; r4 < NELEMS(gRfuStatic->linkEmergencyFlag); ++r4) { r3 = 1 << r4; @@ -1154,10 +1147,10 @@ void rfu_clearAllSlot(void) u16 IMEBackup = REG_IME; REG_IME = 0; - for (i = 0; i < NELEMS(gRfuSlotStatusNI); ++i) + for (i = 0; i < RFU_CHILD_MAX; ++i) { - CpuFill16(0, gRfuSlotStatusNI[i], sizeof(gRfuSlotStatusNI[i]->sub)); - CpuFill16(0, gRfuSlotStatusUNI[i], sizeof(gRfuSlotStatusUNI[i]->sub)); + CpuFill16(0, gRfuSlotStatusNI[i], 2 * sizeof(struct NIComm)); + CpuFill16(0, gRfuSlotStatusUNI[i], sizeof(struct UNISend) + sizeof(struct UNIRecv)); gRfuLinkStatus->remainLLFrameSizeChild[i] = 16; } gRfuLinkStatus->remainLLFrameSizeParent = 87; @@ -1185,43 +1178,43 @@ static void rfu_STC_releaseFrame(u8 r5, u8 r3, struct NIComm *r4) } } -s32 rfu_clearSlot(u8 r8, u8 r7) +u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) { u16 r10, r3, r1; struct NIComm *r4; - if (r7 > 3) + if (slotStatusIndex >= RFU_CHILD_MAX) return 0x400; - if ((r8 & 0xF) == 0) + if ((connTypeFlag & 0xF) == 0) return 0x600; r10 = REG_IME; REG_IME = 0; - if (r8 & 0xC) + if (connTypeFlag & 0xC) { for (r3 = 0; r3 < 2; ++r3) { r4 = NULL; if (r3 == 0) { - if (r8 & 4) + if (connTypeFlag & 4) { - r4 = &gRfuSlotStatusNI[r7]->sub.send; + r4 = &gRfuSlotStatusNI[slotStatusIndex]->send; gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlotOrg; } } else { - if (r8 & 8) + if (connTypeFlag & 8) { - r4 = &gRfuSlotStatusNI[r7]->sub.recv; - gRfuLinkStatus->recvSlotNIFlag &= ~(1 << r7); + r4 = &gRfuSlotStatusNI[slotStatusIndex]->recv; + gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex); } } if (r4 != NULL) { if (r4->state & 0x8000) { - rfu_STC_releaseFrame(r7, r3, r4); + rfu_STC_releaseFrame(slotStatusIndex, r3, r4); for (r1 = 0; r1 < 4; ++r1) if ((r4->bmSlotOrg >> r1) & 1) r4->failCounter = 0; @@ -1230,71 +1223,71 @@ s32 rfu_clearSlot(u8 r8, u8 r7) } } } - if (r8 & 1) + if (connTypeFlag & 1) { - struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7]; + struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[slotStatusIndex]; - if (r3->sub.send.state & 0x8000) + if (r3->send.state & 0x8000) { if (!(gRfuStatic->flags & 0x80)) - gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->sub.send.payloadSize; + gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->send.payloadSize; else - gRfuLinkStatus->remainLLFrameSizeChild[r7] += 2 + (u8)r3->sub.send.payloadSize; - gRfuLinkStatus->sendSlotUNIFlag &= ~r3->sub.send.bmSlot; + gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] += 2 + (u8)r3->send.payloadSize; + gRfuLinkStatus->sendSlotUNIFlag &= ~r3->send.bmSlot; } - CpuFill16(0, &r3->sub.send, sizeof(struct UNISend)); + CpuFill16(0, &r3->send, sizeof(struct UNISend)); } - if (r8 & 2) + if (connTypeFlag & 2) { - CpuFill16(0, &gRfuSlotStatusUNI[r7]->sub.recv, sizeof(struct UNIRecv)); + CpuFill16(0, &gRfuSlotStatusUNI[slotStatusIndex]->recv, sizeof(struct UNIRecv)); } REG_IME = r10; return 0; } -s32 rfu_setRecvBuffer(u8 r3, u8 r4, void *r5, size_t r6) +u16 rfu_setRecvBuffer(u8 connType, u8 slotNo, void *buffer, u32 buffSize) { - if (r4 > 3) + if (slotNo >= RFU_CHILD_MAX) return 0x400; - if (r3 & 0x20) + if (connType & 0x20) { - gRfuSlotStatusNI[r4]->recvBuffer = r5; - gRfuSlotStatusNI[r4]->recvBufferSize = r6; + gRfuSlotStatusNI[slotNo]->recvBuffer = buffer; + gRfuSlotStatusNI[slotNo]->recvBufferSize = buffSize; } - else if (!(r3 & 0x10)) + else if (!(connType & 0x10)) { return 0x600; } else { - gRfuSlotStatusUNI[r4]->recvBuffer = r5; - gRfuSlotStatusUNI[r4]->recvBufferSize = r6; + gRfuSlotStatusUNI[slotNo]->recvBuffer = buffer; + gRfuSlotStatusUNI[slotNo]->recvBufferSize = buffSize; } return 0; } -s32 rfu_NI_setSendData(u8 a1, u8 a2, const void *a3, u32 a4) +u16 rfu_NI_setSendData(u8 bmSendSlot, u8 subFrameSize, const void *src, u32 size) { - return rfu_STC_setSendData_org(32, a1, a2, a3, a4); + return rfu_STC_setSendData_org(32, bmSendSlot, subFrameSize, src, size); } -s32 rfu_UNI_setSendData(u8 flag, const void *ptr, u8 size) +u16 rfu_UNI_setSendData(u8 bmSendSlot, const void *src, u8 size) { - u8 r0; + u8 subFrameSize; - if (gRfuLinkStatus->connMode == 1) - r0 = size + 3; + if (gRfuLinkStatus->parentChild == 1) + subFrameSize = size + 3; else - r0 = size + 2; - return rfu_STC_setSendData_org(16, flag, r0, ptr, 0); + subFrameSize = size + 2; + return rfu_STC_setSendData_org(16, bmSendSlot, subFrameSize, src, 0); } -s32 rfu_NI_CHILD_setSendGameName(u8 a1, u8 a2) +u16 rfu_NI_CHILD_setSendGameName(u8 slotNo, u8 subFrameSize) { - return rfu_STC_setSendData_org(64, 1 << a1, a2, &gRfuLinkStatus->my.serialNum, 26); + return rfu_STC_setSendData_org(64, 1 << slotNo, subFrameSize, &gRfuLinkStatus->my.serialNo, 26); } -static u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp28) +static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const void *src, u32 sp28) { u8 r2, r0; u8 r4; @@ -1305,26 +1298,26 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp struct RfuSlotStatusUNI *r1; struct RfuSlotStatusNI *r12; - if (gRfuLinkStatus->connMode == 0xFF) + if (gRfuLinkStatus->parentChild == 0xFF) return 0x301; - if (!(r3 & 0xF)) + if (!(bmSendSlot & 0xF)) return 0x400; - if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & r3) != r3) + if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmSendSlot) != bmSendSlot) return 0x401; if (r6 & 0x10) r0 = gRfuLinkStatus->sendSlotUNIFlag; else r0 = gRfuLinkStatus->sendSlotNIFlag; - if (r0 & r3) + if (r0 & bmSendSlot) return 0x402; - for (r2 = 0; r2 < 4 && !((r3 >> r2) & 1); ++r2) + for (r2 = 0; r2 < 4 && !((bmSendSlot >> r2) & 1); ++r2) ; - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) r9 = &gRfuLinkStatus->remainLLFrameSizeParent; - else if (gRfuLinkStatus->connMode == 0) + else if (gRfuLinkStatus->parentChild == 0) r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2]; - r4 = _Str_RfuHeader[gRfuLinkStatus->connMode].unk00; - if (r8 > *r9 || r8 <= r4) + r4 = _Str_RfuHeader[gRfuLinkStatus->parentChild].unk00; + if (subFrameSize > *r9 || subFrameSize <= r4) return 0x500; sp04 = REG_IME; REG_IME = 0; @@ -1335,82 +1328,82 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 r3, u8 r8, const void *sp00, u32 sp r12 = gRfuSlotStatusNI[r2]; r1 = NULL; - r12->sub.send.errorCode = 0; - *r12->sub.send.nowP = r1 = &r12->sub.send.dataType; - r12->sub.send.remainSize = 7; - r12->sub.send.bmSlotOrg = r3; - r12->sub.send.bmSlot = r3; - r12->sub.send.payloadSize = r8 - r4; + r12->send.errorCode = 0; + *r12->send.now_p = r1 = &r12->send.dataType; + r12->send.remainSize = 7; + r12->send.bmSlotOrg = bmSendSlot; + r12->send.bmSlot = bmSendSlot; + r12->send.payloadSize = subFrameSize - r4; if (r5 != 0) *r1 = 0; else *r1 = 1; - r12->sub.send.dataSize = sp28; - r12->sub.send.src = sp00; - r12->sub.send.ack = 0; - r12->sub.send.phase = 0; + r12->send.dataSize = sp28; + r12->send.src = src; + r12->send.ack = 0; + r12->send.phase = 0; #ifndef NONMATCHING // to fix r2, r3, r4, r5 register roulette asm("":::"r2"); #endif - for (i = 0; i < NELEMS(r12->sub.send.recvAckFlag); ++i) + for (i = 0; i < WINDOW_COUNT; ++i) { - r12->sub.send.recvAckFlag[i] = 0; - r12->sub.send.n[i] = 1; + r12->send.recvAckFlag[i] = 0; + r12->send.n[i] = 1; } - for (r2 = 0; r2 < NELEMS(gRfuSlotStatusNI); ++r2) - if ((r3 >> r2) & 1) - gRfuSlotStatusNI[r2]->sub.send.failCounter = 0; - gRfuLinkStatus->sendSlotNIFlag |= r3; - *r9 -= r8; - r12->sub.send.state = 0x8021; + for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2) + if ((bmSendSlot >> r2) & 1) + gRfuSlotStatusNI[r2]->send.failCounter = 0; + gRfuLinkStatus->sendSlotNIFlag |= bmSendSlot; + *r9 -= subFrameSize; + r12->send.state = 0x8021; } else if (r6 & 0x10) { r1 = gRfuSlotStatusUNI[r2]; - r1->sub.send.bmSlot = r3; - r1->sub.send.src = sp00; - r1->sub.send.payloadSize = r8 - r4; - *r9 -= r8; - r1->sub.send.state = 0x8024; - gRfuLinkStatus->sendSlotUNIFlag |= r3; + r1->send.bmSlot = bmSendSlot; + r1->send.src = src; + r1->send.payloadSize = subFrameSize - r4; + *r9 -= subFrameSize; + r1->send.state = 0x8024; + gRfuLinkStatus->sendSlotUNIFlag |= bmSendSlot; } REG_IME = sp04; return 0; } -s32 rfu_changeSendTarget(u8 r3, u8 r7, u8 r6) +u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) { struct RfuSlotStatusNI *r5; u16 r8; u8 r2; - if (r7 >= NELEMS(gRfuSlotStatusNI)) + if (slotStatusIndex >= RFU_CHILD_MAX) return 0x400; - if (r3 == 0x20) + if (connType == 0x20) { - r5 = gRfuSlotStatusNI[r7]; - if ((r5->sub.send.state & 0x8000) - && (r5->sub.send.state & 0x20)) + r5 = gRfuSlotStatusNI[slotStatusIndex]; + if ((r5->send.state & 0x8000) + && (r5->send.state & 0x20)) { - r3 = r6 ^ r5->sub.send.bmSlot; + connType = bmNewTgtSlot ^ r5->send.bmSlot; - if (!(r3 & r6)) + if (!(connType & bmNewTgtSlot)) { - if (r3) + if (connType) { r8 = REG_IME; REG_IME = 0; - for (r2 = 0; r2 < NELEMS(gRfuSlotStatusNI); ++r2) + for (r2 = 0; r2 < RFU_CHILD_MAX; ++r2) { - if ((r3 >> r2) & 1) - gRfuSlotStatusNI[r2]->sub.send.failCounter = 0; + if ((connType >> r2) & 1) + gRfuSlotStatusNI[r2]->send.failCounter = 0; } - gRfuLinkStatus->sendSlotNIFlag &= ~r3; - r5->sub.send.bmSlot = r6; - if (r5->sub.send.bmSlot == 0) + gRfuLinkStatus->sendSlotNIFlag &= ~connType; + r5->send.bmSlot = bmNewTgtSlot; + if (r5->send.bmSlot == 0) { - rfu_STC_releaseFrame(r7, 0, &r5->sub.send); - r5->sub.send.state = 39; + rfu_STC_releaseFrame(slotStatusIndex, 0, &r5->send); + r5->send.state = 39; } REG_IME = r8; } @@ -1427,22 +1420,22 @@ s32 rfu_changeSendTarget(u8 r3, u8 r7, u8 r6) } else { - if (r3 == 16) + if (connType == 16) { s32 r3; - if (gRfuSlotStatusUNI[r7]->sub.send.state != 0x8024) + if (gRfuSlotStatusUNI[slotStatusIndex]->send.state != 0x8024) return 0x403; - for (r3 = 0, r2 = 0; r2 < NELEMS(gRfuSlotStatusUNI); ++r2) - if (r2 != r7) - r3 |= gRfuSlotStatusUNI[r2]->sub.send.bmSlot; - if (r6 & r3) + for (r3 = 0, r2 = 0; r2 < RFU_CHILD_MAX; ++r2) + if (r2 != slotStatusIndex) + r3 |= gRfuSlotStatusUNI[r2]->send.bmSlot; + if (bmNewTgtSlot & r3) return 0x404; r8 = REG_IME; REG_IME = 0; - gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[r7]->sub.send.bmSlot; - gRfuLinkStatus->sendSlotUNIFlag |= r6; - gRfuSlotStatusUNI[r7]->sub.send.bmSlot = r6; + gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot; + gRfuLinkStatus->sendSlotUNIFlag |= bmNewTgtSlot; + gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot = bmNewTgtSlot; REG_IME = r8; } else @@ -1453,84 +1446,84 @@ s32 rfu_changeSendTarget(u8 r3, u8 r7, u8 r6) return 0; } -s32 rfu_NI_stopReceivingData(u8 who) +u16 rfu_NI_stopReceivingData(u8 slotStatusIndex) { struct NIComm *r5; u16 r4, r1; - if (who > 3) + if (slotStatusIndex > 3) return 0x400; - r5 = &gRfuSlotStatusNI[who]->sub.recv; + r5 = &gRfuSlotStatusNI[slotStatusIndex]->recv; r4 = REG_IME; ++r4; --r4; // fix r4, r5 register swap REG_IME = 0; - if (gRfuSlotStatusNI[who]->sub.recv.state & 0x8000) + if (gRfuSlotStatusNI[slotStatusIndex]->recv.state & 0x8000) { - if (gRfuSlotStatusNI[who]->sub.recv.state == 0x8043) - gRfuSlotStatusNI[who]->sub.recv.state = 72; + if (gRfuSlotStatusNI[slotStatusIndex]->recv.state == 0x8043) + gRfuSlotStatusNI[slotStatusIndex]->recv.state = 72; else - gRfuSlotStatusNI[who]->sub.recv.state = 71; - gRfuLinkStatus->recvSlotNIFlag &= ~(1 << who); - rfu_STC_releaseFrame(who, 1, r5); + gRfuSlotStatusNI[slotStatusIndex]->recv.state = 71; + gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex); + rfu_STC_releaseFrame(slotStatusIndex, 1, r5); } REG_IME = r4; return 0; } -s32 rfu_UNI_changeAndReadySendData(u8 r3, const void *r7, u8 r5) +u16 rfu_UNI_changeAndReadySendData(u8 slotStatusIndex, const void *src, u8 size) { struct UNISend *r4; u8 *r6; u16 r1; u8 r3_; - if (r3 >= 4) + if (slotStatusIndex >= RFU_CHILD_MAX) return 0x400; - r4 = &gRfuSlotStatusUNI[r3]->sub.send; + r4 = &gRfuSlotStatusUNI[slotStatusIndex]->send; if (r4->state != 0x8024) return 0x403; - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) { r6 = &gRfuLinkStatus->remainLLFrameSizeParent; r3_ = gRfuLinkStatus->remainLLFrameSizeParent + (u8)r4->payloadSize; } else { - r6 = &gRfuLinkStatus->remainLLFrameSizeChild[r3]; - r3_ = gRfuLinkStatus->remainLLFrameSizeChild[r3] + (u8)r4->payloadSize; + r6 = &gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex]; + r3_ = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)r4->payloadSize; } - if (r3_ < r5) + if (r3_ < size) return 0x500; r1 = REG_IME; REG_IME = 0; - r4->src = r7; - *r6 = r3_ - r5; - r4->payloadSize = r5; + r4->src = src; + *r6 = r3_ - size; + r4->payloadSize = size; r4->dataReadyFlag = 1; REG_IME = r1; return 0; } -void rfu_UNI_readySendData(u8 a1) +void rfu_UNI_readySendData(u8 slotStatusIndex) { - if (a1 < NELEMS(gRfuSlotStatusUNI)) + if (slotStatusIndex < RFU_CHILD_MAX) { - if (gRfuSlotStatusUNI[a1]->sub.send.state == 0x8024) - gRfuSlotStatusUNI[a1]->sub.send.dataReadyFlag = 1; + if (gRfuSlotStatusUNI[slotStatusIndex]->send.state == 0x8024) + gRfuSlotStatusUNI[slotStatusIndex]->send.dataReadyFlag = 1; } } -void rfu_UNI_clearRecvNewDataFlag(u8 a1) +void rfu_UNI_clearRecvNewDataFlag(u8 slotStatusIndex) { - if (a1 < NELEMS(gRfuSlotStatusUNI)) - gRfuSlotStatusUNI[a1]->sub.recv.newDataFlag = 0; + if (slotStatusIndex < RFU_CHILD_MAX) + gRfuSlotStatusUNI[slotStatusIndex]->recv.newDataFlag = 0; } -void rfu_REQ_sendData(u8 r5) +void rfu_REQ_sendData(u8 clockChangeFlag) { - if (gRfuLinkStatus->connMode != 0xFF) + if (gRfuLinkStatus->parentChild != 0xFF) { - if (gRfuLinkStatus->connMode == 1 + if (gRfuLinkStatus->parentChild == 1 && !(gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag)) { if (gRfuStatic->commExistFlag) @@ -1548,7 +1541,7 @@ void rfu_REQ_sendData(u8 r5) gRfuFixed->LLFBuffer[0] = 1; gRfuFixed->LLFBuffer[4] = 0xFF; STWI_set_Callback_M(rfu_CB_sendData3); - if (r5 == 0) + if (clockChangeFlag == 0) STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, 1); else STWI_send_DataTxAndChangeREQ(gRfuFixed->LLFBuffer, 1); @@ -1562,7 +1555,7 @@ void rfu_REQ_sendData(u8 r5) if (gRfuLinkStatus->LLFReadyFlag) { STWI_set_Callback_M(rfu_CB_sendData); - if (r5 != 0) + if (clockChangeFlag != 0) { STWI_send_DataTxAndChangeREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); return; @@ -1570,9 +1563,9 @@ void rfu_REQ_sendData(u8 r5) STWI_send_DataTxREQ(gRfuFixed->LLFBuffer, gRfuStatic->totalPacketSize + 4); } } - if (r5 != 0) + if (clockChangeFlag != 0) { - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) { if (gRfuState->callbackS != NULL) gRfuState->callbackS(39); @@ -1593,11 +1586,11 @@ static void rfu_CB_sendData(UNUSED u8 r0, u16 r7) if (r7 == 0) { - for (r6 = 0; r6 < NELEMS(gRfuSlotStatusNI); ++r6) + for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) { - if (gRfuSlotStatusUNI[r6]->sub.send.dataReadyFlag) - gRfuSlotStatusUNI[r6]->sub.send.dataReadyFlag = 0; - r4 = &gRfuSlotStatusNI[r6]->sub.send; + if (gRfuSlotStatusUNI[r6]->send.dataReadyFlag) + gRfuSlotStatusUNI[r6]->send.dataReadyFlag = 0; + r4 = &gRfuSlotStatusNI[r6]->send; if (r4->state == 0x8020) { rfu_STC_releaseFrame(r6, 0, r4); @@ -1632,24 +1625,24 @@ static void rfu_constructSendLLFrame(void) u8 *sp00; struct RfuSlotStatusNI *r2; - if (gRfuLinkStatus->connMode != 0xFF + if (gRfuLinkStatus->parentChild != 0xFF && gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag) { gRfuLinkStatus->LLFReadyFlag = 0; r8 = 0; sp00 = (u8 *)&gRfuFixed->LLFBuffer[1]; - for (r6 = 0; r6 < NELEMS(gRfuSlotStatusUNI); ++r6) + for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) { r5 = 0; - if (gRfuSlotStatusNI[r6]->sub.send.state & 0x8000) - r5 = rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->sub.send); - if (gRfuSlotStatusNI[r6]->sub.recv.state & 0x8000) - r5 += rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->sub.recv); - if (gRfuSlotStatusUNI[r6]->sub.send.state == 0x8024) + if (gRfuSlotStatusNI[r6]->send.state & 0x8000) + r5 = rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->send); + if (gRfuSlotStatusNI[r6]->recv.state & 0x8000) + r5 += rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->recv); + if (gRfuSlotStatusUNI[r6]->send.state == 0x8024) r5 += rfu_STC_UNI_constructLLSF(r6, &sp00); if (r5 != 0) { - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) r8 += r5; else r8 |= r5 << (5 * r6 + 8); @@ -1660,7 +1653,7 @@ static void rfu_constructSendLLFrame(void) while ((u32)sp00 & 3) *sp00++ = 0; gRfuFixed->LLFBuffer[0] = r8; - if (gRfuLinkStatus->connMode == 0) + if (gRfuLinkStatus->parentChild == 0) { u8 *r0 = sp00 - offsetof(struct RfuFixed, LLFBuffer[1]); @@ -1680,11 +1673,11 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) u32 sp00; u8 i; u8 *r2; - const struct RfuHeader *r8 = &_Str_RfuHeader[gRfuLinkStatus->connMode]; + const struct RfuHeader *r8 = &_Str_RfuHeader[gRfuLinkStatus->parentChild]; if (r4->state == 0x8022) { - while (r4->nowP[r4->phase] >= (const u8 *)r4->src + r4->dataSize) + while (r4->now_p[r4->phase] >= (const u8 *)r4->src + r4->dataSize) { ++r4->phase; if (r4->phase == 4) @@ -1697,8 +1690,8 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) } else if (r4->state == 0x8022) { - if (r4->nowP[r4->phase] + r4->payloadSize > (const u8 *)r4->src + r4->dataSize) - r5 = (const u8 *)r4->src + r4->dataSize - r4->nowP[r4->phase]; + if (r4->now_p[r4->phase] + r4->payloadSize > (const u8 *)r4->src + r4->dataSize) + r5 = (const u8 *)r4->src + r4->dataSize - r4->now_p[r4->phase]; else r5 = r4->payloadSize; } @@ -1714,14 +1707,14 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) | r4->phase << r8->unk05 | r4->n[r4->phase] << r8->unk06 | r5; - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) sp00 |= r4->bmSlot << 18; r2 = (u8 *)&sp00; for (i = 0; i < r8->unk00; ++i) *(*r12)++ = *r2++; if (r5 != 0) { - const u8 *sp04 = r4->nowP[r4->phase]; + const u8 *sp04 = r4->now_p[r4->phase]; gRfuFixed->fastCopyPtr(&sp04, r12, r5); } @@ -1731,7 +1724,7 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) if (r4->phase == 4) r4->phase = 0; } - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) gRfuLinkStatus->LLFReadyFlag = 1; else gRfuLinkStatus->LLFReadyFlag |= 1 << r10; @@ -1745,21 +1738,21 @@ static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) u32 sp00; u8 *r2; u8 i; - struct UNISend *r4 = &gRfuSlotStatusUNI[r8]->sub.send; + struct UNISend *r4 = &gRfuSlotStatusUNI[r8]->send; if (!r4->dataReadyFlag || !r4->bmSlot) return 0; - r5 = &_Str_RfuHeader[gRfuLinkStatus->connMode]; + r5 = &_Str_RfuHeader[gRfuLinkStatus->parentChild]; sp00 = (r4->state & 0xF) << r5->unk03 | r4->payloadSize; - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) sp00 |= r4->bmSlot << 18; r2 = (u8 *)&sp00; for (i = 0; i < r5->unk00; ++i) *(*r6)++ = *r2++; sp04 = r4->src; gRfuFixed->fastCopyPtr(&sp04, r6, r4->payloadSize); - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) gRfuLinkStatus->LLFReadyFlag = 16; else gRfuLinkStatus->LLFReadyFlag |= 16 << r8; @@ -1768,7 +1761,7 @@ static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) void rfu_REQ_recvData(void) { - if (gRfuLinkStatus->connMode != 0xFF) + if (gRfuLinkStatus->parentChild != 0xFF) { gRfuStatic->commExistFlag = gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag; gRfuStatic->recvErrorFlag = 0; @@ -1786,21 +1779,21 @@ static void rfu_CB_recvData(u8 r9, u16 r7) if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]) { gRfuStatic->NIEndRecvFlag = 0; - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) rfu_STC_PARENT_analyzeRecvPacket(); else rfu_STC_CHILD_analyzeRecvPacket(); - for (r6 = 0; r6 < NELEMS(gRfuSlotStatusNI); ++r6) + for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) { r4 = gRfuSlotStatusNI[r6]; - if (r4->sub.recv.state == 0x8043 && !((gRfuStatic->NIEndRecvFlag >> r6) & 1)) + if (r4->recv.state == 0x8043 && !((gRfuStatic->NIEndRecvFlag >> r6) & 1)) { - r5 = &r4->sub.recv; + r5 = &r4->recv; if (r5->dataType == 1) gRfuLinkStatus->getNameFlag |= 1 << r6; rfu_STC_releaseFrame(r6, 1, r5); gRfuLinkStatus->recvSlotNIFlag &= ~r5->bmSlot; - r4->sub.recv.state = 70; + r4->recv.state = 70; } } if (gRfuStatic->recvErrorFlag) @@ -1871,7 +1864,7 @@ static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) u32 r0; u16 r10; - r6 = &_Str_RfuHeader[~gRfuLinkStatus->connMode & 1]; + r6 = &_Str_RfuHeader[~gRfuLinkStatus->parentChild & 1]; if (r3 < r6->unk00) return r3; r5 = 0; @@ -1887,7 +1880,7 @@ static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) r10 = sp00.unk06 + r6->unk00; if (sp00.unk00 == 0) { - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) { if ((gRfuLinkStatus->connSlotFlag >> r12) & 1) { @@ -1901,8 +1894,8 @@ static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) } else { - for (r4 = 0; r4 < NELEMS(gRfuSlotStatusNI); ++r4) - if (((gRfuSlotStatusNI[r4]->sub.send.bmSlot >> r12) & 1) + for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) + if (((gRfuSlotStatusNI[r4]->send.bmSlot >> r12) & 1) && ((gRfuLinkStatus->sendSlotNIFlag >> r12) & 1)) break; if (r4 <= 3) @@ -1939,12 +1932,12 @@ static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 u8 *sp04; u32 r2; struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[r7]; - struct UNIRecv *r5 = &r3->sub.recv; + struct UNIRecv *r5 = &r3->recv; r5->errorCode = 0; if (gRfuSlotStatusUNI[r7]->recvBufferSize < r6->unk06) { - r3->sub.recv.state = 73; + r3->recv.state = 73; r5->errorCode = 0x701; } else @@ -1976,7 +1969,7 @@ _081E2F0E: static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct *r6, const u8 *r3) { - struct NIComm *r12 = &gRfuSlotStatusNI[r0]->sub.send; + struct NIComm *r12 = &gRfuSlotStatusNI[r0]->send; u16 r9 = r12->state; u8 sp00 = r12->n[r6->unk04]; u8 *r8; @@ -1997,9 +1990,9 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct if ((u16)(r12->state + ~0x8020) <= 1) { if (r12->state == 0x8021) - r12->nowP[r6->unk04] += r12->payloadSize; + r12->now_p[r6->unk04] += r12->payloadSize; else - r12->nowP[r6->unk04] += r12->payloadSize << 2; + r12->now_p[r6->unk04] += r12->payloadSize << 2; r12->remainSize -= r12->payloadSize; if (r12->remainSize != 0) if (r12->remainSize >= 0) @@ -2012,10 +2005,10 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct r12->phase = 0; if (r12->state == 0x8021) { - for (r4 = 0; r4 < NELEMS(r12->n); ++r4) + for (r4 = 0; r4 < WINDOW_COUNT; ++r4) { r12->n[r4] = 1; - r12->nowP[r4] = r12->src + r12->payloadSize * r4; + r12->now_p[r4] = r12->src + r12->payloadSize * r4; } r12->remainSize = r12->dataSize; r12->state = 0x8022; @@ -2041,7 +2034,7 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct r2 = REG_IME; REG_IME = 0; gRfuStatic->recvRenewalFlag |= 16 << r10; - gRfuSlotStatusNI[r10]->sub.send.failCounter = 0; + gRfuSlotStatusNI[r10]->send.failCounter = 0; REG_IME = r2; } } @@ -2051,18 +2044,18 @@ static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, u16 r2; u32 r7 = 0; struct RfuSlotStatusNI *r4 = gRfuSlotStatusNI[r8]; - struct NIComm *r5 = &r4->sub.recv; - u16 r9 = r4->sub.recv.state; - u8 r10 = r4->sub.recv.n[r6->unk04]; + struct NIComm *r5 = &r4->recv; + u16 r9 = r4->recv.state; + u8 r10 = r4->recv.n[r6->unk04]; if (r6->unk02 == 3) { gRfuStatic->NIEndRecvFlag |= 1 << r8; - if (r4->sub.recv.state == 0x8042) + if (r4->recv.state == 0x8042) { - r4->sub.recv.phase = 0; - r4->sub.recv.n[0] = 0; - r4->sub.recv.state = 0x8043; + r4->recv.phase = 0; + r4->recv.n[0] = 0; + r4->recv.state = 0x8043; } } else if (r6->unk02 == 2) @@ -2081,7 +2074,7 @@ static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, else { rfu_STC_NI_initSlot_asRecvControllData(r8, r5); - if (r4->sub.recv.state != 0x8041) + if (r4->recv.state != 0x8041) return; r7 = 1; } @@ -2090,9 +2083,9 @@ static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, { if (r6->unk05 == ((r5->n[r6->unk04] + 1) & 3)) { - gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->nowP[r6->unk04], r6->unk06); + gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->now_p[r6->unk04], r6->unk06); if (r5->state == 0x8042) - r5->nowP[r6->unk04] += 3 * r5->payloadSize; + r5->now_p[r6->unk04] += 3 * r5->payloadSize; r5->remainSize -= r6->unk06; r5->n[r6->unk04] = r6->unk05; } @@ -2117,7 +2110,7 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) u32 r5; u8 r6; - if (gRfuLinkStatus->connMode == 1) + if (gRfuLinkStatus->parentChild == 1) { r5 = 3; r1 = &gRfuLinkStatus->remainLLFrameSizeParent; @@ -2140,7 +2133,7 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) { r2->errorCode = 0; *r1 -= r5; - r2->nowP[0] = &r2->dataType; + r2->now_p[0] = &r2->dataType; r2->remainSize = 7; r2->ack = 1; r2->payloadSize = 0; @@ -2157,7 +2150,7 @@ static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4) if (r4->dataType == 1) { - r4->nowP[0] = (void *)&gRfuLinkStatus->partner[r5].serialNum; + r4->now_p[0] = (void *)&gRfuLinkStatus->partner[r5].serialNo; } else { @@ -2171,12 +2164,12 @@ static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4) rfu_STC_releaseFrame(r5, 1, r4); return; } - r4->nowP[0] = gRfuSlotStatusNI[r5]->recvBuffer; + r4->now_p[0] = gRfuSlotStatusNI[r5]->recvBuffer; } for (r3 = 0; r3 < 4; ++r3) { r4->n[r3] = 0; - r4->nowP[r3] = &r4->nowP[0][r4->payloadSize * r3]; + r4->now_p[r3] = &r4->now_p[0][r4->payloadSize * r3]; } r4->remainSize = r4->dataSize; r4->state = 0x8042; @@ -2193,15 +2186,15 @@ static void rfu_NI_checkCommFailCounter(void) r12 = REG_IME; REG_IME = 0; r7 = gRfuStatic->recvRenewalFlag >> 4; - for (r3 = 0; r3 < NELEMS(gRfuSlotStatusNI); ++r3) + for (r3 = 0; r3 < RFU_CHILD_MAX; ++r3) { r2 = 1 << r3; if (gRfuLinkStatus->sendSlotNIFlag & r2 && !(gRfuStatic->recvRenewalFlag & r2)) - ++gRfuSlotStatusNI[r3]->sub.send.failCounter; + ++gRfuSlotStatusNI[r3]->send.failCounter; if (gRfuLinkStatus->recvSlotNIFlag & r2 && !(r7 & r2)) - ++gRfuSlotStatusNI[r3]->sub.recv.failCounter; + ++gRfuSlotStatusNI[r3]->recv.failCounter; } gRfuStatic->recvRenewalFlag = 0; REG_IME = r12; @@ -2213,157 +2206,3 @@ void rfu_REQ_noise(void) STWI_set_Callback_M(rfu_STC_REQ_callback); STWI_send_TestModeREQ(1, 0); } - -static s32 sub_81E349C(u8 r5) -{ - u16 r8; - vu16 *r4; - s32 r6; - - if (REG_IME == 0) - return -1; - r8 = REG_IE; - gRfuState->state = 10; - STWI_set_Callback_ID(sub_81E36B8); - sub_81E3550(); - r4 = ®_TMCNT_L(gRfuState->timerSelect); - r5 *= 8; - while (--r5 != 0xFF) - { - r6 = sub_81E35C4(); - if (r6 != 0) - break; - r4[1] = 0; - r4[0] = 0; - r4[1] = TIMER_1024CLK | TIMER_ENABLE; - while (r4[0] < 32) - ; - r4[1] = 0; - r4[0] = 0; - } - REG_IME = 0; - REG_IE = r8; - REG_IME = 1; - gRfuState->state = 0; - STWI_set_Callback_ID(NULL); - return r6; -} - -static void sub_81E3550(void) -{ - REG_IME = 0; - REG_IE &= ~((8 << gRfuState->timerSelect) | INTR_FLAG_SERIAL); - REG_IME = 1; - REG_RCNT = 0; - REG_SIOCNT = SIO_32BIT_MODE; - REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; - CpuFill32(0, &gUnknown_3007470, sizeof(struct Unk_3007470)); - REG_IF = INTR_FLAG_SERIAL; -} - -static s32 sub_81E35C4(void) -{ - u8 r12; - - switch (r12 = gUnknown_3007470.unk1) - { - case 0: - gUnknown_3007470.unk0 = 1; - REG_SIOCNT |= SIO_38400_BPS; - REG_IME = r12; - REG_IE |= INTR_FLAG_SERIAL; - REG_IME = 1; - gUnknown_3007470.unk1 = 1; - *(vu8 *)®_SIOCNT |= SIO_ENABLE; - break; - case 1: - if (gUnknown_3007470.unkA == 0) - { - if (gUnknown_3007470.unk0 == 1) - { - if (gUnknown_3007470.unk2 == 0) - { - REG_IME = gUnknown_3007470.unk2; - REG_SIOCNT |= SIO_ENABLE; - REG_IME = r12; - } - } - else if (gUnknown_3007470.unk4 != 0x8001 && !gUnknown_3007470.unk2) - { - REG_IME = gUnknown_3007470.unk2; - REG_IE &= ~INTR_FLAG_SERIAL; - REG_IME = r12; - REG_SIOCNT = gUnknown_3007470.unk2; - REG_SIOCNT = SIO_32BIT_MODE; - REG_IF = INTR_FLAG_SERIAL; - REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; - REG_IME = gUnknown_3007470.unk2; - REG_IE |= INTR_FLAG_SERIAL; - REG_IME = r12; - } - break; - } - else - { - gUnknown_3007470.unk1 = 2; - // fallthrough - } - default: - return gUnknown_3007470.unkA; - } - return 0; -} - -static void sub_81E36B8(void) -{ - u32 r5; - u16 r0; -#ifndef NONMATCHING - register u32 r1 asm("r1"); - register u16 r0_ asm("r0"); -#else - u32 r1; - u16 r0_; -#endif - - r5 = REG_SIODATA32; - if (gUnknown_3007470.unk0 != 1) - REG_SIOCNT |= SIO_ENABLE; - r1 = 16 * gUnknown_3007470.unk0; // to handle side effect of inline asm - r1 = (r5 << r1) >> 16; - r5 = (r5 << 16 * (1 - gUnknown_3007470.unk0)) >> 16; - if (gUnknown_3007470.unkA == 0) - { - if (r1 == gUnknown_3007470.unk6) - { - if (gUnknown_3007470.unk2 > 3) - { - gUnknown_3007470.unkA = r5; - } - else if (r1 == (u16)~gUnknown_3007470.unk4) - { - r0_ = ~gUnknown_3007470.unk6; - if (r5 == r0_) - ++gUnknown_3007470.unk2; - } - } - else - { - gUnknown_3007470.unk2 = gUnknown_3007470.unkA; - } - } - if (gUnknown_3007470.unk2 < 4) - gUnknown_3007470.unk4 = *(gUnknown_3007470.unk2 + _Str_Sio32ID); - else - gUnknown_3007470.unk4 = 0x8001; - gUnknown_3007470.unk6 = ~r5; - REG_SIODATA32 = (gUnknown_3007470.unk4 << 16 * (1 - gUnknown_3007470.unk0)) - + (gUnknown_3007470.unk6 << 16 * gUnknown_3007470.unk0); - if (gUnknown_3007470.unk0 == 1 && (gUnknown_3007470.unk2 || r5 == 0x494E)) - { - for (r0 = 0; r0 < 600; ++r0) - ; - if (gUnknown_3007470.unkA == 0) - REG_SIOCNT |= SIO_ENABLE; - } -} diff --git a/src/librfu_s32id.c b/src/librfu_s32id.c new file mode 100644 index 000000000..c3bb922e2 --- /dev/null +++ b/src/librfu_s32id.c @@ -0,0 +1,163 @@ +#include "librfu.h" + +extern const u16 _Str_Sio32ID[]; + +static void Sio32IDIntr(void); +static void Sio32IDInit(void); +static s32 Sio32IDMain(void); + +struct RfuS32Id gRfuS32Id; + +s32 AgbRFU_checkID(u8 r5) +{ + u16 r8; + vu16 *r4; + s32 r6; + + if (REG_IME == 0) + return -1; + r8 = REG_IE; + gRfuState->state = 10; + STWI_set_Callback_ID(Sio32IDIntr); + Sio32IDInit(); + r4 = ®_TMCNT_L(gRfuState->timerSelect); + r5 *= 8; + while (--r5 != 0xFF) + { + r6 = Sio32IDMain(); + if (r6 != 0) + break; + r4[1] = 0; + r4[0] = 0; + r4[1] = TIMER_1024CLK | TIMER_ENABLE; + while (r4[0] < 32) + ; + r4[1] = 0; + r4[0] = 0; + } + REG_IME = 0; + REG_IE = r8; + REG_IME = 1; + gRfuState->state = 0; + STWI_set_Callback_ID(NULL); + return r6; +} + +static void Sio32IDInit(void) +{ + REG_IME = 0; + REG_IE &= ~((8 << gRfuState->timerSelect) | INTR_FLAG_SERIAL); + REG_IME = 1; + REG_RCNT = 0; + REG_SIOCNT = SIO_32BIT_MODE; + REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; + CpuFill32(0, &gRfuS32Id, sizeof(struct RfuS32Id)); + REG_IF = INTR_FLAG_SERIAL; +} + +static s32 Sio32IDMain(void) +{ + u8 r12; + + switch (r12 = gRfuS32Id.unk1) + { + case 0: + gRfuS32Id.unk0 = 1; + REG_SIOCNT |= SIO_38400_BPS; + REG_IME = r12; + REG_IE |= INTR_FLAG_SERIAL; + REG_IME = 1; + gRfuS32Id.unk1 = 1; + *(vu8 *)®_SIOCNT |= SIO_ENABLE; + break; + case 1: + if (gRfuS32Id.unkA == 0) + { + if (gRfuS32Id.unk0 == 1) + { + if (gRfuS32Id.unk2 == 0) + { + REG_IME = gRfuS32Id.unk2; + REG_SIOCNT |= SIO_ENABLE; + REG_IME = r12; + } + } + else if (gRfuS32Id.unk4 != 0x8001 && !gRfuS32Id.unk2) + { + REG_IME = gRfuS32Id.unk2; + REG_IE &= ~INTR_FLAG_SERIAL; + REG_IME = r12; + REG_SIOCNT = gRfuS32Id.unk2; + REG_SIOCNT = SIO_32BIT_MODE; + REG_IF = INTR_FLAG_SERIAL; + REG_SIOCNT |= SIO_INTR_ENABLE | SIO_ENABLE; + REG_IME = gRfuS32Id.unk2; + REG_IE |= INTR_FLAG_SERIAL; + REG_IME = r12; + } + break; + } + else + { + gRfuS32Id.unk1 = 2; + // fallthrough + } + default: + return gRfuS32Id.unkA; + } + return 0; +} + +static void Sio32IDIntr(void) +{ + u32 r5; + u16 r0; +#ifndef NONMATCHING + register u32 r1 asm("r1"); + register u16 r0_ asm("r0"); +#else + u32 r1; + u16 r0_; +#endif + + r5 = REG_SIODATA32; + if (gRfuS32Id.unk0 != 1) + REG_SIOCNT |= SIO_ENABLE; + r1 = 16 * gRfuS32Id.unk0; // to handle side effect of inline asm + r1 = (r5 << r1) >> 16; + r5 = (r5 << 16 * (1 - gRfuS32Id.unk0)) >> 16; + if (gRfuS32Id.unkA == 0) + { + if (r1 == gRfuS32Id.unk6) + { + if (gRfuS32Id.unk2 > 3) + { + gRfuS32Id.unkA = r5; + } + else if (r1 == (u16)~gRfuS32Id.unk4) + { + r0_ = ~gRfuS32Id.unk6; + if (r5 == r0_) + ++gRfuS32Id.unk2; + } + } + else + { + gRfuS32Id.unk2 = gRfuS32Id.unkA; + } + } + if (gRfuS32Id.unk2 < 4) + gRfuS32Id.unk4 = *(gRfuS32Id.unk2 + _Str_Sio32ID); + else + gRfuS32Id.unk4 = 0x8001; + gRfuS32Id.unk6 = ~r5; + REG_SIODATA32 = (gRfuS32Id.unk4 << 16 * (1 - gRfuS32Id.unk0)) + + (gRfuS32Id.unk6 << 16 * gRfuS32Id.unk0); + if (gRfuS32Id.unk0 == 1 && (gRfuS32Id.unk2 || r5 == 0x494E)) + { + for (r0 = 0; r0 < 600; ++r0) + ; + if (gRfuS32Id.unkA == 0) + REG_SIOCNT |= SIO_ENABLE; + } +} diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c index 8e27c04d8..50e102f19 100644 --- a/src/librfu_stwi.c +++ b/src/librfu_stwi.c @@ -1,4 +1,3 @@ -#include "global.h" #include "librfu.h" static void STWI_intr_timer(void); @@ -12,7 +11,7 @@ static s32 STWI_reset_ClockCounter(void); void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, bool8 copyInterruptToRam) { // If we're copying our interrupt into RAM, DMA it to block1 and use - // block2 for our RfuStruct, otherwise block1 holds the RfuStruct. + // block2 for our STWIStatus, otherwise block1 holds the STWIStatus. // interrupt usually is a pointer to gIntrTable[1] if (copyInterruptToRam == TRUE) { @@ -23,7 +22,7 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b else { *interrupt = IntrSIO32; - gRfuState = (struct RfuStruct *)interruptStruct->block1; + gRfuState = (struct STWIStatus *)interruptStruct->block1; } gRfuState->rxPacket = &interruptStruct->rxPacketAlloc; gRfuState->txPacket = &interruptStruct->txPacketAlloc; @@ -142,7 +141,7 @@ u16 STWI_poll_CommandEnd(void) void STWI_send_ResetREQ(void) { - if (!STWI_init(RFU_RESET)) + if (!STWI_init(ID_RESET_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -151,7 +150,7 @@ void STWI_send_ResetREQ(void) void STWI_send_LinkStatusREQ(void) { - if (!STWI_init(RFU_LINK_STATUS)) + if (!STWI_init(ID_LINK_STATUS_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -160,7 +159,7 @@ void STWI_send_LinkStatusREQ(void) void STWI_send_VersionStatusREQ(void) { - if (!STWI_init(RFU_VERSION_STATUS)) + if (!STWI_init(ID_VERSION_STATUS_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -169,7 +168,7 @@ void STWI_send_VersionStatusREQ(void) void STWI_send_SystemStatusREQ(void) { - if (!STWI_init(RFU_SYSTEM_STATUS)) + if (!STWI_init(ID_SYSTEM_STATUS_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -178,7 +177,7 @@ void STWI_send_SystemStatusREQ(void) void STWI_send_SlotStatusREQ(void) { - if (!STWI_init(RFU_SLOT_STATUS)) + if (!STWI_init(ID_SLOT_STATUS_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -187,7 +186,7 @@ void STWI_send_SlotStatusREQ(void) void STWI_send_ConfigStatusREQ(void) { - if (!STWI_init(RFU_CONFIG_STATUS)) + if (!STWI_init(ID_CONFIG_STATUS_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -199,7 +198,7 @@ void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data) u8 *packetBytes; s32 i; - if (!STWI_init(RFU_GAME_CONFIG)) + if (!STWI_init(ID_GAME_CONFIG_REQ)) { gRfuState->reqLength = 6; // TODO: what is unk1 @@ -226,7 +225,7 @@ void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data) void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3) { - if (!STWI_init(RFU_SYSTEM_CONFIG)) + if (!STWI_init(ID_SYSTEM_CONFIG_REQ)) { u8 *packetBytes; @@ -242,7 +241,7 @@ void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3) void STWI_send_SC_StartREQ(void) { - if (!STWI_init(RFU_SC_START)) + if (!STWI_init(ID_SC_START_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -251,7 +250,7 @@ void STWI_send_SC_StartREQ(void) void STWI_send_SC_PollingREQ(void) { - if (!STWI_init(RFU_SC_POLLING)) + if (!STWI_init(ID_SC_POLL_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -260,7 +259,7 @@ void STWI_send_SC_PollingREQ(void) void STWI_send_SC_EndREQ(void) { - if (!STWI_init(RFU_SC_END)) + if (!STWI_init(ID_SC_END_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -269,7 +268,7 @@ void STWI_send_SC_EndREQ(void) void STWI_send_SP_StartREQ(void) { - if (!STWI_init(RFU_SP_START)) + if (!STWI_init(ID_SP_START_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -278,7 +277,7 @@ void STWI_send_SP_StartREQ(void) void STWI_send_SP_PollingREQ(void) { - if (!STWI_init(RFU_SP_POLLING)) + if (!STWI_init(ID_SP_POLL_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -287,7 +286,7 @@ void STWI_send_SP_PollingREQ(void) void STWI_send_SP_EndREQ(void) { - if (!STWI_init(RFU_SP_END)) + if (!STWI_init(ID_SP_END_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -296,7 +295,7 @@ void STWI_send_SP_EndREQ(void) void STWI_send_CP_StartREQ(u16 unk1) { - if (!STWI_init(RFU_CP_START)) + if (!STWI_init(ID_CP_START_REQ)) { gRfuState->reqLength = 1; gRfuState->txPacket->rfuPacket32.data[0] = unk1; @@ -306,7 +305,7 @@ void STWI_send_CP_StartREQ(u16 unk1) void STWI_send_CP_PollingREQ(void) { - if (!STWI_init(RFU_CP_POLLING)) + if (!STWI_init(ID_CP_POLL_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -315,7 +314,7 @@ void STWI_send_CP_PollingREQ(void) void STWI_send_CP_EndREQ(void) { - if (!STWI_init(RFU_CP_END)) + if (!STWI_init(ID_CP_END_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -324,7 +323,7 @@ void STWI_send_CP_EndREQ(void) void STWI_send_DataTxREQ(const void *in, u8 size) { - if (!STWI_init(RFU_DATA_TX)) + if (!STWI_init(ID_DATA_TX_REQ)) { u8 reqLength = (size / sizeof(u32)); if (size & (sizeof(u32) - 1)) @@ -337,7 +336,7 @@ void STWI_send_DataTxREQ(const void *in, u8 size) void STWI_send_DataTxAndChangeREQ(const void *in, u8 size) { - if (!STWI_init(RFU_DATA_TX_AND_CHANGE)) + if (!STWI_init(ID_DATA_TX_AND_CHANGE_REQ)) { u8 reqLength = (size / sizeof(u32)); if (size & (sizeof(u32) - 1)) @@ -350,7 +349,7 @@ void STWI_send_DataTxAndChangeREQ(const void *in, u8 size) void STWI_send_DataRxREQ(void) { - if (!STWI_init(RFU_DATA_RX)) + if (!STWI_init(ID_DATA_RX_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -359,7 +358,7 @@ void STWI_send_DataRxREQ(void) void STWI_send_MS_ChangeREQ(void) { - if (!STWI_init(RFU_MS_CHANGE)) + if (!STWI_init(ID_MS_CHANGE_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -368,7 +367,7 @@ void STWI_send_MS_ChangeREQ(void) void STWI_send_DataReadyAndChangeREQ(u8 unk) { - if (!STWI_init(RFU_DATA_READY_AND_CHANGE)) + if (!STWI_init(ID_DATA_READY_AND_CHANGE_REQ)) { if (!unk) { @@ -392,7 +391,7 @@ void STWI_send_DataReadyAndChangeREQ(u8 unk) void STWI_send_DisconnectedAndChangeREQ(u8 unk0, u8 unk1) { - if (!STWI_init(RFU_DISCONNECTED_AND_CHANGE)) + if (!STWI_init(ID_DISCONNECTED_AND_CHANGE_REQ)) { u8 *packetBytes; @@ -409,7 +408,7 @@ void STWI_send_DisconnectedAndChangeREQ(u8 unk0, u8 unk1) void STWI_send_ResumeRetransmitAndChangeREQ(void) { - if (!STWI_init(RFU_RESUME_RETRANSMIT_AND_CHANGE)) + if (!STWI_init(ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -418,7 +417,7 @@ void STWI_send_ResumeRetransmitAndChangeREQ(void) void STWI_send_DisconnectREQ(u8 unk) { - if (!STWI_init(RFU_DISCONNECT)) + if (!STWI_init(ID_DISCONNECT_REQ)) { gRfuState->reqLength = 1; gRfuState->txPacket->rfuPacket32.data[0] = unk; @@ -428,7 +427,7 @@ void STWI_send_DisconnectREQ(u8 unk) void STWI_send_TestModeREQ(u8 unk0, u8 unk1) { - if (!STWI_init(RFU_TEST_MODE)) + if (!STWI_init(ID_TEST_MODE_REQ)) { gRfuState->reqLength = 1; gRfuState->txPacket->rfuPacket32.data[0] = unk0 | (unk1 << 8); @@ -441,7 +440,7 @@ void STWI_send_CPR_StartREQ(u16 unk0, u16 unk1, u8 unk2) u32 *packetData; u32 arg1; - if (!STWI_init(RFU_CPR_START)) + if (!STWI_init(ID_CPR_START_REQ)) { gRfuState->reqLength = 2; arg1 = unk1 | (unk0 << 16); @@ -454,7 +453,7 @@ void STWI_send_CPR_StartREQ(u16 unk0, u16 unk1, u8 unk2) void STWI_send_CPR_PollingREQ(void) { - if (!STWI_init(RFU_CPR_POLLING)) + if (!STWI_init(ID_CPR_POLL_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -463,7 +462,7 @@ void STWI_send_CPR_PollingREQ(void) void STWI_send_CPR_EndREQ(void) { - if (!STWI_init(RFU_CPR_END)) + if (!STWI_init(ID_CPR_END_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -472,7 +471,7 @@ void STWI_send_CPR_EndREQ(void) void STWI_send_StopModeREQ(void) { - if (!STWI_init(RFU_STOP_MODE)) + if (!STWI_init(ID_STOP_MODE_REQ)) { gRfuState->reqLength = 0; STWI_start_Command(); @@ -614,7 +613,7 @@ static s32 STWI_restart_Command(void) } else { - if (gRfuState->reqActiveCommand == RFU_MS_CHANGE || gRfuState->reqActiveCommand == RFU_DATA_TX_AND_CHANGE || gRfuState->reqActiveCommand == RFU_UNK35 || gRfuState->reqActiveCommand == RFU_RESUME_RETRANSMIT_AND_CHANGE) + if (gRfuState->reqActiveCommand == ID_MS_CHANGE_REQ || gRfuState->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ || gRfuState->reqActiveCommand == ID_UNK35_REQ || gRfuState->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ) { gRfuState->error = 1; gRfuState->unk_2c = 0; -- cgit v1.2.3 From 0ce29c0ee9e7a37089e9bea8111ef40e16d6a63e Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Fri, 10 Jan 2020 03:17:00 +0800 Subject: use constants --- src/librfu_rfu.c | 333 ++++++++++++++++++++++++++--------------------------- src/librfu_s32id.c | 8 +- src/librfu_stwi.c | 292 +++++++++++++++++++++++----------------------- 3 files changed, 317 insertions(+), 316 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 7e4e26fad..70d5b4990 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -70,14 +70,13 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8, struct NIComm *); extern const char _Str_RFU_MBOOT[]; extern const struct RfuHeader _Str_RfuHeader[2]; -struct STWIStatus *gRfuState; -ALIGNED(8) struct RfuSlotStatusUNI *gRfuSlotStatusUNI[RFU_CHILD_MAX]; +struct RfuSlotStatusUNI *gRfuSlotStatusUNI[RFU_CHILD_MAX]; struct RfuSlotStatusNI *gRfuSlotStatusNI[RFU_CHILD_MAX]; struct RfuLinkStatus *gRfuLinkStatus; struct RfuStatic *gRfuStatic; struct RfuFixed *gRfuFixed; -u16 rfu_initializeAPI(struct RfuStructsBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam) +u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam) { u16 i; u16 *dst; @@ -86,24 +85,24 @@ u16 rfu_initializeAPI(struct RfuStructsBuffer *APIBuffer, u16 buffByteSize, Intr // is in EWRAM? if (((u32)APIBuffer & 0xF000000) == 0x2000000 && copyInterruptToRam) - return 2; + return ERR_RFU_API_BUFF_ADR; // is not 4-byte aligned? if ((u32)APIBuffer & 3) - return 2; + return ERR_RFU_API_BUFF_ADR; if (copyInterruptToRam) { // An assert/debug print may have existed before, ie // printf("%s %u < %u", "somefile.c:12345", buffByteSize, num) // to push this into r3? - r3 = 0xe64; + r3 = sizeof(struct RfuAPIBuffer); if (buffByteSize < r3) - return 1; + return ERR_RFU_API_BUFF_SIZE; } if (!copyInterruptToRam) { - r3 = 0x504; // same as above, this should be r3 not r0 + r3 = 0x504; // same issue as above if (buffByteSize < r3) - return 1; + return ERR_RFU_API_BUFF_SIZE; } gRfuLinkStatus = &APIBuffer->linkStatus; gRfuStatic = &APIBuffer->static_; @@ -124,9 +123,9 @@ u16 rfu_initializeAPI(struct RfuStructsBuffer *APIBuffer, u16 buffByteSize, Intr rfu_STC_clearAPIVariables(); for (i = 0; i < RFU_CHILD_MAX; ++i) { - gRfuSlotStatusNI[i]->recvBuffer = 0; + gRfuSlotStatusNI[i]->recvBuffer = NULL; gRfuSlotStatusNI[i]->recvBufferSize = 0; - gRfuSlotStatusUNI[i]->recvBuffer = 0; + gRfuSlotStatusUNI[i]->recvBuffer = NULL; gRfuSlotStatusUNI[i]->recvBufferSize = 0; } src = (const u16 *)((u32)&rfu_STC_fastCopy & ~1); @@ -150,7 +149,7 @@ static void rfu_STC_clearAPIVariables(void) CpuFill16(0, gRfuLinkStatus, sizeof(struct RfuLinkStatus)); gRfuLinkStatus->watchInterval = 4; gRfuStatic->nowWatchInterval = 0; - gRfuLinkStatus->parentChild = 0xFF; + gRfuLinkStatus->parentChild = MODE_NEUTRAL; rfu_clearAllSlot(); gRfuStatic->SCStartFlag = 0; for (i = 0; i < NELEMS(gRfuStatic->cidBak); ++i) @@ -169,8 +168,8 @@ u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) struct RfuIntrStruct *buf; *ackFlag = 0; - if (gRfuLinkStatus->parentChild != 1) - return 0x300; + if (gRfuLinkStatus->parentChild != MODE_PARENT) + return ERR_MODE_NOT_PARENT; buf = rfu_getSTWIRecvBuffer(); switch (buf->rxPacketAlloc.rfuPacket8.data[0]) { @@ -182,7 +181,7 @@ u16 rfu_UNI_PARENT_getDRAC_ACK(u8 *ackFlag) *ackFlag = buf->rxPacketAlloc.rfuPacket8.data[4]; return 0; default: - return 0x10; + return ERR_REQ_CMD_ID; } } @@ -233,10 +232,10 @@ static void rfu_CB_defaultCallback(u8 r0, u16 reqResult) if (gRfuStatic->flags & 8) gRfuFixed->reqCallback(r0, reqResult); r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; - for (i = 0; i < 4; ++i) + for (i = 0; i < RFU_CHILD_MAX; ++i) if ((r5 >> i) & 1) rfu_STC_removeLinkData(i, 1); - gRfuLinkStatus->parentChild = 0xFF; + gRfuLinkStatus->parentChild = MODE_NEUTRAL; } } @@ -255,7 +254,7 @@ void rfu_REQ_RFUStatus(void) u16 rfu_getRFUStatus(u8 *rfuState) { if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[0] != 0x93) - return 0x10; + return ERR_REQ_CMD_ID; if (STWI_poll_CommandEnd() == 0) *rfuState = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7]; else @@ -292,7 +291,7 @@ void rfu_REQ_stopMode(void) if (REG_IME == 0) { rfu_STC_REQ_callback(61, 6); - gRfuState->error = 6; + gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE; } else { @@ -300,7 +299,7 @@ void rfu_REQ_stopMode(void) rfu_STC_clearAPIVariables(); if (AgbRFU_checkID(8) == 0x8001) { - timerReg = ®_TMCNT(gRfuState->timerSelect); + timerReg = ®_TMCNT(gSTWIStatus->timerSelect); *timerReg = 0; *timerReg = (TIMER_ENABLE | TIMER_1024CLK) << 16; while (*timerReg << 16 < 262 << 16) @@ -326,10 +325,10 @@ static void rfu_CB_stopMode(u8 a1, u16 reqResult) u32 rfu_REQBN_softReset_and_checkID(void) { - s32 r2; + u32 r2; if (REG_IME == 0) - return -1; + return ERR_ID_CHECK_IME_DISABLE; AgbRFU_SoftReset(); rfu_STC_clearAPIVariables(); if ((r2 = AgbRFU_checkID(30)) == 0) @@ -353,7 +352,7 @@ static void rfu_CB_reset(u8 a1, u16 reqResult) void rfu_REQ_configSystem(u16 availSlotFlag, u8 maxMFrame, u8 mcTimer) { STWI_set_Callback_M(rfu_STC_REQ_callback); - STWI_send_SystemConfigREQ((availSlotFlag & 3) | 0x3C, maxMFrame, mcTimer); + STWI_send_SystemConfigREQ((availSlotFlag & AVAIL_SLOT1) | 0x3C, maxMFrame, mcTimer); if (mcTimer == 0) { gRfuStatic->unk_1a = 1; @@ -405,7 +404,7 @@ static void rfu_CB_configGameData(u8 ip, u16 r7) if (r7 == 0) { - r1 = gRfuState->txPacket->rfuPacket8.data; + r1 = gSTWIStatus->txPacket->rfuPacket8.data; r2 = gRfuLinkStatus->my.serialNo = r1[4]; gRfuLinkStatus->my.serialNo = (r1[5] << 8) | r2; r4 = &r1[6]; @@ -500,7 +499,7 @@ static void rfu_CB_pollAndEndSearchChild(u8 r4, u16 reqResult) } else if (r4 == 27) { - if (gRfuLinkStatus->parentChild == 255) + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) gRfuLinkStatus->my.id = 0; gRfuStatic->SCStartFlag = 0; } @@ -534,7 +533,7 @@ static void rfu_STC_readChildList(void) r4 += 4) { r2 = r4[2]; - if (r2 < 4 && !((gRfuLinkStatus->connSlotFlag >> r2) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> r2) & 1)) + if (r2 < RFU_CHILD_MAX && !((gRfuLinkStatus->connSlotFlag >> r2) & 1) && !((gRfuLinkStatus->linkLossSlotFlag >> r2) & 1)) { if (sp[r2] != 0) ++gRfuStatic->lsFixedCount[r2]; @@ -546,7 +545,7 @@ static void rfu_STC_readChildList(void) ++gRfuLinkStatus->connCount; gRfuLinkStatus->partner[r2].id = *(u16 *)r4; gRfuLinkStatus->partner[r2].slot = r2; - gRfuLinkStatus->parentChild = 1; + gRfuLinkStatus->parentChild = MODE_PARENT; gRfuStatic->flags &= 0x7F; gRfuStatic->cidBak[r2] = gRfuLinkStatus->partner[r2].id; } @@ -682,7 +681,7 @@ static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) gRfuLinkStatus->linkLossSlotFlag &= ~r2; gRfuLinkStatus->my.id = id; ++gRfuLinkStatus->connCount; - gRfuLinkStatus->parentChild = 0; + gRfuLinkStatus->parentChild = MODE_CHILD; gRfuStatic->flags |= 0x80; for (r5 = 0; r5 < RFU_CHILD_MAX; ++r5) { @@ -702,7 +701,7 @@ static void rfu_CB_pollConnectParent(u8 sp24, u16 sp28) break; } } - if (r5 < 4) + if (r5 < RFU_CHILD_MAX) { CpuCopy16(r9, &gRfuLinkStatus->partner[slot], sizeof(struct RfuTgtData)); gRfuLinkStatus->partner[slot].slot = slot; @@ -727,7 +726,7 @@ u16 rfu_getConnectParentStatus(u8 *status, u8 *connectSlotNo) *status = r2[1]; return 0; } - return 0x10; + return ERR_REQ_CMD_ID; } void rfu_REQ_endConnectParent(void) @@ -744,7 +743,7 @@ u16 rfu_syncVBlank(void) s32 r5; rfu_NI_checkCommFailCounter(); - if (gRfuLinkStatus->parentChild == 0xFF) + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) return 0; if (gRfuStatic->nowWatchInterval != 0) --gRfuStatic->nowWatchInterval; @@ -771,10 +770,10 @@ u16 rfu_syncVBlank(void) { gRfuStatic->flags &= 0xFB; r5 = gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag; - for (r4 = 0; r4 < 4; ++r4) + for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) if ((r5 >> r4) & 1) rfu_STC_removeLinkData(r4, 1); - gRfuLinkStatus->parentChild = 0xFF; + gRfuLinkStatus->parentChild = MODE_NEUTRAL; return 1; } --gRfuStatic->watchdogTimer; @@ -791,9 +790,9 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason u8 r9, r6, r3, connSlotFlag, r0; *bmLinkLossSlot = 0; - *linkLossReason = 0; + *linkLossReason = REASON_DISCONNECTED; *parentBmLinkRecoverySlot = 0; - if (gRfuLinkStatus->parentChild == 0xFF || gRfuState->msMode == 0) + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL || gSTWIStatus->msMode == 0) return 0; if (gRfuStatic->flags & 4) gRfuStatic->watchdogTimer = 360; @@ -808,7 +807,7 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason *bmLinkLossSlot = r1[4]; *linkLossReason = r1[5]; - if (*linkLossReason == 1) + if (*linkLossReason == REASON_LINK_LOSS) *bmLinkLossSlot = gRfuLinkStatus->connSlotFlag; sp08 = 2; } @@ -819,7 +818,7 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason r6 = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[5]; r6 ^= gRfuLinkStatus->connSlotFlag; *bmLinkLossSlot = r6 & gRfuLinkStatus->connSlotFlag; - *linkLossReason = 1; + *linkLossReason = REASON_LINK_LOSS; for (i = 0; i < RFU_CHILD_MAX; ++i) { if ((*bmLinkLossSlot >> i) & 1) @@ -850,7 +849,7 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason rfu_STC_REQ_callback(17, sp0C); return sp0C; } - for (; i < 4; ++i) + for (; i < RFU_CHILD_MAX; ++i) { r6 = 1 << i; if (sp0C == 0) @@ -859,13 +858,13 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason { if (gRfuLinkStatus->strength[i] == 0) { - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) { ++gRfuStatic->linkEmergencyFlag[i]; if (gRfuStatic->linkEmergencyFlag[i] > 3) { *bmLinkLossSlot |= r6; - *linkLossReason = sp08; // why not directly use 1? + *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS? } } else @@ -876,7 +875,7 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason if (gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[7] == 0) { *bmLinkLossSlot |= r6; - *linkLossReason = sp08; + *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS? } else { @@ -886,7 +885,7 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason STWI_send_DisconnectREQ(gRfuLinkStatus->connSlotFlag); STWI_poll_CommandEnd(); *bmLinkLossSlot |= r6; - *linkLossReason = sp08; // why not directly use 1? + *linkLossReason = sp08; // why not directly use REASON_LINK_LOSS? } } } @@ -897,7 +896,7 @@ u16 rfu_REQBN_watchLink(u16 reqCommandId, u8 *bmLinkLossSlot, u8 *linkLossReason gRfuStatic->linkEmergencyFlag[i] = sp0C; // why not directly use 0? } } - if (gRfuLinkStatus->parentChild == 1 && gRfuLinkStatus->strength[i] != 0) + if (gRfuLinkStatus->parentChild == MODE_PARENT && gRfuLinkStatus->strength[i] != 0) { if (r6 & gRfuLinkStatus->linkLossSlotFlag) { @@ -964,7 +963,7 @@ static void rfu_STC_removeLinkData(u8 r7, u8 r12) gRfuLinkStatus->connSlotFlag &= r6 = ~r5; gRfuLinkStatus->linkLossSlotFlag |= r5; if ((*(u32 *)gRfuLinkStatus & 0xFF00FF) == 0) - gRfuLinkStatus->parentChild = 0xFF; + gRfuLinkStatus->parentChild = MODE_NEUTRAL; if (r12 != 0) { CpuFill16(0, &gRfuLinkStatus->partner[r7], sizeof(struct RfuTgtData)); @@ -981,7 +980,7 @@ void rfu_REQ_disconnect(u8 bmDisconnectSlot) if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmDisconnectSlot) { gRfuStatic->recoveryBmSlot = bmDisconnectSlot; - if (gRfuLinkStatus->parentChild == 0xFF && gRfuStatic->flags & 0x80) + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL && gRfuStatic->flags & 0x80) { if (gRfuLinkStatus->linkLossSlotFlag & bmDisconnectSlot) rfu_CB_disconnect(48, 0); @@ -1005,7 +1004,7 @@ static void rfu_CB_disconnect(u8 r6, u16 r5) { u8 r4, r0; - if (r5 == 3 && gRfuLinkStatus->parentChild == 0) + if (r5 == 3 && gRfuLinkStatus->parentChild == MODE_CHILD) { STWI_set_Callback_M(rfu_CB_defaultCallback); STWI_send_SystemStatusREQ(); @@ -1016,7 +1015,7 @@ static void rfu_CB_disconnect(u8 r6, u16 r5) gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[8] = gRfuStatic->recoveryBmSlot; if (r5 == 0) { - for (r4 = 0; r4 < 4; ++r4) + for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) { r0 = 1 << r4; if (r0 & gRfuStatic->recoveryBmSlot) @@ -1024,7 +1023,7 @@ static void rfu_CB_disconnect(u8 r6, u16 r5) } } if ((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) == 0) - gRfuLinkStatus->parentChild = 0xFF; + gRfuLinkStatus->parentChild = MODE_NEUTRAL; rfu_STC_REQ_callback(r6, r5); if (gRfuStatic->SCStartFlag) { @@ -1041,7 +1040,7 @@ void rfu_REQ_CHILD_startConnectRecovery(u8 bmRecoverySlot) u8 i; gRfuStatic->recoveryBmSlot = bmRecoverySlot; - for (i = 0; i < 4 && !((bmRecoverySlot >> i) & 1); ++i) + for (i = 0; i < RFU_CHILD_MAX && !((bmRecoverySlot >> i) & 1); ++i) ; STWI_set_Callback_M(rfu_STC_REQ_callback); // if i == 4, gRfuLinkStatus->partner[i].id becomes gRfuLinkStatus->my.id @@ -1061,7 +1060,7 @@ static void rfu_CB_CHILD_pollConnectRecovery(u8 r8, u16 r7) if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4] == 0 && gRfuStatic->recoveryBmSlot) { - gRfuLinkStatus->parentChild = 0; + gRfuLinkStatus->parentChild = MODE_CHILD; for (r4 = 0; r4 < NELEMS(gRfuStatic->linkEmergencyFlag); ++r4) { r3 = 1 << r4; @@ -1090,7 +1089,7 @@ u16 rfu_CHILD_getConnectRecoveryStatus(u8 *status) *status = gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[4]; return 0; } - return 0x10; + return ERR_REQ_CMD_ID; } void rfu_REQ_CHILD_endConnectRecovery(void) @@ -1126,19 +1125,19 @@ void rfu_REQ_changeMasterSlave(void) bool8 rfu_getMasterSlave(void) { - bool8 r2 = STWI_read_status(1); + bool8 masterSlave = STWI_read_status(1); - if (r2 == 1) + if (masterSlave == AGB_CLK_MASTER) { - if (gRfuState->unk_2c) + if (gSTWIStatus->unk_2c) { - if (gRfuState->reqActiveCommand == 39 - || gRfuState->reqActiveCommand == 37 - || gRfuState->reqActiveCommand == 55) - r2 = 0; + if (gSTWIStatus->reqActiveCommand == 39 + || gSTWIStatus->reqActiveCommand == 37 + || gSTWIStatus->reqActiveCommand == 55) + masterSlave = AGB_CLK_SLAVE; } } - return r2; + return masterSlave; } void rfu_clearAllSlot(void) @@ -1153,7 +1152,7 @@ void rfu_clearAllSlot(void) CpuFill16(0, gRfuSlotStatusUNI[i], sizeof(struct UNISend) + sizeof(struct UNIRecv)); gRfuLinkStatus->remainLLFrameSizeChild[i] = 16; } - gRfuLinkStatus->remainLLFrameSizeParent = 87; + gRfuLinkStatus->remainLLFrameSizeParent = LLF_P_SIZE; gRfuLinkStatus->sendSlotNIFlag = 0; gRfuLinkStatus->recvSlotNIFlag = 0; gRfuLinkStatus->sendSlotUNIFlag = 0; @@ -1184,19 +1183,19 @@ u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) struct NIComm *r4; if (slotStatusIndex >= RFU_CHILD_MAX) - return 0x400; - if ((connTypeFlag & 0xF) == 0) - return 0x600; + return ERR_SLOT_NO; + if (!(connTypeFlag & (TYPE_UNI_SEND | TYPE_UNI_RECV | TYPE_NI_SEND | TYPE_NI_RECV))) + return ERR_COMM_TYPE; r10 = REG_IME; REG_IME = 0; - if (connTypeFlag & 0xC) + if (connTypeFlag & (TYPE_NI_SEND | TYPE_NI_RECV)) { for (r3 = 0; r3 < 2; ++r3) { r4 = NULL; if (r3 == 0) { - if (connTypeFlag & 4) + if (connTypeFlag & TYPE_NI_SEND) { r4 = &gRfuSlotStatusNI[slotStatusIndex]->send; gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlotOrg; @@ -1204,7 +1203,7 @@ u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) } else { - if (connTypeFlag & 8) + if (connTypeFlag & TYPE_NI_RECV) { r4 = &gRfuSlotStatusNI[slotStatusIndex]->recv; gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex); @@ -1212,10 +1211,10 @@ u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) } if (r4 != NULL) { - if (r4->state & 0x8000) + if (r4->state & SLOT_BUSY_FLAG) { rfu_STC_releaseFrame(slotStatusIndex, r3, r4); - for (r1 = 0; r1 < 4; ++r1) + for (r1 = 0; r1 < RFU_CHILD_MAX; ++r1) if ((r4->bmSlotOrg >> r1) & 1) r4->failCounter = 0; } @@ -1223,11 +1222,11 @@ u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) } } } - if (connTypeFlag & 1) + if (connTypeFlag & TYPE_UNI_SEND) { struct RfuSlotStatusUNI *r3 = gRfuSlotStatusUNI[slotStatusIndex]; - if (r3->send.state & 0x8000) + if (r3->send.state & SLOT_BUSY_FLAG) { if (!(gRfuStatic->flags & 0x80)) gRfuLinkStatus->remainLLFrameSizeParent += 3 + (u8)r3->send.payloadSize; @@ -1237,7 +1236,7 @@ u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) } CpuFill16(0, &r3->send, sizeof(struct UNISend)); } - if (connTypeFlag & 2) + if (connTypeFlag & TYPE_UNI_RECV) { CpuFill16(0, &gRfuSlotStatusUNI[slotStatusIndex]->recv, sizeof(struct UNIRecv)); } @@ -1248,15 +1247,15 @@ u16 rfu_clearSlot(u8 connTypeFlag, u8 slotStatusIndex) u16 rfu_setRecvBuffer(u8 connType, u8 slotNo, void *buffer, u32 buffSize) { if (slotNo >= RFU_CHILD_MAX) - return 0x400; - if (connType & 0x20) + return ERR_SLOT_NO; + if (connType & TYPE_NI) { gRfuSlotStatusNI[slotNo]->recvBuffer = buffer; gRfuSlotStatusNI[slotNo]->recvBufferSize = buffSize; } - else if (!(connType & 0x10)) + else if (!(connType & TYPE_UNI)) { - return 0x600; + return ERR_COMM_TYPE; } else { @@ -1275,7 +1274,7 @@ u16 rfu_UNI_setSendData(u8 bmSendSlot, const void *src, u8 size) { u8 subFrameSize; - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) subFrameSize = size + 3; else subFrameSize = size + 2; @@ -1298,27 +1297,27 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const struct RfuSlotStatusUNI *r1; struct RfuSlotStatusNI *r12; - if (gRfuLinkStatus->parentChild == 0xFF) - return 0x301; + if (gRfuLinkStatus->parentChild == MODE_NEUTRAL) + return ERR_MODE_NOT_CONNECTED; if (!(bmSendSlot & 0xF)) - return 0x400; + return ERR_SLOT_NO; if (((gRfuLinkStatus->connSlotFlag | gRfuLinkStatus->linkLossSlotFlag) & bmSendSlot) != bmSendSlot) - return 0x401; + return ERR_SLOT_NOT_CONNECTED; if (r6 & 0x10) r0 = gRfuLinkStatus->sendSlotUNIFlag; else r0 = gRfuLinkStatus->sendSlotNIFlag; if (r0 & bmSendSlot) - return 0x402; - for (r2 = 0; r2 < 4 && !((bmSendSlot >> r2) & 1); ++r2) + return ERR_SLOT_BUSY; + for (r2 = 0; r2 < RFU_CHILD_MAX && !((bmSendSlot >> r2) & 1); ++r2) ; - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) r9 = &gRfuLinkStatus->remainLLFrameSizeParent; - else if (gRfuLinkStatus->parentChild == 0) + else if (gRfuLinkStatus->parentChild == MODE_CHILD) r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2]; r4 = _Str_RfuHeader[gRfuLinkStatus->parentChild].unk00; if (subFrameSize > *r9 || subFrameSize <= r4) - return 0x500; + return ERR_SUBFRAME_SIZE; sp04 = REG_IME; REG_IME = 0; r5 = r6 & 0x20; @@ -1355,7 +1354,7 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const gRfuSlotStatusNI[r2]->send.failCounter = 0; gRfuLinkStatus->sendSlotNIFlag |= bmSendSlot; *r9 -= subFrameSize; - r12->send.state = 0x8021; + r12->send.state = SLOT_STATE_SEND_START; } else if (r6 & 0x10) { @@ -1364,7 +1363,7 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const r1->send.src = src; r1->send.payloadSize = subFrameSize - r4; *r9 -= subFrameSize; - r1->send.state = 0x8024; + r1->send.state = SLOT_STATE_SEND_UNI; gRfuLinkStatus->sendSlotUNIFlag |= bmSendSlot; } REG_IME = sp04; @@ -1378,12 +1377,12 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) u8 r2; if (slotStatusIndex >= RFU_CHILD_MAX) - return 0x400; + return ERR_SLOT_NO; if (connType == 0x20) { r5 = gRfuSlotStatusNI[slotStatusIndex]; - if ((r5->send.state & 0x8000) - && (r5->send.state & 0x20)) + if ((r5->send.state & SLOT_BUSY_FLAG) + && (r5->send.state & SLOT_SEND_FLAG)) { connType = bmNewTgtSlot ^ r5->send.bmSlot; @@ -1403,19 +1402,19 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) if (r5->send.bmSlot == 0) { rfu_STC_releaseFrame(slotStatusIndex, 0, &r5->send); - r5->send.state = 39; + r5->send.state = SLOT_STATE_SEND_FAILED; } REG_IME = r8; } } else { - return 0x404; + return ERR_SLOT_TARGET; } } else { - return 0x403; + return ERR_SLOT_NOT_SENDING; } } else @@ -1424,13 +1423,13 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) { s32 r3; - if (gRfuSlotStatusUNI[slotStatusIndex]->send.state != 0x8024) - return 0x403; + if (gRfuSlotStatusUNI[slotStatusIndex]->send.state != SLOT_STATE_SEND_UNI) + return ERR_SLOT_NOT_SENDING; for (r3 = 0, r2 = 0; r2 < RFU_CHILD_MAX; ++r2) if (r2 != slotStatusIndex) r3 |= gRfuSlotStatusUNI[r2]->send.bmSlot; if (bmNewTgtSlot & r3) - return 0x404; + return ERR_SLOT_TARGET; r8 = REG_IME; REG_IME = 0; gRfuLinkStatus->sendSlotUNIFlag &= ~gRfuSlotStatusUNI[slotStatusIndex]->send.bmSlot; @@ -1440,7 +1439,7 @@ u16 rfu_changeSendTarget(u8 connType, u8 slotStatusIndex, u8 bmNewTgtSlot) } else { - return 0x600; + return ERR_COMM_TYPE; } } return 0; @@ -1451,18 +1450,18 @@ u16 rfu_NI_stopReceivingData(u8 slotStatusIndex) struct NIComm *r5; u16 r4, r1; - if (slotStatusIndex > 3) - return 0x400; + if (slotStatusIndex >= RFU_CHILD_MAX) + return ERR_SLOT_NO; r5 = &gRfuSlotStatusNI[slotStatusIndex]->recv; r4 = REG_IME; ++r4; --r4; // fix r4, r5 register swap REG_IME = 0; - if (gRfuSlotStatusNI[slotStatusIndex]->recv.state & 0x8000) + if (gRfuSlotStatusNI[slotStatusIndex]->recv.state & SLOT_BUSY_FLAG) { - if (gRfuSlotStatusNI[slotStatusIndex]->recv.state == 0x8043) - gRfuSlotStatusNI[slotStatusIndex]->recv.state = 72; + if (gRfuSlotStatusNI[slotStatusIndex]->recv.state == SLOT_STATE_RECV_LAST) + gRfuSlotStatusNI[slotStatusIndex]->recv.state = SLOT_STATE_RECV_SUCCESS_AND_SENDSIDE_UNKNOWN; else - gRfuSlotStatusNI[slotStatusIndex]->recv.state = 71; + gRfuSlotStatusNI[slotStatusIndex]->recv.state = SLOT_STATE_RECV_FAILED; gRfuLinkStatus->recvSlotNIFlag &= ~(1 << slotStatusIndex); rfu_STC_releaseFrame(slotStatusIndex, 1, r5); } @@ -1478,11 +1477,11 @@ u16 rfu_UNI_changeAndReadySendData(u8 slotStatusIndex, const void *src, u8 size) u8 r3_; if (slotStatusIndex >= RFU_CHILD_MAX) - return 0x400; + return ERR_SLOT_NO; r4 = &gRfuSlotStatusUNI[slotStatusIndex]->send; - if (r4->state != 0x8024) - return 0x403; - if (gRfuLinkStatus->parentChild == 1) + if (r4->state != SLOT_STATE_SEND_UNI) + return ERR_SLOT_NOT_SENDING; + if (gRfuLinkStatus->parentChild == MODE_PARENT) { r6 = &gRfuLinkStatus->remainLLFrameSizeParent; r3_ = gRfuLinkStatus->remainLLFrameSizeParent + (u8)r4->payloadSize; @@ -1493,7 +1492,7 @@ u16 rfu_UNI_changeAndReadySendData(u8 slotStatusIndex, const void *src, u8 size) r3_ = gRfuLinkStatus->remainLLFrameSizeChild[slotStatusIndex] + (u8)r4->payloadSize; } if (r3_ < size) - return 0x500; + return ERR_SUBFRAME_SIZE; r1 = REG_IME; REG_IME = 0; r4->src = src; @@ -1508,7 +1507,7 @@ void rfu_UNI_readySendData(u8 slotStatusIndex) { if (slotStatusIndex < RFU_CHILD_MAX) { - if (gRfuSlotStatusUNI[slotStatusIndex]->send.state == 0x8024) + if (gRfuSlotStatusUNI[slotStatusIndex]->send.state == SLOT_STATE_SEND_UNI) gRfuSlotStatusUNI[slotStatusIndex]->send.dataReadyFlag = 1; } } @@ -1521,7 +1520,7 @@ void rfu_UNI_clearRecvNewDataFlag(u8 slotStatusIndex) void rfu_REQ_sendData(u8 clockChangeFlag) { - if (gRfuLinkStatus->parentChild != 0xFF) + if (gRfuLinkStatus->parentChild != MODE_NEUTRAL) { if (gRfuLinkStatus->parentChild == 1 && !(gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag)) @@ -1565,10 +1564,10 @@ void rfu_REQ_sendData(u8 clockChangeFlag) } if (clockChangeFlag != 0) { - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) { - if (gRfuState->callbackS != NULL) - gRfuState->callbackS(39); + if (gSTWIStatus->callbackS != NULL) + gSTWIStatus->callbackS(39); } else { @@ -1591,13 +1590,13 @@ static void rfu_CB_sendData(UNUSED u8 r0, u16 r7) if (gRfuSlotStatusUNI[r6]->send.dataReadyFlag) gRfuSlotStatusUNI[r6]->send.dataReadyFlag = 0; r4 = &gRfuSlotStatusNI[r6]->send; - if (r4->state == 0x8020) + if (r4->state == SLOT_STATE_SEND_NULL) { rfu_STC_releaseFrame(r6, 0, r4); gRfuLinkStatus->sendSlotNIFlag &= ~r4->bmSlot; if (r4->dataType == 1) gRfuLinkStatus->getNameFlag |= 1 << r6; - r4->state = 38; + r4->state = SLOT_STATE_SEND_SUCCESS; } } } @@ -1625,7 +1624,7 @@ static void rfu_constructSendLLFrame(void) u8 *sp00; struct RfuSlotStatusNI *r2; - if (gRfuLinkStatus->parentChild != 0xFF + if (gRfuLinkStatus->parentChild != MODE_NEUTRAL && gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag) { gRfuLinkStatus->LLFReadyFlag = 0; @@ -1634,15 +1633,15 @@ static void rfu_constructSendLLFrame(void) for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) { r5 = 0; - if (gRfuSlotStatusNI[r6]->send.state & 0x8000) + if (gRfuSlotStatusNI[r6]->send.state & SLOT_BUSY_FLAG) r5 = rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->send); - if (gRfuSlotStatusNI[r6]->recv.state & 0x8000) + if (gRfuSlotStatusNI[r6]->recv.state & SLOT_BUSY_FLAG) r5 += rfu_STC_NI_constructLLSF(r6, &sp00, &gRfuSlotStatusNI[r6]->recv); - if (gRfuSlotStatusUNI[r6]->send.state == 0x8024) + if (gRfuSlotStatusUNI[r6]->send.state == SLOT_STATE_SEND_UNI) r5 += rfu_STC_UNI_constructLLSF(r6, &sp00); if (r5 != 0) { - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) r8 += r5; else r8 |= r5 << (5 * r6 + 8); @@ -1653,7 +1652,7 @@ static void rfu_constructSendLLFrame(void) while ((u32)sp00 & 3) *sp00++ = 0; gRfuFixed->LLFBuffer[0] = r8; - if (gRfuLinkStatus->parentChild == 0) + if (gRfuLinkStatus->parentChild == MODE_CHILD) { u8 *r0 = sp00 - offsetof(struct RfuFixed, LLFBuffer[1]); @@ -1675,7 +1674,7 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) u8 *r2; const struct RfuHeader *r8 = &_Str_RfuHeader[gRfuLinkStatus->parentChild]; - if (r4->state == 0x8022) + if (r4->state == SLOT_STATE_SENDING) { while (r4->now_p[r4->phase] >= (const u8 *)r4->src + r4->dataSize) { @@ -1684,11 +1683,11 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) r4->phase = 0; } } - if (r4->state & 0x40) + if (r4->state & SLOT_RECV_FLAG) { r5 = 0; } - else if (r4->state == 0x8022) + else if (r4->state == SLOT_STATE_SENDING) { if (r4->now_p[r4->phase] + r4->payloadSize > (const u8 *)r4->src + r4->dataSize) r5 = (const u8 *)r4->src + r4->dataSize - r4->now_p[r4->phase]; @@ -1707,7 +1706,7 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) | r4->phase << r8->unk05 | r4->n[r4->phase] << r8->unk06 | r5; - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) sp00 |= r4->bmSlot << 18; r2 = (u8 *)&sp00; for (i = 0; i < r8->unk00; ++i) @@ -1718,13 +1717,13 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) gRfuFixed->fastCopyPtr(&sp04, r12, r5); } - if (r4->state == 0x8022) + if (r4->state == SLOT_STATE_SENDING) { ++r4->phase; if (r4->phase == 4) r4->phase = 0; } - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) gRfuLinkStatus->LLFReadyFlag = 1; else gRfuLinkStatus->LLFReadyFlag |= 1 << r10; @@ -1745,14 +1744,14 @@ static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) r5 = &_Str_RfuHeader[gRfuLinkStatus->parentChild]; sp00 = (r4->state & 0xF) << r5->unk03 | r4->payloadSize; - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) sp00 |= r4->bmSlot << 18; r2 = (u8 *)&sp00; for (i = 0; i < r5->unk00; ++i) *(*r6)++ = *r2++; sp04 = r4->src; gRfuFixed->fastCopyPtr(&sp04, r6, r4->payloadSize); - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) gRfuLinkStatus->LLFReadyFlag = 16; else gRfuLinkStatus->LLFReadyFlag |= 16 << r8; @@ -1761,7 +1760,7 @@ static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) void rfu_REQ_recvData(void) { - if (gRfuLinkStatus->parentChild != 0xFF) + if (gRfuLinkStatus->parentChild != MODE_NEUTRAL) { gRfuStatic->commExistFlag = gRfuLinkStatus->sendSlotNIFlag | gRfuLinkStatus->recvSlotNIFlag | gRfuLinkStatus->sendSlotUNIFlag; gRfuStatic->recvErrorFlag = 0; @@ -1779,25 +1778,25 @@ static void rfu_CB_recvData(u8 r9, u16 r7) if (r7 == 0 && gRfuFixed->STWIBuffer->rxPacketAlloc.rfuPacket8.data[1]) { gRfuStatic->NIEndRecvFlag = 0; - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) rfu_STC_PARENT_analyzeRecvPacket(); else rfu_STC_CHILD_analyzeRecvPacket(); for (r6 = 0; r6 < RFU_CHILD_MAX; ++r6) { r4 = gRfuSlotStatusNI[r6]; - if (r4->recv.state == 0x8043 && !((gRfuStatic->NIEndRecvFlag >> r6) & 1)) + if (r4->recv.state == SLOT_STATE_RECV_LAST && !((gRfuStatic->NIEndRecvFlag >> r6) & 1)) { r5 = &r4->recv; if (r5->dataType == 1) gRfuLinkStatus->getNameFlag |= 1 << r6; rfu_STC_releaseFrame(r6, 1, r5); gRfuLinkStatus->recvSlotNIFlag &= ~r5->bmSlot; - r4->recv.state = 70; + r4->recv.state = SLOT_STATE_RECV_SUCCESS; } } if (gRfuStatic->recvErrorFlag) - r7 = gRfuStatic->recvErrorFlag | 0x700; + r7 = gRfuStatic->recvErrorFlag | ERR_DATA_RECV; } rfu_STC_REQ_callback(r9, r7); } @@ -1864,7 +1863,7 @@ static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) u32 r0; u16 r10; - r6 = &_Str_RfuHeader[~gRfuLinkStatus->parentChild & 1]; + r6 = &_Str_RfuHeader[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)]; if (r3 < r6->unk00) return r3; r5 = 0; @@ -1880,7 +1879,7 @@ static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) r10 = sp00.unk06 + r6->unk00; if (sp00.unk00 == 0) { - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) { if ((gRfuLinkStatus->connSlotFlag >> r12) & 1) { @@ -1909,7 +1908,7 @@ static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) if (r5) { - for (r4 = 0; r4 < 4; ++r4) + for (r4 = 0; r4 < RFU_CHILD_MAX; ++r4) { if ((r5 >> r4) & 1) { @@ -1937,8 +1936,8 @@ static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 r5->errorCode = 0; if (gRfuSlotStatusUNI[r7]->recvBufferSize < r6->unk06) { - r3->recv.state = 73; - r5->errorCode = 0x701; + r3->recv.state = SLOT_STATE_RECV_IGNORE; + r5->errorCode = ERR_RECV_BUFF_OVER; } else { @@ -1946,16 +1945,16 @@ static void rfu_STC_UNI_receive(u8 r7, const struct RfuLocalStruct *r6, const u8 { if (r5->newDataFlag) { - r5->errorCode = 0x709; + r5->errorCode = ERR_RECV_UNK; goto _081E2F0E; } } else { if (r5->newDataFlag) - r5->errorCode = 0x708; + r5->errorCode = ERR_RECV_DATA_OVERWRITED; } - r5->state = 0x8042; + r5->state = SLOT_STATE_RECEIVING; r2 = r5->dataSize = r6->unk06; sp04 = gRfuSlotStatusUNI[r7]->recvBuffer; gRfuFixed->fastCopyPtr(&sp00, &sp04, r2); @@ -1976,9 +1975,9 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct u8 r4; u16 r2; - if ((r6->unk02 == 2 && r9 == 0x8022) - || (r6->unk02 == 1 && r9 == 0x8021) - || (r6->unk02 == 3 && r9 == 0x8023)) + if ((r6->unk02 == 2 && r9 == SLOT_STATE_SENDING) + || (r6->unk02 == 1 && r9 == SLOT_STATE_SEND_START) + || (r6->unk02 == 3 && r9 == SLOT_STATE_SEND_LAST)) { if (r12->n[r6->unk04] == r6->unk05) r12->recvAckFlag[r6->unk04] |= 1 << r10; @@ -1987,9 +1986,9 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct { r12->n[r6->unk04] = (r12->n[r6->unk04] + 1) & 3; r12->recvAckFlag[r6->unk04] = 0; - if ((u16)(r12->state + ~0x8020) <= 1) + if ((u16)(r12->state + ~SLOT_STATE_SEND_NULL) <= 1) { - if (r12->state == 0x8021) + if (r12->state == SLOT_STATE_SEND_START) r12->now_p[r6->unk04] += r12->payloadSize; else r12->now_p[r6->unk04] += r12->payloadSize << 2; @@ -2003,7 +2002,7 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct // if (r12->remainSize == 0 || r12->remainSize < 0) { r12->phase = 0; - if (r12->state == 0x8021) + if (r12->state == SLOT_STATE_SEND_START) { for (r4 = 0; r4 < WINDOW_COUNT; ++r4) { @@ -2011,20 +2010,20 @@ static void rfu_STC_NI_receive_Sender(u8 r0, u8 r10, const struct RfuLocalStruct r12->now_p[r4] = r12->src + r12->payloadSize * r4; } r12->remainSize = r12->dataSize; - r12->state = 0x8022; + r12->state = SLOT_STATE_SENDING; } else { r12->n[0] = 0; r12->remainSize = 0; - r12->state = 0x8023; + r12->state = SLOT_STATE_SEND_LAST; } } _081E30AE: } - else if (r12->state == 0x8023) + else if (r12->state == SLOT_STATE_SEND_LAST) { - r12->state = 0x8020; + r12->state = SLOT_STATE_SEND_NULL; } } if (r12->state != r9 @@ -2051,30 +2050,30 @@ static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, if (r6->unk02 == 3) { gRfuStatic->NIEndRecvFlag |= 1 << r8; - if (r4->recv.state == 0x8042) + if (r4->recv.state == SLOT_STATE_RECEIVING) { r4->recv.phase = 0; r4->recv.n[0] = 0; - r4->recv.state = 0x8043; + r4->recv.state = SLOT_STATE_RECV_LAST; } } else if (r6->unk02 == 2) { - if (r9 == 0x8041 && !r5->remainSize) + if (r9 == SLOT_STATE_RECV_START && !r5->remainSize) rfu_STC_NI_initSlot_asRecvDataEntity(r8, r5); - if (r5->state == 0x8042) + if (r5->state == SLOT_STATE_RECEIVING) r7 = 1; } else if (r6->unk02 == 1) { - if (r9 == 0x8041) + if (r9 == SLOT_STATE_RECV_START) { r7 = 1; } else { rfu_STC_NI_initSlot_asRecvControllData(r8, r5); - if (r4->recv.state != 0x8041) + if (r4->recv.state != SLOT_STATE_RECV_START) return; r7 = 1; } @@ -2084,7 +2083,7 @@ static void rfu_STC_NI_receive_Receiver(u8 r8, const struct RfuLocalStruct *r6, if (r6->unk05 == ((r5->n[r6->unk04] + 1) & 3)) { gRfuFixed->fastCopyPtr(&sp00, (u8 **)&r5->now_p[r6->unk04], r6->unk06); - if (r5->state == 0x8042) + if (r5->state == SLOT_STATE_RECEIVING) r5->now_p[r6->unk04] += 3 * r5->payloadSize; r5->remainSize -= r6->unk06; r5->n[r6->unk04] = r6->unk05; @@ -2110,7 +2109,7 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) u32 r5; u8 r6; - if (gRfuLinkStatus->parentChild == 1) + if (gRfuLinkStatus->parentChild == MODE_PARENT) { r5 = 3; r1 = &gRfuLinkStatus->remainLLFrameSizeParent; @@ -2125,8 +2124,8 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) { if (*r1 < r5) { - r2->state = 73; - r2->errorCode = 0x702; + r2->state = SLOT_STATE_RECV_IGNORE; + r2->errorCode = ERR_RECV_REPLY_SUBFRAME_SIZE; gRfuStatic->recvErrorFlag |= r6; } else @@ -2138,7 +2137,7 @@ static void rfu_STC_NI_initSlot_asRecvControllData(u8 r4, struct NIComm *r2) r2->ack = 1; r2->payloadSize = 0; r2->bmSlot = r6; - r2->state = 0x8041; + r2->state = SLOT_STATE_RECV_START; gRfuLinkStatus->recvSlotNIFlag |= r6; } } @@ -2159,20 +2158,20 @@ static void rfu_STC_NI_initSlot_asRecvDataEntity(u8 r5, struct NIComm *r4) r1 = 1 << r5; gRfuStatic->recvErrorFlag |= r1; gRfuLinkStatus->recvSlotNIFlag &= ~r1; - r4->errorCode = 0x701; - r4->state = 71; + r4->errorCode = ERR_RECV_BUFF_OVER; + r4->state = SLOT_STATE_RECV_FAILED; rfu_STC_releaseFrame(r5, 1, r4); return; } r4->now_p[0] = gRfuSlotStatusNI[r5]->recvBuffer; } - for (r3 = 0; r3 < 4; ++r3) + for (r3 = 0; r3 < WINDOW_COUNT; ++r3) { r4->n[r3] = 0; r4->now_p[r3] = &r4->now_p[0][r4->payloadSize * r3]; } r4->remainSize = r4->dataSize; - r4->state = 0x8042; + r4->state = SLOT_STATE_RECEIVING; } static void rfu_NI_checkCommFailCounter(void) diff --git a/src/librfu_s32id.c b/src/librfu_s32id.c index c3bb922e2..7c99cda2d 100644 --- a/src/librfu_s32id.c +++ b/src/librfu_s32id.c @@ -17,10 +17,10 @@ s32 AgbRFU_checkID(u8 r5) if (REG_IME == 0) return -1; r8 = REG_IE; - gRfuState->state = 10; + gSTWIStatus->state = 10; STWI_set_Callback_ID(Sio32IDIntr); Sio32IDInit(); - r4 = ®_TMCNT_L(gRfuState->timerSelect); + r4 = ®_TMCNT_L(gSTWIStatus->timerSelect); r5 *= 8; while (--r5 != 0xFF) { @@ -38,7 +38,7 @@ s32 AgbRFU_checkID(u8 r5) REG_IME = 0; REG_IE = r8; REG_IME = 1; - gRfuState->state = 0; + gSTWIStatus->state = 0; STWI_set_Callback_ID(NULL); return r6; } @@ -46,7 +46,7 @@ s32 AgbRFU_checkID(u8 r5) static void Sio32IDInit(void) { REG_IME = 0; - REG_IE &= ~((8 << gRfuState->timerSelect) | INTR_FLAG_SERIAL); + REG_IE &= ~((8 << gSTWIStatus->timerSelect) | INTR_FLAG_SERIAL); REG_IME = 1; REG_RCNT = 0; REG_SIOCNT = SIO_32BIT_MODE; diff --git a/src/librfu_stwi.c b/src/librfu_stwi.c index 50e102f19..b88f21737 100644 --- a/src/librfu_stwi.c +++ b/src/librfu_stwi.c @@ -8,6 +8,8 @@ static void STWI_stop_timer(void); static s32 STWI_restart_Command(void); static s32 STWI_reset_ClockCounter(void); +struct STWIStatus *gSTWIStatus; + void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, bool8 copyInterruptToRam) { // If we're copying our interrupt into RAM, DMA it to block1 and use @@ -17,27 +19,27 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b { *interrupt = (IntrFunc)interruptStruct->block1; DmaCopy16(3, &IntrSIO32, interruptStruct->block1, sizeof(interruptStruct->block1)); - gRfuState = &interruptStruct->block2; + gSTWIStatus = &interruptStruct->block2; } else { *interrupt = IntrSIO32; - gRfuState = (struct STWIStatus *)interruptStruct->block1; - } - gRfuState->rxPacket = &interruptStruct->rxPacketAlloc; - gRfuState->txPacket = &interruptStruct->txPacketAlloc; - gRfuState->msMode = 1; - gRfuState->state = 0; - gRfuState->reqLength = 0; - gRfuState->reqNext = 0; - gRfuState->ackLength = 0; - gRfuState->ackNext = 0; - gRfuState->ackActiveCommand = 0; - gRfuState->timerState = 0; - gRfuState->timerActive = 0; - gRfuState->error = 0; - gRfuState->recoveryCount = 0; - gRfuState->unk_2c = 0; + gSTWIStatus = (struct STWIStatus *)interruptStruct->block1; + } + gSTWIStatus->rxPacket = &interruptStruct->rxPacketAlloc; + gSTWIStatus->txPacket = &interruptStruct->txPacketAlloc; + gSTWIStatus->msMode = 1; + gSTWIStatus->state = 0; + gSTWIStatus->reqLength = 0; + gSTWIStatus->reqNext = 0; + gSTWIStatus->ackLength = 0; + gSTWIStatus->ackNext = 0; + gSTWIStatus->ackActiveCommand = 0; + gSTWIStatus->timerState = 0; + gSTWIStatus->timerActive = 0; + gSTWIStatus->error = 0; + gSTWIStatus->recoveryCount = 0; + gSTWIStatus->unk_2c = 0; REG_RCNT = 0x100; // TODO: mystery bit? REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; STWI_init_Callback_M(); @@ -48,8 +50,8 @@ void STWI_init_all(struct RfuIntrStruct *interruptStruct, IntrFunc *interrupt, b void STWI_init_timer(IntrFunc *interrupt, s32 timerSelect) { *interrupt = STWI_intr_timer; - gRfuState->timerSelect = timerSelect; - IntrEnable(INTR_FLAG_TIMER0 << gRfuState->timerSelect); + gSTWIStatus->timerSelect = timerSelect; + IntrEnable(INTR_FLAG_TIMER0 << gSTWIStatus->timerSelect); } void AgbRFU_SoftReset(void) @@ -59,8 +61,8 @@ void AgbRFU_SoftReset(void) REG_RCNT = 0x8000; REG_RCNT = 0x80A0; // all these bits are undocumented - timerL = ®_TMCNT_L(gRfuState->timerSelect); - timerH = ®_TMCNT_H(gRfuState->timerSelect); + timerL = ®_TMCNT_L(gSTWIStatus->timerSelect); + timerH = ®_TMCNT_H(gSTWIStatus->timerSelect); *timerH = 0; *timerL = 0; *timerH = TIMER_ENABLE | TIMER_1024CLK; @@ -69,24 +71,24 @@ void AgbRFU_SoftReset(void) *timerH = 3; REG_RCNT = 0x80A0; REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; - gRfuState->state = 0; - gRfuState->reqLength = 0; - gRfuState->reqNext = 0; - gRfuState->reqActiveCommand = 0; - gRfuState->ackLength = 0; - gRfuState->ackNext = 0; - gRfuState->ackActiveCommand = 0; - gRfuState->timerState = 0; - gRfuState->timerActive = 0; - gRfuState->error = 0; - gRfuState->msMode = 1; - gRfuState->recoveryCount = 0; - gRfuState->unk_2c = 0; + gSTWIStatus->state = 0; + gSTWIStatus->reqLength = 0; + gSTWIStatus->reqNext = 0; + gSTWIStatus->reqActiveCommand = 0; + gSTWIStatus->ackLength = 0; + gSTWIStatus->ackNext = 0; + gSTWIStatus->ackActiveCommand = 0; + gSTWIStatus->timerState = 0; + gSTWIStatus->timerActive = 0; + gSTWIStatus->error = 0; + gSTWIStatus->msMode = 1; + gSTWIStatus->recoveryCount = 0; + gSTWIStatus->unk_2c = 0; } void STWI_set_MS_mode(u8 mode) { - gRfuState->msMode = mode; + gSTWIStatus->msMode = mode; } u16 STWI_read_status(u8 index) @@ -94,13 +96,13 @@ u16 STWI_read_status(u8 index) switch (index) { case 0: - return gRfuState->error; + return gSTWIStatus->error; case 1: - return gRfuState->msMode; + return gSTWIStatus->msMode; case 2: - return gRfuState->state; + return gSTWIStatus->state; case 3: - return gRfuState->reqActiveCommand; + return gSTWIStatus->reqActiveCommand; default: return 0xFFFF; } @@ -119,31 +121,31 @@ void STWI_init_Callback_S(void) // The callback can take 2 or 3 arguments. void STWI_set_Callback_M(void *callbackM) { - gRfuState->callbackM = callbackM; + gSTWIStatus->callbackM = callbackM; } void STWI_set_Callback_S(void (*callbackS)(u16)) { - gRfuState->callbackS = callbackS; + gSTWIStatus->callbackS = callbackS; } void STWI_set_Callback_ID(void (*func)(void)) // name in SDK, but is actually setting a function pointer { - gRfuState->unk_20 = func; + gSTWIStatus->unk_20 = func; } u16 STWI_poll_CommandEnd(void) { - while (gRfuState->unk_2c == TRUE) + while (gSTWIStatus->unk_2c == TRUE) ; - return gRfuState->error; + return gSTWIStatus->error; } void STWI_send_ResetREQ(void) { if (!STWI_init(ID_RESET_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -152,7 +154,7 @@ void STWI_send_LinkStatusREQ(void) { if (!STWI_init(ID_LINK_STATUS_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -161,7 +163,7 @@ void STWI_send_VersionStatusREQ(void) { if (!STWI_init(ID_VERSION_STATUS_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -170,7 +172,7 @@ void STWI_send_SystemStatusREQ(void) { if (!STWI_init(ID_SYSTEM_STATUS_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -179,7 +181,7 @@ void STWI_send_SlotStatusREQ(void) { if (!STWI_init(ID_SLOT_STATUS_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -188,7 +190,7 @@ void STWI_send_ConfigStatusREQ(void) { if (!STWI_init(ID_CONFIG_STATUS_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -200,9 +202,9 @@ void STWI_send_GameConfigREQ(const u8 *unk1, const u8 *data) if (!STWI_init(ID_GAME_CONFIG_REQ)) { - gRfuState->reqLength = 6; + gSTWIStatus->reqLength = 6; // TODO: what is unk1 - packetBytes = gRfuState->txPacket->rfuPacket8.data; + packetBytes = gSTWIStatus->txPacket->rfuPacket8.data; packetBytes += sizeof(u32); *(u16 *)packetBytes = *(u16 *)unk1; packetBytes += sizeof(u16); @@ -229,8 +231,8 @@ void STWI_send_SystemConfigREQ(u16 unk1, u8 unk2, u8 unk3) { u8 *packetBytes; - gRfuState->reqLength = 1; - packetBytes = gRfuState->txPacket->rfuPacket8.data; + gSTWIStatus->reqLength = 1; + packetBytes = gSTWIStatus->txPacket->rfuPacket8.data; packetBytes += sizeof(u32); *packetBytes++ = unk3; *packetBytes++ = unk2; @@ -243,7 +245,7 @@ void STWI_send_SC_StartREQ(void) { if (!STWI_init(ID_SC_START_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -252,7 +254,7 @@ void STWI_send_SC_PollingREQ(void) { if (!STWI_init(ID_SC_POLL_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -261,7 +263,7 @@ void STWI_send_SC_EndREQ(void) { if (!STWI_init(ID_SC_END_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -270,7 +272,7 @@ void STWI_send_SP_StartREQ(void) { if (!STWI_init(ID_SP_START_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -279,7 +281,7 @@ void STWI_send_SP_PollingREQ(void) { if (!STWI_init(ID_SP_POLL_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -288,7 +290,7 @@ void STWI_send_SP_EndREQ(void) { if (!STWI_init(ID_SP_END_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -297,8 +299,8 @@ void STWI_send_CP_StartREQ(u16 unk1) { if (!STWI_init(ID_CP_START_REQ)) { - gRfuState->reqLength = 1; - gRfuState->txPacket->rfuPacket32.data[0] = unk1; + gSTWIStatus->reqLength = 1; + gSTWIStatus->txPacket->rfuPacket32.data[0] = unk1; STWI_start_Command(); } } @@ -307,7 +309,7 @@ void STWI_send_CP_PollingREQ(void) { if (!STWI_init(ID_CP_POLL_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -316,7 +318,7 @@ void STWI_send_CP_EndREQ(void) { if (!STWI_init(ID_CP_END_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -328,8 +330,8 @@ void STWI_send_DataTxREQ(const void *in, u8 size) u8 reqLength = (size / sizeof(u32)); if (size & (sizeof(u32) - 1)) reqLength += 1; - gRfuState->reqLength = reqLength; - CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->reqLength * sizeof(u32)); + gSTWIStatus->reqLength = reqLength; + CpuCopy32(in, gSTWIStatus->txPacket->rfuPacket32.data, gSTWIStatus->reqLength * sizeof(u32)); STWI_start_Command(); } } @@ -341,8 +343,8 @@ void STWI_send_DataTxAndChangeREQ(const void *in, u8 size) u8 reqLength = (size / sizeof(u32)); if (size & (sizeof(u32) - 1)) reqLength += 1; - gRfuState->reqLength = reqLength; - CpuCopy32(in, gRfuState->txPacket->rfuPacket32.data, gRfuState->reqLength * sizeof(u32)); + gSTWIStatus->reqLength = reqLength; + CpuCopy32(in, gSTWIStatus->txPacket->rfuPacket32.data, gSTWIStatus->reqLength * sizeof(u32)); STWI_start_Command(); } } @@ -351,7 +353,7 @@ void STWI_send_DataRxREQ(void) { if (!STWI_init(ID_DATA_RX_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -360,7 +362,7 @@ void STWI_send_MS_ChangeREQ(void) { if (!STWI_init(ID_MS_CHANGE_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -371,14 +373,14 @@ void STWI_send_DataReadyAndChangeREQ(u8 unk) { if (!unk) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; } else { u8 *packetBytes; - gRfuState->reqLength = 1; - packetBytes = gRfuState->txPacket->rfuPacket8.data; + gSTWIStatus->reqLength = 1; + packetBytes = gSTWIStatus->txPacket->rfuPacket8.data; packetBytes += sizeof(u32); *packetBytes++ = unk; *packetBytes++ = 0; @@ -395,8 +397,8 @@ void STWI_send_DisconnectedAndChangeREQ(u8 unk0, u8 unk1) { u8 *packetBytes; - gRfuState->reqLength = 1; - packetBytes = gRfuState->txPacket->rfuPacket8.data; + gSTWIStatus->reqLength = 1; + packetBytes = gSTWIStatus->txPacket->rfuPacket8.data; packetBytes += sizeof(u32); *packetBytes++ = unk0; *packetBytes++ = unk1; @@ -410,7 +412,7 @@ void STWI_send_ResumeRetransmitAndChangeREQ(void) { if (!STWI_init(ID_RESUME_RETRANSMIT_AND_CHANGE_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -419,8 +421,8 @@ void STWI_send_DisconnectREQ(u8 unk) { if (!STWI_init(ID_DISCONNECT_REQ)) { - gRfuState->reqLength = 1; - gRfuState->txPacket->rfuPacket32.data[0] = unk; + gSTWIStatus->reqLength = 1; + gSTWIStatus->txPacket->rfuPacket32.data[0] = unk; STWI_start_Command(); } } @@ -429,8 +431,8 @@ void STWI_send_TestModeREQ(u8 unk0, u8 unk1) { if (!STWI_init(ID_TEST_MODE_REQ)) { - gRfuState->reqLength = 1; - gRfuState->txPacket->rfuPacket32.data[0] = unk0 | (unk1 << 8); + gSTWIStatus->reqLength = 1; + gSTWIStatus->txPacket->rfuPacket32.data[0] = unk0 | (unk1 << 8); STWI_start_Command(); } } @@ -442,9 +444,9 @@ void STWI_send_CPR_StartREQ(u16 unk0, u16 unk1, u8 unk2) if (!STWI_init(ID_CPR_START_REQ)) { - gRfuState->reqLength = 2; + gSTWIStatus->reqLength = 2; arg1 = unk1 | (unk0 << 16); - packetData = gRfuState->txPacket->rfuPacket32.data; + packetData = gSTWIStatus->txPacket->rfuPacket32.data; packetData[0] = arg1; packetData[1] = unk2; STWI_start_Command(); @@ -455,7 +457,7 @@ void STWI_send_CPR_PollingREQ(void) { if (!STWI_init(ID_CPR_POLL_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -464,7 +466,7 @@ void STWI_send_CPR_EndREQ(void) { if (!STWI_init(ID_CPR_END_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } @@ -473,18 +475,18 @@ void STWI_send_StopModeREQ(void) { if (!STWI_init(ID_STOP_MODE_REQ)) { - gRfuState->reqLength = 0; + gSTWIStatus->reqLength = 0; STWI_start_Command(); } } static void STWI_intr_timer(void) { - switch (gRfuState->timerState) + switch (gSTWIStatus->timerState) { // TODO: Make an enum for these case 2: - gRfuState->timerActive = 1; + gSTWIStatus->timerActive = 1; STWI_set_timer(50); break; case 1: @@ -493,11 +495,11 @@ static void STWI_intr_timer(void) STWI_restart_Command(); break; case 3: - gRfuState->timerActive = 1; + gSTWIStatus->timerActive = 1; STWI_stop_timer(); STWI_reset_ClockCounter(); - if (gRfuState->callbackM != NULL) - gRfuState->callbackM(255, 0); + if (gSTWIStatus->callbackM != NULL) + gSTWIStatus->callbackM(255, 0); break; } } @@ -507,78 +509,78 @@ static void STWI_set_timer(u8 unk) vu16 *timerL; vu16 *timerH; - timerL = ®_TMCNT_L(gRfuState->timerSelect); - timerH = ®_TMCNT_H(gRfuState->timerSelect); + timerL = ®_TMCNT_L(gSTWIStatus->timerSelect); + timerH = ®_TMCNT_H(gSTWIStatus->timerSelect); REG_IME = 0; switch (unk) { case 50: *timerL = 0xFCCB; - gRfuState->timerState = 1; + gSTWIStatus->timerState = 1; break; case 80: *timerL = 0xFAE0; - gRfuState->timerState = 2; + gSTWIStatus->timerState = 2; break; case 100: *timerL = 0xF996; - gRfuState->timerState = 3; + gSTWIStatus->timerState = 3; break; case 130: *timerL = 0xF7AD; - gRfuState->timerState = 4; + gSTWIStatus->timerState = 4; break; } *timerH = TIMER_ENABLE | TIMER_INTR_ENABLE | TIMER_1024CLK; - REG_IF = INTR_FLAG_TIMER0 << gRfuState->timerSelect; + REG_IF = INTR_FLAG_TIMER0 << gSTWIStatus->timerSelect; REG_IME = 1; } static void STWI_stop_timer(void) { - gRfuState->timerState = 0; - REG_TMCNT_L(gRfuState->timerSelect) = 0; - REG_TMCNT_H(gRfuState->timerSelect) = 0; + gSTWIStatus->timerState = 0; + REG_TMCNT_L(gSTWIStatus->timerSelect) = 0; + REG_TMCNT_H(gSTWIStatus->timerSelect) = 0; } static u16 STWI_init(u8 request) { if (!REG_IME) { - gRfuState->error = 6; - if (gRfuState->callbackM != NULL) - gRfuState->callbackM(request, gRfuState->error); + gSTWIStatus->error = ERR_REQ_CMD_IME_DISABLE; + if (gSTWIStatus->callbackM != NULL) + gSTWIStatus->callbackM(request, gSTWIStatus->error); return TRUE; } - else if (gRfuState->unk_2c == TRUE) + else if (gSTWIStatus->unk_2c == TRUE) { - gRfuState->error = 2; - gRfuState->unk_2c = FALSE; - if (gRfuState->callbackM != NULL) - gRfuState->callbackM(request, gRfuState->error); + gSTWIStatus->error = ERR_REQ_CMD_SENDING; + gSTWIStatus->unk_2c = FALSE; + if (gSTWIStatus->callbackM != NULL) + gSTWIStatus->callbackM(request, gSTWIStatus->error); return TRUE; } - else if(!gRfuState->msMode) + else if(!gSTWIStatus->msMode) { - gRfuState->error = 4; - if (gRfuState->callbackM != NULL) - gRfuState->callbackM(request, gRfuState->error, gRfuState); + gSTWIStatus->error = ERR_REQ_CMD_CLOCK_SLAVE; + if (gSTWIStatus->callbackM != NULL) + gSTWIStatus->callbackM(request, gSTWIStatus->error, gSTWIStatus); return TRUE; } else { - gRfuState->unk_2c = TRUE; - gRfuState->reqActiveCommand = request; - gRfuState->state = 0; - gRfuState->reqLength = 0; - gRfuState->reqNext = 0; - gRfuState->ackLength = 0; - gRfuState->ackNext = 0; - gRfuState->ackActiveCommand = 0; - gRfuState->timerState = 0; - gRfuState->timerActive = 0; - gRfuState->error = 0; - gRfuState->recoveryCount = 0; + gSTWIStatus->unk_2c = TRUE; + gSTWIStatus->reqActiveCommand = request; + gSTWIStatus->state = 0; + gSTWIStatus->reqLength = 0; + gSTWIStatus->reqNext = 0; + gSTWIStatus->ackLength = 0; + gSTWIStatus->ackNext = 0; + gSTWIStatus->ackActiveCommand = 0; + gSTWIStatus->timerState = 0; + gSTWIStatus->timerActive = 0; + gSTWIStatus->error = 0; + gSTWIStatus->recoveryCount = 0; REG_RCNT = 0x100; REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; return FALSE; @@ -589,15 +591,15 @@ static s32 STWI_start_Command(void) { u16 imeTemp; - // equivalent to gRfuState->txPacket->rfuPacket32.command, + // equivalent to gSTWIStatus->txPacket->rfuPacket32.command, // but the cast here is required to avoid register issue - *(u32 *)gRfuState->txPacket->rfuPacket8.data = 0x99660000 | (gRfuState->reqLength << 8) | gRfuState->reqActiveCommand; - REG_SIODATA32 = gRfuState->txPacket->rfuPacket32.command; - gRfuState->state = 0; - gRfuState->reqNext = 1; + *(u32 *)gSTWIStatus->txPacket->rfuPacket8.data = 0x99660000 | (gSTWIStatus->reqLength << 8) | gSTWIStatus->reqActiveCommand; + REG_SIODATA32 = gSTWIStatus->txPacket->rfuPacket32.command; + gSTWIStatus->state = 0; + gSTWIStatus->reqNext = 1; imeTemp = REG_IME; REG_IME = 0; - REG_IE |= (INTR_FLAG_TIMER0 << gRfuState->timerSelect); + REG_IE |= (INTR_FLAG_TIMER0 << gSTWIStatus->timerSelect); REG_IE |= INTR_FLAG_SERIAL; REG_IME = imeTemp; REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_MULTI_BUSY | SIO_115200_BPS; @@ -606,27 +608,27 @@ static s32 STWI_start_Command(void) static s32 STWI_restart_Command(void) { - if (gRfuState->recoveryCount <= 1) + if (gSTWIStatus->recoveryCount <= 1) { - ++gRfuState->recoveryCount; + ++gSTWIStatus->recoveryCount; STWI_start_Command(); } else { - if (gRfuState->reqActiveCommand == ID_MS_CHANGE_REQ || gRfuState->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ || gRfuState->reqActiveCommand == ID_UNK35_REQ || gRfuState->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ) + if (gSTWIStatus->reqActiveCommand == ID_MS_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_DATA_TX_AND_CHANGE_REQ || gSTWIStatus->reqActiveCommand == ID_UNK35_REQ || gSTWIStatus->reqActiveCommand == ID_RESUME_RETRANSMIT_AND_CHANGE_REQ) { - gRfuState->error = 1; - gRfuState->unk_2c = 0; - if (gRfuState->callbackM != NULL) - gRfuState->callbackM(gRfuState->reqActiveCommand, gRfuState->error); + gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT; + gSTWIStatus->unk_2c = 0; + if (gSTWIStatus->callbackM != NULL) + gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error); } else { - gRfuState->error = 1; - gRfuState->unk_2c = 0; - if (gRfuState->callbackM != NULL) - gRfuState->callbackM(gRfuState->reqActiveCommand, gRfuState->error); - gRfuState->state = 4; // TODO: what's 4 + gSTWIStatus->error = ERR_REQ_CMD_CLOCK_DRIFT; + gSTWIStatus->unk_2c = 0; + if (gSTWIStatus->callbackM != NULL) + gSTWIStatus->callbackM(gSTWIStatus->reqActiveCommand, gSTWIStatus->error); + gSTWIStatus->state = 4; // TODO: what's 4 } } return 0; @@ -634,9 +636,9 @@ static s32 STWI_restart_Command(void) static s32 STWI_reset_ClockCounter(void) { - gRfuState->state = 5; // TODO: what is 5 - gRfuState->reqLength = 0; - gRfuState->reqNext = 0; + gSTWIStatus->state = 5; // TODO: what is 5 + gSTWIStatus->reqLength = 0; + gSTWIStatus->reqNext = 0; REG_SIODATA32 = (1 << 31); REG_SIOCNT = 0; REG_SIOCNT = SIO_INTR_ENABLE | SIO_32BIT_MODE | SIO_115200_BPS; -- cgit v1.2.3 From aa9843199592012301931381bd2fe1396fe29c82 Mon Sep 17 00:00:00 2001 From: jiangzhengwenjz Date: Fri, 10 Jan 2020 04:13:33 +0800 Subject: librfu rodata --- src/librfu_rfu.c | 37 ++++++++++++++++++++++++++----------- src/librfu_s32id.c | 7 ++++--- 2 files changed, 30 insertions(+), 14 deletions(-) (limited to 'src') diff --git a/src/librfu_rfu.c b/src/librfu_rfu.c index 70d5b4990..96de99c2a 100644 --- a/src/librfu_rfu.c +++ b/src/librfu_rfu.c @@ -1,6 +1,6 @@ #include "librfu.h" -struct RfuHeader +struct LLSFStruct { u8 unk00; u8 unk01; @@ -67,15 +67,30 @@ static void rfu_STC_NI_receive_Sender(u8, u8, const struct RfuLocalStruct *, UNU static void rfu_STC_NI_initSlot_asRecvDataEntity(u8, struct NIComm *); static void rfu_STC_NI_initSlot_asRecvControllData(u8, struct NIComm *); -extern const char _Str_RFU_MBOOT[]; -extern const struct RfuHeader _Str_RfuHeader[2]; - struct RfuSlotStatusUNI *gRfuSlotStatusUNI[RFU_CHILD_MAX]; struct RfuSlotStatusNI *gRfuSlotStatusNI[RFU_CHILD_MAX]; struct RfuLinkStatus *gRfuLinkStatus; struct RfuStatic *gRfuStatic; struct RfuFixed *gRfuFixed; +static const struct LLSFStruct llsf_struct[2] = { + { + 2, 14, 0, 10, 9, 5, 7, 2, + 0, 15, 1, 3, 3, 0x1f + }, { + 3, 22, 18, 14, 13, 9, 11, 3, + 15, 15, 1, 3, 3, 0x7f + } +}; + +#ifdef EMERALD +static const char lib_ver[] = "RFU_V1026"; +#else +static const char lib_ver[] = "RFU_V1024"; +#endif + +static const char str_checkMbootLL[] = "RFU-MBOOT"; + u16 rfu_initializeAPI(struct RfuAPIBuffer *APIBuffer, u16 buffByteSize, IntrFunc *sioIntrTable_p, bool8 copyInterruptToRam) { u16 i; @@ -264,7 +279,7 @@ u16 rfu_getRFUStatus(u8 *rfuState) u16 rfu_MBOOT_CHILD_inheritanceLinkStatus(void) { - const char *s1 = _Str_RFU_MBOOT; + const char *s1 = str_checkMbootLL; char *s2 = (char *)0x30000F0; u16 checksum; u16 *r2; @@ -1315,7 +1330,7 @@ static u16 rfu_STC_setSendData_org(u8 r6, u8 bmSendSlot, u8 subFrameSize, const r9 = &gRfuLinkStatus->remainLLFrameSizeParent; else if (gRfuLinkStatus->parentChild == MODE_CHILD) r9 = &gRfuLinkStatus->remainLLFrameSizeChild[r2]; - r4 = _Str_RfuHeader[gRfuLinkStatus->parentChild].unk00; + r4 = llsf_struct[gRfuLinkStatus->parentChild].unk00; if (subFrameSize > *r9 || subFrameSize <= r4) return ERR_SUBFRAME_SIZE; sp04 = REG_IME; @@ -1672,7 +1687,7 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) u32 sp00; u8 i; u8 *r2; - const struct RfuHeader *r8 = &_Str_RfuHeader[gRfuLinkStatus->parentChild]; + const struct LLSFStruct *r8 = &llsf_struct[gRfuLinkStatus->parentChild]; if (r4->state == SLOT_STATE_SENDING) { @@ -1732,7 +1747,7 @@ static u16 rfu_STC_NI_constructLLSF(u8 r10, u8 **r12, struct NIComm *r4) static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) { - const struct RfuHeader *r5; + const struct LLSFStruct *r5; const u8 *sp04; u32 sp00; u8 *r2; @@ -1741,7 +1756,7 @@ static u16 rfu_STC_UNI_constructLLSF(u8 r8, u8 **r6) if (!r4->dataReadyFlag || !r4->bmSlot) return 0; - r5 = &_Str_RfuHeader[gRfuLinkStatus->parentChild]; + r5 = &llsf_struct[gRfuLinkStatus->parentChild]; sp00 = (r4->state & 0xF) << r5->unk03 | r4->payloadSize; if (gRfuLinkStatus->parentChild == MODE_PARENT) @@ -1857,13 +1872,13 @@ static void rfu_STC_CHILD_analyzeRecvPacket(void) static u16 rfu_STC_analyzeLLSF(u8 r12, const u8 *r7, u16 r3) { struct RfuLocalStruct sp00; - const struct RfuHeader *r6; + const struct LLSFStruct *r6; u32 r5; u8 r4; u32 r0; u16 r10; - r6 = &_Str_RfuHeader[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)]; + r6 = &llsf_struct[~gRfuLinkStatus->parentChild & (MODE_NEUTRAL & MODE_PARENT)]; if (r3 < r6->unk00) return r3; r5 = 0; diff --git a/src/librfu_s32id.c b/src/librfu_s32id.c index 7c99cda2d..ed51dcd12 100644 --- a/src/librfu_s32id.c +++ b/src/librfu_s32id.c @@ -1,13 +1,14 @@ #include "librfu.h" -extern const u16 _Str_Sio32ID[]; - static void Sio32IDIntr(void); static void Sio32IDInit(void); static s32 Sio32IDMain(void); struct RfuS32Id gRfuS32Id; +static const u16 Sio32ConnectionData[] = { 0x494e, 0x544e, 0x4e45, 0x4f44 }; // NINTENDO +static const char Sio32IDLib_Var[] = "Sio32ID_030820"; + s32 AgbRFU_checkID(u8 r5) { u16 r8; @@ -147,7 +148,7 @@ static void Sio32IDIntr(void) } } if (gRfuS32Id.unk2 < 4) - gRfuS32Id.unk4 = *(gRfuS32Id.unk2 + _Str_Sio32ID); + gRfuS32Id.unk4 = *(gRfuS32Id.unk2 + Sio32ConnectionData); else gRfuS32Id.unk4 = 0x8001; gRfuS32Id.unk6 = ~r5; -- cgit v1.2.3