| /** |
| **************************************************************************************** |
| * |
| * @file data.c |
| * |
| * @brief FTDF data send/receive functions |
| * |
| * Copyright (c) 2016, Dialog Semiconductor |
| * All rights reserved. |
| * Redistribution and use in source and binary forms, with or without modification, |
| * are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the names of its contributors |
| * may be used to endorse or promote products derived from this software without |
| * specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, |
| * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, |
| * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED |
| * OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * |
| **************************************************************************************** |
| */ |
| |
| #include <stdlib.h> |
| |
| #include <ftdf.h> |
| #include "internal.h" |
| #include "regmap.h" |
| |
| #ifndef FTDF_LITE |
| void FTDF_processDataRequest(FTDF_DataRequest *dataRequest) |
| { |
| #ifndef FTDF_NO_TSCH |
| |
| if (FTDF_pib.tschEnabled && |
| FTDF_tschSlotLink->request != dataRequest) |
| { |
| FTDF_Status status; |
| |
| if (dataRequest->dstAddrMode == FTDF_SHORT_ADDRESS && |
| !dataRequest->indirectTX) |
| { |
| status = FTDF_scheduleTsch((FTDF_MsgBuffer *) dataRequest); |
| |
| if (status == FTDF_SUCCESS) |
| { |
| return; |
| } |
| } |
| else |
| { |
| status = FTDF_INVALID_PARAMETER; |
| } |
| |
| FTDF_sendDataConfirm(dataRequest, |
| status, |
| 0, |
| 0, |
| 0, |
| NULL); |
| |
| return; |
| } |
| |
| #endif /* FTDF_NO_TSCH */ |
| |
| int queue; |
| FTDF_AddressMode dstAddrMode = dataRequest->dstAddrMode; |
| FTDF_PANId dstPANId = dataRequest->dstPANId; |
| FTDF_Address dstAddr = dataRequest->dstAddr; |
| |
| // Search for an existing indirect queue |
| for (queue = 0; queue < FTDF_NR_OF_REQ_BUFFERS; queue++) |
| { |
| if (dstAddrMode == FTDF_SHORT_ADDRESS) |
| { |
| if (FTDF_txPendingList[ queue ].addrMode == dstAddrMode && |
| FTDF_txPendingList[ queue ].addr.shortAddress == dstAddr.shortAddress) |
| { |
| break; |
| } |
| } |
| else if (dstAddrMode == FTDF_EXTENDED_ADDRESS) |
| { |
| if (FTDF_txPendingList[ queue ].addrMode == dstAddrMode && |
| FTDF_txPendingList[ queue ].addr.extAddress == dstAddr.extAddress) |
| { |
| break; |
| } |
| } |
| } |
| |
| if (dataRequest->indirectTX) |
| { |
| FTDF_Status status = FTDF_SUCCESS; |
| |
| if (queue < FTDF_NR_OF_REQ_BUFFERS) |
| { |
| // Queue request in existing queue |
| status = FTDF_queueReqHead((FTDF_MsgBuffer *) dataRequest, &FTDF_txPendingList[ queue ].queue); |
| |
| if (status == FTDF_SUCCESS) |
| { |
| FTDF_addTxPendingTimer((FTDF_MsgBuffer *) dataRequest, |
| queue, |
| FTDF_pib.transactionPersistenceTime * FTDF_BASE_SUPERFRAME_DURATION, |
| FTDF_sendTransactionExpired); |
| return; |
| } |
| } |
| |
| if (dstAddrMode != FTDF_EXTENDED_ADDRESS && |
| dstAddrMode != FTDF_SHORT_ADDRESS) |
| { |
| status = FTDF_INVALID_PARAMETER; |
| } |
| |
| if (status != FTDF_SUCCESS) |
| { |
| // Queueing of indirect transfer was not successful |
| FTDF_sendDataConfirm(dataRequest, |
| status, |
| 0, |
| 0, |
| 0, |
| NULL); |
| |
| return; |
| } |
| |
| #if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO |
| uint8_t entry, shortAddrIdx; |
| |
| if (dstAddrMode == FTDF_SHORT_ADDRESS) |
| { |
| if (FTDF_fpprGetFreeShortAddress(&entry, &shortAddrIdx) == FTDF_FALSE) |
| { |
| goto transaction_overflow; |
| } |
| } |
| else if (dstAddrMode == FTDF_EXTENDED_ADDRESS) |
| { |
| if (FTDF_fpprGetFreeExtAddress(&entry) == FTDF_FALSE) |
| { |
| goto transaction_overflow; |
| } |
| } |
| else |
| { |
| status = FTDF_INVALID_PARAMETER; |
| } |
| |
| #endif |
| |
| // Search for an empty indirect queue |
| for (queue = 0; queue < FTDF_NR_OF_REQ_BUFFERS; queue++) |
| { |
| if (FTDF_txPendingList[ queue ].addrMode == FTDF_NO_ADDRESS) |
| { |
| FTDF_txPendingList[ queue ].addrMode = dstAddrMode; |
| FTDF_txPendingList[ queue ].PANId = dstPANId; |
| FTDF_txPendingList[ queue ].addr = dstAddr; |
| |
| status = FTDF_queueReqHead((FTDF_MsgBuffer *) dataRequest, |
| &FTDF_txPendingList[ queue ].queue); |
| |
| if (status == FTDF_SUCCESS) |
| { |
| #if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO |
| |
| if (dstAddrMode == FTDF_SHORT_ADDRESS) |
| { |
| FTDF_fpprSetShortAddress(entry, shortAddrIdx, dstAddr.shortAddress); |
| FTDF_fpprSetShortAddressValid(entry, shortAddrIdx, FTDF_TRUE); |
| } |
| else if (dstAddrMode == FTDF_EXTENDED_ADDRESS) |
| { |
| FTDF_fpprSetExtAddress(entry, dstAddr.shortAddress); |
| FTDF_fpprSetExtAddressValid(entry, FTDF_TRUE); |
| } |
| else |
| { |
| ASSERT_WARNING(0); |
| } |
| |
| #endif /* FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */ |
| FTDF_addTxPendingTimer((FTDF_MsgBuffer *) dataRequest, |
| queue, |
| FTDF_pib.transactionPersistenceTime * FTDF_BASE_SUPERFRAME_DURATION, |
| FTDF_sendTransactionExpired); |
| return; |
| } |
| else |
| { |
| break; |
| } |
| } |
| } |
| |
| // Did not find an existing or an empty queue |
| #if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO |
| transaction_overflow: |
| #endif |
| FTDF_sendDataConfirm(dataRequest, FTDF_TRANSACTION_OVERFLOW, |
| 0, |
| 0, |
| 0, |
| NULL); |
| |
| return; |
| } |
| |
| if (FTDF_reqCurrent == NULL) |
| { |
| FTDF_reqCurrent = (FTDF_MsgBuffer *) dataRequest; |
| } |
| else |
| { |
| if (FTDF_queueReqHead((FTDF_MsgBuffer *) dataRequest, &FTDF_reqQueue) == FTDF_TRANSACTION_OVERFLOW) |
| { |
| FTDF_sendDataConfirm(dataRequest, FTDF_TRANSACTION_OVERFLOW, |
| 0, |
| 0, |
| 0, |
| NULL); |
| } |
| |
| return; |
| } |
| |
| FTDF_FrameHeader *frameHeader = &FTDF_fh; |
| FTDF_SecurityHeader *securityHeader = &FTDF_sh; |
| |
| frameHeader->frameType = dataRequest->sendMultiPurpose ? FTDF_MULTIPURPOSE_FRAME : FTDF_DATA_FRAME; |
| |
| FTDF_Boolean framePending; |
| |
| if (queue < FTDF_NR_OF_REQ_BUFFERS) |
| { |
| framePending = FTDF_TRUE; |
| } |
| else |
| { |
| framePending = FTDF_FALSE; |
| } |
| |
| frameHeader->options = |
| (dataRequest->securityLevel > 0 ? FTDF_OPT_SECURITY_ENABLED : 0) | |
| (dataRequest->ackTX ? FTDF_OPT_ACK_REQUESTED : 0) | |
| (framePending ? FTDF_OPT_FRAME_PENDING : 0) | |
| ((dataRequest->frameControlOptions & FTDF_PAN_ID_PRESENT) ? FTDF_OPT_PAN_ID_PRESENT : 0) | |
| ((dataRequest->frameControlOptions & FTDF_IES_INCLUDED) ? FTDF_OPT_IES_PRESENT : 0) | |
| ((dataRequest->frameControlOptions & FTDF_SEQ_NR_SUPPRESSED) ? FTDF_OPT_SEQ_NR_SUPPRESSED : 0); |
| |
| if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled) |
| { |
| frameHeader->options |= FTDF_OPT_ENHANCED; |
| } |
| |
| frameHeader->srcAddrMode = dataRequest->srcAddrMode; |
| frameHeader->srcPANId = FTDF_pib.PANId; |
| frameHeader->dstAddrMode = dataRequest->dstAddrMode; |
| frameHeader->dstPANId = dataRequest->dstPANId; |
| frameHeader->dstAddr = dataRequest->dstAddr; |
| |
| securityHeader->securityLevel = dataRequest->securityLevel; |
| securityHeader->keyIdMode = dataRequest->keyIdMode; |
| securityHeader->keyIndex = dataRequest->keyIndex; |
| securityHeader->keySource = dataRequest->keySource; |
| securityHeader->frameCounter = FTDF_pib.frameCounter; |
| securityHeader->frameCounterMode = FTDF_pib.frameCounterMode; |
| |
| #ifndef FTDF_NO_TSCH |
| |
| if (FTDF_pib.tschEnabled) |
| { |
| frameHeader->SN = FTDF_processTschSN((FTDF_MsgBuffer *)dataRequest, |
| FTDF_pib.DSN, |
| &dataRequest->requestSN); |
| } |
| else |
| #endif /* FTDF_NO_TSCH */ |
| { |
| frameHeader->SN = FTDF_pib.DSN; |
| } |
| |
| FTDF_Octet *txPtr = (FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO) + |
| (FTDF_BUFFER_LENGTH * FTDF_TX_DATA_BUFFER); |
| |
| // Skip PHY header (= MAC length) |
| txPtr++; |
| |
| FTDF_DataLength msduLength = dataRequest->msduLength; |
| |
| txPtr = FTDF_addFrameHeader(txPtr, |
| frameHeader, |
| msduLength); |
| |
| txPtr = FTDF_addSecurityHeader(txPtr, |
| securityHeader); |
| |
| #if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH) |
| |
| if (dataRequest->frameControlOptions & FTDF_IES_INCLUDED) |
| { |
| txPtr = FTDF_addIes(txPtr, |
| dataRequest->headerIEList, |
| dataRequest->payloadIEList, |
| dataRequest->msduLength); |
| } |
| |
| #endif /* !FTDF_NO_CSL || !FTDF_NO_TSCH */ |
| |
| FTDF_Status status = FTDF_sendFrame(FTDF_pib.currentChannel, |
| frameHeader, |
| securityHeader, |
| txPtr, |
| dataRequest->msduLength, |
| dataRequest->msdu); |
| |
| if (status != FTDF_SUCCESS) |
| { |
| FTDF_sendDataConfirm(dataRequest, status, |
| 0, |
| 0, |
| 0, |
| NULL); |
| |
| FTDF_reqCurrent = NULL; |
| |
| return; |
| } |
| |
| FTDF_nrOfRetries = 0; |
| |
| if (frameHeader->SN == FTDF_pib.DSN) |
| { |
| FTDF_pib.DSN++; |
| } |
| } |
| |
| void FTDF_sendDataConfirm(FTDF_DataRequest *dataRequest, |
| FTDF_Status status, |
| FTDF_Time timestamp, |
| FTDF_SN DSN, |
| FTDF_NumOfBackoffs numOfBackoffs, |
| FTDF_IEList *ackPayload) |
| { |
| FTDF_REL_DATA_BUFFER(dataRequest->msdu); |
| |
| FTDF_DataConfirm *dataConfirm = (FTDF_DataConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_DataConfirm)); |
| |
| dataConfirm->msgId = FTDF_DATA_CONFIRM; |
| dataConfirm->msduHandle = dataRequest->msduHandle; |
| dataConfirm->status = status; |
| dataConfirm->timestamp = timestamp; |
| dataConfirm->numOfBackoffs = numOfBackoffs; |
| dataConfirm->DSN = DSN; |
| dataConfirm->ackPayload = ackPayload; |
| |
| if (FTDF_reqCurrent == (FTDF_MsgBuffer *)dataRequest) |
| { |
| FTDF_reqCurrent = NULL; |
| } |
| |
| FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) dataRequest); |
| FTDF_RCV_MSG((FTDF_MsgBuffer *) dataConfirm); |
| #if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO |
| FTDF_fpFsmClearPending(); |
| #endif /* FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */ |
| FTDF_processNextRequest(); |
| } |
| |
| void FTDF_sendDataIndication(FTDF_FrameHeader *frameHeader, |
| FTDF_SecurityHeader *securityHeader, |
| FTDF_IEList *payloadIEList, |
| FTDF_DataLength msduLength, |
| FTDF_Octet *msdu, |
| FTDF_LinkQuality mpduLinkQuality, |
| FTDF_Time timestamp) |
| { |
| FTDF_DataIndication *dataIndication = (FTDF_DataIndication *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_DataIndication)); |
| FTDF_Octet *msduBuf = FTDF_GET_DATA_BUFFER(msduLength); |
| FTDF_Octet *bufPtr = msduBuf; |
| |
| int n; |
| |
| for (n = 0; n < msduLength; n++) |
| { |
| *msduBuf++ = *msdu++; |
| } |
| |
| dataIndication->msgId = FTDF_DATA_INDICATION; |
| dataIndication->srcAddrMode = frameHeader->srcAddrMode; |
| dataIndication->srcPANId = frameHeader->srcPANId; |
| dataIndication->srcAddr = frameHeader->srcAddr; |
| dataIndication->dstAddrMode = frameHeader->dstAddrMode; |
| dataIndication->dstPANId = frameHeader->dstPANId; |
| dataIndication->dstAddr = frameHeader->dstAddr; |
| dataIndication->msduLength = msduLength; |
| dataIndication->msdu = bufPtr; |
| dataIndication->mpduLinkQuality = mpduLinkQuality; |
| dataIndication->DSN = frameHeader->SN; |
| dataIndication->timestamp = timestamp; |
| dataIndication->securityLevel = securityHeader->securityLevel; |
| dataIndication->keyIdMode = securityHeader->keyIdMode; |
| dataIndication->keyIndex = securityHeader->keyIndex; |
| dataIndication->payloadIEList = payloadIEList; |
| |
| if (dataIndication->keyIdMode == 0x2) |
| { |
| for (n = 0; n < 4; n++) |
| { |
| dataIndication->keySource[ n ] = securityHeader->keySource[ n ]; |
| } |
| } |
| else if (dataIndication->keyIdMode == 0x3) |
| { |
| for (n = 0; n < 8; n++) |
| { |
| dataIndication->keySource[ n ] = securityHeader->keySource[ n ]; |
| } |
| } |
| |
| FTDF_RCV_MSG((FTDF_MsgBuffer *) dataIndication); |
| } |
| |
| void FTDF_processPollRequest(FTDF_PollRequest *pollRequest) |
| { |
| if (FTDF_reqCurrent == NULL) |
| { |
| FTDF_reqCurrent = (FTDF_MsgBuffer *) pollRequest; |
| } |
| else |
| { |
| if (FTDF_queueReqHead((FTDF_MsgBuffer *) pollRequest, &FTDF_reqQueue) == FTDF_TRANSACTION_OVERFLOW) |
| { |
| FTDF_sendPollConfirm(pollRequest, FTDF_TRANSACTION_OVERFLOW); |
| } |
| |
| return; |
| } |
| |
| FTDF_FrameHeader *frameHeader = &FTDF_fh; |
| FTDF_SecurityHeader *securityHeader = &FTDF_sh; |
| |
| frameHeader->frameType = FTDF_MAC_COMMAND_FRAME; |
| frameHeader->options = |
| (pollRequest->securityLevel > 0 ? FTDF_OPT_SECURITY_ENABLED : 0) | FTDF_OPT_ACK_REQUESTED; |
| |
| if (FTDF_pib.shortAddress < 0xfffe) |
| { |
| frameHeader->srcAddrMode = FTDF_SHORT_ADDRESS; |
| frameHeader->srcAddr.shortAddress = FTDF_pib.shortAddress; |
| } |
| else |
| { |
| frameHeader->srcAddrMode = FTDF_EXTENDED_ADDRESS; |
| frameHeader->srcAddr.extAddress = FTDF_pib.extAddress; |
| } |
| |
| frameHeader->srcPANId = FTDF_pib.PANId; |
| frameHeader->dstAddrMode = pollRequest->coordAddrMode; |
| frameHeader->dstPANId = pollRequest->coordPANId; |
| frameHeader->dstAddr = pollRequest->coordAddr; |
| |
| securityHeader->securityLevel = pollRequest->securityLevel; |
| securityHeader->keyIdMode = pollRequest->keyIdMode; |
| securityHeader->keyIndex = pollRequest->keyIndex; |
| securityHeader->keySource = pollRequest->keySource; |
| securityHeader->frameCounter = FTDF_pib.frameCounter; |
| securityHeader->frameCounterMode = FTDF_pib.frameCounterMode; |
| |
| FTDF_Octet *txPtr = (FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO) + |
| (FTDF_BUFFER_LENGTH * FTDF_TX_DATA_BUFFER); |
| |
| // Skip PHY header (= MAC length) |
| txPtr++; |
| |
| frameHeader->SN = FTDF_pib.DSN; |
| |
| txPtr = FTDF_addFrameHeader(txPtr, |
| frameHeader, |
| 1); |
| |
| txPtr = FTDF_addSecurityHeader(txPtr, |
| securityHeader); |
| |
| *txPtr++ = FTDF_COMMAND_DATA_REQUEST; |
| |
| FTDF_Status status = FTDF_sendFrame(FTDF_pib.currentChannel, |
| frameHeader, |
| securityHeader, |
| txPtr, |
| 0, |
| NULL); |
| |
| if (status != FTDF_SUCCESS) |
| { |
| FTDF_sendPollConfirm(pollRequest, status); |
| |
| return; |
| } |
| |
| FTDF_nrOfRetries = 0; |
| FTDF_pib.DSN++; |
| } |
| |
| void FTDF_sendPollConfirm(FTDF_PollRequest *pollRequest, FTDF_Status status) |
| { |
| FTDF_PollConfirm *pollConfirm = (FTDF_PollConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_PollConfirm)); |
| |
| pollConfirm->msgId = FTDF_POLL_CONFIRM; |
| pollConfirm->status = status; |
| |
| if (FTDF_reqCurrent == (FTDF_MsgBuffer *)pollRequest) |
| { |
| FTDF_reqCurrent = NULL; |
| } |
| |
| FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) pollRequest); |
| FTDF_RCV_MSG((FTDF_MsgBuffer *) pollConfirm); |
| |
| FTDF_processNextRequest(); |
| } |
| |
| void FTDF_processPurgeRequest(FTDF_PurgeRequest *purgeRequest) |
| { |
| FTDF_Handle msduHandle = purgeRequest->msduHandle; |
| FTDF_Status status = FTDF_INVALID_HANDLE; |
| |
| int n; |
| |
| for (n = 0; n < FTDF_NR_OF_REQ_BUFFERS; n++) |
| { |
| FTDF_MsgBuffer *request = FTDF_dequeueByHandle(msduHandle, &FTDF_txPendingList[ n ].queue); |
| |
| if (request) |
| { |
| FTDF_DataRequest *dataRequest = (FTDF_DataRequest *) request; |
| |
| if (dataRequest->indirectTX == FTDF_TRUE) |
| { |
| FTDF_removeTxPendingTimer(request); |
| #if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO |
| |
| if (FTDF_txPendingList[ n ].addrMode == FTDF_SHORT_ADDRESS) |
| { |
| uint8_t entry, shortAddrIdx; |
| FTDF_Boolean found = FTDF_fpprLookupShortAddress( |
| FTDF_txPendingList[ n ].addr.shortAddress, &entry, |
| &shortAddrIdx); |
| ASSERT_WARNING(found); |
| FTDF_fpprSetShortAddressValid(entry, shortAddrIdx, FTDF_FALSE); |
| } |
| else if (FTDF_txPendingList[ n ].addrMode == FTDF_EXTENDED_ADDRESS) |
| { |
| uint8_t entry; |
| FTDF_Boolean found = FTDF_fpprLookupExtAddress( |
| FTDF_txPendingList[ n ].addr.extAddress, &entry); |
| ASSERT_WARNING(found); |
| FTDF_fpprSetExtAddressValid(entry, FTDF_FALSE); |
| } |
| else |
| { |
| ASSERT_WARNING(0); |
| } |
| |
| #endif /* FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */ |
| |
| if (FTDF_isQueueEmpty(&FTDF_txPendingList[ n ].queue)) |
| { |
| FTDF_txPendingList[ n ].addrMode = FTDF_NO_ADDRESS; |
| } |
| } |
| |
| FTDF_REL_DATA_BUFFER(dataRequest->msdu); |
| FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) dataRequest); |
| |
| status = FTDF_SUCCESS; |
| |
| break; |
| } |
| } |
| |
| FTDF_PurgeConfirm *purgeConfirm = (FTDF_PurgeConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_PurgeConfirm)); |
| |
| purgeConfirm->msgId = FTDF_PURGE_CONFIRM; |
| purgeConfirm->msduHandle = msduHandle; |
| purgeConfirm->status = status; |
| |
| FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) purgeRequest); |
| FTDF_RCV_MSG((FTDF_MsgBuffer *) purgeConfirm); |
| } |
| #endif /* !FTDF_LITE */ |
| |
| #ifdef FTDF_PHY_API |
| FTDF_Status FTDF_sendFrameSimple(FTDF_DataLength frameLength, |
| FTDF_Octet *frame, |
| FTDF_ChannelNumber channel, |
| FTDF_PTI pti, |
| FTDF_Boolean csmaSuppress) |
| { |
| |
| FTDF_Octet *fp = frame; |
| |
| if (frameLength > 127 || |
| FTDF_transparentMode != FTDF_TRUE) |
| { |
| return FTDF_INVALID_PARAMETER; |
| } |
| |
| FTDF_Octet *txPtr = (FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO) + |
| (FTDF_BUFFER_LENGTH * FTDF_TX_DATA_BUFFER); |
| |
| /* This data copy could/should be optimized using DMA */ |
| *txPtr++ = frameLength; |
| |
| int n; |
| |
| for (n = 0; n < frameLength; n++) |
| { |
| *txPtr++ = *fp++; |
| } |
| |
| FTDF_criticalVar(); |
| FTDF_enterCritical(); |
| FTDF_nrOfRetries = 0; |
| FTDF_exitCritical(); |
| FTDF_sendTransparentFrame(frameLength, |
| frame, |
| channel, |
| pti, |
| csmaSuppress); |
| |
| return FTDF_SUCCESS; |
| } |
| |
| |
| |
| #else /* !FTDF_PHY_API */ |
| void FTDF_processTransparentRequest(FTDF_TransparentRequest *transparentRequest) |
| { |
| FTDF_DataLength frameLength = transparentRequest->frameLength; |
| |
| if (frameLength > 127 || |
| FTDF_transparentMode != FTDF_TRUE) |
| { |
| FTDF_SEND_FRAME_TRANSPARENT_CONFIRM(transparentRequest->handle, |
| FTDF_INVALID_PARAMETER); |
| |
| FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) transparentRequest); |
| |
| return; |
| } |
| |
| if (FTDF_reqCurrent == NULL) |
| { |
| FTDF_reqCurrent = (FTDF_MsgBuffer *) transparentRequest; |
| } |
| else |
| { |
| #ifndef FTDF_LITE |
| |
| if (FTDF_queueReqHead((FTDF_MsgBuffer *) transparentRequest, &FTDF_reqQueue) == FTDF_TRANSACTION_OVERFLOW) |
| { |
| #endif /* !FTDF_LITE */ |
| FTDF_SEND_FRAME_TRANSPARENT_CONFIRM(transparentRequest->handle, |
| FTDF_TRANSPARENT_OVERFLOW); |
| |
| FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) transparentRequest); |
| #ifndef FTDF_LITE |
| } |
| |
| #endif /* !FTDF_LITE */ |
| return; |
| } |
| |
| FTDF_Octet *txPtr = (FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO) + |
| (FTDF_BUFFER_LENGTH * FTDF_TX_DATA_BUFFER); |
| |
| *txPtr++ = frameLength; |
| |
| FTDF_Octet *frame = transparentRequest->frame; |
| |
| int n; |
| |
| for (n = 0; n < frameLength; n++) |
| { |
| *txPtr++ = *frame++; |
| } |
| |
| FTDF_sendTransparentFrame(frameLength, |
| transparentRequest->frame, |
| transparentRequest->channel, |
| transparentRequest->pti, |
| transparentRequest->cmsaSuppress); |
| FTDF_nrOfRetries = 0; |
| } |
| |
| |
| void FTDF_sendFrameTransparent(FTDF_DataLength frameLength, |
| FTDF_Octet *frame, |
| FTDF_ChannelNumber channel, |
| FTDF_PTI pti, |
| FTDF_Boolean cmsaSuppress, |
| void *handle) |
| { |
| FTDF_TransparentRequest *transparentRequest = |
| (FTDF_TransparentRequest *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_TransparentRequest)); |
| |
| transparentRequest->msgId = FTDF_TRANSPARENT_REQUEST; |
| transparentRequest->frameLength = frameLength; |
| transparentRequest->frame = frame; |
| transparentRequest->channel = channel; |
| transparentRequest->pti = pti; |
| transparentRequest->cmsaSuppress = cmsaSuppress; |
| transparentRequest->handle = handle; |
| |
| FTDF_processTransparentRequest(transparentRequest); |
| } |
| |
| #endif /* FTDF_PHY_API */ |
