/*****************************************************************************
* FUNCTION: RawMove
*
* RETURNS: Number of bytes that were overlayed (not always applicable)
*
* PARAMS:
* rawId - RAW ID
* srcDest - MRF24W object that will either source or destination of move
* rawIsDestination - TRUE if RAW engine is the destination, FALSE if its the source
* size - number of bytes to overlay (not always applicable)
*
* NOTES: Performs a RAW move operation between a RAW engine and a MRF24W object
*****************************************************************************/
static UINT16 RawMove(UINT16 rawId,
UINT16 srcDest,
BOOL rawIsDestination,
UINT16 size)
{
UINT16 byteCount;
UINT8 regId;
UINT8 regValue8;
UINT16 ctrlVal = 0;
if (rawIsDestination)
{
ctrlVal |= 0x8000;
}
/* fix later, simply need to ensure that size is 12 bits are less */
ctrlVal |= (srcDest << 8); /* defines are already shifted by 4 bits */
ctrlVal |= ((size >> 8) & 0x0f) << 8; /* MS 4 bits of size (bits 11:8) */
ctrlVal |= (size & 0x00ff); /* LS 8 bits of size (bits 7:0) */
/* Clear the interrupt bit in the register */
regValue8 = (rawId == RAW_ID_0)? WF_HOST_INT_MASK_RAW_0_INT_0 : WF_HOST_INT_MASK_RAW_1_INT_0;
Write8BitWFRegister(WF_HOST_INTR_REG, regValue8);
/* write update control value to register to control register */
regId = (rawId == RAW_ID_0) ? RAW_0_CTRL_0_REG : RAW_1_CTRL_0_REG;
Write16BitWFRegister(regId, ctrlVal);
// Wait for the RAW move operation to complete, and read back the number of bytes, if any, that were overlayed
byteCount = WaitForRawMoveComplete(rawId);
return byteCount;
}
/*****************************************************************************
Function: UINT16 RawMove(UINT16 rawId,
UINT16 srcDest,
BOOL rawIsDestination,
UINT16 size)
Summary:
Performs RAW Move operation
Description:
Raw Moves perform a variety of operations (e.g. allocating tx buffers,
mounting rx buffers, copying from one raw window to another, etc.)
Precondition:
None
Parameters:
rawId -- Raw ID 0 thru 5, except is srcDest is RAW_COPY, in which case rawId
contains the source address in the upper 4 bits and destination
address in lower 4 bits.
srcDest -- object that will either be the source or destination of the move:
RAW_MAC
RAW_MGMT_POOL
RAW_DATA_POOL
RAW_SCRATCH_POOL
RAW_STACK_MEM
RAW_COPY (this object not allowed, handled in RawToRawCopy() )
rawIsDestination -- true is srcDest is the destination, false if srcDest is
the source of the move
size -- number of bytes to overlay (not always applicable)
Returns:
Not always applicable, depending on the type of the raw move. When applicable,
this function returns the number of bytes overlayed by the raw move.
Remarks:
None
*****************************************************************************/
static UINT16 RawMove(UINT16 rawId,
UINT16 srcDest,
BOOL rawIsDestination,
UINT16 size)
{
UINT16 byteCount;
UINT8 regId;
UINT8 regValue;
UINT16 ctrlVal = 0;
/* create control value that will be written to raw control register, which initiates the raw move */
if (rawIsDestination)
{
ctrlVal |= 0x8000;
}
/* fix later, simply need to ensure that size is 12 bits are less */
ctrlVal |= (srcDest << 8); /* defines are already shifted by 4 bits */
ctrlVal |= ((size >> 8) & 0x0f) << 8; /* MS 4 bits of size (bits 11:8) */
ctrlVal |= (size & 0x00ff); /* LS 8 bits of size (bits 7:0) */
/*---------------------------------------------------------------------------------------*/
/* this next 'if' block is used to ensure the expected raw interrupt signifying raw move */
/* complete is cleared */
/*---------------------------------------------------------------------------------------*/
/* if doing a raw move on Raw 0 or 1 (data rx or data tx) */
if (rawId <= RAW_ID_1)
{
/* Clear the interrupt bit in the host interrupt register (Raw 0 and 1 are in 8-bit host intr reg) */
regValue = (UINT8)g_RawIntMask[rawId];
Write8BitWFRegister(WF_HOST_INTR_REG, regValue);
}
/* else doing raw move on mgmt rx, mgmt tx, or scratch */
else
{
/* Clear the interrupt bit in the host interrupt 2 register (Raw 2,3, and 4 are in 16-bit host intr2 reg */
regValue = g_RawIntMask[rawId];
Write16BitWFRegister(WF_HOST_INTR2_REG, regValue);
}
/*------------------------------------------------------------------------------------------------*/
/* now that the expected raw move complete interrupt has been cleared and we are ready to receive */
/* it, initiate the raw move operation by writing to the appropriate RawCtrl0. */
/*------------------------------------------------------------------------------------------------*/
regId = g_RawCtrl0Reg[rawId]; /* get RawCtrl0 register address for desired raw ID */
Write16BitWFRegister(regId, ctrlVal); /* write ctrl value to register */
byteCount = WaitForRawMoveComplete(rawId); /* wait for raw move to complete */
/* byte count is not valid for all raw move operations */
return byteCount;
}
/*****************************************************************************
* FUNCTION: RawMove
*
* RETURNS: Number of bytes that were overlayed (not always applicable)
*
* PARAMS:
* rawId - RAW ID
* srcDest - MRF24W object that will either source or destination of move
* rawIsDestination - true if RAW engine is the destination, false if its the source
* size - number of bytes to overlay (not always applicable)
*
* NOTES: Performs a RAW move operation between a RAW engine and a MRF24W object
*****************************************************************************/
static uint16_t RawMove(uint16_t rawId,
uint16_t srcDest,
bool rawIsDestination,
uint16_t size)
{
uint16_t byteCount;
uint8_t regId;
uint8_t regValue8;
uint16_t ctrlVal = 0;
if (rawIsDestination)
{
ctrlVal |= 0x8000;
}
/* fix later, simply need to ensure that size is 12 bits are less */
/* if size is legal, (bits 11:0) of ctrlVal contains the information of size, */
/* (bits 15:12) of ctriVal contains the information of srcDest */
ctrlVal |= (srcDest << 8); /* defines are already shifted by 4 bits */
ctrlVal |= ((size >> 8) & 0x0f) << 8; /* MS 4 bits of size (bits 11:8) */
ctrlVal |= (size & 0x00ff); /* LS 8 bits of size (bits 7:0) */
/* Clear the interrupt bit in the register */
regValue8 = (rawId == RAW_ID_0) ? WF_HOST_INT_MASK_RAW_0_INT_0:WF_HOST_INT_MASK_RAW_1_INT_0;
Write8BitWFRegister(WF_HOST_INTR_REG, regValue8);
/* write update control value to register to control register */
regId = (rawId==RAW_ID_0) ? RAW_0_CTRL_0_REG:RAW_1_CTRL_0_REG;
gIntDisabled = WF_EintIsDisabled();
WF_EintDisable();
Write16BitWFRegister(regId, ctrlVal);
// Wait for the RAW move operation to complete, and read back the number of bytes, if any, that were overlayed
byteCount = WaitForRawMoveComplete(rawId);
return byteCount;
}
/*****************************************************************************
Function: uint16_t RawMove(uint16_t rawId,
uint16_t srcDest,
bool rawIsDestination,
uint16_t size)
Summary:
Performs RAW Move operation
Description:
Raw Moves perform a variety of operations (e.g. allocating tx buffers,
mounting rx buffers, copying from one raw window to another, etc.)
Precondition:
None
Parameters:
rawId -- Raw ID 0 thru 5, except is srcDest is RAW_COPY, in which case rawId
contains the source address in the upper 4 bits and destination
address in lower 4 bits.
srcDest -- object that will either be the source or destination of the move:
RAW_MAC
RAW_MGMT_POOL
RAW_DATA_POOL
RAW_SCRATCH_POOL
RAW_STACK_MEM
RAW_COPY (this object not allowed, handled in RawToRawCopy() )
rawIsDestination -- true is srcDest is the destination, false if srcDest is
the source of the move
size -- number of bytes to overlay (not always applicable)
Returns:
Not always applicable, depending on the type of the raw move. When applicable,
this function returns the number of bytes overlayed by the raw move.
Remarks:
None
*****************************************************************************/
uint16_t RawMove(uint16_t rawId,
uint16_t srcDest,
bool rawIsDestination,
uint16_t size)
{
uint16_t byteCount;
uint8_t regId;
uint8_t regValue;
uint16_t ctrlVal = 0;
bool intDisabled;
// save current state of External interrupt and disable it
intDisabled = WF_isEintDisabled();
WF_EintDisable();
/*
These variables are shared with the ISR so need to be careful when setting them.
the WF_EintHandler() 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 guaranteed that the ISR won't touch RawMoveState.rawInterrupt and
RawMoveState.waitingForRawMoveCompleteInterrupt.
*/
RawMoveState.rawInterruptMask = 0;
RawMoveState.waitingForRawMoveCompleteInterrupt = true;
/* create control value that will be written to raw control register, which initiates the raw move */
if (rawIsDestination)
{
ctrlVal |= 0x8000;
}
/* fix later, simply need to ensure that size is 12 bits are less */
ctrlVal |= (srcDest << 8); /* defines are already shifted by 4 bits */
ctrlVal |= ((size >> 8) & 0x0f) << 8; /* MS 4 bits of size (bits 11:8) */
ctrlVal |= (size & 0x00ff); /* LS 8 bits of size (bits 7:0) */
/*---------------------------------------------------------------------------------------*/
/* this next 'if' block is used to ensure the expected raw interrupt signifying raw move */
/* complete is cleared */
/*---------------------------------------------------------------------------------------*/
/* if doing a raw move on Raw 0 or 1 (data rx or data tx) */
if (rawId <= RAW_ID_1)
{
/* Clear the interrupt bit in the host interrupt register (Raw 0 and 1 are in 8-bit host intr reg) */
regValue = (uint8_t)g_RawIntMask[rawId];
Write8BitWFRegister(WF_HOST_INTR_REG, regValue);
}
/* else doing raw move on mgmt rx, mgmt tx, or scratch */
else
{
/* Clear the interrupt bit in the host interrupt 2 register (Raw 2,3, and 4 are in 16-bit host intr2 reg */
regValue = g_RawIntMask[rawId];
Write16BitWFRegister(WF_HOST_INTR2_REG, regValue);
}
/*------------------------------------------------------------------------------------------------*/
/* now that the expected raw move complete interrupt has been cleared and we are ready to receive */
/* it, initiate the raw move operation by writing to the appropriate RawCtrl0. */
/*------------------------------------------------------------------------------------------------*/
regId = g_RawCtrl0Reg[rawId]; /* get RawCtrl0 register address for desired raw ID */
Write16BitWFRegister(regId, ctrlVal); /* write ctrl value to register */
// enable interrupts so we get raw move complete interrupt
WF_EintEnable();
byteCount = WaitForRawMoveComplete(rawId); /* wait for raw move to complete */
// if interrupts were disabled coming into this function, put back to that state
if (intDisabled)
{
WF_EintDisable();
}
/* byte count is not valid for all raw move operations */
return byteCount;
}
