mac_rx_engine.c

ucos在NEC平台下的移植

//        } else {
//            nextState = MRX_STATE_FCS;
//            mrxSetFifopThreshold(1);
//        }
//        mrxInfo.state = nextState;
//        break;
//
//    case MRX_STATE_SECURITY_INIT:
//        // Store the current length of the received packet
//        // Adjust for optional security overhead at a later stage
//        pMDI->msduLength = mrxInfo.length;
//
//        // Initialize the payload storage pointer (note: this will overwrite some old variables)
//        mrxInfo.pPayloadStoragePtr = pMDI->pMsdu;
//
//#if (MAC_OPT_SECURITY)
//        // By default, no security material has been found
//        mrxSecurityInfo.pMrxSecurityMaterial = NULL;
//#endif
//
//
//#if ((MAC_OPT_SECURITY) || (MAC_OPT_ACL_SIZE>0))
//        // MAC security and / or ACL available.
//
//        switch (mpib.macSecurityMode) {
//        case MAC_UNSECURED_MODE:
//            if (pMDI->securityUse) {
//                // Secure packets cannot be handled in unsecured mode
//                pPacket->securityStatus = FAILED_SECURITY_CHECK;
//            }
//            mrxInfo.state = MRX_STATE_PAYLOAD;
//            break;
//
//        default:
//            // MAC_ACL_MODE or MAC_SECURED_MODE
//            // Set the search index in the ACL
//            mrxInfo.aclEntrySearch = 0;
//            mrxInfo.state = MRX_STATE_SECURITY_ACL_SEARCH;
//            break;
//        }
//        break;
//
//    case MRX_STATE_SECURITY_ACL_SEARCH:
//        // Search through one entry in the ACL for each interrupt event to allow
//        // other ISRs to run during security search
//
//        n = mrxInfo.aclEntrySearch;
//        aclEntryFound = FALSE;
//
//        if (n < mpib.macACLEntryDescriptorSetSize) {
//            // Not all ACL entries searched so far, try one more
//
//            // Exended address match?
//            if (pMDI->srcAddrMode == AM_EXTENDED_64) {
//                if (msupCompareQword(&pMDI->srcAddr.Extended, &mpib.ppMacACLEntryDescriptorSet[n]->extendedAddress)) {
//                    aclEntryFound = TRUE;
//                }
//
//            // Short address match?
//            } else if ((pMDI->srcAddrMode == AM_SHORT_16) && (pMDI->srcPanId == mpib.ppMacACLEntryDescriptorSet[n]->panId)) {
//                if (pMDI->srcAddr.Short == mpib.ppMacACLEntryDescriptorSet[n]->shortAddress) {
//                    aclEntryFound = TRUE;
//                }
//            }
//
//            // Match for this ACL entry?
//            if (aclEntryFound) {
//                pMDI->aclEntry = mpib.ppMacACLEntryDescriptorSet[n]->securitySuite;
//#if MAC_OPT_SECURITY
//                mrxSecurityInfo.securitySuite = mpib.ppMacACLEntryDescriptorSet[n]->securitySuite;
//                mrxSecurityInfo.pMrxSecurityMaterial = &mpib.ppMacACLEntryDescriptorSet[n]->securityMaterial;
//                mrxSecurityInfo.pExtendedAddress = &mpib.ppMacACLEntryDescriptorSet[n]->extendedAddress;
//                mrxInfo.state = MRX_STATE_FIND_COUNTERS;
//#else // Only ACL implemented
//                mrxInfo.state = MRX_STATE_PAYLOAD;
//#endif
//
//            // No match for this ACL
//            } else {
//                // Search next entry
//                n++;
//                mrxInfo.aclEntrySearch = n;
//            }
//
//        } else {
//            // All ACL entries searched, without success.
//
//#if MAC_OPT_SECURITY
//            // Check default security
//            if (mpib.macDefaultSecurity) {
//                // Default security used
//                mrxSecurityInfo.pMrxSecurityMaterial = mpib.pMacDefaultSecurityMaterial;
//                mrxSecurityInfo.securitySuite = mpib.macDefaultSecuritySuite;
//                
//                // Default security can only be used for receiving extended source addresses
//                mrxSecurityInfo.pExtendedAddress = &pMDI->srcAddr.Extended;
//                mrxInfo.state = MRX_STATE_FIND_COUNTERS;
//                
//            } else {
//                // No key found
//                pPacket->securityStatus = UNAVAILABLE_KEY;
//                mrxSecurityInfo.securitySuite = MAC_SECURITY_NONE;
//                mrxInfo.state = MRX_STATE_PAYLOAD;
//            }
//#else // Only ACL implemented
//            mrxInfo.state = MRX_STATE_PAYLOAD;
//#endif
//        }
//        break;
//#if MAC_OPT_SECURITY
//    case MRX_STATE_FIND_COUNTERS:
//        if ((mpib.macSecurityMode != MAC_SECURED_MODE) || (!pMDI->securityUse)) {
//            // Not in secured mode or unsecure packet received
//            mrxInfo.state = MRX_STATE_PAYLOAD;
//
//        } else {
//            // Security suite has been found. Decode setup info
//            msecDecodeSecuritySuite(&mrxSecurityInfo.securitySetup, mrxSecurityInfo.securitySuite);
//
//            if (mrxSecurityInfo.securitySetup.secFlags2420) {
//
//                // The security suite (CCM /CTR) includes frame and key sequence counters
//
//                if ((pMDI->srcAddrMode != AM_EXTENDED_64) && (pMDI->aclEntry == 0x08)) {
//                    // Source mode must be extended when default security is used
//                    // and security suite is CCM / CTR
//                    pPacket->securityStatus = FAILED_SECURITY_CHECK;
//                    mrxInfo.state = MRX_STATE_PAYLOAD;
//    
//                } else {
//                    // Set the number of cleartext bytes to be authenticated but not decrypted (in CCM)
//                    // or cleartext bytes before encryption (in CTR)
//                    mrxSecurityInfo.securitySetup.clearTextLength -= (mrxInfo.length + 2 - 5);
//    
//                    // Handle each frame type separately
//                    switch ((BYTE) mrxInfo.frameControlField & FRAME_TYPE_BM) {
//                    case FT_BEACON:
//                        // TBD: Not yet handled
//                        break;
//                    case FT_DATA:
//                        // No additional data is authenticated
//                        mrxInfo.state = MRX_STATE_READ_FRAME_COUNTER;
//                        break;
//                    case FT_MAC_COMMAND:
//                        // One additional byte of cleartext
//                        mrxSecurityInfo.securitySetup.clearTextLength++;
//                        mrxInfo.state = MRX_STATE_CMD_IDENTIFIER;
//                        break;
//                    case FT_ACKNOWLEDGMENT:
//                        // Security is not allowed for acknowledge frames, ignore the rest of the packet
//                        mrxInfo.state = MRX_STATE_DISCARD_REMAINING;
//                        break;
//                    } // switch
//                } // if
//            } else {
//                // No frame counter / key sequence counter is included in this frame
//                mrxSecurityInfo.securitySetup.clearTextLength = 0;
//                mrxInfo.state = MRX_STATE_KEY_SETUP_AND_DECRYPT;
//            }
//        }
//        break;
//
//    case MRX_STATE_CMD_IDENTIFIER:
//        // Read the one byte command frame identifier
//        readLength = 1;
//        msupReadFifo(mrxInfo.pPayloadStoragePtr, readLength);
//        mrxInfo.length--;
//        mrxInfo.pPayloadStoragePtr++;
//        mrxInfo.state = MRX_STATE_READ_FRAME_COUNTER;
//        break;
//
//    case MRX_STATE_READ_FRAME_COUNTER:
//        if (mrxInfo.length >= 5) {
//            // Read 4-byte frame counter
//            readLength = 4;
//            msupReadFifo((BYTE*) &mrxSecurityInfo.frameCounter, readLength);
//
//            // Don't include the 5 counter bytes in the payload length!
//            pMDI->msduLength -= 5;
//
//            // Update counters
//            mrxInfo.length -= 5;
//
//            // Next state
//            mrxInfo.state = MRX_STATE_READ_KEY_SEQUENCE_COUNTER;
//
//        } else {
//            // There are not enough bytes in the RXFIFO to read the frame counter + key sequence counter
//            pPacket->securityStatus = FAILED_SECURITY_CHECK;
//            mrxInfo.state = MRX_STATE_PAYLOAD;
//        }
//        break;
//
//        
//    case MRX_STATE_READ_KEY_SEQUENCE_COUNTER:
//        // Read 1-byte key sequence counter
//        readLength = 1;
//        msupReadFifo((BYTE*) &mrxSecurityInfo.keySequenceCounter, readLength);
//
//        // Note: mrxInfo.length updated in the previous step, including key sequence counter
//            
//        // Start decryption / authentication process
//        mrxInfo.state = MRX_STATE_KEY_SETUP_AND_DECRYPT;
//
//        // no break here!
//
//    case MRX_STATE_KEY_SETUP_AND_DECRYPT:
//        // Setup key / nonce for the packet
//        msecSetupCC2420KeyAndNonce(FALSE, &mrxSecurityInfo.securitySetup, mrxSecurityInfo.pMrxSecurityMaterial->pSymmetricKey, (BYTE*) &mrxSecurityInfo.frameCounter);
//
//        // Setup security related registers in CC2420
//        msecSetupCC2420Regs(&mrxSecurityInfo.securitySetup);
//
//        // Decrypt / authenticate data in rxfifo
//        FASTSPI_STROBE(CC2420_SRXDEC);
//        mrxInfo.state = MRX_STATE_PAYLOAD;
//        
//        // Set the FIFOP threshold for short packets
//        if (mrxInfo.length == 1) {
//            mrxSetFifopThreshold(0);
//        } else if (mrxInfo.length == 0) {
//            mrxInfo.state = MRX_STATE_FCS;
//            mrxSetFifopThreshold(1);          
//        }
//        break;
//#endif // MAC_OPT_SECURITY
//
//#else 
//        // No MAC security available (MAC_OPT_SECURITY=0), go directly to the next state
//        mrxInfo.state = MRX_STATE_PAYLOAD;
//
//        // No break here!
//#endif
//
//    case MRX_STATE_PAYLOAD:
//        readLength = MIN(4, mrxInfo.length);
//        msupReadFifo(mrxInfo.pPayloadStoragePtr, readLength);
//        mrxInfo.length -= readLength;
//        mrxInfo.pPayloadStoragePtr += readLength;
//        if (mrxInfo.length == 1) {
//            mrxSetFifopThreshold(0);
//        } else if (mrxInfo.length == 0) {
//            mrxInfo.state = MRX_STATE_FCS;
//            mrxSetFifopThreshold(1);          
//        }
//        break;
//
//    case MRX_STATE_FCS:
//        msupReadFifo(mrxInfo.pFooter, 2);
//        mrxSetFifopThreshold(3);
//
//        pMDI->mpduLinkQuality = ED_2_LQI(RSSI_2_ED((INT8) mrxInfo.pFooter[0]));
//        
//        // If the CRC is OK, then spawn a task to do the further processing
//        pProcessTask = NULL;
//        processTaskData = (WORD) pPacket;
//        if (mrxInfo.pFooter[1] & 0x80) {
//            // CRC is OK
//
//#if MAC_OPT_SECURITY
//            // Verify MIC for received CBC-MAC or CCM frames
//            if (mrxSecurityInfo.securitySetup.micLength > 0) {
//
//                if (pMDI->msduLength >= mrxSecurityInfo.securitySetup.micLength) {
//                    // Sufficient number of bytes received for the MIC
//                    if (pMDI->pMsdu[(pMDI->msduLength)-1] != 0x00) {
//                        pPacket->securityStatus = FAILED_SECURITY_CHECK;
//                    }
//                    
//                    // Subtract the micLength from the msduLength
//                    pMDI->msduLength -= mrxSecurityInfo.securitySetup.micLength;
//
//                } else {
//                    // Too few bytes received for the MIC
//                    pPacket->securityStatus = FAILED_SECURITY_CHECK;
//                }
//            }
//#endif
//
//            switch ((BYTE) mrxInfo.frameControlField & FRAME_TYPE_BM) {
//            case FT_BEACON:         
//                // Get the sequence number (overwrites pPacket->framePending)
//                pPacket->sequenceNumber = mrxInfo.sequenceNumber;
//#if MAC_OPT_SECURITY
//                if ((mpib.macSecurityMode == MAC_SECURED_MODE) && 
//                    (macInfo.state != MAC_STATE_ACTIVE_OR_PASSIVE_SCAN) &&
//                    (pPacket->securityStatus != SUCCESS)) {
//                    // Security error when not running active / passive scan
//                    pProcessTask = mrxCommStatusIndication;
//
//                } else {
//                    // Security OK
//                    pProcessTask = mrxProcessBeacon;
//                }
//#else
//                pProcessTask = mrxProcessBeacon;
//#endif
//                break;
//            case FT_DATA:           
//#if MAC_OPT_SECURITY
//                if ((mpib.macSecurityMode == MAC_SECURED_MODE) && (pPacket->securityStatus != SUCCESS)) {
//                    // Security error on incoming data
//                    pProcessTask = mrxCommStatusIndication;
//
//                } else {
//                    // Securiy OK
//                    pProcessTask = mrxProcessData; 
//                }
//#else
//                pProcessTask = mrxProcessData; 
//#endif
//                break;
//            case FT_ACKNOWLEDGMENT:
//                if (((mtxInfo.status == MTX_STATUS_TRANSMISSION_STARTED) || (mtxInfo.status == MTX_STATUS_ACK_TIMEOUT)) && (mrxInfo.sequenceNumber == mtxInfo.pPacket->pHeader[2])) {
//                    // Note: If a timeout has occurred, but not been handled by the low-priority task, it will be undone here :)
//                    // We'll use an intermediate state until the mrxProcessAcknowledgment task has started, because we could already 
//                    // be inside the transmission task (interrupted by the FIFOP ISR). It must be done this way, because otherwise the
//                    // TX engine would release the packet, and we wouldn't be able to con