Finish link.s decomp

1 files changed, 559 insertions, 62 deletions

diff --git a/src/link.c b/src/link.c
index 385538e5e..0bb637881 100644
--- a/src/link.c
+++ b/src/link.c
@@ -53,7 +53,6 @@ struct LinkTestBGInfo
 
 #define SIO_MULTI_CNT ((struct SioMultiCnt *)REG_ADDR_SIOCNT)
 
-#define static __attribute__((section(".bss")))
 static struct BlockTransfer sBlockSend;
 ALIGNED(8) static struct BlockTransfer sBlockRecv[MAX_LINK_PLAYERS];
 static u32 sBlockSendDelayCounter;
@@ -63,23 +62,23 @@ static u32 sPlayerDataExchangeStatus;
 static u32 gUnknown_3000E58;
 static u8 sLinkTestLastBlockSendPos;
 ALIGNED(8) static u8 sLinkTestLastBlockRecvPos[MAX_LINK_PLAYERS];
+// File break?
 static u8 sNumVBlanksWithoutSerialIntr;
 static bool8 sSendBufferEmpty;
 static u16 sSendNonzeroCheck;
 static u16 sRecvNonzeroCheck;
 static u8 sChecksumAvailable;
 static u8 sHandshakePlayerCount;
-#undef static
 
 u16 gLinkPartnersHeldKeys[6];
 u32 gLinkDebugSeed;
 struct LinkPlayerBlock gLocalLinkPlayerBlock;
 bool8 gLinkErrorOccurred;
 u32 gLinkDebugFlags;
-//u32 gFiller_03003074;
+u32 gFiller_3003EB4;
 bool8 gRemoteLinkPlayersNotReceived[MAX_LINK_PLAYERS];
 u8 gBlockReceivedStatus[MAX_LINK_PLAYERS];
-//u32 gFiller_03003080;
+u32 gFiller_3003EC0;
 u16 gLinkHeldKeys;
 u16 gRecvCmds[MAX_RFU_PLAYERS][CMD_LENGTH];
 u32 gLinkStatus;
@@ -99,15 +98,13 @@ void (*gLinkCallback)(void);
 u8 gShouldAdvanceLinkState;
 u16 gLinkTestBlockChecksums[MAX_LINK_PLAYERS];
 u8 gBlockRequestType;
-//u32 gFiller_03003154;
-//u32 gFiller_03003158;
-//u32 gFiller_0300315c;
+u32 gFiller_3003F94; // file
+u32 gFiller_3003F98; // boundary
+u32 gFiller_3003F9C; // here?
 u8 gLastSendQueueCount;
 struct Link gLink;
 u8 gLastRecvQueueCount;
 u16 gLinkSavedIme;
-//u32 gFiller_03004138;
-//u32 gFiller_0300413C;
 
 EWRAM_DATA bool8 gLinkTestDebugValuesEnabled = FALSE;
 EWRAM_DATA bool8 gUnknown_2022111 = FALSE;
