diff options
Diffstat (limited to 'src/engine/link.c')
| -rw-r--r-- | src/engine/link.c | 1820 |
1 files changed, 1820 insertions, 0 deletions
diff --git a/src/engine/link.c b/src/engine/link.c new file mode 100644 index 000000000..5858ad8bf --- /dev/null +++ b/src/engine/link.c @@ -0,0 +1,1820 @@ +#include "global.h" +#include "link.h" +#include "battle.h" +#include "berry.h" +#include "berry_blender.h" +#include "hall_of_fame.h" +#include "item_use.h" +#include "main.h" +#include "menu.h" +#include "palette.h" +#include "rng.h" +#include "save.h" +#include "songs.h" +#include "sound.h" +#include "sprite.h" +#include "strings2.h" +#include "task.h" +#include "text.h" + +#define SIO_MULTI_CNT ((struct SioMultiCnt *)REG_ADDR_SIOCNT) + +struct BlockTransfer +{ + u16 pos; + u16 size; + void *src; + bool8 active; + u8 multiplayerId; +}; + +struct LinkTestBGInfo +{ + u32 screenBaseBlock; + u32 paletteNum; + u32 dummy_8; + u32 dummy_C; +}; + +extern u8 unk_2000000[]; +extern u8 unk_2004000[]; +extern u16 gBattleTypeFlags; + +extern u16 word_3004858; + +static void InitLinkTestBG(u8, u8, u8, u8); +void InitLinkTestBG_Unused(u8, u8, u8, u8); +void LinkTestScreen(); +static void InitLocalLinkPlayer(void); +static void VBlankCB_LinkTest(void); +static void InitLink(void); +static void Task_TriggerHandshake(u8); +static void TestBlockTransfer(u32, u32, u32); +static void LinkTestProcessKeyInput(void); +static void CB2_LinkTest(void); +static void HandleReceiveRemoteLinkPlayer(u8); +static void ProcessRecvCmds(u8); +static void BuildSendCmd(u16); +static void sub_8007B44(void); +static void ResetBlockSend(void); +static bool8 InitBlockSend(void *, u32); +static void LinkCB_BlockSendBegin(void); +static void LinkCB_BlockSend(void); +static void LinkCB_BlockSendEnd(void); +static void sub_8007E04(void); +u32 sub_8007E40(void); +static void SetBlockReceivedFlag(u8); +static u16 LinkTestCalcBlockChecksum(void *, u16); +static void PrintHexDigit(u8, u8, u8); +static void PrintHex(u32, u8, u8, u8); +static void LinkCB_RequestPlayerDataExchange(void); +static void Task_PrintTestData(u8); +bool8 sub_8008224(void); +u8 GetDummy2(void); +static void sub_8008350(void); +static void sub_800837C(void); +static void sub_80083E0(void); +static void sub_8008454(void); +static void sub_80084C8(void); +static void sub_80084F4(void); + +static void CheckErrorStatus(void); +static void CB2_PrintErrorMessage(void); +static u8 IsSioMultiMaster(void); +static void DisableSerial(void); +static void EnableSerial(void); +static void CheckMasterOrSlave(void); +static void InitTimer(void); +static void EnqueueSendCmd(u16 *); +static void DequeueRecvCmds(u16[CMD_LENGTH][MAX_LINK_PLAYERS]); +static void StartTransfer(void); +static bool8 DoHandshake(void); +static void DoRecv(void); +static void DoSend(void); +static void StopTimer(void); +static void SendRecvDone(void); +void ResetSendBuffer(void); +void ResetRecvBuffer(void); + +static struct BlockTransfer sBlockSend; +static struct BlockTransfer sBlockRecv[MAX_LINK_PLAYERS]; +static u32 sBlockSendDelayCounter; +static u32 sDummy1; +static u8 sDummy2; +static u32 sPlayerDataExchangeStatus; +static u32 sErrorLinkStatus; +static u32 sErrorLastRecvQueueCount; +static u32 sErrorLastSendQueueCount; +static u32 sDummy3; +static u8 sLinkTestLastBlockSendPos; +static u8 sLinkTestLastBlockRecvPos[MAX_LINK_PLAYERS]; +static u8 sNumVBlanksWithoutSerialIntr; +static bool8 sSendBufferEmpty; +static u16 sSendNonzeroCheck; +static u16 sRecvNonzeroCheck; +static u8 sChecksumAvailable; +static u8 sHandshakePlayerCount; + +u16 word_3002910[MAX_LINK_PLAYERS]; +u32 gLinkDebugValue1; +struct LinkPlayerBlock localLinkPlayerBlock; +bool8 gLinkErrorOccurred; +u32 gLinkDebugValue2; +bool8 gLinkPlayerPending[MAX_LINK_PLAYERS]; +struct LinkPlayer gLinkPlayers[MAX_LINK_PLAYERS]; +bool8 gBlockReceived[MAX_LINK_PLAYERS]; +u16 gLinkHeldKeys; +u16 gLinkTimeOutCounter; +struct LinkPlayer localLinkPlayer; +u16 gRecvCmds[CMD_LENGTH][MAX_LINK_PLAYERS]; +u32 gLinkStatus; +bool8 gLinkDummyBool; +u8 byte_3002A68; +u8 gBlockSendBuffer[BLOCK_BUFFER_SIZE]; +bool8 u8_array_3002B70[MAX_LINK_PLAYERS]; +u16 gLinkType; +bool8 u8_array_3002B78[MAX_LINK_PLAYERS]; +u16 gBlockRecvBuffer[MAX_LINK_PLAYERS][BLOCK_BUFFER_SIZE / 2]; +bool8 gSuppressLinkErrorMessage; +u8 gSavedLinkPlayerCount; +u16 gSendCmd[CMD_LENGTH]; +u8 gSavedMultiplayerId; +bool8 gReceivedRemoteLinkPlayers; +struct LinkTestBGInfo gLinkTestBGInfo; +void (*gLinkCallback)(void); +struct LinkPlayer gSavedLinkPlayers[MAX_LINK_PLAYERS]; +u8 gShouldAdvanceLinkState; +u16 gLinkTestBlockChecksums[MAX_LINK_PLAYERS]; +u8 gBlockRequestType; +u8 gLastSendQueueCount; +struct Link gLink; +u8 gLastRecvQueueCount; +u16 gLinkSavedIme; + +#ifdef GERMAN +u8 deUnkValue1; +u8 deUnkValue2; +#endif + +EWRAM_DATA bool8 gLinkTestDebugValuesEnabled = {0}; +EWRAM_DATA bool8 gLinkTestDummyBool = {0}; +EWRAM_DATA u32 gFiller_20238B8 = {0}; +EWRAM_DATA u32 dword_20238BC = {0}; +EWRAM_DATA bool8 gLinkOpen = {0}; + +static const u16 sLinkTestDigitPalette[] = INCBIN_U16("graphics/interface/link_test_digits.gbapal"); +static const u32 sLinkTestDigitTiles[] = INCBIN_U32("graphics/interface/link_test_digits.4bpp"); + +static const u8 sDebugMessages[7][12] = +{ + _("せつぞく ちゅうです"), + _("せつぞく できません"), + _("かくにん ちゅうです"), + _("かくにん できました"), + _("かくにん できません"), + _("かくにん を かくにん"), + _("かくにん は しっぱい"), +}; + +static const u8 sColorCodes[] = _("{HIGHLIGHT TRANSPARENT}{COLOR WHITE2}"); + +const struct BlockRequest sBlockRequestLookupTable[5] = +{ + {gBlockSendBuffer, 200}, + {gBlockSendBuffer, 200}, + {gBlockSendBuffer, 100}, + {gBlockSendBuffer, 220}, + {gBlockSendBuffer, 40}, +}; + +static const u8 sTestString[] = _("テストな"); + +ALIGNED(4) static const u8 sMagic[] = "GameFreak inc."; + +ALIGNED(4) static const u8 sEmptyString[] = _(""); + +void Task_DestroySelf(u8 taskId) +{ + DestroyTask(taskId); +} + +static void InitLinkTestBG(u8 paletteNum, u8 bgNum, u8 screenBaseBlock, u8 charBaseBlock) +{ + LoadPalette(sLinkTestDigitPalette, 16 * paletteNum, 32); + DmaCopy16(3, sLinkTestDigitTiles, BG_CHAR_ADDR(charBaseBlock), 0x220); + + gLinkTestBGInfo.screenBaseBlock = screenBaseBlock; + gLinkTestBGInfo.paletteNum = paletteNum; + + switch (bgNum) + { + case 1: + REG_BG1CNT = BGCNT_PRIORITY(1) | BGCNT_SCREENBASE(screenBaseBlock) | BGCNT_CHARBASE(charBaseBlock); + break; + case 2: + REG_BG2CNT = BGCNT_PRIORITY(1) | BGCNT_SCREENBASE(screenBaseBlock) | BGCNT_CHARBASE(charBaseBlock); + break; + case 3: + REG_BG3CNT = BGCNT_PRIORITY(1) | BGCNT_SCREENBASE(screenBaseBlock) | BGCNT_CHARBASE(charBaseBlock); + break; + } +} + +void InitLinkTestBG_Unused(u8 paletteNum, u8 bgNum, u8 screenBaseBlock, u8 charBaseBlock) +{ + LoadPalette(sLinkTestDigitPalette, 16 * paletteNum, 32); + DmaCopy16(3, sLinkTestDigitTiles, BG_CHAR_ADDR(charBaseBlock), 0x220); + + gLinkTestBGInfo.screenBaseBlock = screenBaseBlock; + gLinkTestBGInfo.paletteNum = paletteNum; + + *gBGControlRegs[bgNum] = (screenBaseBlock << 8) | (charBaseBlock << 2); +} + +void LinkTestScreen(void) +{ + s32 i; + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetTasks(); + SetVBlankCallback(VBlankCB_LinkTest); + SetUpWindowConfig(&gWindowConfig_81E6CE4); + InitMenuWindow((struct WindowConfig *)&gWindowConfig_81E6CE4); + ResetBlockSend(); + gLinkType = 0x1111; + OpenLink(); + SeedRng(gMain.vblankCounter1); + + for (i = 0; i < 4; i++) + { + // Very weird code, but nothing else seems to match. + // The following would have the same effect: + // gSaveBlock2.playerTrainerId[i] = Random(); + u8 *trainerId = gSaveBlock2.playerTrainerId; + s32 r; + s32 mask = 0xFF; + trainerId[i] = (r = Random()) & mask; + } + + InitLinkTestBG(0, 2, 4, 0); + REG_DISPCNT = DISPCNT_MODE_0 | DISPCNT_OBJ_ON | DISPCNT_BG0_ON | DISPCNT_BG2_ON | DISPCNT_OBJ_1D_MAP; + CreateTask(Task_DestroySelf, 0); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); + sDummy3 = 0; + InitLocalLinkPlayer(); + CreateTask(Task_PrintTestData, 0); + SetMainCallback2(CB2_LinkTest); +} + +void sub_8007270(u8 a1) +{ + localLinkPlayer.lp_field_18 = a1; +} + +static void InitLocalLinkPlayer(void) +{ + s32 i; + + localLinkPlayer.trainerId = gSaveBlock2.playerTrainerId[0] + | (gSaveBlock2.playerTrainerId[1] << 8) + | (gSaveBlock2.playerTrainerId[2] << 16) + | (gSaveBlock2.playerTrainerId[3] << 24); + + for (i = 0; i < (s32)sizeof(localLinkPlayer.name); i++) + localLinkPlayer.name[i] = gSaveBlock2.playerName[i]; // UB: reads past the end of "playerName" array + + localLinkPlayer.gender = gSaveBlock2.playerGender; + localLinkPlayer.linkType = gLinkType; + localLinkPlayer.language = gGameLanguage; + localLinkPlayer.version = gGameVersion + 0x4000; + localLinkPlayer.lp_field_2 = 0; +} + +static void VBlankCB_LinkTest(void) +{ + LoadOam(); + ProcessSpriteCopyRequests(); + TransferPlttBuffer(); +} + +static void InitLink(void) +{ + s32 i; + + for (i = 0; i < CMD_LENGTH; i++) + gSendCmd[i] = 0xEFFF; + + gLinkOpen = TRUE; + EnableSerial(); +} + +static void Task_TriggerHandshake(u8 taskId) +{ + gTasks[taskId].data[0]++; + + if (gTasks[taskId].data[0] == 5) + { + gShouldAdvanceLinkState = 1; + DestroyTask(taskId); + } +} + +void OpenLink(void) +{ + s32 i; + + ResetSerial(); + InitLink(); + + gLinkCallback = LinkCB_RequestPlayerDataExchange; + gLinkVSyncDisabled = FALSE; + gLinkErrorOccurred = FALSE; + gSuppressLinkErrorMessage = FALSE; + + ResetBlockReceivedFlags(); + + sDummy1 = 0; + byte_3002A68 = 0; + gLinkDummyBool = FALSE; + gReceivedRemoteLinkPlayers = FALSE; + + for (i = 0; i < 4; i++) + { + gLinkPlayerPending[i] = TRUE; + u8_array_3002B78[i] = 0; + u8_array_3002B70[i] = 0; + } + + CreateTask(Task_TriggerHandshake, 2); +} + +void CloseLink(void) +{ + gReceivedRemoteLinkPlayers = FALSE; + gLinkOpen = FALSE; + DisableSerial(); +} + +static void TestBlockTransfer(u32 a1, u32 a2, u32 a3) +{ + u8 i; + u8 val; + + if (sLinkTestLastBlockSendPos != sBlockSend.pos) + { + PrintHex(sBlockSend.pos, 2, 3, 2); + sLinkTestLastBlockSendPos = sBlockSend.pos; + } + + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + if (sLinkTestLastBlockRecvPos[i] != sBlockRecv[i].pos) + { + PrintHex(sBlockRecv[i].pos, 2, i + 4, 2); + sLinkTestLastBlockRecvPos[i] = sBlockRecv[i].pos; + } + } + + val = GetBlockReceivedStatus(); + + if (val == 0xF) + { + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + if ((val >> i) & 1) + { + gLinkTestBlockChecksums[i] = LinkTestCalcBlockChecksum(&gBlockRecvBuffer[i], sBlockRecv[i].size); + ResetBlockReceivedFlag(i); + if (gLinkTestBlockChecksums[i] != 834) + { + gLinkTestDebugValuesEnabled = FALSE; + gLinkTestDummyBool = FALSE; + } + } + } + } +} + +static void LinkTestProcessKeyInput(void) +{ + if (gMain.newKeys & A_BUTTON) + gShouldAdvanceLinkState = 1; + if (gMain.heldKeys & B_BUTTON) + InitBlockSend(unk_2004000, 0x2004); + if (gMain.newKeys & L_BUTTON) + BeginNormalPaletteFade(-1, 0, 0x10, 0, 2); + if (gMain.newKeys & START_BUTTON) + SetSuppressLinkErrorMessage(TRUE); + if (gMain.newKeys & R_BUTTON) + TrySavingData(LINK_SAVE); + if (gMain.newKeys & SELECT_BUTTON) + sub_800832C(); + if (gLinkTestDebugValuesEnabled) + { + u32 vblankCounter1 = gMain.vblankCounter1; + u8 val = gLinkVSyncDisabled; + if (!gLinkCallback) + val = gLinkVSyncDisabled | 0x10; + SetLinkDebugValues(vblankCounter1, val); + } +} + +static void CB2_LinkTest(void) +{ + LinkTestProcessKeyInput(); + TestBlockTransfer(1, 1, 0); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); +} + +u16 LinkMain2(u16 *heldKeys) +{ + u8 i; + + if (!gLinkOpen) + return 0; + + for (i = 0; i < CMD_LENGTH; i++) + gSendCmd[i] = 0; + + gLinkHeldKeys = *heldKeys; + + if (gLinkStatus & LINK_STAT_CONN_ESTABLISHED) + { + ProcessRecvCmds(SIO_MULTI_CNT->id); + if (gLinkCallback) + gLinkCallback(); + CheckErrorStatus(); + } + + return gLinkStatus; +} + +static void HandleReceiveRemoteLinkPlayer(u8 multiplayerId) +{ + u32 pendingLinkPlayerCount = 0; + s32 i; + + gLinkPlayerPending[multiplayerId] = FALSE; + + for (i = 0; i < GetLinkPlayerCount_2(); i++) + pendingLinkPlayerCount += gLinkPlayerPending[i]; + + if (pendingLinkPlayerCount == 0 && !gReceivedRemoteLinkPlayers) + gReceivedRemoteLinkPlayers = TRUE; +} + +static void ProcessRecvCmds(u8 unusedParam) +{ + u16 i; + for (i = 0; i < MAX_LINK_PLAYERS; i++) + { + word_3002910[i] = 0; + if (!gRecvCmds[0][i]) + continue; + switch (gRecvCmds[0][i]) + { + case 0x2222: + InitLocalLinkPlayer(); + localLinkPlayerBlock.linkPlayer = localLinkPlayer; + memcpy(localLinkPlayerBlock.magic1, sMagic, sizeof(localLinkPlayerBlock.magic1) - 1); + memcpy(localLinkPlayerBlock.magic2, sMagic, sizeof(localLinkPlayerBlock.magic2) - 1); + InitBlockSend(&localLinkPlayerBlock, sizeof(localLinkPlayerBlock)); + break; + case 0x4444: + word_3002910[i] = gRecvCmds[1][i]; + break; + case 0x5555: + byte_3002A68 = 1; + break; + case 0x5566: + byte_3002A68 = 1; + break; + case 0xBBBB: + { + struct BlockTransfer *blockRecv = &sBlockRecv[i]; + blockRecv->pos = 0; + blockRecv->size = gRecvCmds[1][i]; + blockRecv->multiplayerId = gRecvCmds[2][i]; + break; + } + case 0x8888: + if (sBlockRecv[i].size > BLOCK_BUFFER_SIZE) + { + u16 *buffer = (u16 *)unk_2000000; + u16 j; + for (j = 0; j < CMD_LENGTH - 1; j++) + buffer[(sBlockRecv[i].pos / 2) + j] = gRecvCmds[j + 1][i]; + } + else + { + u16 j; + for (j = 0; j < CMD_LENGTH - 1; j++) + gBlockRecvBuffer[i][(sBlockRecv[i].pos / 2) + j] = gRecvCmds[j + 1][i]; + } + + sBlockRecv[i].pos += (CMD_LENGTH - 1) * 2; + + if (sBlockRecv[i].pos >= sBlockRecv[i].size) + { + if (gLinkPlayerPending[i] == TRUE) + { + struct LinkPlayerBlock *block = (struct LinkPlayerBlock *)&gBlockRecvBuffer[i]; + struct LinkPlayer *linkPlayer = &gLinkPlayers[i]; + *linkPlayer = block->linkPlayer; + + if (strcmp(block->magic1, sMagic) + || strcmp(block->magic2, sMagic)) + { + SetMainCallback2(CB2_LinkError); + } + else + { + HandleReceiveRemoteLinkPlayer(i); + } + + ConvertInternationalString(gLinkPlayers[i].name, gLinkPlayers[i].language); + } + else + { + SetBlockReceivedFlag(i); + } + } + break; + case 0x5FFF: + u8_array_3002B78[i] = 1; + break; + case 0x2FFE: + u8_array_3002B70[i] = 1; + break; + case 0xAAAA: + sub_8007E24(); + break; + case 0xAAAB: + sub_80516C4(i, gRecvCmds[1][i]); + break; + case 0xCCCC: +#if defined(ENGLISH) + SendBlock(0, sBlockRequestLookupTable[gRecvCmds[1][i]].address, sBlockRequestLookupTable[gRecvCmds[1][i]].size); +#elif defined(GERMAN) + if (deUnkValue2 == 1) + { + deUnkValue2 = 2; + deUnkValue1 = gRecvCmds[1][i]; + } + else if (deUnkValue2 == 2 || deUnkValue2 == 3) + { + SendBlock(0, sBlockRequestLookupTable[gRecvCmds[1][i]].address, sBlockRequestLookupTable[gRecvCmds[1][i]].size); + + if (deUnkValue2 == 2) + deUnkValue2 = 1; + else + deUnkValue2 = 0; + } + else + { + SendBlock(0, sBlockRequestLookupTable[gRecvCmds[1][i]].address, sBlockRequestLookupTable[gRecvCmds[1][i]].size); + } +#endif + break; + case 0xCAFE: + word_3002910[i] = gRecvCmds[1][i]; + break; + } + } +} + +static void BuildSendCmd(u16 code) +{ + switch (code) + { + case 0x2222: + gSendCmd[0] = 0x2222; + gSendCmd[1] = gLinkType; + break; + case 0x2FFE: + gSendCmd[0] = 0x2FFE; + break; + case 0x4444: + gSendCmd[0] = 0x4444; + gSendCmd[1] = gMain.heldKeys; + break; + case 0x5555: + gSendCmd[0] = 0x5555; + break; + case 0x5566: + gSendCmd[0] = 0x5566; + break; + case 0x6666: + gSendCmd[0] = 0x6666; + gSendCmd[1] = 0; + break; + case 0x7777: + { + u8 i; + + gSendCmd[0] = 0x7777; + + for (i = 0; i < 5; i++) + gSendCmd[i + 1] = 0xEE; + + break; + } + case 0xBBBB: + gSendCmd[0] = 0xBBBB; + gSendCmd[1] = sBlockSend.size; + gSendCmd[2] = sBlockSend.multiplayerId + 128; + break; + case 0xAAAA: + gSendCmd[0] = 0xAAAA; + break; + case 0xAAAB: + gSendCmd[0] = 0xAAAB; + gSendCmd[1] = gScriptItemId; + break; + case 0xCCCC: + gSendCmd[0] = 0xCCCC; + gSendCmd[1] = gBlockRequestType; + break; + case 0x5FFF: + gSendCmd[0] = 0x5FFF; + break; + case 0xCAFE: + if (!word_3004858 || gLinkTransferringData) + break; + gSendCmd[0] = 0xCAFE; + gSendCmd[1] = word_3004858; + break; + } +} + +void sub_8007B14(void) +{ + gLinkCallback = sub_8007B44; +} + +bool32 sub_8007B24(void) +{ + if (gLinkCallback == sub_8007B44) + return TRUE; + else + return FALSE; +} + +static void sub_8007B44(void) +{ + if (gReceivedRemoteLinkPlayers == TRUE) + BuildSendCmd(0xCAFE); +} + +void ClearLinkCallback(void) +{ + gLinkCallback = NULL; +} + +void ClearLinkCallback_2(void) +{ + gLinkCallback = NULL; +} + +u8 GetLinkPlayerCount(void) +{ + return EXTRACT_PLAYER_COUNT(gLinkStatus); +} + +void OpenLinkTimed(void) +{ + sPlayerDataExchangeStatus = EXCHANGE_NOT_STARTED; + gLinkTimeOutCounter = 0; +#if defined(GERMAN) + ResetBlockSend(); +#endif + OpenLink(); +} + +u8 GetLinkPlayerDataExchangeStatusTimed(void) +{ + s32 i; + s32 count = 0; + u32 index; + + if (gReceivedRemoteLinkPlayers == TRUE) + { + if (GetLinkPlayerCount() == 0) + { + gLinkErrorOccurred = TRUE; + CloseLink(); + } + + i = 0; + index = 0; + + while (i < GetLinkPlayerCount()) + { + if (gLinkPlayers[index].linkType == gLinkPlayers[0].linkType) + ++count; + ++index; + ++i; + } + + if (count == GetLinkPlayerCount()) + sPlayerDataExchangeStatus = EXCHANGE_COMPLETE; + else + sPlayerDataExchangeStatus = EXCHANGE_IN_PROGRESS; + } + else + { + gLinkTimeOutCounter++; + if (gLinkTimeOutCounter > 600) + sPlayerDataExchangeStatus = EXCHANGE_TIMED_OUT; + } + + return sPlayerDataExchangeStatus; +} + +bool8 IsLinkPlayerDataExchangeComplete(void) +{ + u8 i; + u8 count = 0; + u8 isComplete; + + for (i = 0; i < GetLinkPlayerCount(); i++) + if (gLinkPlayers[i].linkType == gLinkPlayers[0].linkType) + count++; + + if (count == GetLinkPlayerCount()) + { + isComplete = TRUE; + sPlayerDataExchangeStatus = EXCHANGE_COMPLETE; + } + else + { + isComplete = FALSE; + sPlayerDataExchangeStatus = EXCHANGE_IN_PROGRESS; + } + + return isComplete; +} + +u32 GetLinkPlayerTrainerId(u8 multiplayerId) +{ + return gLinkPlayers[multiplayerId].trainerId; +} + +void ResetLinkPlayers(void) +{ + s32 i; + for (i = 0; i < 4; i++) + memset(&gLinkPlayers[i], 0, sizeof(struct LinkPlayer)); +} + +static void ResetBlockSend(void) +{ + sBlockSend.active = FALSE; + sBlockSend.pos = 0; + sBlockSend.size = 0; + sBlockSend.src = NULL; +} + +static bool8 InitBlockSend(void *data, u32 size) +{ + if (sBlockSend.active) + { + return FALSE; + } + else + { + sBlockSend.multiplayerId = GetMultiplayerId(); + sBlockSend.active = TRUE; + sBlockSend.size = size; + sBlockSend.pos = 0; + + if (size > BLOCK_BUFFER_SIZE) + { + sBlockSend.src = data; + } + else + { + if (data != gBlockSendBuffer) + memcpy(gBlockSendBuffer, data, size); + sBlockSend.src = gBlockSendBuffer; + } + + BuildSendCmd(0xBBBB); + gLinkCallback = LinkCB_BlockSendBegin; + sBlockSendDelayCounter = 0; + return TRUE; + } +} + +static void LinkCB_BlockSendBegin(void) +{ + sBlockSendDelayCounter++; + if (sBlockSendDelayCounter > 2) + gLinkCallback = LinkCB_BlockSend; +} + +static void LinkCB_BlockSend(void) +{ + s32 i; + u8 *buffer = sBlockSend.src; + + gSendCmd[0] = 0x8888; + + for (i = 0; i < CMD_LENGTH - 1; i++) + { + s32 offset = sBlockSend.pos + 2 * i; + gSendCmd[i + 1] = (buffer[offset + 1] << 8) | buffer[offset]; + } + + sBlockSend.pos += (CMD_LENGTH - 1) * 2; + + if (sBlockSend.size <= sBlockSend.pos) + { + sBlockSend.active = FALSE; + gLinkCallback = LinkCB_BlockSendEnd; + } +} + +static void LinkCB_BlockSendEnd(void) +{ + gLinkCallback = NULL; +} + +static void sub_8007E04(void) +{ + GetMultiplayerId(); // whats the point of calling this if you dont use the multiplayer ID? + BuildSendCmd(0x4444); + dword_20238BC++; +} + +void sub_8007E24(void) +{ + dword_20238BC = 0; + gLinkCallback = sub_8007E04; +} + +u32 sub_8007E40(void) +{ + return dword_20238BC; +} + +void sub_8007E4C(void) +{ + BuildSendCmd(0xAAAA); +} + +u8 GetMultiplayerId(void) +{ + return SIO_MULTI_CNT->id; +} + +u8 bitmask_all_link_players_but_self(void) +{ + return ((1 << GetMultiplayerId()) ^ 0xF); +} + +bool8 SendBlock(u8 a1, void *a2, u16 a3) +{ + return InitBlockSend(a2, a3); +} + +bool8 sub_8007E9C(u8 a1) +{ + if (!gLinkCallback) + { + gBlockRequestType = a1; + BuildSendCmd(0xCCCC); + return TRUE; + } + else + { + return FALSE; + } +} + +bool8 sub_8007ECC(void) +{ + u8 retVal = FALSE; + + if (!gLinkCallback) + retVal = TRUE; + + return retVal; +} + +u8 GetBlockReceivedStatus(void) +{ + return (gBlockReceived[3] << 3) + | (gBlockReceived[2] << 2) + | (gBlockReceived[1] << 1) + | gBlockReceived[0]; +} + +static void SetBlockReceivedFlag(u8 multiplayerId) +{ + gBlockReceived[multiplayerId] = TRUE; +} + +void ResetBlockReceivedFlags(void) +{ + s32 i; + for (i = 0; i < 4; i++) + gBlockReceived[i] = FALSE; +} + +void ResetBlockReceivedFlag(u8 multiplayerId) +{ + if (gBlockReceived[multiplayerId]) + gBlockReceived[multiplayerId] = FALSE; +} + +void sub_8007F4C(void) +{ + if ((gLinkStatus & LINK_STAT_MASTER) && EXTRACT_PLAYER_COUNT(gLinkStatus) > 1) + gShouldAdvanceLinkState = 1; +} + +static u16 LinkTestCalcBlockChecksum(void *data, u16 size) +{ + u16 sum = 0; + u16 i; + + for (i = 0; i < size / 2; i++) + sum += ((u16 *)data)[i]; + + return sum; +} + +static void PrintHexDigit(u8 tileNum, u8 x, u8 y) +{ + u16 *tilemap = (u16 *)BG_SCREEN_ADDR(gLinkTestBGInfo.screenBaseBlock); + tilemap[(32 * y) + x] = (gLinkTestBGInfo.paletteNum << 12) | (tileNum + 1); +} + +static void PrintHex(u32 num, u8 x, u8 y, u8 maxDigits) +{ + u8 buffer[16]; + s32 i; + + for (i = 0; i < maxDigits; i++) + { + buffer[i] = num & 0xF; + num >>= 4; + } + + for (i = maxDigits - 1; i >= 0; i--) + { + PrintHexDigit(buffer[i], x, y); + x++; + } +} + +static void LinkCB_RequestPlayerDataExchange(void) +{ + // Only one request needs to be sent, so only the master sends it. + if (gLinkStatus & LINK_STAT_MASTER) + BuildSendCmd(0x2222); + gLinkCallback = NULL; +} + +void Task_PrintTestData(u8 taskId) +{ + s32 i; + + PrintHex(gShouldAdvanceLinkState, 2, 1, 2); + PrintHex(gLinkStatus, 15, 1, 8); + PrintHex(gLink.state, 2, 10, 2); + PrintHex(EXTRACT_PLAYER_COUNT(gLinkStatus), 15, 10, 2); + PrintHex(GetMultiplayerId(), 15, 12, 2); + PrintHex(gLastSendQueueCount, 25, 1, 2); + PrintHex(gLastRecvQueueCount, 25, 2, 2); + PrintHex(GetBlockReceivedStatus(), 15, 5, 2); + PrintHex(gLinkDebugValue1, 2, 12, 8); + PrintHex(gLinkDebugValue2, 2, 13, 8); + PrintHex(GetSioMultiSI(), 25, 5, 1); + PrintHex(IsSioMultiMaster(), 25, 6, 1); + PrintHex(IsLinkConnectionEstablished(), 25, 7, 1); + PrintHex(HasLinkErrorOccurred(), 25, 8, 1); + + for (i = 0; i < MAX_LINK_PLAYERS; i++) + PrintHex(gLinkTestBlockChecksums[i], 10, 4 + i, 4); +} + +void SetLinkDebugValues(u32 value1, u32 value2) +{ + gLinkDebugValue1 = value1; + gLinkDebugValue2 = value2; +} + +u8 sub_8008198(void) +{ + u8 result = 0; + s32 i; + + for (i = 0; i < gSavedLinkPlayerCount; i++) + result |= (1 << i); + + return result; +} + +void sub_80081C8(u8 playerCount) +{ + s32 i; + + gSavedLinkPlayerCount = playerCount; + gSavedMultiplayerId = GetMultiplayerId(); + + for (i = 0; i < 4; i++) + gSavedLinkPlayers[i] = gLinkPlayers[i]; +} + +u8 sub_800820C(void) +{ + return gSavedLinkPlayerCount; +} + +u8 sub_8008218(void) +{ + return gSavedMultiplayerId; +} + +bool8 sub_8008224(void) +{ + s32 count = 0; + s32 i; + + for (i = 0; i < gSavedLinkPlayerCount; i++) + if (gLinkPlayers[i].trainerId == gSavedLinkPlayers[i].trainerId) + count++; + + if (count == gSavedLinkPlayerCount) + return TRUE; + else + return FALSE; +} + +void sub_800826C(void) +{ + u8 i; + + for (i = 0; i < gSavedLinkPlayerCount; i++) + { + if (gSavedLinkPlayers[i].trainerId != gLinkPlayers[i].trainerId + || StringCompareWithoutExtCtrlCodes(gSavedLinkPlayers[i].name, gLinkPlayers[i].name)) + { + gLinkErrorOccurred = TRUE; + CloseLink(); + SetMainCallback2(CB2_LinkError); + } + } +} + +void sub_80082EC(void) +{ + gSavedLinkPlayerCount = 0; + gSavedMultiplayerId = 0; +} + +u8 GetLinkPlayerCount_2(void) +{ + return EXTRACT_PLAYER_COUNT(gLinkStatus); +} + +bool8 IsLinkMaster(void) +{ + return EXTRACT_MASTER(gLinkStatus); +} + +u8 GetDummy2(void) +{ + return sDummy2; +} + +void sub_800832C(void) +{ + if (!gLinkCallback) + { + gLinkCallback = sub_8008350; + gLinkDummyBool = FALSE; + } +} + +static void sub_8008350(void) +{ + if (gLastRecvQueueCount == 0) + { + BuildSendCmd(0x5FFF); + gLinkCallback = sub_800837C; + } +} + +static void sub_800837C(void) +{ + s32 i; + s32 totalCount = GetLinkPlayerCount(); + s32 count = 0; + + for (i = 0; i < totalCount; i++) + if (u8_array_3002B78[i]) + count++; + + if (count == totalCount) + { + gBattleTypeFlags &= ~BATTLE_TYPE_20; + gLinkVSyncDisabled = TRUE; + CloseLink(); + gLinkCallback = NULL; + gLinkDummyBool = TRUE; + } +} + +static void sub_80083E0(void) +{ + s32 i; + s32 totalCount = GetLinkPlayerCount(); + s32 count = 0; + + for (i = 0; i < totalCount; i++) + { + if (gLinkPlayers[i].language == 1) + count++; + else if (u8_array_3002B78[i]) + count++; + } + + if (count == totalCount) + { + gBattleTypeFlags &= ~BATTLE_TYPE_20; + gLinkVSyncDisabled = TRUE; + CloseLink(); + gLinkCallback = 0; + gLinkDummyBool = TRUE; + } +} + +static void sub_8008454(void) +{ + if (gLastRecvQueueCount == 0) + { + BuildSendCmd(0x5FFF); + gLinkCallback = sub_80083E0; + } +} + +void sub_8008480(void) +{ + if (!gLinkCallback) + { + gLinkCallback = sub_8008454; + gLinkDummyBool = FALSE; + } +} + +void sub_80084A4(void) +{ + if (!gLinkCallback) + gLinkCallback = sub_80084C8; + gLinkDummyBool = FALSE; +} + +static void sub_80084C8(void) +{ + if (gLastRecvQueueCount == 0) + { + BuildSendCmd(0x2FFE); + gLinkCallback = sub_80084F4; + } +} + +static void sub_80084F4(void) +{ + u8 totalCount = GetLinkPlayerCount(); + u8 count = 0; + + while (count < totalCount && u8_array_3002B70[count]) + count++; + + if (count == totalCount) + { + u8 i; + for (i = 0; i < 4; i++) + u8_array_3002B70[i] = 0; + gLinkCallback = NULL; + } +} + +static void CheckErrorStatus(void) +{ + if (gLinkOpen) + { + if (gLinkStatus & LINK_STAT_ERRORS) + { + if (!gSuppressLinkErrorMessage) + { + sErrorLinkStatus = gLinkStatus; + sErrorLastRecvQueueCount = gLastRecvQueueCount; + sErrorLastSendQueueCount = gLastSendQueueCount; + SetMainCallback2(CB2_LinkError); + } + gLinkErrorOccurred = TRUE; + CloseLink(); + } + } +} + +void CB2_LinkError(void) +{ + ResetSpriteData(); + FreeAllSpritePalettes(); + ResetPaletteFadeControl(); + FillPalette(0, 0, 2); + ResetTasks(); + SetVBlankCallback(VBlankCB_LinkTest); + SetUpWindowConfig(&gWindowConfig_81E7198); + InitMenuWindow((struct WindowConfig *)&gWindowConfig_81E7198); + MenuZeroFillScreen(); + REG_BLDALPHA = 0; + REG_BG0VOFS = 0; + REG_BG0HOFS = 0; + REG_DISPCNT = DISPCNT_MODE_0 | DISPCNT_OBJ_1D_MAP | DISPCNT_BG0_ON; + gSoftResetDisabled = FALSE; + CreateTask(Task_DestroySelf, 0); + StopMapMusic(); + RunTasks(); + AnimateSprites(); + BuildOamBuffer(); + UpdatePaletteFade(); + SetMainCallback2(CB2_PrintErrorMessage); +} + +static void CB2_PrintErrorMessage(void) +{ + u8 array[64] __attribute__((unused)); // unused + + switch (gMain.state) + { + case 0: + MenuPrint_PixelCoords(gMultiText_LinkError, 20, 56, 1); + break; + case 30: + case 60: + PlaySE(SE_BOO); + break; + case 90: + PlaySE(SE_BOO); + break; + } + + if (gMain.state != 200) + gMain.state++; +} + +u8 GetSioMultiSI(void) +{ + return (REG_SIOCNT >> SIO_MULTI_SI_SHIFT) & SIO_MULTI_SI_MASK; +} + +static bool8 IsSioMultiMaster(void) +{ + bool8 isMaster = FALSE; + + if ((REG_SIOCNT & SIO_MULTI_SD) && !(REG_SIOCNT & SIO_MULTI_SI)) + isMaster = TRUE; + + return isMaster; +} + +bool8 IsLinkConnectionEstablished(void) +{ + return EXTRACT_CONN_ESTABLISHED(gLinkStatus); +} + +void SetSuppressLinkErrorMessage(bool8 value) +{ + gSuppressLinkErrorMessage = value; +} + +bool8 HasLinkErrorOccurred(void) +{ + return gLinkErrorOccurred; +} + +static void DisableSerial(void) +{ + gLinkSavedIme = REG_IME; + REG_IME = 0; + REG_IE &= ~(INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL); + REG_IME = gLinkSavedIme; + + REG_SIOCNT = 0; + REG_TM3CNT_H = 0; + REG_IF = INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL; + + CpuFill32(0, &gLink, sizeof(gLink)); +} + +static void EnableSerial(void) +{ + gLinkSavedIme = REG_IME; + REG_IME = 0; + REG_IE &= ~(INTR_FLAG_TIMER3 | INTR_FLAG_SERIAL); + REG_IME = gLinkSavedIme; + + REG_RCNT = 0; + + REG_SIOCNT = SIO_MULTI_MODE; + REG_SIOCNT |= SIO_INTR_ENABLE | SIO_115200_BPS; + + gLinkSavedIme = REG_IME; + REG_IME = 0; + REG_IE |= INTR_FLAG_SERIAL; + REG_IME = gLinkSavedIme; + + REG_SIOMLT_SEND = 0; + + CpuFill32(0, &gLink, sizeof(gLink)); + + sNumVBlanksWithoutSerialIntr = 0; + sSendNonzeroCheck = 0; + sRecvNonzeroCheck = 0; + sChecksumAvailable = FALSE; + sHandshakePlayerCount = 0; + gLastSendQueueCount = 0; + gLastRecvQueueCount = 0; +} + +void ResetSerial(void) +{ + EnableSerial(); + DisableSerial(); +} + +u32 LinkMain1(u8 *shouldAdvanceLinkState, u16 *sendCmd, u16 recvCmds[CMD_LENGTH][MAX_LINK_PLAYERS]) +{ + 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) + { + case 1: + if (gLink.isMaster == 8 && gLink.playerCount > 1) + gLink.handshakeAsMaster = TRUE; + break; + case 2: + gLink.state = LINK_STATE_START0; + REG_SIOMLT_SEND = 0; + break; + default: + CheckMasterOrSlave(); + break; + } + break; + case LINK_STATE_INIT_TIMER: + InitTimer(); + gLink.state = LINK_STATE_CONN_ESTABLISHED; + case LINK_STATE_CONN_ESTABLISHED: + EnqueueSendCmd(sendCmd); + DequeueRecvCmds(recvCmds); + break; + } + + *shouldAdvanceLinkState = 0; + + retVal = gLink.localId; + retVal |= (gLink.playerCount << 2); + + if (gLink.isMaster == 8) + retVal |= 0x20; + + { + u32 receivedNothing = gLink.receivedNothing << 8; + u32 link_field_F = gLink.link_field_F << 9; + u32 hardwareError = gLink.hardwareError << 12; + u32 badChecksum = gLink.badChecksum << 13; + u32 queueFull = gLink.queueFull << 14; + u32 val; + + if (gLink.state == LINK_STATE_CONN_ESTABLISHED) + { + val = 0x40; + 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 |= 0x10000; + + if (gLink.localId > 3) + retVal |= 0x20000; + + retVal2 = retVal; + if (gLink.lag == LAG_SLAVE) + retVal2 |= 0x40000; + + return retVal2; +} + +static void CheckMasterOrSlave(void) +{ + u32 terminals = *(u32 *)REG_ADDR_SIOCNT & (SIO_MULTI_SD | SIO_MULTI_SI); + + if (terminals == SIO_MULTI_SD && !gLink.localId) + gLink.isMaster = 8; + else + gLink.isMaster = 0; +} + +static void InitTimer(void) +{ + if (gLink.isMaster) + { + REG_TM3CNT_L = 65339; + REG_TM3CNT_H = TIMER_INTR_ENABLE | TIMER_64CLK; + + gLinkSavedIme = REG_IME; + REG_IME = 0; + REG_IE |= INTR_FLAG_TIMER3; + REG_IME = gLinkSavedIme; + } +} + +static void EnqueueSendCmd(u16 *sendCmd) +{ + gLinkSavedIme = REG_IME; + REG_IME = 0; + + if (gLink.sendQueue.count < QUEUE_CAPACITY) + { + u8 i; + u8 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; +} + +void DequeueRecvCmds(u16 recvCmds[CMD_LENGTH][MAX_LINK_PLAYERS]) +{ + u8 i; + u8 j; + + gLinkSavedIme = REG_IME; + REG_IME = 0; + + if (gLink.recvQueue.count == 0) + { + for (i = 0; i < CMD_LENGTH; i++) + for (j = 0; j < gLink.playerCount; j++) + recvCmds[i][j] = 0; + + gLink.receivedNothing = TRUE; + } + else + { + for (i = 0; i < CMD_LENGTH; i++) + for (j = 0; j < gLink.playerCount; j++) + recvCmds[i][j] = gLink.recvQueue.data[j][i][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_HANDSHAKE: + StartTransfer(); + break; + case LINK_STATE_CONN_ESTABLISHED: + if (gLink.serialIntrCounter > 8) + { + if (gLink.lag == LAG_MASTER) + return; + gLink.serialIntrCounter = 0; + } + else if (gLink.hardwareError != TRUE) + { + gLink.lag = LAG_MASTER; + return; + } + StartTransfer(); + break; + } + } + else if (gLink.state == LINK_STATE_CONN_ESTABLISHED + || gLink.state == LINK_STATE_HANDSHAKE) + { + sNumVBlanksWithoutSerialIntr++; + + 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 = 0; + } + } + } +} + +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 = 0; + u16 minRecv = 0xFFFF; + + if (gLink.handshakeAsMaster == TRUE) + REG_SIOMLT_SEND = MASTER_HANDSHAKE; + else + REG_SIOMLT_SEND = SLAVE_HANDSHAKE; + + *(u64 *)&gLink.tempRecvBuffer[0] = 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; + + // The handshake is successful when: + // 1. There are multiple players. + // 2. The number of players agrees with the last attempt. + // 3. Player no. 0 is identifying as the master. + 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 recvBuffer[4]; + u8 i; + + *(u64 *)&recvBuffer[0] = REG_SIOMLT_RECV; + + if (gLink.sendCmdIndex == 0) + { + for (i = 0; i < gLink.playerCount; i++) + if (gLink.checksum != recvBuffer[i] && sChecksumAvailable) + gLink.badChecksum = TRUE; + + gLink.checksum = 0; + sChecksumAvailable = TRUE; + } + else + { + u8 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 += recvBuffer[i]; + sRecvNonzeroCheck |= recvBuffer[i]; + gLink.recvQueue.data[i][gLink.recvCmdIndex][index] = recvBuffer[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 = 65339; + } +} + +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 < 4; i++) + for (j = 0; j < CMD_LENGTH; j++) + for (k = 0; k < QUEUE_CAPACITY; k++) + gLink.recvQueue.data[i][j][k] = 0xEFFF; +} |