/*****************************************************************************
* FUNCTION: ChipReset
*
* RETURNS: N/A
*
* PARAMS:
* N/A
*
*
* NOTES: Performs the necessary SPI operations to cause the MRF24WB0M to reset.
* This function also implements a delay so that it will not return until
* the WiFi device is ready to receive messages again. The delay time will
* vary depending on the amount of code that must be loaded from serial
* flash.
*****************************************************************************/
static void ChipReset(void)
{
UINT16 value;
UINT32 timeoutPeriod;
UINT32 startTickCount;
timeoutPeriod = TICKS_PER_SECOND; /* 1000 ms */
/* needed for Microchip PICTail (chip enable active low) */
WF_SetCE_N(WF_LOW); /* set low to enable regulator */
/* Configure reset pin */
WF_SetRST_N(WF_HIGH);
/* Let SPI lines settle before first SPI transaction */
DelayMs(1);
/* clear the power bit to disable low power mode on the MRF24WB0M */
Write16BitWFRegister(WF_PSPOLL_H_REG, 0x0000);
/* Set HOST_RESET bit in register to put device in reset */
Write16BitWFRegister(WF_HOST_RESET_REG, Read16BitWFRegister(WF_HOST_RESET_REG) | WF_HOST_RESET_MASK);
/* Clear HOST_RESET bit in register to take device out of reset */
Write16BitWFRegister(WF_HOST_RESET_REG, Read16BitWFRegister(WF_HOST_RESET_REG) & ~WF_HOST_RESET_MASK);
/* after reset is started poll register to determine when HW reset has completed */
startTickCount = (UINT32)TickGet();
do
{
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_HW_STATUS_REG);
value = Read16BitWFRegister(WF_INDEX_DATA_REG);
if (TickGet() - startTickCount >= timeoutPeriod)
{
WF_ASSERT(FALSE);
}
} while ( (value & WF_HW_STATUS_NOT_IN_RESET_MASK) == 0);
/* if SPI not connected will read all 1's */
WF_ASSERT(value != 0xffff);
/* now that chip has come out of HW reset, poll the FIFO byte count register */
/* which will be set to a non-zero value when the MRF24WB0M initialization is */
/* complete. */
startTickCount = (UINT32)TickGet();
do
{
value = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG);
if (TickGet() - startTickCount >= timeoutPeriod)
{
WF_ASSERT(FALSE);
}
} while (value == 0);
}
/*****************************************************************************
* FUNCTION: ChipReset
*
* RETURNS: N/A
*
* PARAMS:
* N/A
*
*
* NOTES: Performs the necessary SPI operations to cause the MRF24W to do a soft
* reset.
*
* This function waits for the MRF24WG to complete its initialization before
* returning to the caller. The largest part of the wait is for the MRF24WG
* to download any patch code in FLASH into its RAM.
*****************************************************************************/
static void ChipReset(void)
{
UINT16 value;
UINT32 timeoutPeriod;
UINT32 startTickCount;
/* clear the power bit to disable low power mode on the MRF24W */
Write16BitWFRegister(WF_PSPOLL_H_REG, 0x0000);
/* Set HOST_RESET bit in register to put device in reset */
Write16BitWFRegister(WF_HOST_RESET_REG, Read16BitWFRegister(WF_HOST_RESET_REG) | WF_HOST_RESET_MASK);
/* Clear HOST_RESET bit in register to take device out of reset */
Write16BitWFRegister(WF_HOST_RESET_REG, Read16BitWFRegister(WF_HOST_RESET_REG) & ~WF_HOST_RESET_MASK);
/* after reset is started poll register to determine when HW reset has completed */
timeoutPeriod = TICKS_PER_SECOND * 3; /* 3000 ms */
startTickCount = (UINT32)TickGet();
do
{
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_HW_STATUS_REG);
value = Read16BitWFRegister(WF_INDEX_DATA_REG);
if (TickGet() - startTickCount >= timeoutPeriod)
{
WF_ASSERT(FALSE);
}
} while ( (value & WF_HW_STATUS_NOT_IN_RESET_MASK) == 0);
/* if SPI not connected will read all 1's */
WF_ASSERT(value != 0xffff);
/* now that chip has come out of HW reset, poll the FIFO byte count register */
/* which will be set to a non-zero value when the MRF24W initialization is */
/* complete. */
startTickCount = (UINT32)TickGet();
do
{
value = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG);
if (TickGet() - startTickCount >= timeoutPeriod)
{
#if defined(__Digilent_Build__)
break;
#else
WF_ASSERT(FALSE);
#endif
}
} while (value == 0);
}
/*****************************************************************************
* FUNCTION: isRawMoveComplete
*
* RETURNS: true if raw move complete, else false
*
* PARAMS:
* p_status -- pointer to current state of Raw move
* RM_COMPLETE -- Raw move completed successfully, function will return true in conjunction with this state
* RM_WAITING -- Still waiting for Raw move to complete, function will return true in conjunction with this state
* RM_TIMEOUT -- Raw move failed due to timeout, function will return true in conjunction with this state
* p_byteCount -- pointer to where byte count is written upon raw move completion; only
* valid when function returns true (not always used)
*
* NOTES: Checks if a RAW move to complete.
*****************************************************************************/
bool isRawMoveComplete(int rawId, int *p_status, uint16_t *p_byteCount)
{
uint8_t regId;
*p_byteCount = 0;
*p_status = RM_WAITING;
bool retCode = false;
// if received an external interrupt that signalled the RAW Move completed
if(RawMoveState[rawId].rawInterrupt & g_rawMoveWaitState.rawIntMask)
{
RawMoveState[rawId].waitingForRawMoveCompleteInterrupt = false;
// stop raw move timer
StopRawMoveTimer(g_rawMoveWaitState.rawId);
/* read the byte count and save it */
regId = g_RawCtrl1Reg[g_rawMoveWaitState.rawId];
*p_byteCount = Read16BitWFRegister(regId) & 0x0fff; // LS 12 bits contain byte count (when used)
*p_status = RM_COMPLETE;
retCode = true;
}
return retCode;
}
/*****************************************************************************
* FUNCTION: RawSetIndex
*
* RETURNS: True is success, false if timed out, which means attempted to set
* raw index past end of raw window. Not a problem as long as no read
* or write occurs.
*
* PARAMS:
* rawId - RAW ID
* index - desired index
*
* NOTES: Sets the RAW index for the specified RAW engine. If attempt to set RAW
* index outside boundaries of RAW window this function will time out.
*****************************************************************************/
bool RawSetIndex(uint16_t rawId, uint16_t index)
{
uint8_t regId;
uint16_t regValue;
uint32_t startTickCount;
uint32_t maxAllowedTicks;
// set the RAW index
regId = (rawId==RAW_ID_0) ? RAW_0_INDEX_REG:RAW_1_INDEX_REG;
Write16BitWFRegister(regId, index);
startTickCount = (uint32_t)TickGet();
maxAllowedTicks = TICKS_PER_SECOND / 200; /* 5ms */
regId = (rawId==RAW_ID_0) ? RAW_0_STATUS_REG:RAW_1_STATUS_REG;
while (1)
{
regValue = Read16BitWFRegister(regId);
if ((regValue & WF_RAW_STATUS_REG_BUSY_MASK) == 0)
{
return true;
}
/* if timed out then trying to set index past end of raw window, which is OK so long as the app */
/* doesn't try to access it */
if (TickGet() - startTickCount >= maxAllowedTicks)
{
return false; /* timed out waiting for Raw set index to complete */
}
}
}
bool AllocateMgmtTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
uint16_t byteCount;
/* get total bytes available for MGMT tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT1_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_TX_ID, RAW_MGMT_POOL, true, bytesNeeded);
if (byteCount == 0)
return false; // just return and let host retry again
}
/* else not enough bytes available at this time to satisfy request */
else
{
return false;
}
RawWindowReady[RAW_TX_ID] = true;
SetRawWindowState(RAW_TX_ID, WF_RAW_MGMT_MOUNTED);
return true;
}
BOOL AllocateMgmtTxBuffer(UINT16 bytesNeeded)
{
UINT16 bufAvail;
UINT16 byteCount;
/* get total bytes available for MGMT tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT1_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_TX_ID, RAW_MGMT_POOL, TRUE, bytesNeeded);
WF_ASSERT(byteCount != 0);
}
/* else not enough bytes available at this time to satisfy request */
else
{
return FALSE;
}
RawWindowReady[RAW_TX_ID] = TRUE;
SetRawWindowState(RAW_TX_ID, WF_RAW_MGMT_MOUNTED);
return TRUE;
}
/*****************************************************************************
* FUNCTION: HostInterrupt2RegInit
*
* RETURNS: N/A
*
* PARAMS:
* hostIntrMaskRegMask - The bit mask to be modified.
* state - One of WF_INT_DISABLE, WF_INT_ENABLE where
* Disable implies clearing the bits and enable sets the bits.
*
*
* NOTES: Initializes the 16-bit Host Interrupt register on the MRF24WB0M with the
* specified mask value either setting or clearing the mask register
* as determined by the input parameter state.
*****************************************************************************/
static void HostInterrupt2RegInit(UINT16 hostIntMaskRegMask,
UINT8 state)
{
UINT16 int2MaskValue;
/* Host Int Register is a status register where each bit indicates a specific event */
/* has occurred. In addition, writing a 1 to a bit location in this register clears */
/* the event. */
/* Host Int Mask Register is used to enable those events activated in Host Int Register */
/* to cause an interrupt to the host */
/* read current state of int2 mask reg */
int2MaskValue = Read16BitWFRegister(WF_HOST_INTR2_MASK_REG);
/* if caller is disabling a set of interrupts */
if (state == WF_INT_DISABLE)
{
/* zero out that set of interrupts in the interrupt mask copy */
int2MaskValue &= ~hostIntMaskRegMask;
}
/* else caller is enabling a set of interrupts */
else
{
/* set to 1 that set of interrupts in the interrupt mask copy */
int2MaskValue |= hostIntMaskRegMask;
}
/* write out new interrupt mask value */
Write16BitWFRegister(WF_HOST_INTR2_MASK_REG, int2MaskValue);
/* ensure that pending interrupts from those updated interrupts are cleared */
Write16BitWFRegister(WF_HOST_INTR2_REG, hostIntMaskRegMask);
}
/*****************************************************************************
* FUNCTION: RawSetIndex
*
* RETURNS: True is success, false if timed out, which means attempted to set
* raw index past end of raw window. Not a problem as long as no read
* or write occurs.
*
* PARAMS:
* rawId - RAW ID
* index - desired index
*
* NOTES: Sets the RAW index for the specified RAW engine. If attempt to set RAW
* index outside boundaries of RAW window this function will time out.
*****************************************************************************/
BOOL RawSetIndex(UINT16 rawId, UINT16 index)
{
UINT8 regId;
UINT16 regValue;
UINT32 startTickCount;
UINT32 maxAllowedTicks;
// set the RAW index
regId = (rawId==RAW_ID_0)?RAW_0_INDEX_REG:RAW_1_INDEX_REG;
Write16BitWFRegister(regId, index);
startTickCount = (UINT32)TickGet();
maxAllowedTicks = TICKS_PER_SECOND / 200; /* 5ms */
regId = (rawId==RAW_ID_0)?RAW_0_STATUS_REG:RAW_1_STATUS_REG;
while (1)
{
regValue = Read16BitWFRegister(regId);
if ((regValue & WF_RAW_STATUS_REG_BUSY_MASK) == 0)
{
return TRUE;
}
/* if timed out then trying to set index past end of raw window, which is OK so long as the app */
/* doesn't try to access it */
if (TickGet() - startTickCount >= maxAllowedTicks)
{
return FALSE; /* timed out waiting for Raw set index to complete */
}
}
}
/*******************************************************************************
Function:
void WFConfigureLowPowerMode(uint8_t action)
Summary:
Driver function to configure PS Poll mode.
Description:
This function is only used by the driver, not the application. This
function, other than at initialization, is only used when the application
has enabled PS-Poll mode. This function is used to temporarily deactivate
PS-Poll mode when there is mgmt or data message tx/rx and then, when message
activity has ceased, to again activate PS-Poll mode.
Precondition:
MACInit must be called first.
Parameters:
action - Can be either:
* WF_LOW_POWER_MODE_ON
* WF_LOW_POWER_MODE_OFF
Returns:
None.
Remarks:
None.
*****************************************************************************/
void WFConfigureLowPowerMode(uint8_t action)
{
uint16_t lowPowerStatusRegValue;
/*-----------------------------------------*/
/* if activating PS-Poll mode on MRF24W */
/*-----------------------------------------*/
if (action == WF_LOW_POWER_MODE_ON)
{
SYS_CONSOLE_MESSAGE("EPS\r\n");
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_ENABLE_LOW_POWER_MASK);
g_psPollActive = true;
}
/*---------------------------------------------------------------------------------------------*/
/* else deactivating PS-Poll mode on MRF24W (taking it out of low-power mode and waking it up) */
/*---------------------------------------------------------------------------------------------*/
else /* action == WF_LOW_POWER_MODE_OFF */
{
SYS_CONSOLE_MESSAGE("DPS\r\n");
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_DISABLE_LOW_POWER_MASK);
g_psPollActive = false;
/* poll the response bit that indicates when the MRF24W has come out of low power mode */
do
{
/* set the index register to the register we wish to read */
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_LOW_POWER_STATUS_REG);
lowPowerStatusRegValue = Read16BitWFRegister(WF_INDEX_DATA_REG);
} while (lowPowerStatusRegValue & REG_ENABLE_LOW_POWER_MASK);
}
}
/*****************************************************************************
Function:
BOOL AllocateMgmtTxBuffer(UINT16 bytesNeeded)
Summary:
Allocates a Mgmt Tx buffer
Description:
Determines if WiFi chip has enough memory to allocate a tx mgmt buffer, and,
if so, allocates it.
Precondition:
None
Parameters:
bytesNeeded -- number of bytes needed for the mgmt tx message
Returns:
True if mgmt tx buffer successfully allocated, else False
Remarks:
None
*****************************************************************************/
BOOL AllocateMgmtTxBuffer(UINT16 bytesNeeded)
{
UINT16 bufAvail;
UINT16 byteCount;
/* get total bytes available for MGMT tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT1_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Mgmt Tx buffer */
byteCount = RawMove(RAW_MGMT_TX_ID, RAW_MGMT_POOL, TRUE, bytesNeeded);
WF_ASSERT(byteCount != 0);
return TRUE;
}
/* else not enough bytes available at this time to satisfy request */
else
{
/* if we allocated some bytes, but not enough, then dealloacate what was allocated */
if (bufAvail > 0)
{
RawMove(RAW_MGMT_RX_ID, RAW_MGMT_POOL, FALSE, 0);
}
return FALSE;
}
}
/*****************************************************************************
Function:
bool AllocateDataTxBuffer(uint16_t bytesNeeded)
Summary:
Allocates a Data Tx buffer for use by the TCP/IP stack.
Description:
Determines if WiFi chip has enough memory to allocate a tx data buffer, and,
if so, allocates it.
Precondition:
None
Parameters:
bytesNeeded -- number of bytes needed for the data tx message
Returns:
True if data tx buffer successfully allocated, else False
Remarks:
None
*****************************************************************************/
bool AllocateDataTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
uint16_t byteCount;
/* get total bytes available for DATA tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_DATA_TX_ID, RAW_DATA_POOL, true, bytesNeeded);
if (byteCount == 0)
{
EventEnqueue(WF_EVENT_ERROR, UD_TX_ALLOCATION_FAILED);
return false;
}
/* flag this raw window as mounted (in use) */
SetRawDataWindowState(RAW_DATA_TX_ID, WF_RAW_DATA_MOUNTED);
return true;
}
/* else not enough bytes available at this time to satisfy request */
else
{
return false;
}
}
/*****************************************************************************
Function:
BOOL AllocateMgmtTxBuffer(uint16_t bytesNeeded)
Summary:
Allocates a Mgmt Tx buffer
Description:
Determines if WiFi chip has enough memory to allocate a tx mgmt buffer, and,
if so, allocates it.
Precondition:
None
Parameters:
bytesNeeded -- number of bytes needed for the mgmt tx message
Returns:
True if mgmt tx buffer successfully allocated, else False
Remarks:
None
*****************************************************************************/
bool AllocateMgmtTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
uint16_t byteCount;
/* get total bytes available for MGMT tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT1_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Mgmt Tx buffer */
byteCount = RawMove(RAW_MGMT_TX_ID, RAW_MGMT_POOL, true, bytesNeeded);
if (byteCount == 0)
{
EventEnqueue(WF_EVENT_ERROR, UD_ERROR_MGMT_BUFFER_ALLOCATION_FAILED);
return false;
}
ClearIndexOutOfBoundsFlag(RAW_MGMT_TX_ID);
return true;
}
/* else not enough bytes available at this time to satisfy request */
else
{
/* if we allocated some bytes, but not enough, then deallocate what was allocated */
if (bufAvail > 0)
{
RawMove(RAW_MGMT_RX_ID, RAW_MGMT_POOL, false, 0);
}
return false;
}
}
/*******************************************************************************
Function:
void WFConfigureLowPowerMode(UINT8 action)
Summary:
Driver function to configure PS Poll mode.
Description:
This function is only used by the driver, not the application. This
function, other than at initialization, is only used when the application
has enabled PS-Poll mode. This function is used to temporarily deactivate
PS-Poll mode when there is mgmt or data message tx/rx and then, when message
activity has ceased, to again activate PS-Poll mode.
Precondition:
MACInit must be called first.
Parameters:
action - Can be either:
* WF_LOW_POWER_MODE_ON
* WF_LOW_POWER_MODE_OFF
Returns:
None.
Remarks:
None.
*****************************************************************************/
void WFConfigureLowPowerMode(UINT8 action)
{
UINT16 lowPowerStatusRegValue;
/*-----------------------------------------*/
/* if activating PS-Poll mode on MRF24WB0M */
/*-----------------------------------------*/
if (action == WF_LOW_POWER_MODE_ON)
{
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_ENABLE_LOW_POWER_MASK);
g_psPollActive = TRUE;
}
/*---------------------------------------------------------------------------------------------*/
/* else deactivating PS-Poll mode on MRF24WB0M (taking it out of low-power mode and waking it up) */
/*---------------------------------------------------------------------------------------------*/
else /* action == WF_LOW_POWER_MODE_OFF */
{
Write16BitWFRegister(WF_PSPOLL_H_REG, 0x00);
g_psPollActive = FALSE;
/* poll the response bit that indicates when the MRF24WB0M has come out of low power mode */
do
{
/* set the index register to the register we wish to read (kWFCOMRegLoPwrStatusReg) */
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_LOW_POWER_STATUS_REG);
lowPowerStatusRegValue = Read16BitWFRegister(WF_INDEX_DATA_REG);
} while (lowPowerStatusRegValue & REG_ENABLE_LOW_POWER_MASK);
}
}
/*******************************************************************************
Function:
void WFConfigureLowPowerMode(uint8_t action)
Summary:
Driver function to configure PS Poll mode.
Description:
This function is only used by the driver, not the application. This
function, other than at initialization, is only used when the application
has enabled PS-Poll mode. This function is used to temporarily deactivate
PS-Poll mode when there is mgmt or data message tx/rx and then, when message
activity has ceased, to again activate PS-Poll mode.
Precondition:
MACInit must be called first.
Parameters:
action - Can be either:
* WF_LOW_POWER_MODE_ON
* WF_LOW_POWER_MODE_OFF
Returns:
None.
Remarks:
None.
*****************************************************************************/
void WFConfigureLowPowerMode(uint8_t action)
{
uint16_t lowPowerStatusRegValue;
//-------------------------------------
// if activating PS-Poll mode on MRF24W
//-------------------------------------
if (action == WF_LOW_POWER_MODE_ON)
{
// dbgprintf("Enable PS\n");
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_ENABLE_LOW_POWER_MASK);
}
//---------------------------------------------------------------------------------------------
// else deactivating PS-Poll mode on MRF24W (taking it out of low-power mode and waking it up)
//---------------------------------------------------------------------------------------------
else // action == WF_LOW_POWER_MODE_OFF
{
// dbgprintf("Disable PS\n");
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_DISABLE_LOW_POWER_MASK);
/* poll the response bit that indicates when the MRF24W has come out of low power mode */
do
{
// set the index register to the register we wish to read
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_SCRATCHPAD_1_REG);
// read register
lowPowerStatusRegValue = Read16BitWFRegister(WF_INDEX_DATA_REG);
} while (lowPowerStatusRegValue & REG_ENABLE_LOW_POWER_MASK);
}
}
/*****************************************************************************
Function:
BOOL AllocateDataTxBuffer(UINT16 bytesNeeded)
Summary:
Allocates a Data Tx buffer for use by the TCP/IP stack.
Description:
Determines if WiFi chip has enough memory to allocate a tx data buffer, and,
if so, allocates it.
Precondition:
None
Parameters:
bytesNeeded -- number of bytes needed for the data tx message
Returns:
True if data tx buffer successfully allocated, else False
Remarks:
None
*****************************************************************************/
BOOL AllocateDataTxBuffer(UINT16 bytesNeeded)
{
UINT16 bufAvail;
UINT16 byteCount;
WF_ASSERT(GetRawWindowState(RAW_DATA_TX_ID) != WF_RAW_DATA_MOUNTED);
/* Ensure the MRF24W is awake (only applies if PS-Poll was enabled) */
EnsureWFisAwake();
/* get total bytes available for DATA tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_DATA_TX_ID, RAW_DATA_POOL, TRUE, bytesNeeded);
WF_ASSERT(byteCount != 0);
/* flag this raw window as mounted (in use) */
SetRawWindowState(RAW_DATA_TX_ID, WF_RAW_DATA_MOUNTED);
return TRUE;
}
/* else not enough bytes available at this time to satisfy request */
else
{
return FALSE;
}
}
bool AllocateDataTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
uint16_t byteCount;
/* Ensure the MRF24W is awake (only applies if PS-Poll was enabled) */
EnsureWFisAwake();
/* get total bytes available for DATA tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
/* allocate and create the new Tx buffer (mgmt or data) */
byteCount = RawMove(RAW_TX_ID, RAW_DATA_POOL, true, bytesNeeded);
SYS_ASSERT(byteCount != 0, "");
}
/* else not enough bytes available at this time to satisfy request */
else
{
return false;
}
RawWindowReady[RAW_TX_ID] = true;
SetRawWindowState(RAW_TX_ID, WF_RAW_DATA_MOUNTED);
return true;
}
/*****************************************************************************
* FUNCTION: RawGetIndex
*
* RETURNS: Returns the current RAW index for the specified RAW engine.
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: None
*****************************************************************************/
UINT16 RawGetIndex(UINT16 rawId)
{
UINT8 regId;
UINT16 index;
regId = (rawId==RAW_ID_0)?RAW_0_INDEX_REG:RAW_1_INDEX_REG;
index = Read16BitWFRegister(regId);
return index;
}
/*****************************************************************************
* FUNCTION: RawGetIndex
*
* RETURNS: Returns the current RAW index for the specified RAW engine.
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: None
*****************************************************************************/
uint16_t RawGetIndex(uint16_t rawId)
{
uint8_t regId;
uint16_t index;
regId = (rawId==RAW_ID_0)?RAW_0_INDEX_REG:RAW_1_INDEX_REG;
index = Read16BitWFRegister(regId);
return index;
}
/*****************************************************************************
* FUNCTION: RawGetIndex
*
* RETURNS: Returns the current RAW index for the specified RAW engine.
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: None
*****************************************************************************/
uint16_t RawGetIndex(uint16_t rawId)
{
uint8_t regId;
uint16_t index;
regId = g_RawIndexReg[rawId];
index = Read16BitWFRegister(regId);
return index;
}
/*****************************************************************************
* FUNCTION: RawGetIndex
*
* RETURNS: Returns the current RAW index for the specified RAW engine.
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: None
*****************************************************************************/
UINT16 RawGetIndex(UINT16 rawId)
{
UINT8 regId;
UINT16 index;
regId = g_RawIndexReg[rawId];
index = Read16BitWFRegister(regId);
return index;
}
/*****************************************************************************
* FUNCTION: WaitForRawMoveComplete
*
* RETURNS: Number of bytes that were overlayed (not always applicable)
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: Waits for a RAW move to complete.
*****************************************************************************/
static uint16_t WaitForRawMoveComplete(uint8_t rawId)
{
uint8_t rawIntMask;
uint16_t byteCount;
uint8_t regId;
uint32_t elapsedTime;
uint32_t startTime;
/* create mask to check against for Raw Move complete interrupt for either RAW0 or RAW1 */
if (rawId <= RAW_ID_1)
{
/* will be either raw 0 or raw 1 */
rawIntMask = (rawId == RAW_ID_0)?WF_HOST_INT_MASK_RAW_0_INT_0:WF_HOST_INT_MASK_RAW_1_INT_0;
}
else
{
/* will be INTR2 bit in host register, signifying RAW2, RAW3, or RAW4 */
rawIntMask = WF_HOST_INT_MASK_INT2;
}
startTime = WF_TimerRead();
while (1)
{
// InterruptCheck();
/* if received an external interrupt that signaled the RAW Move */
/* completed then break out of this loop */
if(RawMoveState.rawInterruptMask & rawIntMask)
{
break;
}
elapsedTime = GetElapsedTime(startTime, WF_TimerRead());
if (elapsedTime > 20)
{
EventEnqueue(WF_EVENT_ERROR, UD_ERROR_RAW_INTERRUPT_TIMEOUT);
break;
}
} /* end while */
/* read the byte count and return it */
regId = g_RawCtrl1Reg[rawId];
byteCount = Read16BitWFRegister(regId);
return ( byteCount );
}
/*****************************************************************************
Function:
BOOL RawSetIndex(UINT16 rawId, UINT16 index)
Summary:
Sets the index within the specified RAW window.
Description:
Sets the index within the specified RAW window. If attempt to set RAW index
outside boundaries of RAW window (past the end) this function will time out.
It's legal to set the index past the end of the raw window so long as there
is no attempt to read or write at that index.
Precondition:
None
Parameters:
rawId -- RAW window ID
index -- desired index within RAW window
Returns:
True if successful, False if caller tried to set raw index past end of
window
Remarks:
None
*****************************************************************************/
BOOL RawSetIndex(UINT16 rawId, UINT16 index)
{
UINT8 regId;
UINT16 regValue;
UINT32 startTickCount;
UINT32 maxAllowedTicks;
/* get the index register associated with the raw ID and write to it */
regId = g_RawIndexReg[rawId];
Write16BitWFRegister(regId, index);
/* Get the raw status register address associated with the raw ID. This will be polled to */
/* determine that: */
/* 1) raw set index completed successfully OR */
/* 2) raw set index failed, implying that the raw index was set past the end of the raw window */
regId = g_RawStatusReg[rawId];
maxAllowedTicks = TICKS_PER_SECOND / 200; /* 5ms */
startTickCount = (UINT32)TickGet();
/* read the status register until set index operation completes or times out */
while (1)
{
regValue = Read16BitWFRegister(regId);
if ((regValue & WF_RAW_STATUS_REG_BUSY_MASK) == 0)
{
ClearIndexOutOfBoundsFlag(rawId);
return TRUE;
}
/* if timed out then trying to set index past end of raw window, which is OK so long as the app */
/* doesn't try to access it */
if (TickGet() - startTickCount >= maxAllowedTicks)
{
SetIndexOutOfBoundsFlag(rawId);
return FALSE; /* timed out waiting for Raw set index to complete */
}
}
}
/*****************************************************************************
Function:
void RawSetIndex(uint16_t rawId, uint16_t index)
Summary:
Sets the index within the specified RAW window.
Description:
Sets the index within the specified RAW window. If attempt to set RAW index
outside boundaries of RAW window (past the end) this function will time out.
It's legal to set the index past the end of the raw window so long as there
is no attempt to read or write at that index. For now, flag an event.
Precondition:
None
Parameters:
rawId -- RAW window ID
index -- desired index within RAW window
Returns:
None
Remarks:
None
*****************************************************************************/
void RawSetIndex(uint16_t rawId, uint16_t index)
{
uint8_t regId;
uint16_t regValue;
uint32_t elapsedTime;
uint32_t startTime;
/* get the index register associated with the raw ID and write to it */
regId = g_RawIndexReg[rawId];
Write16BitWFRegister(regId, index);
/* Get the raw status register address associated with the raw ID. This will be polled to */
/* determine that: */
/* 1) raw set index completed successfully OR */
/* 2) raw set index failed, implying that the raw index was set past the end of the raw window */
regId = g_RawStatusReg[rawId];
/* read the status register until set index operation completes or times out */
startTime = WF_TimerRead();
while (1)
{
regValue = Read16BitWFRegister(regId);
if ((regValue & WF_RAW_STATUS_REG_BUSY_MASK) == 0)
{
ClearIndexOutOfBoundsFlag(rawId);
break;
}
elapsedTime = GetElapsedTime(startTime, WF_TimerRead());
if (elapsedTime > 5)
{
// if we timed out that means that the caller is trying to set the index
// past the end of the raw window. Not illegal in of itself so long
// as there is no attempt to read or write at this location. But,
// applications should avoid this to avoid the timeout in
SetIndexOutOfBoundsFlag(rawId);
EventEnqueue(WF_EVENT_ERROR, UD_ERROR_RAW_SET_INDEX_OUT_OF_BOUNDS);
break;
}
}
}
/*****************************************************************************
Function:
bool RawSetIndex(uint16_t rawId, uint16_t index)
Summary:
Sets the index within the specified RAW window.
Description:
Sets the index within the specified RAW window. If attempt to set RAW index
outside boundaries of RAW window (past the end) this function will time out.
It's legal to set the index past the end of the raw window so long as there
is no attempt to read or write at that index.
Precondition:
None
Parameters:
rawId -- RAW window ID
index -- desired index within RAW window
Returns:
True if successful, False if caller tried to set raw index past end of
window
Remarks:
None
*****************************************************************************/
bool RawSetIndex(uint16_t rawId, uint16_t index)
{
uint8_t regId;
uint16_t regValue;
uint32_t startTickCount;
uint32_t maxAllowedTicks;
/* get the index register associated with the raw ID and write to it */
regId = g_RawIndexReg[rawId];
Write16BitWFRegister(regId, index);
/* Get the raw status register address associated with the raw ID. This will be polled to */
/* determine that: */
/* 1) raw set index completed successfully OR */
/* 2) raw set index failed, implying that the raw index was set past the end of the raw window */
regId = g_RawStatusReg[rawId];
maxAllowedTicks = SYS_TMR_TickPerSecond() / 200; /* 5ms */
startTickCount = SYS_TMR_TickCountGet();
/* read the status register until set index operation completes or times out */
while (1)
{
regValue = Read16BitWFRegister(regId);
if ((regValue & WF_RAW_STATUS_REG_BUSY_MASK) == 0)
{
ClearIndexOutOfBoundsFlag(rawId);
return true;
}
/* if timed out then trying to set index past end of raw window, which is OK so long as the app */
/* doesn't try to access it */
if (SYS_TMR_TickCountGet() - startTickCount >= maxAllowedTicks)
{
SetIndexOutOfBoundsFlag(rawId);
return false; /* timed out waiting for Raw set index to complete */
}
}
}
/*******************************************************************************
Function:
void WFConfigureLowPowerMode(UINT8 action)
Summary:
Driver function to configure PS Poll mode.
Description:
This function is only used by the driver, not the application. This
function, other than at initialization, is only used when the application
has enabled PS-Poll mode. This function is used to temporarily deactivate
PS-Poll mode when there is mgmt or data message tx/rx and then, when message
activity has ceased, to again activate PS-Poll mode.
Precondition:
MACInit must be called first.
Parameters:
action - Can be either:
* WF_LOW_POWER_MODE_ON
* WF_LOW_POWER_MODE_OFF
Returns:
None.
Remarks:
None.
*****************************************************************************/
void WFConfigureLowPowerMode(UINT8 action)
{
UINT16 lowPowerStatusRegValue;
/*-----------------------------------------*/
/* if activating PS-Poll mode on MRF24W */
/*-----------------------------------------*/
if (action == WF_LOW_POWER_MODE_ON)
{
//putrsUART("Enable PS\r\n");
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_ENABLE_LOW_POWER_MASK);
g_psPollActive = TRUE;
}
/*---------------------------------------------------------------------------------------------*/
/* else deactivating PS-Poll mode on MRF24W (taking it out of low-power mode and waking it up) */
/*---------------------------------------------------------------------------------------------*/
else /* action == WF_LOW_POWER_MODE_OFF */
{
//putrsUART("Disable PS\r\n");
Write16BitWFRegister(WF_PSPOLL_H_REG, REG_DISABLE_LOW_POWER_MASK);
g_psPollActive = FALSE;
/* poll the response bit that indicates when the MRF24W has come out of low power mode */
do
{
#if defined(MRF24WG)
/* set the index register to the register we wish to read */
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_SCRATCHPAD_1_REG);
#else /* must be a MRF24WB */
/* set the index register to the register we wish to read */
Write16BitWFRegister(WF_INDEX_ADDR_REG, WF_LOW_POWER_STATUS_REG);
#endif
lowPowerStatusRegValue = Read16BitWFRegister(WF_INDEX_DATA_REG);
} while (lowPowerStatusRegValue & REG_ENABLE_LOW_POWER_MASK);
}
}
/*****************************************************************************
Function:
bool AllocateDataTxBuffer(uint16_t bytesNeeded)
Summary:
Allocates a Data Tx buffer for use by the TCP/IP stack.
Description:
Determines if WiFi chip has enough memory to allocate a tx data buffer, and,
if so, allocates it.
Precondition:
None
Parameters:
bytesNeeded -- number of bytes needed for the data tx message
Returns:
True if data tx buffer successfully allocated, else False
Remarks:
None
*****************************************************************************/
bool AllocateDataTxBuffer(uint16_t bytesNeeded)
{
uint16_t bufAvail;
/* Ensure the MRF24W is awake (only applies if PS-Poll was enabled) */
EnsureWFisAwake();
/* get total bytes available for DATA tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT0_REG) & 0x0fff; /* LS 12 bits contain length */
/* if enough bytes available to allocate */
if ( bufAvail >= bytesNeeded )
{
RawMove(RAW_DATA_TX_ID, RAW_DATA_POOL, true, bytesNeeded);
return true;
}
/* else not enough bytes available at this time to satisfy request */
else
{
////SYS_CONSOLE_MESSAGE("NB\r\n");
return false;
}
}
/*****************************************************************************
* FUNCTION: RawSetIndex
*
* RETURNS: True is success, false if timed out, which means attempted to set
* raw index past end of raw window. Not a problem as long as no read
* or write occurs.
*
* PARAMS:
* rawId - RAW ID
* index - desired index
*
* NOTES: Sets the RAW index for the specified RAW engine. If attempt to set RAW
* index outside boundaries of RAW window this function will time out.
*****************************************************************************/
bool RawSetIndex(uint16_t rawId, uint16_t index)
{
uint8_t regId;
uint16_t regValue;
SYS_TICK startTickCount;
SYS_TICK maxAllowedTicks;
// set the RAW index
regId = (rawId==RAW_ID_0)?RAW_0_INDEX_REG:RAW_1_INDEX_REG;
Write16BitWFRegister(regId, index);
startTickCount = SYS_TICK_Get();
maxAllowedTicks = SYS_TICK_TicksPerSecondGet() / 200; /* 5ms */
if(maxAllowedTicks == 0)
{
maxAllowedTicks++; // at least one system tick
}
regId = (rawId==RAW_ID_0)?RAW_0_STATUS_REG:RAW_1_STATUS_REG;
while (1)
{
regValue = Read16BitWFRegister(regId);
if ((regValue & WF_RAW_STATUS_REG_BUSY_MASK) == 0)
{
return true;
}
/* if timed out then trying to set index past end of raw window, which is OK so long as the app */
/* doesn't try to access it */
if (SYS_TICK_Get() - startTickCount >= maxAllowedTicks)
{
return false; /* timed out waiting for Raw set index to complete */
}
}
}
void RawCopyTest()
{
BOOL res;
UINT8 i;
UINT8 byte;
UINT16 rawIndex;
UINT16 bufAvail;
UINT16 srcRawId = 5;
UINT16 byteCount;
/* get total bytes available for MGMT tx memory pool */
bufAvail = Read16BitWFRegister(WF_HOST_WFIFO_BCNT1_REG) & 0x0fff; /* LS 12 bits contain length */
/* verify we can read and write from scratch buffer (already mounted) */
RawSetIndex(RAW_SCRATCH_ID, 0);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
for (i = 0; i < 128; ++i)
{
RawSetByte(RAW_SCRATCH_ID, &i, 1);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == i + 1);
}
rawIndex = RawGetIndex(RAW_SCRATCH_ID); /* raw index should be at 128 */
WF_ASSERT(rawIndex == 128);
RawSetIndex(RAW_SCRATCH_ID, 0);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
for (i = 0; i < 128; ++i)
{
RawGetByte(RAW_SCRATCH_ID, &byte, 1);
WF_ASSERT(byte == i);
}
RawSetIndex(RAW_SCRATCH_ID, 0);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
/* now zero out scratch */
byte = 0;
for (i = 0; i < 128; ++i)
{
RawSetByte(RAW_SCRATCH_ID, &byte, 1);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == i + 1);
}
RawSetIndex(RAW_SCRATCH_ID, 0);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
/* verify scratch is zeroed out */
for (i = 0; i < 128; ++i)
{
RawGetByte(RAW_SCRATCH_ID, &byte, 1);
WF_ASSERT(byte == 0);
}
RawSetIndex(RAW_SCRATCH_ID, 0);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
/* allocate raw buffer of 128 bytes */
byteCount = RawMove(srcRawId, RAW_MGMT_POOL, TRUE, 128);
WF_ASSERT(byteCount >= 128);
/* fill up buffer with known values */
for (i = 0; i < 128; ++i)
{
RawSetByte(srcRawId, &i, 1);
}
rawIndex = RawGetIndex(srcRawId); /* raw index should be at 128 */
WF_ASSERT(rawIndex == 128);
/* put raw index back to 0 and verify */
res = RawSetIndex(srcRawId, 0);
WF_ASSERT(res == TRUE);
rawIndex = RawGetIndex(srcRawId);
WF_ASSERT(rawIndex == 0);
/* read back from source buffer to ensure write was successful */
for (i = 0; i < 128; ++i)
{
RawGetByte(srcRawId, &byte, 1);
rawIndex = RawGetIndex(srcRawId);
WF_ASSERT(rawIndex == i + 1);
if (byte != i)
{
WF_ASSERT(FALSE);
}
}
/* put raw index back to 0 and verify */
res = RawSetIndex(srcRawId, 0);
WF_ASSERT(res == TRUE);
rawIndex = RawGetIndex(srcRawId);
WF_ASSERT(rawIndex == 0);
/* set the Scratch index to 0 and verify */
RawSetIndex(RAW_SCRATCH_ID, 0);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
/* set the raw source index to 0 and verify */
RawSetIndex(srcRawId, 0);
rawIndex = RawGetIndex(srcRawId);
WF_ASSERT(rawIndex == 0);
/* perform raw to raw copy and verify raw indexes*/
RawToRawCopy(RAW_SCRATCH_ID, srcRawId, 128);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 128);
rawIndex = RawGetIndex(srcRawId);
WF_ASSERT(rawIndex == 128);
/* put scratch raw index back to 0 */
res = RawSetIndex(RAW_SCRATCH_ID, 0);
WF_ASSERT(res == TRUE);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == 0);
/* read data from scratch and see if it matches what was copied */
for (i = 0; i < 128; ++i)
{
RawGetByte(RAW_SCRATCH_ID, &byte, 1);
rawIndex = RawGetIndex(RAW_SCRATCH_ID);
WF_ASSERT(rawIndex == (i+1));
if (byte != i)
{
WF_ASSERT(FALSE);
}
}
}
/*****************************************************************************
* FUNCTION: WaitForRawMoveComplete
*
* RETURNS: Number of bytes that were overlayed (not always applicable)
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: Waits for a RAW move to complete.
*****************************************************************************/
static UINT16 WaitForRawMoveComplete(UINT8 rawId)
{
UINT8 rawIntMask;
UINT16 byteCount;
UINT8 regId;
BOOL intDisabled;
#if defined(WF_DEBUG)
UINT32 startTickCount;
UINT32 maxAllowedTicks;
#endif
/* create mask to check against for Raw Move complete interrupt for either RAW0 or RAW1 */
if (rawId <= RAW_ID_1)
{
/* will be either raw 0 or raw 1 */
rawIntMask = (rawId == RAW_ID_0)?WF_HOST_INT_MASK_RAW_0_INT_0:WF_HOST_INT_MASK_RAW_1_INT_0;
}
else
{
/* will be INTR2 bit in host register, signifying RAW2, RAW3, or RAW4 */
rawIntMask = WF_HOST_INT_MASK_INT2;
}
/*
These variables are shared with the ISR so need to be careful when setting them.
the WFEintHandler() is the isr that will touch these variables but will only touch
them if RawMoveState.waitingForRawMoveCompleteInterrupt is set to TRUE.
RawMoveState.waitingForRawMoveCompleteInterrupt is only set TRUE here and only here.
so as long as we set RawMoveState.rawInterrupt first and then set RawMoveState.waitingForRawMoveCompleteInterrupt
to TRUE, we are guranteed that the ISR won't touch RawMoveState.rawInterrupt and
RawMoveState.waitingForRawMoveCompleteInterrupt.
*/
RawMoveState.rawInterrupt = 0;
RawMoveState.waitingForRawMoveCompleteInterrupt = TRUE;
// save state of external interrupt here
intDisabled = WF_EintIsDisabled();
// if external interrupt is disabled, enable it because we need it for the while(1) loop to exit
if(intDisabled)
{
WF_EintEnable();
}
else if(WF_EintIsPending())
{
WF_EintEnable();
}
#if defined(WF_DEBUG)
// Before we enter the while loop, get the tick timer count and save it
maxAllowedTicks = TICKS_PER_SECOND / 2; /* 500 ms timeout */
startTickCount = (UINT32)TickGet();
#endif
while (1)
{
/* if received an external interrupt that signalled the RAW Move */
/* completed then break out of this loop */
if(RawMoveState.rawInterrupt & rawIntMask)
{
break;
}
#if defined(WF_DEBUG)
/* If timed out waiting for RAW Move complete than lock up */
if (TickGet() - startTickCount >= maxAllowedTicks)
{
WF_ASSERT(FALSE);
}
#endif
} /* end while */
/* if interrupt was enabled by us here, we should disable it now that we're finished */
if(intDisabled)
{
WF_EintDisable();
}
/* read the byte count and return it */
regId = g_RawCtrl1Reg[rawId];
byteCount = Read16BitWFRegister(regId);
return ( byteCount );
}
/*****************************************************************************
* FUNCTION: WaitForRawMoveComplete
*
* RETURNS: Number of bytes that were overlayed (not always applicable)
*
* PARAMS:
* rawId - RAW ID
*
* NOTES: Waits for a RAW move to complete.
*****************************************************************************/
static uint16_t WaitForRawMoveComplete(uint8_t rawId)
{
uint8_t rawIntMask;
uint16_t byteCount;
uint8_t regId;
bool intDisabled;
#if defined(SYS_DEBUG_ENABLE)
SYS_TICK startTickCount;
SYS_TICK maxAllowedTicks;
#endif
/* create mask to check against for Raw Move complete interrupt for either RAW0 or RAW1 */
rawIntMask = (rawId == RAW_ID_0)?WF_HOST_INT_MASK_RAW_0_INT_0:WF_HOST_INT_MASK_RAW_1_INT_0;
/*
These variables are shared with the ISR so need to be careful when setting them.
the WFEintHandler() is the isr that will touch these variables but will only touch
them if RawMoveState.waitingForRawMoveCompleteInterrupt is set to true.
RawMoveState.waitingForRawMoveCompleteInterrupt is only set true here and only here.
so as long as we set RawMoveState.rawInterrupt first and then set RawMoveState.waitingForRawMoveCompleteInterrupt
to true, we are guranteed that the ISR won't touch RawMoveState.rawInterrupt and
RawMoveState.waitingForRawMoveCompleteInterrupt.
*/
RawMoveState.rawInterrupt = 0;
RawMoveState.waitingForRawMoveCompleteInterrupt = true;
// save state of external interrupt here
intDisabled = WF_EintIsDisabled();
// if external interrupt is disabled, enable it because we need it for the while(1) loop to exit
if(intDisabled)
{
WF_EintEnable();
}
else if(WF_EintIsPending())
{
WF_EintEnable();
}
#if defined(SYS_DEBUG_ENABLE)
// Before we enter the while loop, get the tick timer count and save it
maxAllowedTicks = SYS_TICK_TicksPerSecondGet() / 2; /* 500 ms timeout */
startTickCount = SYS_TICK_Get();
#endif
while (1)
{
/* if received an external interrupt that signalled the RAW Move */
/* completed then break out of this loop */
if(RawMoveState.rawInterrupt & rawIntMask)
{
break;
}
#if defined(SYS_DEBUG_ENABLE)
/* If timed out waiting for RAW Move complete than lock up */
#if defined (__C30__)
uint32_t x = 0;
T2CON &= 0x7FFF; // Temporary Workaround for 16 bit device Timer23 read issue
x = SYS_TICK_Get();
T2CON |= 0x8000;
if ((x - startTickCount) >= maxAllowedTicks)
{
SYS_ASSERT(false, "");
}
#else
if (SYS_TICK_Get() - startTickCount >= maxAllowedTicks)
{
SYS_ASSERT(false, "");
}
#endif
#endif
} /* end while */
/* if interrupt was enabled by us here, we should disable it now that we're finished */
if(intDisabled)
{
WF_EintDisable();
}
/* read the byte count and return it */
regId = (rawId == RAW_ID_0)?WF_HOST_RAW0_CTRL1_REG:WF_HOST_RAW1_CTRL1_REG;
byteCount = Read16BitWFRegister(regId);
return ( byteCount );
}