@@ -129,34 +126,42 @@ EWRAM_DATA struct {
 EWRAM_DATA u16 gUnknown_202285C = 0;
 EWRAM_DATA void *gUnknown_2022860 = NULL;
 
-void InitLocalLinkPlayer(void);
-void sub_800978C(void);
-void CB2_LinkTest(void);
-void ProcessRecvCmds(u8 id);
-void sub_800A040(void);
-void ResetBlockSend(void);
-bool32 InitBlockSend(const void * src, size_t size);
-void LinkCB_BlockSendBegin(void);
-void LinkCB_BlockSend(void);
-void LinkCB_BlockSendEnd(void);
-void sub_800A3CC(void);
-void SetBlockReceivedFlag(u8 id);
-u16 LinkTestCalcBlockChecksum(const u16 *src, u16 size);
-void LinkTest_prnthex(u32 pos, u8 a0, u8 a1, u8 a2);
-void LinkCB_RequestPlayerDataExchange(void);
-void Task_PrintTestData(u8 taskId);
-void sub_800AB0C(void);
-void sub_800AB38(void);
-void sub_800ABD4(void);
-void sub_800AC00(void);
-void CheckErrorStatus(void);
-void CB2_PrintErrorMessage(void);
-void EnableSerial(void);
-void sub_800B210(void);
-void sub_80F8DC0(void);
-void DisableSerial(void);
-void sub_800B284(struct LinkPlayer * linkPlayer);
-bool8 IsSioMultiMaster(void);
+static void InitLocalLinkPlayer(void);
+static void sub_800978C(void);
+static void CB2_LinkTest(void);
+static void ProcessRecvCmds(u8 id);
+static void sub_800A040(void);
+static void ResetBlockSend(void);
+static bool32 InitBlockSend(const void *src, size_t size);
+static void LinkCB_BlockSendBegin(void);
+static void LinkCB_BlockSend(void);
+static void LinkCB_BlockSendEnd(void);
+static void sub_800A3CC(void);
+static void SetBlockReceivedFlag(u8 id);
+static u16 LinkTestCalcBlockChecksum(const u16 *src, u16 size);
+static void LinkTest_prnthex(u32 pos, u8 a0, u8 a1, u8 a2);
+static void LinkCB_RequestPlayerDataExchange(void);
+static void Task_PrintTestData(u8 taskId);
+static void sub_800AB0C(void);
+static void sub_800AB38(void);
+static void sub_800ABD4(void);
+static void sub_800AC00(void);
+static void CheckErrorStatus(void);
+static void CB2_PrintErrorMessage(void);
+static void sub_800B210(void);
+static void DisableSerial(void);
+static void EnableSerial(void);
+static bool8 IsSioMultiMaster(void);
+static void CheckMasterOrSlave(void);
+static void InitTimer(void);
+static void EnqueueSendCmd(u16 *sendCmd);
+static void DequeueRecvCmds(u16 (*recvCmds)[CMD_LENGTH]);
+static void StartTransfer(void);
+static bool8 DoHandshake(void);
+static void DoRecv(void);
+static void DoSend(void);
+static void StopTimer(void);
+static void SendRecvDone(void);
 
 ALIGNED(4) const u16 gWirelessLinkDisplayPal[] = INCBIN_U16("graphics/interface/wireless_link_display.gbapal");
 const u16 gWirelessLinkDisplay4bpp[] = INCBIN_U16("graphics/interface/wireless_link_display.4bpp.lz");
@@ -314,7 +319,7 @@ void SetLocalLinkPlayerId(u8 playerId)
     gLocalLinkPlayer.id = playerId;
 }
 
-void InitLocalLinkPlayer(void)
+static void InitLocalLinkPlayer(void)
 {
     gLocalLinkPlayer.trainerId = gSaveBlock2Ptr->playerTrainerId[0] | (gSaveBlock2Ptr->playerTrainerId[1] << 8) | (gSaveBlock2Ptr->playerTrainerId[2] << 16) | (gSaveBlock2Ptr->playerTrainerId[3] << 24);
     StringCopy(gLocalLinkPlayer.name, gSaveBlock2Ptr->playerName);
@@ -330,7 +335,7 @@ void InitLocalLinkPlayer(void)
     }
 }
 
-void sub_800978C(void)
+static void sub_800978C(void)
 {
     LoadOam();
     ProcessSpriteCopyRequests();
@@ -471,7 +476,7 @@ void LinkTestProcessKeyInput(void)
     }
 }
 
-void CB2_LinkTest(void)
+static void CB2_LinkTest(void)
 {
     LinkTestProcessKeyInput();
     TestBlockTransfer(1, 1, 0);
@@ -734,7 +739,7 @@ bool32 IsSendingKeysToLink(void)
     return FALSE;
 }
 
-void sub_800A040(void)
+static void sub_800A040(void)
 {
     if (gReceivedRemoteLinkPlayers == TRUE)
     {
@@ -884,7 +889,7 @@ void ResetLinkPlayers(void)
     }
 }
 
-void ResetBlockSend(void)
+static void ResetBlockSend(void)
 {
     sBlockSend.active = FALSE;
     sBlockSend.pos = 0;
@@ -892,7 +897,7 @@ void ResetBlockSend(void)
     sBlockSend.src = NULL;
 }
 
