mac_rx_engine.c

ucos在NEC平台下的移植

#pragma  section @@DATA rxengine at 0xEC00
#include "includes.h"
//-------------------------------------------------------------------------------------------------------
extern MAC_TX_INFO mtxInfo;

// Variables related to the receive engine
MAC_RX_INFO mrxInfo;

// Variables related to the security within the receive engine
#if MAC_OPT_SECURITY
MAC_RX_SECURITY_INFO mrxSecurityInfo;
#endif
//-------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------
//Internal function declaration
void mrxSetFifopThreshold(UINT8 count);
void mrxHandleFifoUnderAndOverflow(void);
void mrxCommStatusIndication(MAC_TASK_INFO *pTask);
void mrxProcessMacCommand(MAC_TASK_INFO *pTask);
void mrxProcessAcknowledgment(MAC_TASK_INFO *pTask);
void mrxProcessData(MAC_TASK_INFO *pTask);
void mrxProcessBeacon(MAC_TASK_INFO *pTask);
MLME_BEACON_NOTIFY_INDICATION* mrxMakeBeaconNotifyIndication(MAC_RX_PACKET *pPacket);
//-------------------------------------------------------------------------------------------------------


/*******************************************************************************************************
 *******************************************************************************************************
 **************************             RECEIVE STATE MANAGEMENT              **************************
 *******************************************************************************************************
 *******************************************************************************************************/




//-------------------------------------------------------------------------------------------------------
//  void mrxIncrOnCounter(void)
//
//  DESCRIPTION:
//      Increments the "RX on" counter, and turns on RX on a 0 -> 1 transition
//-------------------------------------------------------------------------------------------------------
void mrxIncrOnCounter(void) {
    DISABLE_GLOBAL_INT();
    //if (!mrxInfo.onCounter) {
    //    FASTSPI_STROBE(CC2420_SRXON);
    //}
    //mrxInfo.onCounter++;    --li
    ENABLE_GLOBAL_INT(); 
} // mrxIncrOnCounter




//-------------------------------------------------------------------------------------------------------
//  void mrxAutoIncrOnCounter(void)
//
//  DESCRIPTION:
//      Increments the "RX on" counter, but does not turn on RX on a 0 -> 1 transition. This function 
//      should be used when issuing the STXON(CCA) or SACK(PEND) command strobes.
//-------------------------------------------------------------------------------------------------------
void mrxAutoIncrOnCounter(void) {
  ///  DISABLE_GLOBAL_INT();
    mrxInfo.onCounter++;
  ///  ENABLE_GLOBAL_INT();
} // mrxAutoIncrOnCounter




//-------------------------------------------------------------------------------------------------------
//  void mrxDecrOnCounter(void)
//
//  DESCRIPTION:
//      Decrements the "RX on" counter, and turns off RX on a 1 -> 0 transition if SFD is low. If SFD is
//      high, the turn-off operation is delayed by one backoff period by using a callback.
//-------------------------------------------------------------------------------------------------------
void mrxDecrOnCounter(void) {
    //BYTE spiStatus;
    //DISABLE_GLOBAL_INT();
    //if (mrxInfo.onCounter) mrxInfo.onCounter--;
    //if (!mrxInfo.onCounter) {
    //    FASTSPI_UPD_STATUS(spiStatus);
    //    if (SFD_IS_ACTIVE() || (spiStatus & CC2420_TX_ACTIVE_BM)) {
    //        mrxInfo.onCounter++;
    //        mtimSetCallback(mrxDecrOnCounter, (INT32) 1);
    //    } else {
    //        FASTSPI_STROBE(CC2420_SRFOFF);
    //        FASTSPI_STROBE(CC2420_SFLUSHRX);
    //        FASTSPI_STROBE(CC2420_SFLUSHRX); 
    //         
    //    }
    //}
    //ENABLE_GLOBAL_INT();    --li
} // mrxDecrOnCounter




