HAL_ISR_FUNCTION(port1Isr, P1INT_VECTOR)
#endif
{
HAL_ENTER_ISR();
#endif
PxIFG = 0;
PxIF = 0;
spiRdyIsr = 1;
#if !defined HAL_SPI_MASTER
if (spiTxLen == 0)
{
#if !defined HAL_SBL_BOOT_CODE
CLEAR_SLEEP_MODE();
UxDBUF = 0x00;
SPI_SET_RDY_OUT();
#endif
SPI_CLR_RDY_OUT(); /* SPI_RDYOut = 1 */
}
#endif
#if !defined HAL_SBL_BOOT_CODE
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
#endif
HAL_ENABLE_INTERRUPTS();
}
/*
******************************************************************************
*
* INTERRUPT SERVICE ROUTINE
*
******************************************************************************
*/
HAL_ISR_FUNCTION(halKeyPort0Isr, P0INT_VECTOR)
{
HAL_ENTER_ISR();
if (HAL_KEY_SW_1_PXIFG & HAL_KEY_SW_1_BIT) {
halProcessKeyInterrupt();
}
// if (HAL_KEY_SW_2_PXIFG & HAL_KEY_SW_2_BIT) {
//
// }
// if (HAL_KEY_SW_3_PXIFG & HAL_KEY_SW_3_BIT) {
//
// }
if (GSINT_PXIFG & GSINT1_BV) {
adxl345_int1_isr();
}
if (GSINT_PXIFG & GSINT2_BV) {
adxl345_int2_isr();
}
#ifdef POWER_SAVING
CLEAR_SLEEP_MODE();
#endif
/*
* Clear the CPU interrupt flag for Port_0
* PxIFG has to be cleared before PxIF
*/
P0IFG = 0;
P0IF = 0;
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn halKeyPort0Isr
*
* @brief Port0 ISR
*
* @param
*
* @return
**************************************************************************************************/
HAL_ISR_FUNCTION( halKeyPort0Isr, P0INT_VECTOR )
{
HAL_ENTER_ISR();
#if defined ( CC2540_MINIDK )|| (JANSION_KEY)
if ((HAL_KEY_SW_1_PXIFG & HAL_KEY_SW_1_BIT) || (HAL_KEY_SW_2_PXIFG & HAL_KEY_SW_2_BIT))
#else
if (HAL_KEY_SW_6_PXIFG & HAL_KEY_SW_6_BIT)
#endif
{
halProcessKeyInterrupt();
}
/*
Clear the CPU interrupt flag for Port_0
PxIFG has to be cleared before PxIF
*/
#if defined ( CC2540_MINIDK )|| (JANSION_KEY)
HAL_KEY_SW_1_PXIFG = 0;
HAL_KEY_SW_2_PXIFG = 0;
#else
HAL_KEY_SW_6_PXIFG = 0;
#endif
HAL_KEY_CPU_PORT_0_IF = 0;
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
return;
}
/**************************************************************************************************
* @fn halSleepTimerIsr
*
* @brief Sleep timer ISR.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
**************************************************************************************************
*/
HAL_ISR_FUNCTION(halSleepTimerIsr, ST_VECTOR)
{
HAL_SLEEP_TIMER_CLEAR_INT();
CLEAR_SLEEP_MODE();
#ifdef HAL_SLEEP_DEBUG_POWER_MODE
halSleepInt = TRUE;
#endif
}
/**************************************************************************************************
* @fn macMcuRfIsr
*
* @brief Interrupt service routine that handles all RF interrupts. There are a number
* of conditions "ganged" onto this one ISR so each condition must be tested for.
*
* @param none
*
* @return none
**************************************************************************************************
*/
HAL_ISR_FUNCTION( macMcuRfIsr, RF_VECTOR )
{
uint8 rfim;
HAL_ENTER_ISR();
rfim = RFIRQM1;
/* The CPU level RF interrupt flag must be cleared here (before clearing RFIRQFx).
* to allow the interrupts to be nested.
*/
S1CON = 0x00;
if ((RFIRQF1 & IRQ_CSP_MANINT) & rfim)
{
/*
* Important! Because of how the CSP programs are written, CSP_INT interrupts should
* be processed before CSP_STOP interrupts. This becomes an issue when there are
* long critical sections.
*/
/* clear flag */
RFIRQF1 = ~IRQ_CSP_MANINT;
macCspTxIntIsr();
}
else if ((RFIRQF1 & IRQ_CSP_STOP) & rfim)
{
/* clear flag */
RFIRQF1 = ~IRQ_CSP_STOP;
macCspTxStopIsr();
}
else if ((RFIRQF1 & IRQ_TXACKDONE) & rfim)
{
/* disable interrupt - set up is for "one shot" operation */
RFIRQM1 &= ~IM_TXACKDONE;
macRxAckTxDoneCallback();
}
rfim = RFIRQM0;
/* process RFIRQF0 next */
if ((RFIRQF0 & IRQ_FIFOP) & rfim)
{
/* continue to execute interrup t handler as long as FIFOP is active */
do
{
macRxThresholdIsr();
RFIRQF0 = ~IRQ_FIFOP;
} while (FSMSTAT1 & FIFOP);
}
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn macMcuTimer2Isr
*
* @brief Interrupt service routine for timer2, the MAC timer.
*
* @param none
*
* @return none
**************************************************************************************************
*/
HAL_ISR_FUNCTION( macMcuTimer2Isr, T2_VECTOR )
{
uint8 t2irqm;
uint8 t2irqf;
HAL_ENTER_ISR();
t2irqm = T2IRQM;
t2irqf = T2IRQF;
/*------------------------------------------------------------------------------------------------
* Overflow compare interrupt - triggers when then overflow counter is
* equal to the overflow compare register.
*/
if ((t2irqf & TIMER2_OVF_COMPARE1F) & t2irqm)
{
/* call function for dealing with the timer compare interrupt */
macBackoffTimerCompareIsr();
/* clear overflow compare interrupt flag */
T2IRQF = ~TIMER2_OVF_COMPARE1F;
}
/*------------------------------------------------------------------------------------------------
* Overflow compare interrupt - triggers when then overflow counter is
* equal to the overflow compare register.
*/
if ((t2irqf & TIMER2_OVF_PERF) & t2irqm)
{
/* call function for dealing with the timer compare interrupt */
macBackoffTimerPeriodIsr();
/* clear overflow compare interrupt flag */
T2IRQF = ~TIMER2_OVF_PERF;
}
/*------------------------------------------------------------------------------------------------
* Overflow interrupt - triggers when the hardware timer rolls over.
*/
else if ((t2irqf & TIMER2_PERF) & t2irqm)
{
/* call energy detect interrupt function, this interrupt not used for any other functionality */
mcuRecordMaxRssiIsr();
/* clear the interrupt flag */
T2IRQF = ~TIMER2_PERF;
}
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
HAL_ISR_FUNCTION(port1Isr, P1INT_VECTOR)
#endif
{
HAL_ENTER_ISR();
PxIFG = 0;
PxIF = 0;
dmaRdyIsr = 1;
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn halKeyPort1Isr
*
* @brief Port1 ISR
*
* @param
*
* @return
**************************************************************************************************/
HAL_ISR_FUNCTION( halKeyPort1Isr, P1INT_VECTOR )
{
HAL_ENTER_ISR();
halProcessKeyInterrupt();
#if HAL_KEY
P1IFG = (uint8) (~HAL_KEY_P1_INTERRUPT_PINS);
P1IF = 0;
#endif
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn macMcuRfErrIsr
*
* @brief Interrupt service routine that handles all RF Error interrupts. Only the RX FIFO
* overflow condition is handled.
*
* @param none
*
* @return none
**************************************************************************************************
*/
void macMcuRfErrIsr(void)
{
uint8 rferrm;
rferrm = (uint8)RFERRM;
if ((RFERRF & RFERR_RXOVERF) & ((uint32)rferrm))
{
RFERRF = ~RFERR_RXOVERF;
macRxFifoOverflowIsr();
}
CLEAR_SLEEP_MODE();
}
__interrupt void P1_ISR(void) {
//HM-10 - Disable pin interrupts and re-enable UART
HAL_ENTER_ISR();
P1IFG = 0;
P1IF = 0;
uint8 pV = P1_7;
if(pV) {
//active low
activeMode();
}
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
__interrupt void P0_ISR(void) {
//HM-11 - Disable pin interrupts and re-enable UART
HAL_ENTER_ISR();
//clear interrupt
P0IFG = 0;
P0IF = 0;
uint8 pV = P0_2;
if(pV == 0) {
activeMode();
}
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/*******************************************************************************
* @fn halSleepTimerIsr
*
* @brief Sleep timer ISR.
*
* input parameters
*
* None.
*
* output parameters
*
* @param None.
*
* @return None.
*/
HAL_ISR_FUNCTION(halSleepTimerIsr, ST_VECTOR)
{
HAL_ENTER_ISR();
HAL_SLEEP_TIMER_CLEAR_INT();
#ifdef HAL_SLEEP_DEBUG_POWER_MODE
halSleepInt = TRUE;
#endif // HAL_SLEEP_DEBUG_POWER_MODE
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
return;
}
/*
******************************************************************************
* @fn halKeyPort2Isr
*
* @brief Port2 ISR
******************************************************************************
*/
HAL_ISR_FUNCTION(halI2CIsr, I2C_VECTOR)
{
HAL_ENTER_ISR();
#ifdef POWER_SAVING
CLEAR_SLEEP_MODE();
#endif
/*
* Clear the CPU interrupt flag for Port_2
* PxIFG has to be cleared before PxIF
* Notes: P2_1 and P2_2 are debug lines.
*/
P2IFG = 0;
P2IF = 0;
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn macMcuRfErrIsr
*
* @brief Interrupt service routine that handles all RF Error interrupts. Only the RX FIFO
* overflow condition is handled.
*
* @param none
*
* @return none
**************************************************************************************************
*/
HAL_ISR_FUNCTION( macMcuRfErrIsr, RFERR_VECTOR )
{
uint8 rferrm;
HAL_ENTER_ISR();
rferrm = RFERRM;
if ((RFERRF & RFERR_RXOVERF) & rferrm)
{
RFERRF = ~RFERR_RXOVERF;
macRxFifoOverflowIsr();
}
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn INTERRUPT_KEYBD
*
* @brief Interrupt Service Routine for keyboard
*
* @param None
*
* @return None
**************************************************************************************************/
void interrupt_keybd(void)
{
/* Clear the Power interrupt registers */
SysCtrlPowIntClear();
#if (HAL_KEY == TRUE)
/* Read the key before it gone */
halIntKeys = hal_key_int_keys();
if (halIntKeys && (pHal_KeyProcessFunction))
{
(pHal_KeyProcessFunction) (halIntKeys, HAL_KEY_STATE_NORMAL);
}
#endif /* HAL_KEY */
CLEAR_SLEEP_MODE();
}
HAL_ISR_FUNCTION(port1Isr, P1INT_VECTOR)
#endif
{
HAL_ENTER_ISR();
#endif
PxIFG = 0;
PxIF = 0;
spiRdyIsr = 1;
#if !defined HAL_SBL_BOOT_CODE
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
#endif
HAL_ENABLE_INTERRUPTS();
}
/**************************************************************************************************
* @fn halKeyPort0Isr
*
* @brief Port0 ISR
*
* @param
*
* @return
**************************************************************************************************/
HAL_ISR_FUNCTION( halKeyPort0Isr, P0INT_VECTOR )
{
HAL_ENTER_ISR();
if (HAL_KEY_SW_6_PXIFG & HAL_KEY_SW_6_BIT)
{
halProcessKeyInterrupt();
}
/*
Clear the CPU interrupt flag for Port_0
PxIFG has to be cleared before PxIF
*/
HAL_KEY_SW_6_PXIFG = 0;
HAL_KEY_CPU_PORT_0_IF = 0;
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn halKeyPort1Isr
*
* @brief Port1 ISR
*
* @param
*
* @return
**************************************************************************************************/
HAL_ISR_FUNCTION( ButtonDownIsr, P1INT_VECTOR )
{
HAL_ENTER_ISR();
if(P1IFG & 0x04)
{
P1IFG &= 0xFB; //clear interrupt flag
IRCON2 &= 0xF7; //clear CPU interrupt flag
osal_start_timerEx (MiniBeacon_TaskID, SBP_BUTTON_DOWN_EVT, 25);
}
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
return;
}
/**************************************************************************************************
* @fn halKeyPort2Isr
*
* @brief Port2 ISR
*
* @param
*
* @return
**************************************************************************************************/
HAL_ISR_FUNCTION( halKeyPort2Isr, P2INT_VECTOR )
{
HAL_ENTER_ISR();
if (HAL_KEY_JOY_MOVE_PXIFG & HAL_KEY_JOY_MOVE_BIT)
{
halProcessKeyInterrupt();
}
/*
Clear the CPU interrupt flag for Port_2
PxIFG has to be cleared before PxIF
Notes: P2_1 and P2_2 are debug lines.
*/
HAL_KEY_JOY_MOVE_PXIFG = 0;
HAL_KEY_CPU_PORT_2_IF = 0;
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/******************************************************************************
* @fn HalDMAInit
*
* @brief DMA Interrupt Service Routine
*
* @param None
*
* @return None
*****************************************************************************/
HAL_ISR_FUNCTION( halDmaIsr, DMA_VECTOR )
{
extern void HalUARTIsrDMA(void);
HAL_ENTER_ISR();
DMAIF = 0;
#if HAL_UART_DMA
if (HAL_DMA_CHECK_IRQ(HAL_DMA_CH_TX))
{
HalUARTIsrDMA();
}
#endif // HAL_UART_DMA
#if (defined HAL_SPI) && (HAL_SPI == TRUE)
if ( HAL_DMA_CHECK_IRQ( HAL_DMA_CH_RX ) )
{
HAL_DMA_CLEAR_IRQ( HAL_DMA_CH_RX );
HalSpiRxIsr();
}
if ( HAL_DMA_CHECK_IRQ( HAL_DMA_CH_TX ) )
{
HAL_DMA_CLEAR_IRQ( HAL_DMA_CH_TX );
HalSpiTxIsr();
}
#endif // (defined HAL_SPI) && (HAL_SPI == TRUE)
#if (defined HAL_IRGEN) && (HAL_IRGEN == TRUE)
if ( HAL_IRGEN == TRUE && HAL_DMA_CHECK_IRQ( HAL_IRGEN_DMA_CH ) )
{
HAL_DMA_CLEAR_IRQ( HAL_IRGEN_DMA_CH );
HalIrGenDmaIsr();
}
#endif // (defined HAL_IRGEN) && (HAL_IRGEN == TRUE)
CLEAR_SLEEP_MODE();
HAL_EXIT_ISR();
}
/*
******************************************************************************
* @fn halKeyPort1Isr
*
* @brief Port1 ISR
******************************************************************************
*/
HAL_ISR_FUNCTION(halKeyPort1Isr, P1INT_VECTOR)
{
HAL_ENTER_ISR();
// if ((HAL_KEY_SW_2_PXIFG & HAL_KEY_SW_2_BIT) || (HAL_KEY_SW_3_PXIFG & HAL_KEY_SW_3_BIT)) {
// halProcessKeyInterrupt();
// }
if (BATCD_PXIFG & BATCD_BV) {
batt_isr();
}
#ifdef POWER_SAVING
CLEAR_SLEEP_MODE();
#endif
/*
* Clear the CPU interrupt flag for Port_1
* PxIFG has to be cleared before PxIF
*/
P1IFG = 0;
P1IF = 0;
HAL_EXIT_ISR();
}
HAL_ISR_FUNCTION(port0Isr, P0INT_VECTOR)
{
unsigned char status;
unsigned char i;
HAL_ENTER_ISR();
status = P0IFG;
status &= P0IEN;
if (status)
{
P0IFG = ~status;
P0IF = 0;
#if HAL_UART_DMA == 1
extern uint8 Hal_TaskID;
extern volatile uint8 dmaRdyIsr;
dmaRdyIsr = 1;
CLEAR_SLEEP_MODE();
osal_pwrmgr_task_state(Hal_TaskID, PWRMGR_HOLD);
#if HAL_UART_TX_BY_ISR
if (dmaCfg.txHead == dmaCfg.txTail)
{
HAL_UART_DMA_CLR_RDY_OUT();
}
#endif
#endif // HAL_UART_DMA
for (i = 0; i < OS_MAX_INTERRUPT; i++)
{
if (PIN_MAJOR(blueBasic_interrupts[i].pin) == 0 && (status & (1 << PIN_MINOR(blueBasic_interrupts[i].pin))))
{
osal_set_event(blueBasic_TaskID, BLUEBASIC_EVENT_INTERRUPT << i);
}
}
}
HAL_EXIT_ISR();
}
HAL_ISR_FUNCTION(port1Isr, P1INT_VECTOR)
#endif
{
HAL_ENTER_ISR();
PxIFG = 0;
PxIF = 0;
dmaRdyIsr = 1;
#ifdef POWER_SAVING
CLEAR_SLEEP_MODE();
osal_pwrmgr_task_state(Hal_TaskID, PWRMGR_HOLD);
#if HAL_UART_TX_BY_ISR
if (dmaCfg.txHead == dmaCfg.txTail) {
HAL_UART_DMA_CLR_RDY_OUT();
}
#endif
#endif
HAL_EXIT_ISR();
}
/**************************************************************************************************
* @fn HalUARTWriteSPI
*
* @brief Transmit data bytes as a SPI packet.
*
* input parameters
*
* @param buf - pointer to the memory of the data bytes to send.
* @param len - the length of the data bytes to send.
*
* output parameters
*
* None.
*
* @return Zero for any error; otherwise, 'len'.
*/
static spiLen_t HalUARTWriteSPI(uint8 *buf, spiLen_t len)
{
if (spiTxLen != 0)
{
return 0;
}
if (len > SPI_MAX_DAT_LEN)
{
len = SPI_MAX_DAT_LEN;
}
spiTxLen = len;
#if defined HAL_SPI_MASTER
spiRdyIsr = 0;
spiTxPkt[SPI_LEN_IDX] = len;
(void)memcpy(spiTxPkt + SPI_DAT_IDX, buf, len);
spiCalcFcs(spiTxPkt);
spiTxPkt[SPI_SOF_IDX] = SPI_SOF;
halDMADesc_t *ch = HAL_DMA_GET_DESC1234(HAL_SPI_CH_TX);
HAL_DMA_SET_LEN(ch, SPI_PKT_LEN(spiTxPkt)); /* DMA TX might need padding */
/* Abort any pending DMA operations */
HAL_DMA_ABORT_CH( HAL_SPI_CH_RX );
spiRxIdx = 0;
(void)memset(spiRxBuf, (DMA_PAD ^ 0xFF), SPI_MAX_PKT_LEN * sizeof(uint16));
HAL_DMA_ARM_CH(HAL_SPI_CH_RX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
/* Abort any pending DMA operations */
HAL_DMA_ABORT_CH( HAL_SPI_CH_TX );
HAL_DMA_ARM_CH(HAL_SPI_CH_TX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
SPI_SET_CSn_OUT();
while((!SPI_RDY_IN()) && (!spiRdyIsr) );
HAL_DMA_MAN_TRIGGER(HAL_SPI_CH_TX);
#elif !defined HAL_SPI_MASTER
#ifdef POWER_SAVING
/* Disable POWER SAVING when transmission is initiated */
CLEAR_SLEEP_MODE();
#endif
SPI_CLR_RDY_OUT();
HAL_DMA_ARM_CH(HAL_SPI_CH_RX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
if ( SPI_RDY_IN() )
{
SPI_SET_RDY_OUT();
}
spiTxPkt[SPI_LEN_IDX] = len;
(void)memcpy(spiTxPkt + SPI_DAT_IDX, buf, len);
spiCalcFcs(spiTxPkt);
spiTxPkt[SPI_SOF_IDX] = SPI_SOF;
halDMADesc_t *ch = HAL_DMA_GET_DESC1234(HAL_SPI_CH_TX);
HAL_DMA_SET_LEN(ch, SPI_PKT_LEN(spiTxPkt) + 1); /* slave DMA TX might drop the last byte */
HAL_DMA_ARM_CH(HAL_SPI_CH_TX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
SPI_SET_RDY_OUT();
#endif
return len;
}
/**************************************************************************************************
* @fn HalUARTPollSPI
*
* @brief SPI Transport Polling Manager.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
static void HalUARTPollSPI(void)
{
#ifdef HAL_SPI_MASTER
#else
#if defined POWER_SAVING
pktFound = FALSE;
#endif
if ( ( spiRdyIsr ) || (SPI_RDY_IN()) )
{
CLEAR_SLEEP_MODE();
#if defined HAL_SBL_BOOT_CODE
if(!spiTxLen)
{
UxDBUF = 0x00; /* Zero out garbage from UxDBUF */
HAL_DMA_ARM_CH(HAL_SPI_CH_RX); /* Arm RX DMA */
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP");
halIntState_t intState;
HAL_ENTER_CRITICAL_SECTION(intState);
SPI_SET_RDY_OUT(); /* SPI_RDYOut = 0 */
SPI_CLR_RDY_OUT(); /* SPI_RDYOut = 1 */
HAL_EXIT_CRITICAL_SECTION(intState);
}
#endif
#if defined POWER_SAVING
pktFound = TRUE;
#endif
}
#endif
#ifdef HAL_SPI_MASTER
if ( spiRdyIsr && !writeActive)
{
spiParseRx();
}
#else //SPI Slave
if ( spiRdyIsr && !writeActive )
{
if ( !(UxCSR & CSR_ACTIVE) )
{
// MRDY has gone low to set spiRdyIsr
// and has now gone high if SPI_RDY_IN
// is false, read RXed bytes
spiParseRx();
}
else
{
// MRDY has gone low and is still low
// Set SRDY low to signal ready to RX
SPI_SET_RDY_OUT();
}
}
#endif //HAL_SPI_MASTER
#if defined HAL_SPI_MASTER
if( SPI_RX_RDY())
#else
if (SPI_RX_RDY() && !spiTxLen)
#endif
{
if (spiCB != NULL)
{
spiCB((HAL_UART_SPI - 1), HAL_UART_RX_TIMEOUT);
}
}
#if defined POWER_SAVING
if ( SPI_RDY_IN()|| SPI_RX_RDY() || spiRxLen || spiTxLen || spiRdyIsr || pktFound || SPI_RDY_OUT() )
{
CLEAR_SLEEP_MODE();
}
else if ( (!pktFound) && (!SPI_NEW_RX_BYTE(spiRxIdx)) )
{
PxIEN |= SPI_RDYIn_BIT;
SPI_CLR_RDY_OUT();
}
#endif
}
/**************************************************************************************************
* @fn HalUARTWriteSPI
*
* @brief Transmit data bytes as a SPI packet.
*
* input parameters
*
* @param buf - pointer to the memory of the data bytes to send.
* @param len - the length of the data bytes to send.
*
* output parameters
*
* None.
*
* @return Zero for any error; otherwise, 'len'.
*/
static spiLen_t HalUARTWriteSPI(uint8 *buf, spiLen_t len)
{
// Already in Tx or Rx transaction
#ifdef RBA_UART_TO_SPI
// The RBA Bridge is not written to handle re-writes so we must
// just let it write
if (spiTxLen != 0)
#else //!RBA_UART_TO_SPI
if (spiTxLen != 0 || SPI_RDY_OUT())
#endif
{
return 0;
}
if (len > SPI_MAX_DAT_LEN)
{
len = SPI_MAX_DAT_LEN;
}
spiTxLen = len;
writeActive = 1;
#if defined HAL_SPI_MASTER
spiTxPkt[SPI_LEN_IDX] = len;
(void)memcpy(spiTxPkt + SPI_DAT_IDX, buf, len);
spiCalcFcs(spiTxPkt);
spiTxPkt[SPI_SOF_IDX] = SPI_SOF;
halDMADesc_t *ch = HAL_DMA_GET_DESC1234(HAL_SPI_CH_TX);
HAL_DMA_SET_LEN(ch, SPI_PKT_LEN(spiTxPkt)); /* DMA TX might need padding */
/* Abort any pending DMA operations */
HAL_DMA_ABORT_CH( HAL_SPI_CH_RX );
spiRxIdx = 0;
(void)memset(spiRxBuf, (DMA_PAD ^ 0xFF), SPI_MAX_PKT_LEN * sizeof(uint16));
HAL_DMA_ARM_CH(HAL_SPI_CH_RX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
/* Abort any pending DMA operations */
HAL_DMA_ABORT_CH( HAL_SPI_CH_TX );
HAL_DMA_ARM_CH(HAL_SPI_CH_TX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
SPI_SET_CSn_OUT();
while((!SPI_RDY_IN()) && (!spiRdyIsr) );
HAL_DMA_MAN_TRIGGER(HAL_SPI_CH_TX);
#elif !defined HAL_SPI_MASTER
#ifdef POWER_SAVING
/* Disable POWER SAVING when transmission is initiated */
CLEAR_SLEEP_MODE();
#endif
HAL_DMA_ARM_CH(HAL_SPI_CH_RX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
spiTxPkt[SPI_LEN_IDX] = len;
(void)memcpy(spiTxPkt + SPI_DAT_IDX, buf, len);
spiCalcFcs(spiTxPkt);
spiTxPkt[SPI_SOF_IDX] = SPI_SOF;
halDMADesc_t *ch = HAL_DMA_GET_DESC1234(HAL_SPI_CH_TX);
HAL_DMA_SET_LEN(ch, SPI_PKT_LEN(spiTxPkt) + 1); /* slave DMA TX might drop the last byte */
HAL_DMA_ARM_CH(HAL_SPI_CH_TX);
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
SPI_SET_RDY_OUT();
#endif
return len;
}
/**************************************************************************************************
* @fn HalUARTPollSPI
*
* @brief SPI Transport Polling Manager.
*
* input parameters
*
* None.
*
* output parameters
*
* None.
*
* @return None.
*/
static void HalUARTPollSPI(void)
{
#ifdef HAL_SPI_MASTER
#else
#if defined POWER_SAVING
pktFound = FALSE;
#endif
if ( ( spiRdyIsr ) || (SPI_RDY_IN()) )
{
CLEAR_SLEEP_MODE();
#if defined HAL_SBL_BOOT_CODE
if(!spiTxLen)
{
UxDBUF = 0x00; /* Zero out garbage from UxDBUF */
HAL_DMA_ARM_CH(HAL_SPI_CH_RX); /* Arm RX DMA */
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP"); asm("NOP"); asm("NOP"); asm("NOP");
asm("NOP");
halIntState_t intState;
HAL_ENTER_CRITICAL_SECTION(intState);
SPI_SET_RDY_OUT(); /* SPI_RDYOut = 0 */
SPI_CLR_RDY_OUT(); /* SPI_RDYOut = 1 */
HAL_EXIT_CRITICAL_SECTION(intState);
}
#endif
#if defined POWER_SAVING
pktFound = TRUE;
#endif
}
#endif
#if defined HAL_SPI_MASTER
if (!spiTxLen)
#else
if ((!spiTxLen) && (!SPI_RDY_IN()))
#endif
{
SPI_CLR_RDY_OUT(); /* SPI_RDYOut = 1; */
spiParseRx();
}
#if defined HAL_SPI_MASTER
if( SPI_RX_RDY())
#else
if (SPI_RX_RDY() && !spiTxLen)
#endif
{
if (spiCB != NULL)
{
spiCB((HAL_UART_SPI - 1), HAL_UART_RX_TIMEOUT);
}
}
if (!spiTxLen)
{
if ( SPI_RDY_OUT () )
{
SPI_CLR_RDY_OUT(); /* Clear the ready-out signal */
}
}
#if defined POWER_SAVING
if ( SPI_RDY_IN()|| SPI_RX_RDY() || spiRxLen || spiTxLen || spiRdyIsr || pktFound || SPI_RDY_OUT() )
{
CLEAR_SLEEP_MODE();
}
else if ( (!pktFound) && (!SPI_NEW_RX_BYTE(spiRxIdx)) )
{
PxIEN |= SPI_RDYIn_BIT;
SPI_CLR_RDY_OUT();
}
#endif
spiRdyIsr = 0;
}
