GBA SIO: Bring up new lockstep driver

This commit is contained in:
Vicki Pfau 2024-08-22 00:00:10 -07:00
parent 36c1a8cfbc
commit 0955b94466
2 changed files with 844 additions and 2 deletions

View File

@ -1,4 +1,4 @@
/* Copyright (c) 2013-2015 Jeffrey Pfau
/* Copyright (c) 2013-2024 Jeffrey Pfau
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
@ -13,6 +13,9 @@ CXX_GUARD_START
#include <mgba/core/lockstep.h>
#include <mgba/core/timing.h>
#include <mgba/internal/gba/sio.h>
#include <mgba-util/circle-buffer.h>
#include <mgba-util/table.h>
#include <mgba-util/threading.h>
struct GBASIOLockstep {
struct mLockstep d;
@ -48,6 +51,78 @@ void GBASIOLockstepNodeCreate(struct GBASIOLockstepNode*);
bool GBASIOLockstepAttachNode(struct GBASIOLockstep*, struct GBASIOLockstepNode*);
void GBASIOLockstepDetachNode(struct GBASIOLockstep*, struct GBASIOLockstepNode*);
#define MAX_LOCKSTEP_EVENTS 8
enum GBASIOLockstepEventType {
SIO_EV_ATTACH,
SIO_EV_DETACH,
SIO_EV_HARD_SYNC,
SIO_EV_MODE_SET,
SIO_EV_TRANSFER_START,
};
struct GBASIOLockstepCoordinator {
struct Table players;
Mutex mutex;
unsigned nextId;
unsigned attachedPlayers[MAX_GBAS];
int nAttached;
uint32_t waiting;
bool transferActive;
enum GBASIOMode transferMode;
int32_t cycle;
uint16_t multiData[4];
uint32_t normalData[4];
};
struct GBASIOLockstepEvent {
enum GBASIOLockstepEventType type;
int32_t timestamp;
struct GBASIOLockstepEvent* next;
int playerId;
union {
enum GBASIOMode mode;
int32_t finishCycle;
};
};
struct GBASIOLockstepPlayer {
struct GBASIOLockstepDriver* driver;
int playerId;
enum GBASIOMode mode;
enum GBASIOMode otherModes[MAX_GBAS];
bool asleep;
int32_t cycleOffset;
struct GBASIOLockstepEvent* queue;
bool dataReceived;
struct GBASIOLockstepEvent buffer[MAX_LOCKSTEP_EVENTS];
struct GBASIOLockstepEvent* freeList;
};
struct GBASIOLockstepDriver {
struct GBASIODriver d;
struct GBASIOLockstepCoordinator* coordinator;
struct mTimingEvent event;
unsigned lockstepId;
struct mLockstepUser* user;
};
void GBASIOLockstepCoordinatorInit(struct GBASIOLockstepCoordinator*);
void GBASIOLockstepCoordinatorDeinit(struct GBASIOLockstepCoordinator*);
void GBASIOLockstepCoordinatorAttach(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepDriver*);
void GBASIOLockstepCoordinatorDetach(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepDriver*);
size_t GBASIOLockstepCoordinatorAttached(struct GBASIOLockstepCoordinator*);
void GBASIOLockstepDriverCreate(struct GBASIOLockstepDriver*, struct mLockstepUser*);
CXX_GUARD_END
#endif

View File

@ -1,4 +1,4 @@
/* Copyright (c) 2013-2015 Jeffrey Pfau
/* Copyright (c) 2013-2024 Jeffrey Pfau
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
@ -10,6 +10,7 @@
#define LOCKSTEP_INCREMENT 2000
#define LOCKSTEP_TRANSFER 512
#define QUEUE_SIZE 16
static bool GBASIOLockstepNodeInit(struct GBASIODriver* driver);
static void GBASIOLockstepNodeDeinit(struct GBASIODriver* driver);
@ -568,3 +569,769 @@ static uint16_t GBASIOLockstepNodeNormalWriteSIOCNT(struct GBASIODriver* driver,
return value;
}
#define TARGET(P) (1 << (P))
#define TARGET_ALL 0xF
#define TARGET_PRIMARY 0x1
#define TARGET_SECONDARY ((TARGET_ALL) & ~(TARGET_PRIMARY))
static bool GBASIOLockstepDriverInit(struct GBASIODriver* driver);
static void GBASIOLockstepDriverDeinit(struct GBASIODriver* driver);
static void GBASIOLockstepDriverReset(struct GBASIODriver* driver);
static bool GBASIOLockstepDriverLoad(struct GBASIODriver* driver);
static bool GBASIOLockstepDriverUnload(struct GBASIODriver* driver);
static void GBASIOLockstepDriverSetMode(struct GBASIODriver* driver, enum GBASIOMode mode);
static bool GBASIOLockstepDriverHandlesMode(struct GBASIODriver* driver, enum GBASIOMode mode);
static int GBASIOLockstepDriverConnectedDevices(struct GBASIODriver* driver);
static int GBASIOLockstepDriverDeviceId(struct GBASIODriver* driver);
static uint16_t GBASIOLockstepDriverWriteSIOCNT(struct GBASIODriver* driver, uint16_t value);
static uint16_t GBASIOLockstepDriverWriteRCNT(struct GBASIODriver* driver, uint16_t value);
static bool GBASIOLockstepDriverStart(struct GBASIODriver* driver);
static void GBASIOLockstepDriverFinishMultiplayer(struct GBASIODriver* driver, uint16_t data[4]);
static uint8_t GBASIOLockstepDriverFinishNormal8(struct GBASIODriver* driver);
static uint32_t GBASIOLockstepDriverFinishNormal32(struct GBASIODriver* driver);
static void GBASIOLockstepCoordinatorWaitOnPlayers(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer*);
static void GBASIOLockstepCoordinatorAckPlayer(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer*);
static void GBASIOLockstepCoordinatorWakePlayers(struct GBASIOLockstepCoordinator*);
static int32_t GBASIOLockstepTime(struct GBASIOLockstepPlayer*);
static void GBASIOLockstepPlayerWake(struct GBASIOLockstepPlayer*);
static void GBASIOLockstepPlayerSleep(struct GBASIOLockstepPlayer*);
static void _advanceCycle(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer*);
static void _removePlayer(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer*);
static void _reconfigPlayers(struct GBASIOLockstepCoordinator*);
static int32_t _untilNextSync(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer*);
static void _enqueueEvent(struct GBASIOLockstepCoordinator*, const struct GBASIOLockstepEvent*, uint32_t target);
static void _setData(struct GBASIOLockstepCoordinator*, uint32_t id, struct GBASIO* sio);
static void _setReady(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer* activePlayer, int playerId, enum GBASIOMode mode);
static void _hardSync(struct GBASIOLockstepCoordinator*, struct GBASIOLockstepPlayer*);
static void _lockstepEvent(struct mTiming*, void* context, uint32_t cyclesLate);
void GBASIOLockstepDriverCreate(struct GBASIOLockstepDriver* driver, struct mLockstepUser* user) {
memset(driver, 0, sizeof(*driver));
driver->d.init = GBASIOLockstepDriverInit;
driver->d.deinit = GBASIOLockstepDriverDeinit;
driver->d.reset = GBASIOLockstepDriverReset;
driver->d.load = GBASIOLockstepDriverLoad;
driver->d.unload = GBASIOLockstepDriverUnload;
driver->d.setMode = GBASIOLockstepDriverSetMode;
driver->d.handlesMode = GBASIOLockstepDriverHandlesMode;
driver->d.deviceId = GBASIOLockstepDriverDeviceId;
driver->d.connectedDevices = GBASIOLockstepDriverConnectedDevices;
driver->d.writeSIOCNT = GBASIOLockstepDriverWriteSIOCNT;
driver->d.writeRCNT = GBASIOLockstepDriverWriteRCNT;
driver->d.start = GBASIOLockstepDriverStart;
driver->d.finishMultiplayer = GBASIOLockstepDriverFinishMultiplayer;
driver->d.finishNormal8 = GBASIOLockstepDriverFinishNormal8;
driver->d.finishNormal32 = GBASIOLockstepDriverFinishNormal32;
driver->event.context = driver;
driver->event.callback = _lockstepEvent;
driver->event.name = "GBA SIO Lockstep";
driver->event.priority = 0x80;
driver->user = user;
}
static bool GBASIOLockstepDriverInit(struct GBASIODriver* driver) {
GBASIOLockstepDriverReset(driver);
return true;
}
static void GBASIOLockstepDriverDeinit(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (player) {
_removePlayer(coordinator, player);
}
MutexUnlock(&coordinator->mutex);
mTimingDeschedule(&lockstep->d.p->p->timing, &lockstep->event);
lockstep->lockstepId = 0;
}
static void GBASIOLockstepDriverReset(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
if (!lockstep->lockstepId) {
struct GBASIOLockstepPlayer* player = calloc(1, sizeof(*player));
unsigned id;
player->driver = lockstep;
player->mode = driver->p->mode;
player->playerId = -1;
int i;
for (i = 0; i < MAX_LOCKSTEP_EVENTS - 1; ++i) {
player->buffer[i].next = &player->buffer[i + 1];
}
player->freeList = &player->buffer[0];
MutexLock(&coordinator->mutex);
while (true) {
if (coordinator->nextId == UINT_MAX) {
coordinator->nextId = 0;
}
++coordinator->nextId;
id = coordinator->nextId;
if (!TableLookup(&coordinator->players, id)) {
TableInsert(&coordinator->players, id, player);
lockstep->lockstepId = id;
break;
}
}
_reconfigPlayers(coordinator);
if (player->playerId != 0) {
player->cycleOffset = mTimingCurrentTime(&driver->p->p->timing) - coordinator->cycle + LOCKSTEP_INCREMENT;
struct GBASIOLockstepEvent event = {
.type = SIO_EV_ATTACH,
.playerId = player->playerId,
.timestamp = GBASIOLockstepTime(player),
};
_enqueueEvent(coordinator, &event, TARGET_ALL & ~TARGET(player->playerId));
}
MutexUnlock(&coordinator->mutex);
}
if (mTimingIsScheduled(&lockstep->d.p->p->timing, &lockstep->event)) {
return;
}
int32_t nextEvent;
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
_setReady(coordinator, player, player->playerId, player->mode);
if (TableSize(&coordinator->players) == 1) {
coordinator->cycle = mTimingCurrentTime(&lockstep->d.p->p->timing);
nextEvent = LOCKSTEP_INCREMENT;
} else {
_setReady(coordinator, player, 0, coordinator->transferMode);
nextEvent = _untilNextSync(lockstep->coordinator, player);
}
MutexUnlock(&coordinator->mutex);
mTimingSchedule(&lockstep->d.p->p->timing, &lockstep->event, nextEvent);
}
static bool GBASIOLockstepDriverLoad(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
if (lockstep->lockstepId) {
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
_setReady(coordinator, player, 0, coordinator->transferMode);
MutexUnlock(&coordinator->mutex);
GBASIOLockstepDriverSetMode(driver, driver->p->mode);
}
return true;
}
static bool GBASIOLockstepDriverUnload(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
if (lockstep->lockstepId) {
GBASIOLockstepDriverSetMode(driver, -1);
}
return true;
}
static void GBASIOLockstepDriverSetMode(struct GBASIODriver* driver, enum GBASIOMode mode) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (mode != player->mode) {
player->mode = mode;
struct GBASIOLockstepEvent event = {
.type = SIO_EV_MODE_SET,
.playerId = player->playerId,
.timestamp = GBASIOLockstepTime(player),
.mode = mode,
};
if (player->playerId == 0) {
mASSERT(!coordinator->transferActive); // TODO
coordinator->transferMode = mode;
GBASIOLockstepCoordinatorWaitOnPlayers(coordinator, player);
}
_setReady(coordinator, player, player->playerId, mode);
_enqueueEvent(coordinator, &event, TARGET_ALL & ~TARGET(player->playerId));
}
MutexUnlock(&coordinator->mutex);
}
static bool GBASIOLockstepDriverHandlesMode(struct GBASIODriver* driver, enum GBASIOMode mode) {
UNUSED(driver);
UNUSED(mode);
return true;
}
static int GBASIOLockstepDriverConnectedDevices(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
if (!lockstep->lockstepId) {
return 0;
}
MutexLock(&coordinator->mutex);
int attached = coordinator->nAttached - 1;
MutexUnlock(&coordinator->mutex);
return attached;
}
static int GBASIOLockstepDriverDeviceId(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
int playerId = 0;
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (player && player->playerId >= 0) {
playerId = player->playerId;
}
MutexUnlock(&coordinator->mutex);
return playerId;
}
static uint16_t GBASIOLockstepDriverWriteSIOCNT(struct GBASIODriver* driver, uint16_t value) {
UNUSED(driver);
mLOG(GBA_SIO, DEBUG, "Lockstep: SIOCNT <- %04X", value);
return value;
}
static uint16_t GBASIOLockstepDriverWriteRCNT(struct GBASIODriver* driver, uint16_t value) {
UNUSED(driver);
mLOG(GBA_SIO, DEBUG, "Lockstep: RCNT <- %04X", value);
return value;
}
static bool GBASIOLockstepDriverStart(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
bool ret = false;
MutexLock(&coordinator->mutex);
if (coordinator->transferActive) {
mLOG(GBA_SIO, ERROR, "Transfer restarted unexpectedly");
goto out;
}
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (player->playerId != 0) {
mLOG(GBA_SIO, DEBUG, "Secondary player attempted to start transfer");
goto out;
}
mLOG(GBA_SIO, DEBUG, "Transfer starting at %08X", coordinator->cycle);
memset(coordinator->multiData, 0xFF, sizeof(coordinator->multiData));
_setData(coordinator, 0, player->driver->d.p);
int32_t timestamp = GBASIOLockstepTime(player);
struct GBASIOLockstepEvent event = {
.type = SIO_EV_TRANSFER_START,
.timestamp = timestamp,
.finishCycle = timestamp + GBASIOTransferCycles(player->mode, player->driver->d.p->siocnt, coordinator->nAttached - 1),
};
_enqueueEvent(coordinator, &event, TARGET_SECONDARY);
GBASIOLockstepCoordinatorWaitOnPlayers(coordinator, player);
coordinator->transferActive = true;
ret = true;
out:
MutexUnlock(&coordinator->mutex);
return ret;
}
static void GBASIOLockstepDriverFinishMultiplayer(struct GBASIODriver* driver, uint16_t data[4]) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
MutexLock(&coordinator->mutex);
if (coordinator->transferMode == GBA_SIO_MULTI) {
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (!player->dataReceived) {
mLOG(GBA_SIO, WARN, "MULTI did not receive data. Are we running behind?");
memset(data, 0xFF, sizeof(uint16_t) * 4);
} else {
mLOG(GBA_SIO, INFO, "MULTI transfer finished: %04X %04X %04X %04X",
coordinator->multiData[0],
coordinator->multiData[1],
coordinator->multiData[2],
coordinator->multiData[3]);
memcpy(data, coordinator->multiData, sizeof(uint16_t) * 4);
}
player->dataReceived = false;
if (player->playerId == 0) {
_hardSync(coordinator, player);
}
}
MutexUnlock(&coordinator->mutex);
}
static uint8_t GBASIOLockstepDriverFinishNormal8(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
uint8_t data = 0xFF;
MutexLock(&coordinator->mutex);
if (coordinator->transferMode == GBA_SIO_NORMAL_8) {
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (player->playerId > 0) {
if (!player->dataReceived) {
mLOG(GBA_SIO, WARN, "NORMAL did not receive data. Are we running behind?");
} else {
data = coordinator->normalData[player->playerId - 1];
mLOG(GBA_SIO, INFO, "NORMAL8 transfer finished: %02X", data);
}
}
player->dataReceived = false;
if (player->playerId == 0) {
_hardSync(coordinator, player);
}
}
MutexUnlock(&coordinator->mutex);
return data;
}
static uint32_t GBASIOLockstepDriverFinishNormal32(struct GBASIODriver* driver) {
struct GBASIOLockstepDriver* lockstep = (struct GBASIOLockstepDriver*) driver;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
uint32_t data = 0xFFFFFFFF;
MutexLock(&coordinator->mutex);
if (coordinator->transferMode == GBA_SIO_NORMAL_32) {
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
if (player->playerId > 0) {
if (!player->dataReceived) {
mLOG(GBA_SIO, WARN, "Did not receive data. Are we running behind?");
} else {
data = coordinator->normalData[player->playerId - 1];
mLOG(GBA_SIO, INFO, "NORMAL32 transfer finished: %08X", data);
}
}
player->dataReceived = false;
if (player->playerId == 0) {
_hardSync(coordinator, player);
}
}
MutexUnlock(&coordinator->mutex);
return data;
}
void GBASIOLockstepCoordinatorInit(struct GBASIOLockstepCoordinator* coordinator) {
memset(coordinator, 0, sizeof(*coordinator));
MutexInit(&coordinator->mutex);
TableInit(&coordinator->players, 8, free);
}
void GBASIOLockstepCoordinatorDeinit(struct GBASIOLockstepCoordinator* coordinator) {
MutexDeinit(&coordinator->mutex);
TableDeinit(&coordinator->players);
}
void GBASIOLockstepCoordinatorAttach(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepDriver* driver) {
if (driver->coordinator && driver->coordinator != coordinator) {
// TODO
abort();
}
driver->coordinator = coordinator;
}
void GBASIOLockstepCoordinatorDetach(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepDriver* driver) {
if (driver->coordinator != coordinator) {
// TODO
abort();
return;
}
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, driver->lockstepId);
if (player) {
_removePlayer(coordinator, player);
}
MutexUnlock(&coordinator->mutex);
driver->coordinator = NULL;
}
int32_t _untilNextSync(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* player) {
int32_t cycle = coordinator->cycle - GBASIOLockstepTime(player);
if (player->playerId == 0) {
cycle += LOCKSTEP_INCREMENT;
}
return cycle;
}
void _advanceCycle(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* player) {
int32_t newCycle = GBASIOLockstepTime(player);
mASSERT(newCycle - coordinator->cycle >= 0);
//mLOG(GBA_SIO, DEBUG, "Advancing from cycle %08X to %08X (%i cycles)", coordinator->cycle, newCycle, newCycle - coordinator->cycle);
coordinator->cycle = newCycle;
}
void _removePlayer(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* player) {
struct GBASIOLockstepEvent event = {
.type = SIO_EV_DETACH,
.playerId = player->playerId,
.timestamp = GBASIOLockstepTime(player),
};
_enqueueEvent(coordinator, &event, TARGET_ALL & ~TARGET(player->playerId));
GBASIOLockstepCoordinatorWakePlayers(coordinator);
if (player->playerId != 0) {
GBASIOLockstepCoordinatorAckPlayer(coordinator, player);
}
TableRemove(&coordinator->players, player->driver->lockstepId);
_reconfigPlayers(coordinator);
}
void _reconfigPlayers(struct GBASIOLockstepCoordinator* coordinator) {
size_t players = TableSize(&coordinator->players);
memset(coordinator->attachedPlayers, 0, sizeof(coordinator->attachedPlayers));
if (players == 0) {
mLOG(GBA_SIO, WARN, "Reconfiguring player IDs with no players attached somehow?");
} else if (players == 1) {
struct TableIterator iter;
mASSERT(TableIteratorStart(&coordinator->players, &iter));
unsigned p0 = TableIteratorGetKey(&coordinator->players, &iter);
coordinator->attachedPlayers[0] = p0;
struct GBASIOLockstepPlayer* player = TableIteratorGetValue(&coordinator->players, &iter);
coordinator->cycle = mTimingCurrentTime(&player->driver->d.p->p->timing);
if (player->playerId != 0) {
player->playerId = 0;
if (player->driver->user->playerIdChanged) {
player->driver->user->playerIdChanged(player->driver->user, player->playerId);
}
}
if (!coordinator->transferActive) {
coordinator->transferMode = player->mode;
}
} else {
struct UIntList playerPreferences[MAX_GBAS];
int i;
for (i = 0; i < MAX_GBAS; ++i) {
UIntListInit(&playerPreferences[i], 4);
}
// Collect the first four players' requested player IDs so we can sort through them later
int seen = 0;
struct TableIterator iter;
mASSERT(TableIteratorStart(&coordinator->players, &iter));
do {
unsigned pid = TableIteratorGetKey(&coordinator->players, &iter);
struct GBASIOLockstepPlayer* player = TableIteratorGetValue(&coordinator->players, &iter);
int requested = MAX_GBAS - 1;
if (player->driver->user->requestedId) {
requested = player->driver->user->requestedId(player->driver->user);
}
if (requested < 0) {
continue;
}
if (requested >= MAX_GBAS) {
requested = MAX_GBAS - 1;
}
*UIntListAppend(&playerPreferences[requested]) = pid;
++seen;
} while (TableIteratorNext(&coordinator->players, &iter) && seen < MAX_GBAS);
// Now sort each requested player ID to figure out who gets which ID
seen = 0;
for (i = 0; i < MAX_GBAS; ++i) {
int j;
for (j = 0; j <= i; ++j) {
while (UIntListSize(&playerPreferences[j]) && seen < MAX_GBAS) {
unsigned pid = *UIntListGetPointer(&playerPreferences[j], 0);
UIntListShift(&playerPreferences[j], 0, 1);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, pid);
if (!player) {
mLOG(GBA_SIO, ERROR, "Player list appears to have changed unexpectedly. PID %u missing.", pid);
continue;
}
coordinator->attachedPlayers[seen] = pid;
if (player->playerId != seen) {
player->playerId = seen;
if (player->driver->user->playerIdChanged) {
player->driver->user->playerIdChanged(player->driver->user, player->playerId);
}
}
++seen;
}
}
}
for (i = 0; i < MAX_GBAS; ++i) {
UIntListDeinit(&playerPreferences[i]);
}
}
int nAttached = 0;
size_t i;
for (i = 0; i < MAX_GBAS; ++i) {
unsigned pid = coordinator->attachedPlayers[i];
if (!pid) {
continue;
}
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, pid);
if (!player) {
coordinator->attachedPlayers[i] = 0;
} else {
++nAttached;
}
}
coordinator->nAttached = nAttached;
}
static void _setData(struct GBASIOLockstepCoordinator* coordinator, uint32_t id, struct GBASIO* sio) {
switch (coordinator->transferMode) {
case GBA_SIO_MULTI:
coordinator->multiData[id] = sio->p->memory.io[GBA_REG(SIOMLT_SEND)];
break;
case GBA_SIO_NORMAL_8:
coordinator->normalData[id] = sio->p->memory.io[GBA_REG(SIODATA8)];
break;
case GBA_SIO_NORMAL_32:
coordinator->normalData[id] = sio->p->memory.io[GBA_REG(SIODATA32_LO)];
coordinator->normalData[id] |= sio->p->memory.io[GBA_REG(SIODATA32_HI)] << 16;
break;
case GBA_SIO_UART:
case GBA_SIO_GPIO:
case GBA_SIO_JOYBUS:
mLOG(GBA_SIO, ERROR, "Unsupported mode %i in lockstep", coordinator->transferMode);
// TODO: Should we handle this or just abort?
abort();
break;
}
}
void _setReady(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* activePlayer, int playerId, enum GBASIOMode mode) {
activePlayer->otherModes[playerId] = mode;
bool ready = true;
int i;
for (i = 0; ready && i < coordinator->nAttached; ++i) {
ready = activePlayer->otherModes[i] == activePlayer->mode;
}
if (activePlayer->mode == GBA_SIO_MULTI) {
struct GBASIO* sio = activePlayer->driver->d.p;
sio->siocnt = GBASIOMultiplayerSetReady(sio->siocnt, ready);
sio->rcnt = GBASIORegisterRCNTSetSd(sio->rcnt, ready);
}
}
void _hardSync(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* player) {
mASSERT_DEBUG(player->playerId == 0);
struct GBASIOLockstepEvent event = {
.type = SIO_EV_HARD_SYNC,
.playerId = 0,
.timestamp = GBASIOLockstepTime(player),
};
_enqueueEvent(coordinator, &event, TARGET_SECONDARY);
GBASIOLockstepCoordinatorWaitOnPlayers(coordinator, player);
}
void _enqueueEvent(struct GBASIOLockstepCoordinator* coordinator, const struct GBASIOLockstepEvent* event, uint32_t target) {
mLOG(GBA_SIO, DEBUG, "Enqueuing event of type %X from %i for target %X at timestamp %X",
event->type, event->playerId, target, event->timestamp);
int i;
for (i = 0; i < coordinator->nAttached; ++i) {
if (!(target & TARGET(i))) {
continue;
}
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, coordinator->attachedPlayers[i]);
mASSERT_LOG(GBA_SIO, player->freeList, "No free events");
struct GBASIOLockstepEvent* newEvent = player->freeList;
player->freeList = newEvent->next;
memcpy(newEvent, event, sizeof(*event));
struct GBASIOLockstepEvent** previous = &player->queue;
struct GBASIOLockstepEvent* next = player->queue;
while (next) {
int32_t until = newEvent->timestamp - next->timestamp;
if (until < 0) {
break;
}
previous = &next->next;
next = next->next;
}
newEvent->next = next;
*previous = newEvent;
}
}
void _lockstepEvent(struct mTiming* timing, void* context, uint32_t cyclesLate) {
struct GBASIOLockstepDriver* lockstep = context;
struct GBASIOLockstepCoordinator* coordinator = lockstep->coordinator;
MutexLock(&coordinator->mutex);
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, lockstep->lockstepId);
struct GBASIO* sio = player->driver->d.p;
mASSERT(player->playerId >= 0 && player->playerId < 4);
bool wasDetach = false;
if (player->queue && player->queue->type == SIO_EV_DETACH) {
mLOG(GBA_SIO, DEBUG, "Player %i detached at timestamp %X, picking up the pieces",
player->queue->playerId, player->queue->timestamp);
wasDetach = true;
}
if (player->playerId == 0) {
// We are the clock owner; advance the shared clock
_advanceCycle(coordinator, player);
if (!coordinator->transferActive) {
GBASIOLockstepCoordinatorWakePlayers(coordinator);
}
}
int32_t nextEvent = _untilNextSync(coordinator, player);
//mASSERT_DEBUG(nextEvent + cyclesLate > 0);
while (true) {
struct GBASIOLockstepEvent* event = player->queue;
if (!event) {
break;
}
if (event->timestamp > GBASIOLockstepTime(player)) {
break;
}
player->queue = event->next;
struct GBASIOLockstepEvent reply = {
.playerId = player->playerId,
.timestamp = GBASIOLockstepTime(player),
};
mLOG(GBA_SIO, DEBUG, "Got event of type %X from %i at timestamp %X",
event->type, event->playerId, event->timestamp);
switch (event->type) {
case SIO_EV_ATTACH:
_setReady(coordinator, player, event->playerId, -1);
if (player->playerId == 0) {
struct GBASIO* sio = player->driver->d.p;
sio->siocnt = GBASIOMultiplayerClearSlave(sio->siocnt);
}
reply.mode = player->mode;
reply.type = SIO_EV_MODE_SET;
_enqueueEvent(coordinator, &reply, TARGET(event->playerId));
break;
case SIO_EV_HARD_SYNC:
GBASIOLockstepCoordinatorAckPlayer(coordinator, player);
break;
case SIO_EV_TRANSFER_START:
_setData(coordinator, player->playerId, sio);
nextEvent = event->finishCycle - GBASIOLockstepTime(player) - cyclesLate;
player->driver->d.p->siocnt |= 0x80;
mTimingDeschedule(&sio->p->timing, &sio->completeEvent);
mTimingSchedule(&sio->p->timing, &sio->completeEvent, nextEvent);
GBASIOLockstepCoordinatorAckPlayer(coordinator, player);
break;
case SIO_EV_MODE_SET:
_setReady(coordinator, player, event->playerId, event->mode);
if (event->playerId == 0) {
GBASIOLockstepCoordinatorAckPlayer(coordinator, player);
}
break;
case SIO_EV_DETACH:
_setReady(coordinator, player, event->playerId, -1);
_setReady(coordinator, player, player->playerId, player->mode);
reply.mode = player->mode;
reply.type = SIO_EV_MODE_SET;
_enqueueEvent(coordinator, &reply, ~TARGET(event->playerId));
if (player->mode == GBA_SIO_MULTI) {
sio->siocnt = GBASIOMultiplayerSetId(sio->siocnt, player->playerId);
sio->siocnt = GBASIOMultiplayerSetSlave(sio->siocnt, player->playerId || coordinator->nAttached < 2);
}
wasDetach = true;
break;
}
event->next = player->freeList;
player->freeList = event;
}
if (player->queue && player->queue->timestamp - GBASIOLockstepTime(player) < nextEvent) {
nextEvent = player->queue->timestamp - GBASIOLockstepTime(player);
}
if (player->playerId != 0 && nextEvent <= LOCKSTEP_INCREMENT) {
if (!player->queue || wasDetach) {
GBASIOLockstepPlayerSleep(player);
// XXX: Is there a better way to gain sync lock at the beginning?
if (nextEvent < 4) {
nextEvent = 4;
}
}
}
MutexUnlock(&coordinator->mutex);
mASSERT_DEBUG(nextEvent > 0);
mTimingSchedule(timing, &lockstep->event, nextEvent);
}
int32_t GBASIOLockstepTime(struct GBASIOLockstepPlayer* player) {
return mTimingCurrentTime(&player->driver->d.p->p->timing) - player->cycleOffset;
}
void GBASIOLockstepCoordinatorWaitOnPlayers(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* player) {
mASSERT(!coordinator->waiting);
mASSERT(!player->asleep);
mASSERT(player->playerId == 0);
if (coordinator->nAttached < 2) {
return;
}
_advanceCycle(coordinator, player);
mLOG(GBA_SIO, DEBUG, "Primary waiting for players to ack");
coordinator->waiting = ((1 << coordinator->nAttached) - 1) & ~TARGET(player->playerId);
GBASIOLockstepPlayerSleep(player);
GBASIOLockstepCoordinatorWakePlayers(coordinator);
}
void GBASIOLockstepCoordinatorWakePlayers(struct GBASIOLockstepCoordinator* coordinator) {
//mLOG(GBA_SIO, DEBUG, "Waking all secondary players");
int i;
for (i = 1; i < coordinator->nAttached; ++i) {
if (!coordinator->attachedPlayers[i]) {
continue;
}
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, coordinator->attachedPlayers[i]);
GBASIOLockstepPlayerWake(player);
}
}
void GBASIOLockstepPlayerWake(struct GBASIOLockstepPlayer* player) {
if (!player->asleep) {
return;
}
player->asleep = false;
player->driver->user->wake(player->driver->user);
}
void GBASIOLockstepCoordinatorAckPlayer(struct GBASIOLockstepCoordinator* coordinator, struct GBASIOLockstepPlayer* player) {
if (player->playerId == 0) {
return;
}
mLOG(GBA_SIO, DEBUG, "Player %i acking primary", player->playerId);
coordinator->waiting &= ~TARGET(player->playerId);
if (!coordinator->waiting) {
mLOG(GBA_SIO, DEBUG, "All players acked, waking primary");
if (coordinator->transferActive) {
int i;
for (i = 0; i < coordinator->nAttached; ++i) {
if (!coordinator->attachedPlayers[i]) {
continue;
}
struct GBASIOLockstepPlayer* player = TableLookup(&coordinator->players, coordinator->attachedPlayers[i]);
player->dataReceived = true;
}
coordinator->transferActive = false;
}
struct GBASIOLockstepPlayer* runner = TableLookup(&coordinator->players, coordinator->attachedPlayers[0]);
GBASIOLockstepPlayerWake(runner);
}
GBASIOLockstepPlayerSleep(player);
}
void GBASIOLockstepPlayerSleep(struct GBASIOLockstepPlayer* player) {
if (player->asleep) {
return;
}
//mLOG(GBA_SIO, DEBUG, "Player %i going to sleep with %i cycles until sync", player->playerId, _untilNextSync(coordinator, player));
player->asleep = true;
player->driver->user->sleep(player->driver->user);
player->driver->d.p->p->cpu->nextEvent = 0;
player->driver->d.p->p->earlyExit = true;
}
size_t GBASIOLockstepCoordinatorAttached(struct GBASIOLockstepCoordinator* coordinator) {
size_t count;
MutexLock(&coordinator->mutex);
count = TableSize(&coordinator->players);
MutexUnlock(&coordinator->mutex);
return count;
}