-bool32 InitBlockSend(const void *src, size_t size)
+static bool32 InitBlockSend(const void *src, size_t size)
 {
     if (sBlockSend.active)
     {
@@ -920,7 +925,7 @@ bool32 InitBlockSend(const void *src, size_t size)
     return TRUE;
 }
 
-void LinkCB_BlockSendBegin(void)
+static void LinkCB_BlockSendBegin(void)
 {
     if (++sBlockSendDelayCounter > 2)
     {
@@ -928,7 +933,7 @@ void LinkCB_BlockSendBegin(void)
     }
 }
 
-void LinkCB_BlockSend(void)
+static void LinkCB_BlockSend(void)
 {
     int i;
     const u8 *src;
@@ -947,7 +952,7 @@ void LinkCB_BlockSend(void)
     }
 }
 
-void LinkCB_BlockSendEnd(void)
+static void LinkCB_BlockSendEnd(void)
 {
     gLinkCallback = NULL;
 }
@@ -958,7 +963,7 @@ void sub_800A3AC(void)
     gUnknown_2022114++;
 }
 
-void sub_800A3CC(void)
+static void sub_800A3CC(void)
 {
     gUnknown_2022114 = 0;
     gLinkCallback = sub_800A3AC;
@@ -1086,7 +1091,7 @@ void CheckShouldAdvanceLinkState(void)
     }
 }
 
-u16 LinkTestCalcBlockChecksum(const u16 *src, u16 size)
+static u16 LinkTestCalcBlockChecksum(const u16 *src, u16 size)
 {
     u16 chksum;
     u16 i;
@@ -1115,7 +1120,7 @@ void LinkTest_prntchar(char a0, u8 a1, u8 a2)
     vAddr[a2 * 32 + a1] = (gLinkTestBGInfo.paletteNum << 12) | (a0 + gLinkTestBGInfo.dummy_8);
 }
 
-void LinkTest_prnthex(u32 pos, u8 a0, u8 a1, u8 a2)
+static void LinkTest_prnthex(u32 pos, u8 a0, u8 a1, u8 a2)
 {
     char sp[32 / 2];
     int i;
@@ -1155,7 +1160,7 @@ void LinkTest_prntstr(const char *a0, u8 a1, u8 a2)
     }
 }
 
-void LinkCB_RequestPlayerDataExchange(void)
+static void LinkCB_RequestPlayerDataExchange(void)
 {
     if (gLinkStatus & LINK_STAT_MASTER)
     {
@@ -1164,7 +1169,7 @@ void LinkCB_RequestPlayerDataExchange(void)
     gLinkCallback = NULL;
 }
 
-void Task_PrintTestData(u8 taskId)
+static void Task_PrintTestData(u8 taskId)
 {
     char sp[32];
     int i;
@@ -1345,7 +1350,7 @@ void sub_800AAC0(void)
     }
 }
 
-void sub_800AB0C(void)
+static void sub_800AB0C(void)
 {
     if (gLastRecvQueueCount == 0)
     {
@@ -1354,7 +1359,7 @@ void sub_800AB0C(void)
     }
 }
 
-void sub_800AB38(void)
+static void sub_800AB38(void)
 {
     int i;
     unsigned count;
@@ -1395,7 +1400,7 @@ void sub_800AB9C(void)
     }
 }
 
-void sub_800ABD4(void)
+static void sub_800ABD4(void)
 {
     if (gLastRecvQueueCount == 0)
     {
@@ -1404,7 +1409,7 @@ void sub_800ABD4(void)
     }
 }
 
-void sub_800AC00(void)
+static void sub_800AC00(void)
 {
     u8 i;
     u8 linkPlayerCount;
@@ -1427,7 +1432,7 @@ void sub_800AC00(void)
     }
 }
 
-void CheckErrorStatus(void)
+static void CheckErrorStatus(void)
 {
     if (gLinkOpen && EXTRACT_LINK_ERRORS(gLinkStatus))
     {
@@ -1532,7 +1537,7 @@ void sub_800AED0(void)
     ShowBg(0);
 }
 
-void CB2_PrintErrorMessage(void)
+static void CB2_PrintErrorMessage(void)
 {
     switch (gMain.state)
     {
@@ -1601,7 +1606,7 @@ bool8 GetSioMultiSI(void)
     return (REG_SIOCNT & 0x04) != 0;
 }
 
-bool8 IsSioMultiMaster(void)
+static bool8 IsSioMultiMaster(void)
 {
     return (REG_SIOCNT & 0x8) && !(REG_SIOCNT & 0x04);
 }
@@ -1686,7 +1691,7 @@ void sub_800B1F4(void)
     }
 }
 