//-------------------------------------------------------------------------------------------------------
//  void mrxRxEnableRequestOff(void)
//
//  DESCRIPTION:
//      Used in connection with mrxRxEnableRequestTask() to make sure that a mtimCancelCallback operation
//      only removes callbacks initiated by mrxRxEnableRequestTask()
//-------------------------------------------------------------------------------------------------------
void mrxRxEnableRequestOff(void) {
    mrxDecrOnCounter();
} // mrxRxEnableRequestOff




//-------------------------------------------------------------------------------------------------------
//  void mrxRxEnableRequestTask(MAC_TASK_INFO *pTask)
//
//  DESCRIPTION:
//      The task created by mlmeRxEnableRequest() to turn on RX for a period of time. The current version
//      only supports non-beacon PANs.
//
//  TASK DATA
//      0
//-------------------------------------------------------------------------------------------------------
void mrxRxEnableRequestTask(MAC_TASK_INFO *pTask) {
    MAC_ENUM status;
            
    // Only implemented for non-beacon PANs
    if (mpib.macBeaconOrder == 15) {
        
        // Turn off?
        if (mrxInfo.rxEnableOnDuration == 0) {
            if (mtimCancelCallback(mrxRxEnableRequestOff)) {
                mrxDecrOnCounter();
                status = SUCCESS;
            } else {                
                status = INVALID_PARAMETER;
            }
        
        // Turn on + off after timeot?
        } else {
            
            // If there's a timer available to turn RX off, then turn it on now
            if (mtimSetCallback(mrxRxEnableRequestOff, (INT32) mrxInfo.rxEnableOnDuration)) {
                mrxIncrOnCounter();
                status = SUCCESS;
                
            } else {
                // Come back later!
                return;
            }
        }
        
    // Not implemented for beacon-enabled PANs
    } else {
        status = INVALID_PARAMETER;
    }
    
    // Remove the task and confirm to the higher layer
    mschRemoveTask((UINT8) pTask->priority, (BYTE) 0);
    mlmeRxEnableConfirm(status);
    
} // mrxRxEnableRequestTask




//-------------------------------------------------------------------------------------------------------
//  void mrxForceRxOff(void)
//
//  DESCRIPTION:
//      Creates the task that forces RX off at the end of a superframe, if we're not in scan mode.
//-------------------------------------------------------------------------------------------------------
void mrxForceRxOff(void) {
    if (macInfo.state & MAC_STATE_SCAN_BM) return;
    mschAddTask(mschReserveTask(), MAC_TASK_PRI_HIGHEST, mrxForceRxOffTask, MRX_RESET_ON_COUNTER);
} // mrxForceRxOff




//-------------------------------------------------------------------------------------------------------
//  void mrxForceRxOffTask(MAC_TASK_INFO *pTask)
//
//  DESCRIPTION:
//      This task forces RX off by issuing a SRFOFF command strobe, regardless of whether the SFD pin 
//      state. If SFD was high before the command was issued, an RX engine cleanup is performed.
//
//  TASK DATA:
//      Flags (MRX_RESET_ON_COUNTER)
//-------------------------------------------------------------------------------------------------------
void mrxForceRxOffTask(MAC_TASK_INFO *pTask) {
    //ZBOOL sfdWasActiveBeforeStrobe;
    //
    //// Avoid getting FIFOP interrupts...
    //mrxInfo.keepFifopIntOff = TRUE;
    //
    //// Turn off RX at the backoff slot boundary
    //DISABLE_GLOBAL_INT();
    //if (pTask->taskData & MRX_RESET_ON_COUNTER) mrxInfo.onCounter = 0;
    //WAIT_FOR_BOUNDARY();
    //sfdWasActiveBeforeStrobe = SFD_IS_ACTIVE();
    //FASTSPI_STROBE(CC2420_SRFOFF);
    //FASTSPI_STROBE(CC2420_SFLUSHRX);
    //FASTSPI_STROBE(CC2420_SFLUSHRX);    
    //ENABLE_GLOBAL_INT();
    //
    //if (sfdWasActiveBeforeStrobe) mrxResetRxEngine();
    //mrxInfo.keepFifopIntOff = FALSE;
    //
    //mschRemoveTask(pTask->priority, MSCH_KEEP_TASK_IN_PROGRESS_BM); --li
        
} // mrxForceRxOffTask




