void tdifRxStateMachine (uint32 * pEvent)
{
*pEvent = 0;
if (TCTimeElapsed(tdifFSM.lastTime) < FSM_TICKSIZE) return;
tdifFSM.lastTime = TCTimeGet();
if (tdifFSM.state == TDIF_STATE_DISABLED) return;
tdifFSM._status = pDiceTDIFRx->status;
tdifFSM.status.reg |= tdifFSM._status.reg;
switch (tdifFSM.state)
{
case TDIF_STATE_FORCE_PLL:
if (!tdifFSM.stateVal)
{
tdifRxSetState (TDIF_STATE_CHECK);
}
else
{
tdifFSM.stateVal--;
}
break;
case TDIF_STATE_CHECK:
if (!tdifFSM.stateVal)
{
if (tdifFSM._status.bit.lock == 1)
{
tdifRxSetState (TDIF_STATE_LOCKED);
*pEvent |= EVT_TDIF_LOCK_ACQUIRED;
}
else
{
// we need to pump again or try another source
tdifRxSetState (TDIF_STATE_FORCE_PLL);
}
}
else
{
tdifFSM.stateVal--;
}
break;
case TDIF_STATE_LOCKED:
if (tdifFSM._status.bit.no_lock == 0)
{
tdifRxSetState (TDIF_STATE_FORCE_PLL);
*pEvent |= EVT_TDIF_LOCK_LOST;
}
else
{
*pEvent |= tdifFSM._status.reg & DIRECT_EV_MASK;
}
break;
}
}
HRESULT briElapsedTimeSinceResetIndication(uint32 *elapsedTime)
{
HRESULT hResult = NO_ERROR;
*elapsedTime = TCTimeElapsed(briLastResetIndication);
return hResult;
}
HRESULT briElapsedTimeSinceResetCompletion(uint32 *elapsedTime)
{
HRESULT hResult = NO_ERROR;
*elapsedTime = 0;
if (briInBusResetProgress == TRUE)
{
hResult = E_BRI_NEW_BUS_RESET;
}
*elapsedTime = TCTimeElapsed(briLastResetCompletion);
return hResult;
}
void sysPrintElapsedTime(uint32 time)
{
char timestr[32];
sysGetTimeStr(TCTimeElapsed(time), timestr);
sysDebugPrintf(timestr);
}
void aesRxStateMachine (uint8 events[NUM_AES])
{
uint8 i, mask;
uint8 * pEvents = events;
BOOL bLocked;
uAESRX_ERROR mstrError;
memset (events, 0, NUM_AES);
if (TCTimeElapsed(aesFSM.lastTime) < FSM_TICKSIZE) return;
aesFSM.lastTime = TCTimeGet();
if (aesFSM.state == AES_STATE_DISABLED) return;
mstrError = pDiceAESRx->error;
for (i = 0 ; i < NUM_AES; i++)
{
aesFSM._rxError[i].reg = pDiceAESRx->rxError[i].reg; // read and clear sticky bits
if (i == aesFSM.rxMaster)
{
// read the master overrun underrun
aesFSM._rxError[i].bit.o_run = mstrError.bit.o_run;
aesFSM._rxError[i].bit.u_run = mstrError.bit.u_run;
}
aesFSM.rxError[i].reg |= aesFSM._rxError[i].reg; // accumulate sticky bits
}
switch (aesFSM.state)
{
case AES_STATE_FORCE_PLL:
if (!aesFSM.stateVal)
aesRxSetState (AES_STATE_CHECK);
else
aesFSM.stateVal--;
break;
case AES_STATE_CHECK:
if (!aesFSM.stateVal)
{
if (aesFSM._rxError[aesFSM.rxMaster].bit.lock == 1)
{
aesRxSetState (AES_STATE_LOCKED);
break;
}
// we need to pump again or try another source
if (aesFSM.rxSelMaster < NUM_AES)
{
aesRxSetState (AES_STATE_FORCE_PLL);
}
else
{
aesFSM.rxMaster++;
if (aesFSM.rxMaster >= NUM_AES) aesFSM.rxMaster = 0;
pDiceAESRx->setup.bit.master_clock = aesFSM.rxMaster;
aesRxSetState (AES_STATE_FORCE_PLL);
}
}
else
{
aesFSM.stateVal--;
}
break;
case AES_STATE_LOCKED:
if (aesFSM._rxError[aesFSM.rxMaster].bit.no_lock == 1)
{
aesRxSetState (AES_STATE_FORCE_PLL);
}
break;
}
// collect lock status events and other events if locked
mask = 0x1;
for (i = 0 ; i < NUM_AES; i++)
{
if (i == aesFSM.rxMaster)
bLocked = (aesFSM.state == AES_STATE_LOCKED);
else
bLocked = (aesFSM.state == AES_STATE_LOCKED) && ((aesFSM._rxError[i].reg & 0x03) == 0x01);
// now check if we need to notify
if (bLocked && !(aesFSM.lockmask & mask))
{
*pEvents = EVT_AES1_LOCK_ACQUIRED;
aesFSM.lockmask |= mask;
}
else if (!bLocked && (aesFSM.lockmask & mask))
{
*pEvents = EVT_AES1_LOCK_LOST;
aesFSM.lockmask &= ~mask;
}
if (bLocked)
{
*pEvents |= aesFSM._rxError[i].reg & DIRECT_EV_MASK;
}
mask <<= 1;
pEvents++;
}
}