-void sub_800B210(void)
+static void sub_800B210(void)
 {
     if (gReceivedRemoteLinkPlayers == 0)
     {
@@ -1720,13 +1725,15 @@ bool32 sub_800B270(void)
     return FALSE;
 }
 
-void sub_800B284(struct LinkPlayer *player)
+void sub_800B284(struct LinkPlayer * player)
 {
     player->name[10] = player->name[8];
     ConvertInternationalString(player->name, player->language);
 }
 
-void DisableSerial(void)
+// File break?
+
+static void DisableSerial(void)
 {
     DisableInterrupts(INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
     REG_SIOCNT = SIO_MULTI_MODE;
@@ -1737,7 +1744,7 @@ void DisableSerial(void)
     CpuFill32(0, &gLink, sizeof(gLink));
 }
 
-void EnableSerial(void)
+static void EnableSerial(void)
 {
     DisableInterrupts(INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL);
     REG_RCNT = 0;
@@ -1760,3 +1767,493 @@ void ResetSerial(void)
     EnableSerial();
     DisableSerial();
 }
+
+u32 LinkMain1(u8 *shouldAdvanceLinkState, u16 *sendCmd, u16 (*recvCmds)[CMD_LENGTH])
+{
+    u32 retVal;
+    u32 retVal2;
+
+    switch (gLink.state)
+    {
+    case LINK_STATE_START0:
+        DisableSerial();
+        gLink.state = LINK_STATE_START1;
+        break;
+    case LINK_STATE_START1:
+        if (*shouldAdvanceLinkState == 1)
+        {
+            EnableSerial();
+            gLink.state = LINK_STATE_HANDSHAKE;
+        }
+        break;
+    case LINK_STATE_HANDSHAKE:
+        switch (*shouldAdvanceLinkState)
+        {
+        default:
+            CheckMasterOrSlave();
+            break;
+        case 1:
+            if (gLink.isMaster == LINK_MASTER && gLink.playerCount > 1)
+            {
+                gLink.handshakeAsMaster = TRUE;
+            }
+            break;
+        case 2:
+            gLink.state = LINK_STATE_START0;
+            REG_SIOMLT_SEND = 0;
+            break;
+        }
+        break;
+    case LINK_STATE_INIT_TIMER:
+        InitTimer();
+        gLink.state = LINK_STATE_CONN_ESTABLISHED;
+        // fallthrough
+    case LINK_STATE_CONN_ESTABLISHED:
+        EnqueueSendCmd(sendCmd);
+        DequeueRecvCmds(recvCmds);
+        break;
+    }
+    *shouldAdvanceLinkState = 0;
+    retVal = gLink.localId;
+    retVal |= (gLink.playerCount << LINK_STAT_PLAYER_COUNT_SHIFT);
+    if (gLink.isMaster == LINK_MASTER)
+    {
+        retVal |= LINK_STAT_MASTER;
+    }
+    {
+        u32 receivedNothing = gLink.receivedNothing << LINK_STAT_RECEIVED_NOTHING_SHIFT;
+        u32 link_field_F = gLink.link_field_F << LINK_STAT_UNK_FLAG_9_SHIFT;
+        u32 hardwareError = gLink.hardwareError << LINK_STAT_ERROR_HARDWARE_SHIFT;
+        u32 badChecksum = gLink.badChecksum << LINK_STAT_ERROR_CHECKSUM_SHIFT;
+        u32 queueFull = gLink.queueFull << LINK_STAT_ERROR_QUEUE_FULL_SHIFT;
+        u32 val;
+
+        if (gLink.state == LINK_STATE_CONN_ESTABLISHED)
+        {
+            val = LINK_STAT_CONN_ESTABLISHED;
+            val |= receivedNothing;
+            val |= retVal;
+            val |= link_field_F;
+            val |= hardwareError;
+            val |= badChecksum;
+            val |= queueFull;
+        }
+        else
+        {
+            val = retVal;
+            val |= receivedNothing;
+            val |= link_field_F;
+            val |= hardwareError;
+            val |= badChecksum;
+            val |= queueFull;
+        }
+
+        retVal = val;
+    }
+
+    if (gLink.lag == LAG_MASTER)
+    {
+        retVal |= LINK_STAT_ERROR_LAG_MASTER;
+    }
+
+    if (gLink.localId >= MAX_LINK_PLAYERS)
+    {
+        retVal |= LINK_STAT_ERROR_INVALID_ID;
+    }
+
+    retVal2 = retVal;
+    if (gLink.lag == LAG_SLAVE)
+    {
+        retVal2 |= LINK_STAT_ERROR_LAG_SLAVE;
+    }
+
+    return retVal2;
+}
+
+static void CheckMasterOrSlave(void)
+{
+    u32 terminals;
+
+    terminals = *(vu32 *)REG_ADDR_SIOCNT & (SIO_MULTI_SD | SIO_MULTI_SI);
+    if (terminals == SIO_MULTI_SD && gLink.localId == 0)
+    {
+        gLink.isMaster = LINK_MASTER;
+    }
+    else
+    {
+        gLink.isMaster = LINK_SLAVE;
+    }
+}
+
+static void InitTimer(void)
+{
+    if (gLink.isMaster)
+    {
+        REG_TM3CNT_L = -197;
+        REG_TM3CNT_H = TIMER_64CLK | TIMER_INTR_ENABLE;
+        EnableInterrupts(INTR_FLAG_TIMER3);
+    }
+}
+
+static void EnqueueSendCmd(u16 *sendCmd)
+{
+    u8 i;
+    u8 offset;
+
+    gLinkSavedIme = REG_IME;
+    REG_IME = 0;
+    if (gLink.sendQueue.count < QUEUE_CAPACITY)
+    {
+        offset = gLink.sendQueue.pos + gLink.sendQueue.count;
+        if (offset >= QUEUE_CAPACITY)
+        {
+            offset -= QUEUE_CAPACITY;
+        }
+        for (i = 0; i < CMD_LENGTH; i++)
+        {
+            sSendNonzeroCheck |= *sendCmd;
+            gLink.sendQueue.data[i][offset] = *sendCmd;
+            *sendCmd = 0;
+            sendCmd++;
+        }
+    }
+    else
+    {
+        gLink.queueFull = QUEUE_FULL_SEND;
+    }
+    if (sSendNonzeroCheck)
+    {
+        gLink.sendQueue.count++;
+        sSendNonzeroCheck = 0;
+    }
+    REG_IME = gLinkSavedIme;
+    gLastSendQueueCount = gLink.sendQueue.count;
+}
+
+static void DequeueRecvCmds(u16 (*recvCmds)[CMD_LENGTH])
+{
+    u8 i;
+    u8 j;
+
+    gLinkSavedIme = REG_IME;
+    REG_IME = 0;
+    if (gLink.recvQueue.count == 0)
+    {
+        for (i = 0; i < gLink.playerCount; i++)
+        {
+            for (j = 0; j < CMD_LENGTH; j++)
+            {
+                recvCmds[i][j] = 0;
+            }
+        }
+
+        gLink.receivedNothing = TRUE;
+    }
+    else
+    {
+        for (i = 0; i < gLink.playerCount; i++)
+        {
+            for (j = 0; j < CMD_LENGTH; j++)
+            {
+                recvCmds[i][j] = gLink.recvQueue.data[i][j][gLink.recvQueue.pos];
+            }
+        }
+        gLink.recvQueue.count--;
+        gLink.recvQueue.pos++;
+        if (gLink.recvQueue.pos >= QUEUE_CAPACITY)
+        {
+            gLink.recvQueue.pos = 0;
+        }
+        gLink.receivedNothing = FALSE;
+    }
+    REG_IME = gLinkSavedIme;
+}
+
+void LinkVSync(void)
+{
+    if (gLink.isMaster)
+    {
+        switch (gLink.state)
+        {
+        case LINK_STATE_CONN_ESTABLISHED:
+            if (gLink.serialIntrCounter < 9)
+            {
+                if (gLink.hardwareError != TRUE)
+                {
+                    gLink.lag = LAG_MASTER;
+                }
+                else
+                {
+                    StartTransfer();
+                }
+            }
+            else if (gLink.lag != LAG_MASTER)
+            {
+                gLink.serialIntrCounter = 0;
+                StartTransfer();
+            }
+            break;
+        case LINK_STATE_HANDSHAKE:
+            StartTransfer();
+            break;
+        }
+    }
+    else if (gLink.state == LINK_STATE_CONN_ESTABLISHED || gLink.state == LINK_STATE_HANDSHAKE)
+    {
+        if (++sNumVBlanksWithoutSerialIntr > 10)
+        {
+            if (gLink.state == LINK_STATE_CONN_ESTABLISHED)
+            {
+                gLink.lag = LAG_SLAVE;
+            }
+            if (gLink.state == LINK_STATE_HANDSHAKE)
+            {
+                gLink.playerCount = 0;
+                gLink.link_field_F = FALSE;
+            }
+        }
+    }
+}
+
+void Timer3Intr(void)
+{
+    StopTimer();
+    StartTransfer();
+}
+
+void SerialCB(void)
+{
+    gLink.localId = SIO_MULTI_CNT->id;
+    switch (gLink.state)
+    {
+    case LINK_STATE_CONN_ESTABLISHED:
+        gLink.hardwareError = SIO_MULTI_CNT->error;
+        DoRecv();
+        DoSend();
+        SendRecvDone();
+        break;
+    case LINK_STATE_HANDSHAKE:
+        if (DoHandshake())
+        {
+            if (gLink.isMaster)
+            {
+                gLink.state = LINK_STATE_INIT_TIMER;
+                gLink.serialIntrCounter = 8;
+            }
+            else
+            {
+                gLink.state = LINK_STATE_CONN_ESTABLISHED;
+            }
+        }
+        break;
+    }
+    gLink.serialIntrCounter++;
+    sNumVBlanksWithoutSerialIntr = 0;
+    if (gLink.serialIntrCounter == 8)
+    {
+        gLastRecvQueueCount = gLink.recvQueue.count;
+    }
+}
+
+static void StartTransfer(void)
+{
+    REG_SIOCNT |= SIO_START;
+}
+
+static bool8 DoHandshake(void)
+{
+    u8 i;
+    u8 playerCount;
+    u16 minRecv;
+
+    playerCount = 0;
+    minRecv = 0xFFFF;
+    if (gLink.handshakeAsMaster == TRUE)
+    {
+        REG_SIOMLT_SEND = MASTER_HANDSHAKE;
+    }
+    else
+    {
+        REG_SIOMLT_SEND = SLAVE_HANDSHAKE;
+    }
+    *(u64 *)gLink.tempRecvBuffer = REG_SIOMLT_RECV;
+    REG_SIOMLT_RECV = 0;
+    gLink.handshakeAsMaster = FALSE;
+    for (i = 0; i < 4; i++)
+    {
+        if ((gLink.tempRecvBuffer[i] & ~0x3) == SLAVE_HANDSHAKE || gLink.tempRecvBuffer[i] == MASTER_HANDSHAKE)
+        {
+            playerCount++;
+            if (minRecv > gLink.tempRecvBuffer[i] && gLink.tempRecvBuffer[i] != 0)
+            {
+                minRecv = gLink.tempRecvBuffer[i];
+            }
+        }
+        else
+        {
+            if (gLink.tempRecvBuffer[i] != 0xFFFF)
+            {
+                playerCount = 0;
+            }
+            break;
+        }
+    }
+    gLink.playerCount = playerCount;
+    if (gLink.playerCount > 1 && gLink.playerCount == sHandshakePlayerCount && gLink.tempRecvBuffer[0] == MASTER_HANDSHAKE)
+    {
+        return TRUE;
+    }
+    if (gLink.playerCount > 1)
+    {
+        gLink.link_field_F = (minRecv & 3) + 1;
+    }
+    else
+    {
+        gLink.link_field_F = 0;
+    }
+    sHandshakePlayerCount = gLink.playerCount;
+    return FALSE;
+}
+
+static void DoRecv(void)
+{
+    u16 recv[4];
+    u8 i;
+    u8 index;
+
+    *(u64 *)recv = REG_SIOMLT_RECV;
+    if (gLink.sendCmdIndex == 0)
+    {
+        for (i = 0; i < gLink.playerCount; i++)
+        {
+            if (gLink.checksum != recv[i] && sChecksumAvailable)
+            {
+                gLink.badChecksum = TRUE;
+            }
+        }
+        gLink.checksum = 0;
+        sChecksumAvailable = TRUE;
+    }
+    else
+    {
+        index = gLink.recvQueue.pos + gLink.recvQueue.count;
+        if (index >= QUEUE_CAPACITY)
+        {
+            index -= QUEUE_CAPACITY;
+        }
+        if (gLink.recvQueue.count < QUEUE_CAPACITY)
+        {
+            for (i = 0; i < gLink.playerCount; i++)
+            {
+                gLink.checksum += recv[i];
+                sRecvNonzeroCheck |= recv[i];
+                gLink.recvQueue.data[i][gLink.recvCmdIndex][index] = recv[i];
+            }
+        }
+        else
+        {
+            gLink.queueFull = QUEUE_FULL_RECV;
+        }
+        gLink.recvCmdIndex++;
+        if (gLink.recvCmdIndex == CMD_LENGTH && sRecvNonzeroCheck)
+        {
+            gLink.recvQueue.count++;
+            sRecvNonzeroCheck = 0;
+        }
+    }
+}
+
+static void DoSend(void)
+{
+    if (gLink.sendCmdIndex == CMD_LENGTH)
+    {
+        REG_SIOMLT_SEND = gLink.checksum;
+        if (!sSendBufferEmpty)
+        {
+            gLink.sendQueue.count--;
+            gLink.sendQueue.pos++;
+            if (gLink.sendQueue.pos >= QUEUE_CAPACITY)
+            {
+                gLink.sendQueue.pos = 0;
+            }
+        }
+        else
+        {
+            sSendBufferEmpty = FALSE;
+        }
+    }
+    else
+    {
+        if (!sSendBufferEmpty && gLink.sendQueue.count == 0)
+        {
+            sSendBufferEmpty = TRUE;
+        }
+        if (sSendBufferEmpty)
+        {
+            REG_SIOMLT_SEND = 0;
+        }
+        else
+        {
+            REG_SIOMLT_SEND = gLink.sendQueue.data[gLink.sendCmdIndex][gLink.sendQueue.pos];
+        }
+        gLink.sendCmdIndex++;
+    }
+}
+
+static void StopTimer(void)
+{
+    if (gLink.isMaster)
+    {
+        REG_TM3CNT_H &= ~TIMER_ENABLE;
+        REG_TM3CNT_L = -197;
+    }
+}
+
+static void SendRecvDone(void)
+{
+    if (gLink.recvCmdIndex == CMD_LENGTH)
+    {
+        gLink.sendCmdIndex = 0;
+        gLink.recvCmdIndex = 0;
+    }
+    else if (gLink.isMaster)
+    {
+        REG_TM3CNT_H |= TIMER_ENABLE;
+    }
+}
+
+void ResetSendBuffer(void)
+{
+    u8 i;
+    u8 j;
+
+    gLink.sendQueue.count = 0;
+    gLink.sendQueue.pos = 0;
+    for (i = 0; i < CMD_LENGTH; i++)
+    {
+        for (j = 0; j < QUEUE_CAPACITY; j++)
+        {
+            gLink.sendQueue.data[i][j] = 0xEFFF;
+        }
+    }
+}
+
+void ResetRecvBuffer(void)
+{
+    u8 i;
+    u8 j;
+    u8 k;
+
+    gLink.recvQueue.count = 0;
+    gLink.recvQueue.pos = 0;
+    for (i = 0; i < MAX_LINK_PLAYERS; i++)
+    {
+        for (j = 0; j < CMD_LENGTH; j++)
+        {
+            for (k = 0; k < QUEUE_CAPACITY; k++)
+            {
+                gLink.recvQueue.data[i][j][k] = 0xEFFF;
+            }
+        }
+    }
+}