//-------------------------------------------------------------------------------------------------------
//  void mrxResetRxEngine(void)
//
//  DESCRIPTION:
//      Resets the RX engine by clearing the RX FIFO, freeing any recently acquired resources, and
//      resetting the RX engine state. If there's a valid packet in the FIFO, it will be received, and 
//      the FIFO will be flushed afterwards.
//-------------------------------------------------------------------------------------------------------
void mrxResetRxEngine(void) {
    //ZBOOL doReset = FALSE;
    //WORD oldIocfg1;
    //WORD testIocfg0;
    //
    //DISABLE_GLOBAL_INT();
    //
    //// Just started receiving a new packet, or handling a garbage packet
    //switch (mrxInfo.state) {
    //case MRX_STATE_LEN_FCF_SEQ:
    //case MRX_STATE_DISCARD_ALL:
    //case MRX_STATE_DISCARD_REMAINING:
    //case MRX_STATE_DISCARD:
    //    doReset = TRUE;
    //    break;
    //    
    //// Have a closer look...
    //default:
    //
    //    // Modify the FIFOP threshold to see if there are multiple packets in the RX FIFO
    //    FASTSPI_GETREG(CC2420_IOCFG0, oldIocfg1);
    //    testIocfg0 = (WORD) mrxInfo.length + (WORD) 1;
    //    FASTSPI_SETREG(CC2420_IOCFG0, testIocfg0);
    //                    
    //    // FIFOP is not inverted here!!!
    //    if (!FIFOP_IS_ACTIVE()) {
    //        
    //        // There is at least one whole packet in the RX FIFO which can be read out safely
    //        mrxInfo.handleFifoUnderflow = TRUE;
    //    
    //    } else {            
    //        doReset = TRUE;
    //    }
    //    
    //    // Restore the old value
    //    FASTSPI_SETREG(CC2420_IOCFG0, oldIocfg1);
    //    break;
    //}
    //
    //// The reset procedure
    //if (doReset) {
    //    
    //    // Flush the RX FIFO  
    //    FASTSPI_STROBE(CC2420_SFLUSHRX);
    //    FASTSPI_STROBE(CC2420_SFLUSHRX);
    //            
    //    // Free resources
    //    switch (mrxInfo.state) {
    //    case MRX_STATE_DEST_ADDR:
    //    case MRX_STATE_SRC_ADDR:
    //    case MRX_STATE_SECURITY_INIT:
    //    case MRX_STATE_SECURITY_ACL_SEARCH:
    //    case MRX_STATE_FIND_COUNTERS:
    //    case MRX_STATE_CMD_IDENTIFIER:
    //    case MRX_STATE_READ_FRAME_COUNTER:
    //    case MRX_STATE_READ_KEY_SEQUENCE_COUNTER:
    //    case MRX_STATE_KEY_SETUP_AND_DECRYPT:
    //    case MRX_STATE_PAYLOAD:
    //    case MRX_STATE_FCS:
    //        mschReleaseTask(mrxInfo.taskNumber);
    //        mrxpReleasePacket(mrxInfo.pMrxPacket);
    //        break;
    //    default:
    //        break;
    //    }
    //    
    //    // Reset the RX engine state
    //    mrxInfo.state = MRX_STATE_LEN_FCF_SEQ;
    //}
    //
    //ENABLE_GLOBAL_INT();  --li
    
} // mrxResetRxEngine




/*******************************************************************************************************
 *******************************************************************************************************
 **************************          PACKET RECEPTION AND PROCESSING          **************************
 *******************************************************************************************************
 *******************************************************************************************************/




//-------------------------------------------------------------------------------------------------------
//  MLME_BEACON_NOTIFY_INDICATION* mrxMakeBeaconNotifyIndication(MAC_RX_PACKET *pPacket)
//
//  DESCRIPTION:
//      Modifies a MAC_RX_PACKET structure to become a beacon notify indication.
//
//  ARGUMENTS: