Google Git
Sign in
nest-open-source / nest-guard / 1.0 / openthread / c49dabe037451f9dd90960f80fc536ff3c9e2048 / . / third_party / dialog / DialogSDK / interfaces / ftdf / src / common.c
blob: caa379bff42b4e68586edc15e8593c8f27a1ee92 [file] [log] [blame]
/**
****************************************************************************************
*
* @file common.c
*
* @brief Common FTDF 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 <string.h>
#include <stdlib.h>
#include <ftdf.h>
#include "internal.h"
#include "regmap.h"
#include "sdk_defs.h"
#if dg_configCOEX_ENABLE_CONFIG
#include "hw_coex.h"
#endif
typedef struct
{
void *addr;
uint8_t size;
void (* getFunc)(void);
void (* setFunc)(void);
} PIBAttributeDef;
typedef struct
{
PIBAttributeDef attributeDefs[ FTDF_NR_OF_PIB_ATTRIBUTES + 1 ];
} PIBAttributeTable;
struct FTDF_Pib FTDF_pib __attribute__((section(".retention")));
#if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO
#if FTDF_FPPR_DEFER_INVALIDATION
static struct
{
FTDF_AddressMode addrMode;
FTDF_PANId PANId;
FTDF_Address addr;
} FTDF_fpprPending __attribute__((section(".retention")));
#endif /* FTDF_FPPR_DEFER_INVALIDATION */
#endif /* FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */
#ifndef FTDF_LITE
const FTDF_ChannelNumber page0Channels[ FTDF_NR_OF_CHANNELS ] =
{ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26 };
const FTDF_ChannelDescriptor channelDescriptors[ 1 ] = { { 0, 16, (FTDF_ChannelNumber *) page0Channels } };
const FTDF_ChannelDescriptorList channelsSupported = { 1, (FTDF_ChannelDescriptor *) channelDescriptors };
#endif
const PIBAttributeTable pibAttributeTable =
{
.attributeDefs[ FTDF_PIB_EXTENDED_ADDRESS ].addr = &FTDF_pib.extAddress,
.attributeDefs[ FTDF_PIB_EXTENDED_ADDRESS ].size = sizeof(FTDF_pib.extAddress),
.attributeDefs[ FTDF_PIB_EXTENDED_ADDRESS ].getFunc = FTDF_getExtAddress,
.attributeDefs[ FTDF_PIB_EXTENDED_ADDRESS ].setFunc = FTDF_setExtAddress,
.attributeDefs[ FTDF_PIB_ACK_WAIT_DURATION ].addr = &FTDF_pib.ackWaitDuration,
.attributeDefs[ FTDF_PIB_ACK_WAIT_DURATION ].size = 0,
.attributeDefs[ FTDF_PIB_ACK_WAIT_DURATION ].getFunc = FTDF_getAckWaitDuration,
.attributeDefs[ FTDF_PIB_ACK_WAIT_DURATION ].setFunc = NULL,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_ASSOCIATION_PAN_COORD ].addr = &FTDF_pib.associatedPANCoord,
.attributeDefs[ FTDF_PIB_ASSOCIATION_PAN_COORD ].size = sizeof(FTDF_pib.associatedPANCoord),
.attributeDefs[ FTDF_PIB_ASSOCIATION_PAN_COORD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_ASSOCIATION_PAN_COORD ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_ASSOCIATION_PERMIT ].addr = &FTDF_pib.associationPermit,
.attributeDefs[ FTDF_PIB_ASSOCIATION_PERMIT ].size = sizeof(FTDF_pib.associationPermit),
.attributeDefs[ FTDF_PIB_ASSOCIATION_PERMIT ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_ASSOCIATION_PERMIT ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_AUTO_REQUEST ].addr = &FTDF_pib.autoRequest,
.attributeDefs[ FTDF_PIB_AUTO_REQUEST ].size = sizeof(FTDF_pib.autoRequest),
.attributeDefs[ FTDF_PIB_AUTO_REQUEST ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_AUTO_REQUEST ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT ].addr = &FTDF_pib.battLifeExt,
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT ].size = sizeof(FTDF_pib.battLifeExt),
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT_PERIODS ].addr = &FTDF_pib.battLifeExtPeriods,
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT_PERIODS ].size = sizeof(FTDF_pib.battLifeExtPeriods),
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT_PERIODS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BATT_LIFE_EXT_PERIODS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD ].addr = &FTDF_pib.beaconPayload,
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD ].size = sizeof(FTDF_pib.beaconPayload),
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD_LENGTH ].addr = &FTDF_pib.beaconPayloadLength,
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD_LENGTH ].size = sizeof(FTDF_pib.beaconPayloadLength),
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD_LENGTH ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_PAYLOAD_LENGTH ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_ORDER ].addr = &FTDF_pib.beaconOrder,
.attributeDefs[ FTDF_PIB_BEACON_ORDER ].size = 0,
.attributeDefs[ FTDF_PIB_BEACON_ORDER ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_ORDER ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_TX_TIME ].addr = &FTDF_pib.beaconTxTime,
.attributeDefs[ FTDF_PIB_BEACON_TX_TIME ].size = sizeof(FTDF_pib.beaconTxTime),
.attributeDefs[ FTDF_PIB_BEACON_TX_TIME ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_TX_TIME ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_BSN ].addr = &FTDF_pib.BSN,
.attributeDefs[ FTDF_PIB_BSN ].size = sizeof(FTDF_pib.BSN),
.attributeDefs[ FTDF_PIB_BSN ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BSN ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_COORD_EXTENDED_ADDRESS ].addr = &FTDF_pib.coordExtAddress,
.attributeDefs[ FTDF_PIB_COORD_EXTENDED_ADDRESS ].size = sizeof(FTDF_pib.coordExtAddress),
.attributeDefs[ FTDF_PIB_COORD_EXTENDED_ADDRESS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_COORD_EXTENDED_ADDRESS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_COORD_SHORT_ADDRESS ].addr = &FTDF_pib.coordShortAddress,
.attributeDefs[ FTDF_PIB_COORD_SHORT_ADDRESS ].size = sizeof(FTDF_pib.coordShortAddress),
.attributeDefs[ FTDF_PIB_COORD_SHORT_ADDRESS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_COORD_SHORT_ADDRESS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_DSN ].addr = &FTDF_pib.DSN,
.attributeDefs[ FTDF_PIB_DSN ].size = sizeof(FTDF_pib.DSN),
.attributeDefs[ FTDF_PIB_DSN ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_DSN ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_GTS_PERMIT ].addr = &FTDF_pib.GTSPermit,
.attributeDefs[ FTDF_PIB_GTS_PERMIT ].size = 0,
.attributeDefs[ FTDF_PIB_GTS_PERMIT ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_GTS_PERMIT ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_MAX_BE ].addr = &FTDF_pib.maxBE,
.attributeDefs[ FTDF_PIB_MAX_BE ].size = sizeof(FTDF_pib.maxBE),
.attributeDefs[ FTDF_PIB_MAX_BE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MAX_BE ].setFunc = FTDF_setMaxBE,
.attributeDefs[ FTDF_PIB_MAX_CSMA_BACKOFFS ].addr = &FTDF_pib.maxCSMABackoffs,
.attributeDefs[ FTDF_PIB_MAX_CSMA_BACKOFFS ].size = sizeof(FTDF_pib.maxCSMABackoffs),
.attributeDefs[ FTDF_PIB_MAX_CSMA_BACKOFFS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MAX_CSMA_BACKOFFS ].setFunc = FTDF_setMaxCSMABackoffs,
.attributeDefs[ FTDF_PIB_MAX_FRAME_TOTAL_WAIT_TIME ].addr = &FTDF_pib.maxFrameTotalWaitTime,
.attributeDefs[ FTDF_PIB_MAX_FRAME_TOTAL_WAIT_TIME ].size = sizeof(FTDF_pib.maxFrameTotalWaitTime),
.attributeDefs[ FTDF_PIB_MAX_FRAME_TOTAL_WAIT_TIME ].getFunc = FTDF_getMaxFrameTotalWaitTime,
.attributeDefs[ FTDF_PIB_MAX_FRAME_TOTAL_WAIT_TIME ].setFunc = FTDF_setMaxFrameTotalWaitTime,
.attributeDefs[ FTDF_PIB_MAX_FRAME_RETRIES ].addr = &FTDF_pib.maxFrameRetries,
.attributeDefs[ FTDF_PIB_MAX_FRAME_RETRIES ].size = sizeof(FTDF_pib.maxFrameRetries),
.attributeDefs[ FTDF_PIB_MAX_FRAME_RETRIES ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MAX_FRAME_RETRIES ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_MIN_BE ].addr = &FTDF_pib.minBE,
.attributeDefs[ FTDF_PIB_MIN_BE ].size = sizeof(FTDF_pib.minBE),
.attributeDefs[ FTDF_PIB_MIN_BE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MIN_BE ].setFunc = FTDF_setMinBE,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_LIFS_PERIOD ].addr = &FTDF_pib.LIFSPeriod,
.attributeDefs[ FTDF_PIB_LIFS_PERIOD ].size = 0,
.attributeDefs[ FTDF_PIB_LIFS_PERIOD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LIFS_PERIOD ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_SIFS_PERIOD ].addr = &FTDF_pib.SIFSPeriod,
.attributeDefs[ FTDF_PIB_SIFS_PERIOD ].size = 0,
.attributeDefs[ FTDF_PIB_SIFS_PERIOD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SIFS_PERIOD ].setFunc = NULL,
#endif
.attributeDefs[ FTDF_PIB_PAN_ID ].addr = &FTDF_pib.PANId,
.attributeDefs[ FTDF_PIB_PAN_ID ].size = sizeof(FTDF_pib.PANId),
.attributeDefs[ FTDF_PIB_PAN_ID ].getFunc = FTDF_getPANId,
.attributeDefs[ FTDF_PIB_PAN_ID ].setFunc = FTDF_setPANId,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_PROMISCUOUS_MODE ].addr = &FTDF_pib.promiscuousMode,
.attributeDefs[ FTDF_PIB_PROMISCUOUS_MODE ].size = sizeof(FTDF_pib.promiscuousMode),
.attributeDefs[ FTDF_PIB_PROMISCUOUS_MODE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_PROMISCUOUS_MODE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_RESPONSE_WAIT_TIME ].addr = &FTDF_pib.responseWaitTime,
.attributeDefs[ FTDF_PIB_RESPONSE_WAIT_TIME ].size = sizeof(FTDF_pib.responseWaitTime),
.attributeDefs[ FTDF_PIB_RESPONSE_WAIT_TIME ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_RESPONSE_WAIT_TIME ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_RX_ON_WHEN_IDLE ].addr = &FTDF_pib.rxOnWhenIdle,
.attributeDefs[ FTDF_PIB_RX_ON_WHEN_IDLE ].size = sizeof(FTDF_pib.rxOnWhenIdle),
.attributeDefs[ FTDF_PIB_RX_ON_WHEN_IDLE ].getFunc = FTDF_getRxOnWhenIdle,
.attributeDefs[ FTDF_PIB_RX_ON_WHEN_IDLE ].setFunc = FTDF_setRxOnWhenIdle,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_SECURITY_ENABLED ].addr = &FTDF_pib.securityEnabled,
.attributeDefs[ FTDF_PIB_SECURITY_ENABLED ].size = sizeof(FTDF_pib.securityEnabled),
.attributeDefs[ FTDF_PIB_SECURITY_ENABLED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SECURITY_ENABLED ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_SHORT_ADDRESS ].addr = &FTDF_pib.shortAddress,
.attributeDefs[ FTDF_PIB_SHORT_ADDRESS ].size = sizeof(FTDF_pib.shortAddress),
.attributeDefs[ FTDF_PIB_SHORT_ADDRESS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SHORT_ADDRESS ].setFunc = FTDF_setShortAddress,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_SUPERFRAME_ORDER ].addr = &FTDF_pib.superframeOrder,
.attributeDefs[ FTDF_PIB_SUPERFRAME_ORDER ].size = 0,
.attributeDefs[ FTDF_PIB_SUPERFRAME_ORDER ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SUPERFRAME_ORDER ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_SYNC_SYMBOL_OFFSET ].addr = &FTDF_pib.syncSymbolOffset,
.attributeDefs[ FTDF_PIB_SYNC_SYMBOL_OFFSET ].size = 0,
.attributeDefs[ FTDF_PIB_SYNC_SYMBOL_OFFSET ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SYNC_SYMBOL_OFFSET ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TIMESTAMP_SUPPORTED ].addr = &FTDF_pib.timestampSupported,
.attributeDefs[ FTDF_PIB_TIMESTAMP_SUPPORTED ].size = 0,
.attributeDefs[ FTDF_PIB_TIMESTAMP_SUPPORTED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TIMESTAMP_SUPPORTED ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TRANSACTION_PERSISTENCE_TIME ].addr = &FTDF_pib.transactionPersistenceTime,
.attributeDefs[ FTDF_PIB_TRANSACTION_PERSISTENCE_TIME ].size =
sizeof(FTDF_pib.transactionPersistenceTime),
.attributeDefs[ FTDF_PIB_TRANSACTION_PERSISTENCE_TIME ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TRANSACTION_PERSISTENCE_TIME ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_ENH_ACK_WAIT_DURATION ].addr = &FTDF_pib.enhAckWaitDuration,
.attributeDefs[ FTDF_PIB_ENH_ACK_WAIT_DURATION ].size = sizeof(FTDF_pib.enhAckWaitDuration),
.attributeDefs[ FTDF_PIB_ENH_ACK_WAIT_DURATION ].getFunc = FTDF_getEnhAckWaitDuration,
.attributeDefs[ FTDF_PIB_ENH_ACK_WAIT_DURATION ].setFunc = FTDF_setEnhAckWaitDuration,
.attributeDefs[ FTDF_PIB_IMPLICIT_BROADCAST ].addr = &FTDF_pib.implicitBroadcast,
.attributeDefs[ FTDF_PIB_IMPLICIT_BROADCAST ].size = sizeof(FTDF_pib.implicitBroadcast),
.attributeDefs[ FTDF_PIB_IMPLICIT_BROADCAST ].getFunc = FTDF_getImplicitBroadcast,
.attributeDefs[ FTDF_PIB_IMPLICIT_BROADCAST ].setFunc = FTDF_setImplicitBroadcast,
.attributeDefs[ FTDF_PIB_SIMPLE_ADDRESS ].addr = &FTDF_pib.simpleAddress,
.attributeDefs[ FTDF_PIB_SIMPLE_ADDRESS ].size = sizeof(FTDF_pib.simpleAddress),
.attributeDefs[ FTDF_PIB_SIMPLE_ADDRESS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SIMPLE_ADDRESS ].setFunc = FTDF_setSimpleAddress,
.attributeDefs[ FTDF_PIB_DISCONNECT_TIME ].addr = &FTDF_pib.disconnectTime,
.attributeDefs[ FTDF_PIB_DISCONNECT_TIME ].size = sizeof(FTDF_pib.disconnectTime),
.attributeDefs[ FTDF_PIB_DISCONNECT_TIME ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_DISCONNECT_TIME ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_JOIN_PRIORITY ].addr = &FTDF_pib.joinPriority,
.attributeDefs[ FTDF_PIB_JOIN_PRIORITY ].size = sizeof(FTDF_pib.joinPriority),
.attributeDefs[ FTDF_PIB_JOIN_PRIORITY ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_JOIN_PRIORITY ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_ASN ].addr = &FTDF_pib.ASN,
.attributeDefs[ FTDF_PIB_ASN ].size = sizeof(FTDF_pib.ASN),
.attributeDefs[ FTDF_PIB_ASN ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_ASN ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_NO_HL_BUFFERS ].addr = &FTDF_pib.noHLBuffers,
.attributeDefs[ FTDF_PIB_NO_HL_BUFFERS ].size = sizeof(FTDF_pib.noHLBuffers),
.attributeDefs[ FTDF_PIB_NO_HL_BUFFERS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_NO_HL_BUFFERS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_SLOTFRAME_TABLE ].addr = &FTDF_pib.slotframeTable,
.attributeDefs[ FTDF_PIB_SLOTFRAME_TABLE ].size = 0,
.attributeDefs[ FTDF_PIB_SLOTFRAME_TABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SLOTFRAME_TABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_LINK_TABLE ].addr = &FTDF_pib.linkTable,
.attributeDefs[ FTDF_PIB_LINK_TABLE ].size = 0,
.attributeDefs[ FTDF_PIB_LINK_TABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LINK_TABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TIMESLOT_TEMPLATE ].addr = &FTDF_pib.timeslotTemplate,
.attributeDefs[ FTDF_PIB_TIMESLOT_TEMPLATE ].size = sizeof(FTDF_pib.timeslotTemplate),
.attributeDefs[ FTDF_PIB_TIMESLOT_TEMPLATE ].getFunc = NULL,
#ifdef FTDF_NO_TSCH
.attributeDefs[ FTDF_PIB_TIMESLOT_TEMPLATE ].setFunc = NULL,
#else
.attributeDefs[ FTDF_PIB_TIMESLOT_TEMPLATE ].setFunc = FTDF_setTimeslotTemplate,
#endif /* FTDF_NO_TSCH */
.attributeDefs[ FTDF_PIB_HOPPINGSEQUENCE_ID ].addr = &FTDF_pib.HoppingSequenceId,
.attributeDefs[ FTDF_PIB_HOPPINGSEQUENCE_ID ].size = sizeof(FTDF_pib.HoppingSequenceId),
.attributeDefs[ FTDF_PIB_HOPPINGSEQUENCE_ID ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_HOPPINGSEQUENCE_ID ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CHANNEL_PAGE ].addr = &FTDF_pib.channelPage,
.attributeDefs[ FTDF_PIB_CHANNEL_PAGE ].size = sizeof(FTDF_pib.channelPage),
.attributeDefs[ FTDF_PIB_CHANNEL_PAGE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CHANNEL_PAGE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_NUMBER_OF_CHANNELS ].addr = &FTDF_pib.numberOfChannels,
.attributeDefs[ FTDF_PIB_NUMBER_OF_CHANNELS ].size = sizeof(FTDF_pib.numberOfChannels),
.attributeDefs[ FTDF_PIB_NUMBER_OF_CHANNELS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_NUMBER_OF_CHANNELS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_PHY_CONFIGURATION ].addr = &FTDF_pib.phyConfiguration,
.attributeDefs[ FTDF_PIB_PHY_CONFIGURATION ].size = sizeof(FTDF_pib.phyConfiguration),
.attributeDefs[ FTDF_PIB_PHY_CONFIGURATION ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_PHY_CONFIGURATION ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_EXTENTED_BITMAP ].addr = &FTDF_pib.extendedBitmap,
.attributeDefs[ FTDF_PIB_EXTENTED_BITMAP ].size = sizeof(FTDF_pib.extendedBitmap),
.attributeDefs[ FTDF_PIB_EXTENTED_BITMAP ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_EXTENTED_BITMAP ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LENGTH ].addr = &FTDF_pib.hoppingSequenceLength,
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LENGTH ].size = sizeof(FTDF_pib.hoppingSequenceLength),
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LENGTH ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LENGTH ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LIST ].addr = FTDF_pib.hoppingSequenceList,
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LIST ].size = sizeof(FTDF_pib.hoppingSequenceList),
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LIST ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_HOPPING_SEQUENCE_LIST ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CURRENT_HOP ].addr = &FTDF_pib.currentHop,
.attributeDefs[ FTDF_PIB_CURRENT_HOP ].size = sizeof(FTDF_pib.currentHop),
.attributeDefs[ FTDF_PIB_CURRENT_HOP ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CURRENT_HOP ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_DWELL_TIME ].addr = &FTDF_pib.dwellTime,
.attributeDefs[ FTDF_PIB_DWELL_TIME ].size = sizeof(FTDF_pib.dwellTime),
.attributeDefs[ FTDF_PIB_DWELL_TIME ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_DWELL_TIME ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_PERIOD ].addr = &FTDF_pib.CSLPeriod,
.attributeDefs[ FTDF_PIB_CSL_PERIOD ].size = sizeof(FTDF_pib.CSLPeriod),
.attributeDefs[ FTDF_PIB_CSL_PERIOD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_PERIOD ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_MAX_PERIOD ].addr = &FTDF_pib.CSLMaxPeriod,
.attributeDefs[ FTDF_PIB_CSL_MAX_PERIOD ].size = sizeof(FTDF_pib.CSLMaxPeriod),
.attributeDefs[ FTDF_PIB_CSL_MAX_PERIOD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_MAX_PERIOD ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_CHANNEL_MASK ].addr = &FTDF_pib.CSLChannelMask,
.attributeDefs[ FTDF_PIB_CSL_CHANNEL_MASK ].size = sizeof(FTDF_pib.CSLChannelMask),
.attributeDefs[ FTDF_PIB_CSL_CHANNEL_MASK ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_CHANNEL_MASK ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_FRAME_PENDING_WAIT_T ].addr = &FTDF_pib.CSLFramePendingWaitT,
.attributeDefs[ FTDF_PIB_CSL_FRAME_PENDING_WAIT_T ].size = sizeof(FTDF_pib.CSLFramePendingWaitT),
#ifdef FTDF_NO_CSL
.attributeDefs[ FTDF_PIB_CSL_FRAME_PENDING_WAIT_T ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_FRAME_PENDING_WAIT_T ].setFunc = NULL,
#else
.attributeDefs[ FTDF_PIB_CSL_FRAME_PENDING_WAIT_T ].getFunc = FTDF_getCslFramePendingWaitT,
.attributeDefs[ FTDF_PIB_CSL_FRAME_PENDING_WAIT_T ].setFunc = FTDF_setCslFramePendingWaitT,
#endif /* FTDF_NO_CSL */
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SUPPORTED ].addr = &FTDF_pib.lowEnergySuperframeSupported,
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SUPPORTED ].size =
sizeof(FTDF_pib.lowEnergySuperframeSupported),
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SUPPORTED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SUPPORTED ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SYNC_INTERVAL ].addr = &FTDF_pib.lowEnergySuperframeSyncInterval,
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SYNC_INTERVAL ].size =
sizeof(FTDF_pib.lowEnergySuperframeSyncInterval),
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SYNC_INTERVAL ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LOW_ENERGY_SUPERFRAME_SYNC_INTERVAL ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_PERFORMANCE_METRICS ].addr = &FTDF_pib.performanceMetrics,
.attributeDefs[ FTDF_PIB_PERFORMANCE_METRICS ].size = sizeof(FTDF_pib.performanceMetrics),
.attributeDefs[ FTDF_PIB_PERFORMANCE_METRICS ].getFunc = FTDF_getLmacPmData,
.attributeDefs[ FTDF_PIB_PERFORMANCE_METRICS ].setFunc = NULL,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_USE_ENHANCED_BEACON ].addr = &FTDF_pib.useEnhancedBecaon,
.attributeDefs[ FTDF_PIB_USE_ENHANCED_BEACON ].size = sizeof(FTDF_pib.useEnhancedBecaon),
.attributeDefs[ FTDF_PIB_USE_ENHANCED_BEACON ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_USE_ENHANCED_BEACON ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_EB_IE_LIST ].addr = &FTDF_pib.EBIEList,
.attributeDefs[ FTDF_PIB_EB_IE_LIST ].size = sizeof(FTDF_pib.EBIEList),
.attributeDefs[ FTDF_PIB_EB_IE_LIST ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_EB_IE_LIST ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_EB_FILTERING_ENABLED ].addr = &FTDF_pib.EBFilteringEnabled,
.attributeDefs[ FTDF_PIB_EB_FILTERING_ENABLED ].size = sizeof(FTDF_pib.EBFilteringEnabled),
.attributeDefs[ FTDF_PIB_EB_FILTERING_ENABLED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_EB_FILTERING_ENABLED ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_EBSN ].addr = &FTDF_pib.EBSN,
.attributeDefs[ FTDF_PIB_EBSN ].size = sizeof(FTDF_pib.EBSN),
.attributeDefs[ FTDF_PIB_EBSN ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_EBSN ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_EB_AUTO_SA ].addr = &FTDF_pib.EBAutoSA,
.attributeDefs[ FTDF_PIB_EB_AUTO_SA ].size = sizeof(FTDF_pib.EBAutoSA),
.attributeDefs[ FTDF_PIB_EB_AUTO_SA ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_EB_AUTO_SA ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_EACK_IE_LIST ].addr = &FTDF_pib.EAckIEList,
.attributeDefs[ FTDF_PIB_EACK_IE_LIST ].size = sizeof(FTDF_pib.EAckIEList),
.attributeDefs[ FTDF_PIB_EACK_IE_LIST ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_EACK_IE_LIST ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_KEY_TABLE ].addr = &FTDF_pib.keyTable,
.attributeDefs[ FTDF_PIB_KEY_TABLE ].size = sizeof(FTDF_pib.keyTable),
.attributeDefs[ FTDF_PIB_KEY_TABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_KEY_TABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_DEVICE_TABLE ].addr = &FTDF_pib.deviceTable,
.attributeDefs[ FTDF_PIB_DEVICE_TABLE ].size = sizeof(FTDF_pib.deviceTable),
.attributeDefs[ FTDF_PIB_DEVICE_TABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_DEVICE_TABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_SECURITY_LEVEL_TABLE ].addr = &FTDF_pib.securityLevelTable,
.attributeDefs[ FTDF_PIB_SECURITY_LEVEL_TABLE ].size = sizeof(FTDF_pib.securityLevelTable),
.attributeDefs[ FTDF_PIB_SECURITY_LEVEL_TABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SECURITY_LEVEL_TABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_FRAME_COUNTER ].addr = &FTDF_pib.frameCounter,
.attributeDefs[ FTDF_PIB_FRAME_COUNTER ].size = sizeof(FTDF_pib.frameCounter),
.attributeDefs[ FTDF_PIB_FRAME_COUNTER ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_FRAME_COUNTER ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_SECURITY_LEVEL ].addr = &FTDF_pib.mtDataSecurityLevel,
.attributeDefs[ FTDF_PIB_MT_DATA_SECURITY_LEVEL ].size =
sizeof(FTDF_pib.mtDataSecurityLevel),
.attributeDefs[ FTDF_PIB_MT_DATA_SECURITY_LEVEL ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_SECURITY_LEVEL ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_ID_MODE ].addr = &FTDF_pib.mtDataKeyIdMode,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_ID_MODE ].size = sizeof(FTDF_pib.mtDataKeyIdMode),
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_ID_MODE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_ID_MODE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_SOURCE ].addr = &FTDF_pib.mtDataKeySource,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_SOURCE ].size = sizeof(FTDF_pib.mtDataKeySource),
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_SOURCE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_SOURCE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_INDEX ].addr = &FTDF_pib.mtDataKeyIndex,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_INDEX ].size = sizeof(FTDF_pib.mtDataKeyIndex),
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_INDEX ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MT_DATA_KEY_INDEX ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_DEFAULT_KEY_SOURCE ].addr = &FTDF_pib.defaultKeySource,
.attributeDefs[ FTDF_PIB_DEFAULT_KEY_SOURCE ].size = sizeof(FTDF_pib.defaultKeySource),
.attributeDefs[ FTDF_PIB_DEFAULT_KEY_SOURCE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_DEFAULT_KEY_SOURCE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_PAN_COORD_EXTENDED_ADDRESS ].addr = &FTDF_pib.PANCoordExtAddress,
.attributeDefs[ FTDF_PIB_PAN_COORD_EXTENDED_ADDRESS ].size = sizeof(FTDF_pib.PANCoordExtAddress),
.attributeDefs[ FTDF_PIB_PAN_COORD_EXTENDED_ADDRESS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_PAN_COORD_EXTENDED_ADDRESS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_PAN_COORD_SHORT_ADDRESS ].addr = &FTDF_pib.PANCoordShortAddress,
.attributeDefs[ FTDF_PIB_PAN_COORD_SHORT_ADDRESS ].size = sizeof(FTDF_pib.PANCoordShortAddress),
.attributeDefs[ FTDF_PIB_PAN_COORD_SHORT_ADDRESS ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_PAN_COORD_SHORT_ADDRESS ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_FRAME_COUNTER_MODE ].addr = &FTDF_pib.frameCounterMode,
.attributeDefs[ FTDF_PIB_FRAME_COUNTER_MODE ].size = sizeof(FTDF_pib.frameCounterMode),
.attributeDefs[ FTDF_PIB_FRAME_COUNTER_MODE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_FRAME_COUNTER_MODE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_SYNC_TX_MARGIN ].addr = &FTDF_pib.CSLSyncTxMargin,
.attributeDefs[ FTDF_PIB_CSL_SYNC_TX_MARGIN ].size = sizeof(FTDF_pib.CSLSyncTxMargin),
.attributeDefs[ FTDF_PIB_CSL_SYNC_TX_MARGIN ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_SYNC_TX_MARGIN ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_MAX_AGE_REMOTE_INFO ].addr = &FTDF_pib.CSLMaxAgeRemoteInfo,
.attributeDefs[ FTDF_PIB_CSL_MAX_AGE_REMOTE_INFO ].size = sizeof(FTDF_pib.CSLMaxAgeRemoteInfo),
.attributeDefs[ FTDF_PIB_CSL_MAX_AGE_REMOTE_INFO ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CSL_MAX_AGE_REMOTE_INFO ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TSCH_ENABLED ].addr = &FTDF_pib.tschEnabled,
.attributeDefs[ FTDF_PIB_TSCH_ENABLED ].size = 0,
.attributeDefs[ FTDF_PIB_TSCH_ENABLED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TSCH_ENABLED ].setFunc = NULL,
#ifdef FTDF_NO_CSL
.attributeDefs[ FTDF_PIB_LE_ENABLED ].addr = &FTDF_pib.leEnabled,
.attributeDefs[ FTDF_PIB_LE_ENABLED ].size = 0,
.attributeDefs[ FTDF_PIB_LE_ENABLED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LE_ENABLED ].setFunc = NULL,
#else
.attributeDefs[ FTDF_PIB_LE_ENABLED ].addr = &FTDF_pib.leEnabled,
.attributeDefs[ FTDF_PIB_LE_ENABLED ].size = sizeof(FTDF_pib.leEnabled),
.attributeDefs[ FTDF_PIB_LE_ENABLED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LE_ENABLED ].setFunc = FTDF_setLeEnabled,
#endif /* FTDF_NO_CSL */
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_CURRENT_CHANNEL ].addr = &FTDF_pib.currentChannel,
.attributeDefs[ FTDF_PIB_CURRENT_CHANNEL ].size = sizeof(FTDF_pib.currentChannel),
.attributeDefs[ FTDF_PIB_CURRENT_CHANNEL ].getFunc = FTDF_getCurrentChannel,
.attributeDefs[ FTDF_PIB_CURRENT_CHANNEL ].setFunc = FTDF_setCurrentChannel,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_CHANNELS_SUPPORTED ].addr = (void *) &channelsSupported,
.attributeDefs[ FTDF_PIB_CHANNELS_SUPPORTED ].size = 0,
.attributeDefs[ FTDF_PIB_CHANNELS_SUPPORTED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CHANNELS_SUPPORTED ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_TX_POWER_TOLERANCE ].addr = &FTDF_pib.TXPowerTolerance,
.attributeDefs[ FTDF_PIB_TX_POWER_TOLERANCE ].size = sizeof(FTDF_pib.TXPowerTolerance),
.attributeDefs[ FTDF_PIB_TX_POWER_TOLERANCE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TX_POWER_TOLERANCE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TX_POWER ].addr = &FTDF_pib.TXPower,
.attributeDefs[ FTDF_PIB_TX_POWER ].size = sizeof(FTDF_pib.TXPower),
.attributeDefs[ FTDF_PIB_TX_POWER ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TX_POWER ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_CCA_MODE ].addr = &FTDF_pib.CCAMode,
.attributeDefs[ FTDF_PIB_CCA_MODE ].size = sizeof(FTDF_pib.CCAMode),
.attributeDefs[ FTDF_PIB_CCA_MODE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CCA_MODE ].setFunc = FTDF_setTXPower,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_CURRENT_PAGE ].addr = &FTDF_pib.currentPage,
.attributeDefs[ FTDF_PIB_CURRENT_PAGE ].size = 0,
.attributeDefs[ FTDF_PIB_CURRENT_PAGE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_CURRENT_PAGE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_MAX_FRAME_DURATION ].addr = &FTDF_pib.maxFrameDuration,
.attributeDefs[ FTDF_PIB_MAX_FRAME_DURATION ].size = 0,
.attributeDefs[ FTDF_PIB_MAX_FRAME_DURATION ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_MAX_FRAME_DURATION ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_SHR_DURATION ].addr = &FTDF_pib.SHRDuration,
.attributeDefs[ FTDF_PIB_SHR_DURATION ].size = 0,
.attributeDefs[ FTDF_PIB_SHR_DURATION ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_SHR_DURATION ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_TRAFFIC_COUNTERS ].addr = &FTDF_pib.trafficCounters,
.attributeDefs[ FTDF_PIB_TRAFFIC_COUNTERS ].size = 0,
.attributeDefs[ FTDF_PIB_TRAFFIC_COUNTERS ].getFunc = FTDF_getLmacTrafficCounters,
.attributeDefs[ FTDF_PIB_TRAFFIC_COUNTERS ].setFunc = NULL,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_LE_CAPABLE ].addr = &FTDF_pib.LECapable,
.attributeDefs[ FTDF_PIB_LE_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_LE_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LE_CAPABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_LL_CAPABLE ].addr = &FTDF_pib.LLCapable,
.attributeDefs[ FTDF_PIB_LL_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_LL_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_LL_CAPABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_DSME_CAPABLE ].addr = &FTDF_pib.DSMECapable,
.attributeDefs[ FTDF_PIB_DSME_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_DSME_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_DSME_CAPABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_RFID_CAPABLE ].addr = &FTDF_pib.RFIDCapable,
.attributeDefs[ FTDF_PIB_RFID_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_RFID_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_RFID_CAPABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_AMCA_CAPABLE ].addr = &FTDF_pib.AMCACapable,
.attributeDefs[ FTDF_PIB_AMCA_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_AMCA_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_AMCA_CAPABLE ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_METRICS_CAPABLE ].addr = &FTDF_pib.metricsCapable,
.attributeDefs[ FTDF_PIB_METRICS_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_METRICS_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_METRICS_CAPABLE ].setFunc = NULL,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_RANGING_SUPPORTED ].addr = &FTDF_pib.rangingSupported,
.attributeDefs[ FTDF_PIB_RANGING_SUPPORTED ].size = 0,
.attributeDefs[ FTDF_PIB_RANGING_SUPPORTED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_RANGING_SUPPORTED ].setFunc = NULL,
#endif /* !FTDF_LITE */
.attributeDefs[ FTDF_PIB_KEEP_PHY_ENABLED ].addr = &FTDF_pib.keepPhyEnabled,
.attributeDefs[ FTDF_PIB_KEEP_PHY_ENABLED ].size = sizeof(FTDF_pib.keepPhyEnabled),
.attributeDefs[ FTDF_PIB_KEEP_PHY_ENABLED ].getFunc = FTDF_getKeepPhyEnabled,
.attributeDefs[ FTDF_PIB_KEEP_PHY_ENABLED ].setFunc = FTDF_setKeepPhyEnabled,
.attributeDefs[ FTDF_PIB_METRICS_ENABLED ].addr = &FTDF_pib.metricsEnabled,
.attributeDefs[ FTDF_PIB_METRICS_ENABLED ].size = sizeof(FTDF_pib.metricsEnabled),
.attributeDefs[ FTDF_PIB_METRICS_ENABLED ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_METRICS_ENABLED ].setFunc = NULL,
#ifndef FTDF_LITE
.attributeDefs[ FTDF_PIB_BEACON_AUTO_RESPOND ].addr = &FTDF_pib.beaconAutoRespond,
.attributeDefs[ FTDF_PIB_BEACON_AUTO_RESPOND ].size = sizeof(FTDF_pib.beaconAutoRespond),
.attributeDefs[ FTDF_PIB_BEACON_AUTO_RESPOND ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_BEACON_AUTO_RESPOND ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TSCH_CAPABLE ].addr = &FTDF_pib.tschCapable,
.attributeDefs[ FTDF_PIB_TSCH_CAPABLE ].size = 0,
.attributeDefs[ FTDF_PIB_TSCH_CAPABLE ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TSCH_CAPABLE ].setFunc = NULL,
.attributeDefs[ FTDF_PIB_TS_SYNC_CORRECT_THRESHOLD ].addr = &FTDF_pib.tsSyncCorrectThreshold,
.attributeDefs[ FTDF_PIB_TS_SYNC_CORRECT_THRESHOLD ].size = sizeof(FTDF_pib.tsSyncCorrectThreshold),
.attributeDefs[ FTDF_PIB_TS_SYNC_CORRECT_THRESHOLD ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_TS_SYNC_CORRECT_THRESHOLD ].setFunc = NULL,
#endif /* !FTDF_LITE */
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
.attributeDefs[ FTDF_PIB_BO_IRQ_THRESHOLD ].addr = &FTDF_pib.boIrqThreshold,
.attributeDefs[ FTDF_PIB_BO_IRQ_THRESHOLD ].size = sizeof(FTDF_pib.boIrqThreshold),
.attributeDefs[ FTDF_PIB_BO_IRQ_THRESHOLD ].getFunc = FTDF_getBoIrqThreshold,
.attributeDefs[ FTDF_PIB_BO_IRQ_THRESHOLD ].setFunc = FTDF_setBoIrqThreshold,
.attributeDefs[ FTDF_PIB_PTI_CONFIG ].addr = &FTDF_pib.ptiConfig,
.attributeDefs[ FTDF_PIB_PTI_CONFIG ].size = sizeof(FTDF_pib.ptiConfig),
.attributeDefs[ FTDF_PIB_PTI_CONFIG ].getFunc = NULL,
.attributeDefs[ FTDF_PIB_PTI_CONFIG ].setFunc = FTDF_setPtiConfig,
#endif /* dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A */
};
FTDF_Boolean FTDF_transparentMode __attribute__((section(".retention")));
FTDF_Bitmap32 FTDF_transparentModeOptions __attribute__((section(".retention")));
#if FTDF_DBG_BUS_ENABLE
FTDF_DbgMode FTDF_dbgMode __attribute__((section(".retention")));
#endif
#if dg_configUSE_FTDF_DDPHY == 1
uint16_t FTDF_ddphyCcaReg __attribute__((section(".retention")));
#endif
#ifndef FTDF_LITE
FTDF_Buffer FTDF_reqBuffers[ FTDF_NR_OF_REQ_BUFFERS ] __attribute__((section(".retention")));
FTDF_Queue FTDF_reqQueue __attribute__((section(".retention")));
FTDF_Queue FTDF_freeQueue __attribute__((section(".retention")));
FTDF_Pending FTDF_txPendingList[ FTDF_NR_OF_REQ_BUFFERS ] __attribute__((section(".retention")));
FTDF_PendingTL FTDF_txPendingTimerList[ FTDF_NR_OF_REQ_BUFFERS ] __attribute__((section(".retention")));
FTDF_PendingTL *FTDF_txPendingTimerHead __attribute__((section(".retention")));
FTDF_Time FTDF_txPendingTimerLT __attribute__((section(".retention")));
FTDF_Time FTDF_txPendingTimerTime __attribute__((section(".retention")));
#endif /* !FTDF_LITE */
#ifndef FTDF_PHY_API
FTDF_MsgBuffer *FTDF_reqCurrent __attribute__((section(".retention")));
#endif
FTDF_Size FTDF_nrOfRetries __attribute__((section(".retention")));
#if FTDF_USE_SLEEP_DURING_BACKOFF
static FTDF_Sdb FTDF_sdb __attribute__((section(".retention")));
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
#ifndef FTDF_LITE
FTDF_Boolean FTDF_isPANCoordinator __attribute__((section(".retention")));
FTDF_Time FTDF_startCslSampleTime __attribute__((section(".retention")));
FTDF_RxAddressAdmin FTDF_rxa[ FTDF_NR_OF_RX_ADDRS ] __attribute__((section(".retention")));
#endif /* !FTDF_LITE */
FTDF_Boolean FTDF_txInProgress __attribute__((section(".retention")));
#ifndef FTDF_LITE
#ifndef FTDF_NO_CSL
FTDF_PeerCslTiming FTDF_peerCslTiming[ FTDF_NR_OF_CSL_PEERS ] __attribute__((section(".retention")));
FTDF_Boolean FTDF_oldLeEnabled __attribute__((section(".retention")));
FTDF_Time FTDF_rzTime __attribute__((section(".retention")));
FTDF_ShortAddress FTDF_sendFramePending __attribute__((section(".retention")));
#endif /* FTDF_NO_CSL */
#endif /* !FTDF_LITE */
uint32_t FTDF_curTime[ 2 ] __attribute__((section(".retention")));
FTDF_LmacCounters FTDF_lmacCounters __attribute__((section(".retention")));
FTDF_FrameHeader FTDF_fh;
#ifndef FTDF_LITE
FTDF_SecurityHeader FTDF_sh;
FTDF_AssocAdmin FTDF_aa;
#endif /* !FTDF_LITE */
#if FTDF_USE_PTI
/* Packet traffic information used when FTDF is in RX enable. */
static FTDF_PTI FTDF_RxPti __attribute__((section(".retention")));
#endif
static void sendConfirm(FTDF_Status status,
FTDF_MsgId msgId);
void FTDF_reset(int setDefaultPIB)
{
if (setDefaultPIB)
{
// Reset PIB values to their default values
memset(&FTDF_pib, 0, sizeof(FTDF_pib));
FTDF_pib.extAddress = FTDF_GET_EXT_ADDRESS();
FTDF_pib.ackWaitDuration = 0x36;
#ifndef FTDF_LITE
FTDF_pib.autoRequest = FTDF_TRUE;
FTDF_pib.beaconOrder = 15;
FTDF_pib.DSN = FTDF_pib.extAddress & 0xff;
FTDF_pib.BSN = FTDF_pib.extAddress & 0xff;
FTDF_pib.EBSN = FTDF_pib.extAddress & 0xff;
FTDF_pib.coordShortAddress = 0xffff;
#endif /* !FTDF_LITE */
FTDF_pib.maxBE = 5;
FTDF_pib.maxCSMABackoffs = 4;
FTDF_pib.maxFrameTotalWaitTime = 1026; // see asic_vol v40.100.2.30 PR2540
FTDF_pib.maxFrameRetries = 3;
FTDF_pib.minBE = 3;
#ifndef FTDF_LITE
FTDF_pib.LIFSPeriod = 40;
FTDF_pib.SIFSPeriod = 12;
#endif /* !FTDF_LITE */
FTDF_pib.PANId = 0xffff;
#ifndef FTDF_LITE
FTDF_pib.responseWaitTime = 32;
#endif /* !FTDF_LITE */
FTDF_pib.shortAddress = 0xffff;
#ifndef FTDF_LITE
FTDF_pib.superframeOrder = 15;
FTDF_pib.timestampSupported = FTDF_TRUE;
FTDF_pib.transactionPersistenceTime = 0x1f4;
FTDF_pib.enhAckWaitDuration = 0x360;
FTDF_pib.EBAutoSA = FTDF_AUTO_FULL;
#endif /* !FTDF_LITE */
FTDF_pib.currentChannel = 11;
FTDF_pib.CCAMode = FTDF_CCA_MODE_1;
#ifndef FTDF_LITE
FTDF_pib.maxFrameDuration = FTDF_TBD;
FTDF_pib.SHRDuration = FTDF_TBD;
FTDF_pib.frameCounterMode = 4;
#endif /* !FTDF_LITE */
FTDF_pib.metricsCapable = FTDF_TRUE;
#ifndef FTDF_LITE
FTDF_pib.beaconAutoRespond = FTDF_TRUE;
#endif /* !FTDF_LITE */
FTDF_pib.performanceMetrics.counterOctets = 4; // 32 bit counters
#ifndef FTDF_LITE
FTDF_pib.joinPriority = 1;
FTDF_pib.slotframeTable.slotframeEntries = FTDF_slotframeTable;
FTDF_pib.linkTable.linkEntries = FTDF_linkTable;
FTDF_pib.timeslotTemplate.tsCCAOffset = 1800;
FTDF_pib.timeslotTemplate.tsCCA = 128;
FTDF_pib.timeslotTemplate.tsTxOffset = 2120;
FTDF_pib.timeslotTemplate.tsRxOffset = 1020;
FTDF_pib.timeslotTemplate.tsRxAckDelay = 800;
FTDF_pib.timeslotTemplate.tsTxAckDelay = 1000;
FTDF_pib.timeslotTemplate.tsRxWait = 2200;
FTDF_pib.timeslotTemplate.tsAckWait = 400;
FTDF_pib.timeslotTemplate.tsRxTx = 192;
FTDF_pib.timeslotTemplate.tsMaxAck = 2400;
FTDF_pib.timeslotTemplate.tsMaxTs = 4256;
FTDF_pib.timeslotTemplate.tsTimeslotLength = 10000;
FTDF_pib.tsSyncCorrectThreshold = 220;
FTDF_pib.hoppingSequenceLength = 16;
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
int i;
for (i = 0; i < FTDF_PTIS; i++)
{
FTDF_pib.ptiConfig.ptis[i] = 0;
}
#endif
#ifdef FTDF_NO_CSL
FTDF_pib.LECapable = FTDF_FALSE;
#else
FTDF_pib.LECapable = FTDF_TRUE;
#endif /* FTDF_NO_CSL */
#ifdef FTDF_NO_TSCH
FTDF_pib.tschCapable = FTDF_FALSE;
#else
FTDF_pib.tschCapable = FTDF_TRUE;
#endif /* FTDF_NO_TSCH */
int n;
for (n = 0; n < FTDF_MAX_HOPPING_SEQUENCE_LENGTH; n++)
{
FTDF_pib.hoppingSequenceList[ n ] = n + 11;
}
#endif /* !FTDF_LITE */
FTDF_transparentMode = FTDF_FALSE;
#ifndef FTDF_LITE
FTDF_isPANCoordinator = FTDF_FALSE;
#endif /* !FTDF_LITE */
FTDF_lmacCounters.fcsErrorCnt = 0;
FTDF_lmacCounters.txStdAckCnt = 0;
FTDF_lmacCounters.rxStdAckCnt = 0;
#ifndef FTDF_LITE
memset(FTDF_pib.defaultKeySource, 0xff, 8);
#endif /* !FTDF_LITE */
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
FTDF_pib.boIrqThreshold = FTDF_BO_IRQ_THRESHOLD;
#endif /* #if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A */
}
FTDF_initQueues();
volatile uint32_t *lmacReset = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_LMACRESET);
*lmacReset = MSK_R_FTDF_ON_OFF_REGMAP_LMACRESET;
volatile uint32_t *controlStatus = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_LMAC_CONTROL_STATUS);
uint32_t wait = 0;
while ((*controlStatus & MSK_F_FTDF_ON_OFF_REGMAP_LMACREADY4SLEEP) == 0)
{
wait++;
}
volatile uint32_t *wakeupTimerEnableStatus = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_WAKEUPTIMERENABLESTATUS);
#if dg_configBLACK_ORCA_IC_REV == BLACK_ORCA_IC_REV_A
FTDF_SET_FIELD(ALWAYS_ON_REGMAP_WAKEUPTIMERENABLE, 0);
#else
FTDF_SET_FIELD(ON_OFF_REGMAP_WAKEUPTIMERENABLE_CLEAR, 1);
#endif
while (*wakeupTimerEnableStatus & MSK_F_FTDF_ON_OFF_REGMAP_WAKEUPTIMERENABLESTATUS)
{ }
#if dg_configBLACK_ORCA_IC_REV == BLACK_ORCA_IC_REV_A
FTDF_SET_FIELD(ALWAYS_ON_REGMAP_WAKEUPTIMERENABLE, 1);
#else
FTDF_SET_FIELD(ON_OFF_REGMAP_WAKEUPTIMERENABLE_SET, 1);
#endif
while ((*wakeupTimerEnableStatus & MSK_F_FTDF_ON_OFF_REGMAP_WAKEUPTIMERENABLESTATUS) == 0)
{ }
#ifndef FTDF_LITE
int n;
#ifndef FTDF_NO_CSL
for (n = 0; n < FTDF_NR_OF_CSL_PEERS; n++)
{
FTDF_peerCslTiming[ n ].addr = 0xffff;
}
FTDF_oldLeEnabled = FTDF_FALSE;
FTDF_wakeUpEnableLe = FTDF_FALSE;
FTDF_sendFramePending = 0xfffe;
#endif /* FTDF_NO_CSL */
#endif /* !FTDF_LITE */
FTDF_txInProgress = FTDF_FALSE;
FTDF_initCurTime64();
#ifndef FTDF_NO_TSCH
FTDF_initTschRetries();
FTDF_initBackoff();
#endif /* FTDF_NO_TSCH */
#ifndef FTDF_LITE
for (n = 0; n < FTDF_NR_OF_RX_ADDRS; n++)
{
FTDF_rxa[ n ].addrMode = FTDF_NO_ADDRESS;
FTDF_rxa[ n ].dsnValid = FTDF_FALSE;
FTDF_rxa[ n ].bsnValid = FTDF_FALSE;
FTDF_rxa[ n ].ebsnValid = FTDF_FALSE;
}
#ifndef FTDF_NO_TSCH
for (n = 0; n < FTDF_NR_OF_NEIGHBORS; n++)
{
FTDF_neighborTable[ n ].dstAddr = 0xffff;
}
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
#if FTDF_USE_SLEEP_DURING_BACKOFF
FTDF_sdbFsmReset();
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
FTDF_initLmac();
#ifndef FTDF_NO_CSL
FTDF_rzTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
#endif /* FTDF_NO_CSL */
#if dg_configUSE_FTDF_DDPHY == 1
FTDF_ddphySet(0);
#endif
}
#ifndef FTDF_PHY_API
void FTDF_processResetRequest(FTDF_ResetRequest *resetRequest)
{
FTDF_reset(resetRequest->setDefaultPIB);
FTDF_ResetConfirm *resetConfirm = (FTDF_ResetConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_ResetConfirm));
resetConfirm->msgId = FTDF_RESET_CONFIRM;
resetConfirm->status = FTDF_SUCCESS;
FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) resetRequest);
FTDF_RCV_MSG((FTDF_MsgBuffer *) resetConfirm);
}
#endif /* FTDF_PHY_API */
void FTDF_initLmac(void)
{
FTDF_PIBAttribute PIBAttribute;
for (PIBAttribute = 1; PIBAttribute <= FTDF_NR_OF_PIB_ATTRIBUTES; PIBAttribute++)
{
if (pibAttributeTable.attributeDefs[ PIBAttribute ].setFunc != NULL)
{
pibAttributeTable.attributeDefs[ PIBAttribute ].setFunc();
}
}
if (FTDF_transparentMode == FTDF_TRUE)
{
FTDF_enableTransparentMode(FTDF_TRUE, FTDF_transparentModeOptions);
}
#ifndef FTDF_LITE
if (FTDF_isPANCoordinator)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_ISPANCOORDINATOR, 1);
}
#endif /* !FTDF_LITE */
FTDF_SET_FIELD(ON_OFF_REGMAP_CCAIDLEWAIT, 192);
volatile uint32_t *txFlagClear = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_CLEAR);
*txFlagClear = MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR;
volatile uint32_t *phyParams = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_PHY_PARAMETERS_2);
*phyParams = (FTDF_PHYTXSTARTUP << OFF_F_FTDF_ON_OFF_REGMAP_PHYTXSTARTUP) |
(FTDF_PHYTXLATENCY << OFF_F_FTDF_ON_OFF_REGMAP_PHYTXLATENCY) |
(FTDF_PHYTXFINISH << OFF_F_FTDF_ON_OFF_REGMAP_PHYTXFINISH) |
(FTDF_PHYTRXWAIT << OFF_F_FTDF_ON_OFF_REGMAP_PHYTRXWAIT);
phyParams = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_PHY_PARAMETERS_3);
*phyParams = (FTDF_PHYRXSTARTUP << OFF_F_FTDF_ON_OFF_REGMAP_PHYRXSTARTUP) |
(FTDF_PHYRXLATENCY << OFF_F_FTDF_ON_OFF_REGMAP_PHYRXLATENCY) |
(FTDF_PHYENABLE << OFF_F_FTDF_ON_OFF_REGMAP_PHYENABLE);
volatile uint32_t *ftdfCm = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_FTDF_CM);
*ftdfCm = FTDF_MSK_TX_CE | FTDF_MSK_RX_CE | FTDF_MSK_SYMBOL_TMR_CE;
volatile uint32_t *rxMask = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_RX_MASK);
*rxMask = MSK_R_FTDF_ON_OFF_REGMAP_RX_MASK;
volatile uint32_t *lmacMask = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_LMAC_MASK);
*lmacMask = MSK_F_FTDF_ON_OFF_REGMAP_RXTIMEREXPIRED_M;
volatile uint32_t *lmacCtrlMask = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_LMAC_CONTROL_MASK);
*lmacCtrlMask = MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIMETHR_M |
MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIME2THR_M |
MSK_F_FTDF_ON_OFF_REGMAP_SYNCTIMESTAMP_M;
volatile uint32_t *txFlagClearM;
txFlagClearM = FTDF_GET_FIELD_ADDR_INDEXED(ON_OFF_REGMAP_TX_FLAG_CLEAR_M, FTDF_TX_DATA_BUFFER);
*txFlagClearM |= MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_M;
txFlagClearM = FTDF_GET_FIELD_ADDR_INDEXED(ON_OFF_REGMAP_TX_FLAG_CLEAR_M, FTDF_TX_WAKEUP_BUFFER);
*txFlagClearM |= MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_M;
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
#if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO
FTDF_fpprReset();
FTDF_fpprSetMode(FTDF_TRUE, FTDF_FALSE, FTDF_FALSE);
#else
FTDF_fpprSetMode(FTDF_FALSE, FTDF_TRUE, FTDF_TRUE);
#endif /* #if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */
#if FTDF_USE_SLEEP_DURING_BACKOFF
/* Unmask long BO interrupt. */
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_BO_THR_M, 1);
#else /* FTDF_USE_SLEEP_DURING_BACKOFF */
/* Set BO threshold. */
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_BO_THRESHOLD, FTDF_BO_IRQ_THRESHOLD);
/* Mask long BO interrupt. */
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_BO_THR_M, 0);
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
#if FTDF_USE_LPDP == 1
FTDF_lpdpEnable(FTDF_TRUE);
#endif /* #if FTDF_USE_LPDP == 1 */
#endif /* #if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A */
}
#ifdef FTDF_PHY_API
FTDF_PIBAttributeValue *FTDF_getValue(FTDF_PIBAttribute PIBAttribute)
{
if (PIBAttribute <= FTDF_NR_OF_PIB_ATTRIBUTES &&
pibAttributeTable.attributeDefs[ PIBAttribute ].addr != NULL)
{
// Update PIB attribute with current LMAC status if a getFunc is defined
if (pibAttributeTable.attributeDefs[ PIBAttribute ].getFunc != NULL)
{
pibAttributeTable.attributeDefs[ PIBAttribute ].getFunc();
}
return pibAttributeTable.attributeDefs[ PIBAttribute ].addr;
}
return NULL;
}
FTDF_Status FTDF_setValue(FTDF_PIBAttribute PIBAttribute, const FTDF_PIBAttributeValue *PIBAttributeValue)
{
if (PIBAttribute <= FTDF_NR_OF_PIB_ATTRIBUTES &&
pibAttributeTable.attributeDefs[ PIBAttribute ].addr != NULL)
{
if (pibAttributeTable.attributeDefs[ PIBAttribute ].size != 0)
{
memcpy(pibAttributeTable.attributeDefs[ PIBAttribute ].addr,
PIBAttributeValue,
pibAttributeTable.attributeDefs[ PIBAttribute ].size);
// Update LMAC with new PIB attribute value if a setFunc is defined
if (pibAttributeTable.attributeDefs[ PIBAttribute ].setFunc != NULL)
{
pibAttributeTable.attributeDefs[ PIBAttribute ].setFunc();
}
return FTDF_SUCCESS;
}
else
{
return FTDF_READ_ONLY;
}
}
return FTDF_UNSUPPORTED_ATTRIBUTE;
}
#else /* FTDF_PHY_API */
void FTDF_processGetRequest(FTDF_GetRequest *getRequest)
{
FTDF_GetConfirm *getConfirm = (FTDF_GetConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_GetConfirm));
FTDF_PIBAttribute PIBAttribute = getRequest->PIBAttribute;
getConfirm->msgId = FTDF_GET_CONFIRM;
getConfirm->PIBAttribute = PIBAttribute;
if (PIBAttribute <= FTDF_NR_OF_PIB_ATTRIBUTES &&
pibAttributeTable.attributeDefs[ PIBAttribute ].addr != NULL)
{
// Update PIB attribute with current LMAC status if a getFunc is defined
if (pibAttributeTable.attributeDefs[ PIBAttribute ].getFunc != NULL)
{
pibAttributeTable.attributeDefs[ PIBAttribute ].getFunc();
}
getConfirm->status = FTDF_SUCCESS;
getConfirm->PIBAttributeValue = pibAttributeTable.attributeDefs[ PIBAttribute ].addr;
}
else
{
getConfirm->status = FTDF_UNSUPPORTED_ATTRIBUTE;
}
FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) getRequest);
FTDF_RCV_MSG((FTDF_MsgBuffer *) getConfirm);
}
void FTDF_processSetRequest(FTDF_SetRequest *setRequest)
{
FTDF_SetConfirm *setConfirm = (FTDF_SetConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_SetConfirm));
FTDF_PIBAttribute PIBAttribute = setRequest->PIBAttribute;
setConfirm->msgId = FTDF_SET_CONFIRM;
setConfirm->PIBAttribute = PIBAttribute;
if (PIBAttribute <= FTDF_NR_OF_PIB_ATTRIBUTES &&
pibAttributeTable.attributeDefs[ PIBAttribute ].addr != NULL)
{
if (pibAttributeTable.attributeDefs[ PIBAttribute ].size != 0)
{
setConfirm->status = FTDF_SUCCESS;
memcpy(pibAttributeTable.attributeDefs[ PIBAttribute ].addr,
setRequest->PIBAttributeValue,
pibAttributeTable.attributeDefs[ PIBAttribute ].size);
// Update LMAC with new PIB attribute value if a setFunc is defined
if (pibAttributeTable.attributeDefs[ PIBAttribute ].setFunc != NULL)
{
pibAttributeTable.attributeDefs[ PIBAttribute ].setFunc();
}
}
else
{
setConfirm->status = FTDF_READ_ONLY;
}
}
else
{
setConfirm->status = FTDF_UNSUPPORTED_ATTRIBUTE;
}
FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) setRequest);
FTDF_RCV_MSG((FTDF_MsgBuffer *) setConfirm);
}
void FTDF_sendCommStatusIndication(FTDF_MsgBuffer *request,
FTDF_Status status,
FTDF_PANId PANId,
FTDF_AddressMode srcAddrMode,
FTDF_Address srcAddr,
FTDF_AddressMode dstAddrMode,
FTDF_Address dstAddr,
FTDF_SecurityLevel securityLevel,
FTDF_KeyIdMode keyIdMode,
FTDF_Octet *keySource,
FTDF_KeyIndex keyIndex)
{
FTDF_CommStatusIndication *commStatus =
(FTDF_CommStatusIndication *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_CommStatusIndication));
commStatus->msgId = FTDF_COMM_STATUS_INDICATION;
commStatus->PANId = PANId;
commStatus->srcAddrMode = srcAddrMode;
commStatus->srcAddr = srcAddr;
commStatus->dstAddrMode = dstAddrMode;
commStatus->dstAddr = dstAddr;
commStatus->status = status;
commStatus->securityLevel = securityLevel;
commStatus->keyIdMode = keyIdMode;
commStatus->keyIndex = keyIndex;
uint8_t n;
if (securityLevel != 0)
{
if (keyIdMode == 0x2)
{
for (n = 0; n < 4; n++)
{
commStatus->keySource[ n ] = keySource[ n ];
}
}
else if (keyIdMode == 0x3)
{
for (n = 0; n < 8; n++)
{
commStatus->keySource[ n ] = keySource[ n ];
}
}
}
#ifndef FTDF_LITE
if (request &&
(request->msgId == FTDF_ORPHAN_RESPONSE ||
request->msgId == FTDF_ASSOCIATE_RESPONSE))
{
if (FTDF_reqCurrent == request)
{
FTDF_reqCurrent = NULL;
}
FTDF_REL_MSG_BUFFER(request);
FTDF_RCV_MSG((FTDF_MsgBuffer *) commStatus);
/* Check for orphan response. */
#if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO
FTDF_fpFsmClearPending();
#endif /* FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */
FTDF_processNextRequest();
return;
}
#endif /* !FTDF_LITE */
FTDF_RCV_MSG((FTDF_MsgBuffer *) commStatus);
}
#endif /* FTDF_PHY_API */
#ifndef FTDF_LITE
FTDF_Octet *FTDF_addFrameHeader(FTDF_Octet *txPtr,
FTDF_FrameHeader *frameHeader,
FTDF_DataLength msduLength)
{
uint8_t frameVersion;
uint8_t longFrameControl = 0x00;
FTDF_Boolean panIdCompression = FTDF_FALSE;
FTDF_Bitmap8 options = frameHeader->options;
FTDF_Boolean secure = options & FTDF_OPT_SECURITY_ENABLED;
FTDF_Boolean framePending = options & FTDF_OPT_FRAME_PENDING;
FTDF_Boolean ackTX = options & FTDF_OPT_ACK_REQUESTED;
FTDF_Boolean panIdPresent = options & FTDF_OPT_PAN_ID_PRESENT;
FTDF_Boolean seqNrSuppressed = options & FTDF_OPT_SEQ_NR_SUPPRESSED;
FTDF_Boolean iesIncluded = options & FTDF_OPT_IES_PRESENT;
FTDF_FrameType frameType = frameHeader->frameType;
FTDF_AddressMode dstAddrMode = frameHeader->dstAddrMode;
FTDF_AddressMode srcAddrMode = frameHeader->srcAddrMode;
FTDF_PANId dstPANId = frameHeader->dstPANId;
if (frameType == FTDF_MULTIPURPOSE_FRAME)
{
if (options & (FTDF_OPT_SECURITY_ENABLED | FTDF_OPT_ACK_REQUESTED | FTDF_OPT_PAN_ID_PRESENT |
FTDF_OPT_IES_PRESENT | FTDF_OPT_SEQ_NR_SUPPRESSED | FTDF_OPT_FRAME_PENDING))
{
longFrameControl = 0x08;
}
// Frame control field byte 1
*txPtr++ = 0x05 | longFrameControl | dstAddrMode << 4 | srcAddrMode << 6;
if (longFrameControl)
{
// Frame control field byte 2
*txPtr++ =
(panIdPresent ? 0x01 : 0x00) |
(secure ? 0x02 : 0x00) |
(seqNrSuppressed ? 0x04 : 0x00) |
(framePending ? 0x08 : 0x00) |
(ackTX ? 0x40 : 0x00) |
(iesIncluded ? 0x80 : 0x00);
}
}
else
{
// if ( panIdPresent || iesIncluded || seqNrSuppressed || ( options & FTDF_OPT_ENHANCED ) || FTDF_pib.tschEnabled )
if (panIdPresent || iesIncluded || seqNrSuppressed || (options & FTDF_OPT_ENHANCED))
{
frameVersion = 0b10;
}
else
{
if (secure ||
msduLength > FTDF_MAX_MAC_SAFE_PAYLOAD_SIZE)
{
frameVersion = 0b01;
}
else
{
frameVersion = 0b00;
}
}
if (frameVersion < 0b10)
{
if (dstAddrMode != FTDF_NO_ADDRESS &&
srcAddrMode != FTDF_NO_ADDRESS &&
dstPANId == frameHeader->srcPANId)
{
panIdCompression = FTDF_TRUE;
}
}
else
{
panIdCompression = panIdPresent;
}
// Frame control field byte 1
*txPtr++ =
(frameType & 0x7) |
(secure ? 0x08 : 0x00) |
(framePending ? 0x10 : 0x00) |
(ackTX ? 0x20 : 0x00) |
(panIdCompression ? 0x40 : 0x00);
// Frame control field byte 2
*txPtr++ =
(seqNrSuppressed ? 0x01 : 0x00) |
(iesIncluded ? 0x02 : 0x00) |
dstAddrMode << 2 |
frameVersion << 4 |
srcAddrMode << 6;
}
if (!seqNrSuppressed)
{
*txPtr++ = frameHeader->SN;
}
FTDF_Boolean addDstPANId = FTDF_FALSE;
if (frameType == FTDF_MULTIPURPOSE_FRAME)
{
if (panIdPresent)
{
addDstPANId = FTDF_TRUE;
}
}
else
{
if (frameVersion < 0b10)
{
if (dstAddrMode != FTDF_NO_ADDRESS)
{
addDstPANId = FTDF_TRUE;
}
}
else
{
// See Table 2a "PAN ID Compression" of IEEE 802.15.4-2011 for more details
if ((srcAddrMode == FTDF_NO_ADDRESS && dstAddrMode == FTDF_NO_ADDRESS && panIdCompression) ||
(srcAddrMode == FTDF_NO_ADDRESS && dstAddrMode != FTDF_NO_ADDRESS && !panIdCompression) ||
(srcAddrMode != FTDF_NO_ADDRESS && dstAddrMode != FTDF_NO_ADDRESS && !panIdCompression))
{
addDstPANId = FTDF_TRUE;
}
}
}
if (addDstPANId)
{
FTDF_Octet *PANIdPtr = (FTDF_Octet *)&dstPANId;
*txPtr++ = *PANIdPtr++;
*txPtr++ = *PANIdPtr;
}
FTDF_Address dstAddr = frameHeader->dstAddr;
if (dstAddrMode == FTDF_SIMPLE_ADDRESS)
{
*txPtr++ = dstAddr.simpleAddress;
}
else if (dstAddrMode == FTDF_SHORT_ADDRESS)
{
FTDF_Octet *shortAddressPtr = (FTDF_Octet *)&dstAddr.shortAddress;
*txPtr++ = *shortAddressPtr++;
*txPtr++ = *shortAddressPtr;
}
else if (dstAddrMode == FTDF_EXTENDED_ADDRESS)
{
FTDF_Octet *extAddressPtr = (FTDF_Octet *)&dstAddr.extAddress;
int n;
for (n = 0; n < 8; n++)
{
*txPtr++ = *extAddressPtr++;
}
}
FTDF_Boolean addSrcPANId = FTDF_FALSE;
if (frameType != FTDF_MULTIPURPOSE_FRAME)
{
if (frameVersion < 0b10)
{
if (srcAddrMode != FTDF_NO_ADDRESS && !panIdCompression)
{
addSrcPANId = FTDF_TRUE;
}
}
else
{
// See Table 2a "PAN ID Compression" of IEEE 802.15.4-2011 for more details
if (srcAddrMode != FTDF_NO_ADDRESS && dstAddrMode == FTDF_NO_ADDRESS && !panIdCompression)
{
addSrcPANId = FTDF_TRUE;
}
}
}
if (addSrcPANId)
{
FTDF_Octet *PANIdPtr = (FTDF_Octet *)&frameHeader->srcPANId;
*txPtr++ = *PANIdPtr++;
*txPtr++ = *PANIdPtr;
}
if (srcAddrMode == FTDF_SIMPLE_ADDRESS)
{
*txPtr++ = FTDF_pib.simpleAddress;
}
else if (srcAddrMode == FTDF_SHORT_ADDRESS)
{
FTDF_Octet *shortAddressPtr = (FTDF_Octet *)&FTDF_pib.shortAddress;
*txPtr++ = *shortAddressPtr++;
*txPtr++ = *shortAddressPtr;
}
else if (srcAddrMode == FTDF_EXTENDED_ADDRESS)
{
FTDF_Octet *extAddressPtr = (FTDF_Octet *)&FTDF_pib.extAddress;
int n;
for (n = 0; n < 8; n++)
{
*txPtr++ = *extAddressPtr++;
}
}
return txPtr;
}
#endif /* !FTDF_LITE */
FTDF_PTI FTDF_getRxPti(void)
{
#if FTDF_USE_PTI
FTDF_PTI rx_pti;
FTDF_criticalVar();
FTDF_enterCritical();
rx_pti = FTDF_RxPti;
FTDF_exitCritical();
return rx_pti;
#else
return 0;
#endif
}
#ifdef FTDF_PHY_API
void FTDF_rxEnable(FTDF_Time rxOnDuration)
{
#if dg_configCOEX_ENABLE_CONFIG
/* We do not force decision here. It will be automatically made when FTDF begins
* transaction.
*/
hw_coex_update_ftdf_pti((hw_coex_pti_t) FTDF_getRxPti(), NULL, false);
#endif
FTDF_SET_FIELD(ON_OFF_REGMAP_RXENABLE, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_RXONDURATION, rxOnDuration);
FTDF_SET_FIELD(ON_OFF_REGMAP_RXENABLE, 1);
}
#else
void FTDF_processRxEnableRequest(FTDF_RxEnableRequest *rxEnableRequest)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_RXENABLE, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_RXONDURATION, rxEnableRequest->rxOnDuration);
FTDF_SET_FIELD(ON_OFF_REGMAP_RXENABLE, 1);
FTDF_RxEnableConfirm *rxEnableConfirm =
(FTDF_RxEnableConfirm *) FTDF_GET_MSG_BUFFER(sizeof(FTDF_RxEnableConfirm));
rxEnableConfirm->msgId = FTDF_RX_ENABLE_CONFIRM;
rxEnableConfirm->status = FTDF_SUCCESS;
FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) rxEnableRequest);
FTDF_RCV_MSG((FTDF_MsgBuffer *) rxEnableConfirm);
}
#endif /* FTDF_PHY_API */
FTDF_Octet *FTDF_getFrameHeader(FTDF_Octet *rxBuffer,
FTDF_FrameHeader *frameHeader)
{
FTDF_FrameType frameType = *rxBuffer & 0x07;
uint8_t frameVersion = 0;
FTDF_Bitmap8 options = 0;
FTDF_AddressMode dstAddrMode;
FTDF_AddressMode srcAddrMode;
FTDF_Boolean panIdCompression = FTDF_FALSE;
FTDF_Boolean panIdPresent = FTDF_FALSE;
if (frameType == FTDF_MULTIPURPOSE_FRAME)
{
dstAddrMode = (*rxBuffer & 0x30) >> 4;
srcAddrMode = (*rxBuffer & 0xc0) >> 6;
// Check Long Frame Control
if (*rxBuffer & 0x08)
{
rxBuffer++;
panIdPresent = *rxBuffer & 0x01;
if (*rxBuffer & 0x02)
{
options |= FTDF_OPT_SECURITY_ENABLED;
}
if (*rxBuffer & 0x04)
{
options |= FTDF_OPT_SEQ_NR_SUPPRESSED;
}
if (*rxBuffer & 0x08)
{
options |= FTDF_OPT_FRAME_PENDING;
}
if (*rxBuffer & 0x40)
{
options |= FTDF_OPT_ACK_REQUESTED;
}
if (*rxBuffer & 0x80)
{
options |= FTDF_OPT_IES_PRESENT;
}
frameVersion = 0;
frameHeader->frameVersion = FTDF_FRAME_VERSION_E;
rxBuffer++;
}
else
{
rxBuffer++;
}
}
else
{
if (*rxBuffer & 0x08)
{
options |= FTDF_OPT_SECURITY_ENABLED;
}
if (*rxBuffer & 0x10)
{
options |= FTDF_OPT_FRAME_PENDING;
}
if (*rxBuffer & 0x20)
{
options |= FTDF_OPT_ACK_REQUESTED;
}
panIdCompression = *rxBuffer & 0x40;
rxBuffer++;
frameVersion = (*rxBuffer & 0x30) >> 4;
if (frameVersion == 0x02)
{
if (*rxBuffer & 0x01)
{
options |= FTDF_OPT_SEQ_NR_SUPPRESSED;
}
if (*rxBuffer & 0x02)
{
options |= FTDF_OPT_IES_PRESENT;
}
frameHeader->frameVersion = FTDF_FRAME_VERSION_E;
}
else if (frameVersion == 0x01)
{
frameHeader->frameVersion = FTDF_FRAME_VERSION_2011;
}
else if (frameVersion == 0x00)
{
frameHeader->frameVersion = FTDF_FRAME_VERSION_2003;
}
else
{
frameHeader->frameVersion = FTDF_FRAME_VERSION_NOT_SUPPORTED;
return rxBuffer;
}
dstAddrMode = (*rxBuffer & 0x0c) >> 2;
srcAddrMode = (*rxBuffer & 0xc0) >> 6;
rxBuffer++;
}
if ((options & FTDF_OPT_SEQ_NR_SUPPRESSED) == 0)
{
frameHeader->SN = *rxBuffer++;
}
FTDF_Boolean hasDstPANId = FTDF_FALSE;
if (frameType == FTDF_MULTIPURPOSE_FRAME)
{
hasDstPANId = panIdPresent;
}
else
{
if (frameVersion < 0x02)
{
if (dstAddrMode != FTDF_NO_ADDRESS)
{
hasDstPANId = FTDF_TRUE;
}
}
else
{
if ((srcAddrMode == FTDF_NO_ADDRESS && dstAddrMode == FTDF_NO_ADDRESS && panIdCompression) ||
(srcAddrMode == FTDF_NO_ADDRESS && dstAddrMode != FTDF_NO_ADDRESS && !panIdCompression) ||
(srcAddrMode != FTDF_NO_ADDRESS && dstAddrMode != FTDF_NO_ADDRESS && !panIdCompression))
{
hasDstPANId = FTDF_TRUE;
}
}
}
if (hasDstPANId)
{
FTDF_Octet *PANIdPtr = (FTDF_Octet *) &frameHeader->dstPANId;
*PANIdPtr++ = *rxBuffer++;
*PANIdPtr = *rxBuffer++;
}
if (dstAddrMode == FTDF_SIMPLE_ADDRESS)
{
frameHeader->dstAddr.simpleAddress = *rxBuffer++;
}
else if (dstAddrMode == FTDF_SHORT_ADDRESS)
{
FTDF_Octet *shortAddressPtr = (FTDF_Octet *)&frameHeader->dstAddr.shortAddress;
*shortAddressPtr++ = *rxBuffer++;
*shortAddressPtr = *rxBuffer++;
}
else if (dstAddrMode == FTDF_EXTENDED_ADDRESS)
{
FTDF_Octet *extAddressPtr = (FTDF_Octet *)&frameHeader->dstAddr.extAddress;
int n;
for (n = 0; n < 8; n++)
{
*extAddressPtr++ = *rxBuffer++;
}
}
FTDF_Boolean hasSrcPANId = FTDF_FALSE;
if (frameVersion < 0x02 && frameType != FTDF_MULTIPURPOSE_FRAME)
{
if (srcAddrMode != FTDF_NO_ADDRESS && !panIdCompression)
{
hasSrcPANId = FTDF_TRUE;
}
}
else
{
if (srcAddrMode != FTDF_NO_ADDRESS && dstAddrMode == FTDF_NO_ADDRESS && !panIdCompression)
{
hasSrcPANId = FTDF_TRUE;
}
}
if (hasSrcPANId)
{
FTDF_Octet *PANIdPtr = (FTDF_Octet *) &frameHeader->srcPANId;
*PANIdPtr++ = *rxBuffer++;
*PANIdPtr = *rxBuffer++;
}
else
{
frameHeader->srcPANId = frameHeader->dstPANId;
}
if (srcAddrMode == FTDF_SIMPLE_ADDRESS)
{
frameHeader->srcAddr.simpleAddress = *rxBuffer++;
}
else if (srcAddrMode == FTDF_SHORT_ADDRESS)
{
FTDF_Octet *shortAddressPtr = (FTDF_Octet *)&frameHeader->srcAddr.shortAddress;
*shortAddressPtr++ = *rxBuffer++;
*shortAddressPtr = *rxBuffer++;
}
else if (srcAddrMode == FTDF_EXTENDED_ADDRESS)
{
FTDF_Octet *extAddressPtr = (FTDF_Octet *)&frameHeader->srcAddr.extAddress;
int n;
for (n = 0; n < 8; n++)
{
*extAddressPtr++ = *rxBuffer++;
}
}
frameHeader->frameType = frameType;
frameHeader->options = options;
frameHeader->dstAddrMode = dstAddrMode;
frameHeader->srcAddrMode = srcAddrMode;
return rxBuffer;
}
#ifndef FTDF_LITE
void FTDF_processNextRequest(void)
{
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
FTDF_MsgBuffer *request = FTDF_tschGetPending(FTDF_tschSlotLink->request);
FTDF_tschSlotLink->request = NULL;
FTDF_scheduleTsch(request);
return;
}
#endif /* FTDF_NO_TSCH */
while (FTDF_reqCurrent == NULL)
{
FTDF_MsgBuffer *request = FTDF_dequeueReqTail(&FTDF_reqQueue);
if (request)
{
FTDF_processRequest(request);
}
else
{
break;
}
}
}
#endif /* !FTDF_LITE */
static void processRxFrame(int readBuf)
{
static FTDF_PANDescriptor PANDescriptor;
static FTDF_Address pendAddrList[ 7 ];
FTDF_FrameHeader *frameHeader = &FTDF_fh;
#ifndef FTDF_LITE
FTDF_SecurityHeader *securityHeader = &FTDF_sh;
#endif /* !FTDF_LITE */
uint8_t pendAddrSpec = 0;
FTDF_Octet *rxBuffer =
(FTDF_Octet *)(IND_R_FTDF_RX_RAM_RX_FIFO + (intptr_t) readBuf * FTDF_BUFFER_LENGTH);
FTDF_Octet *rxPtr = rxBuffer;
FTDF_DataLength frameLen = *rxPtr++;
if (FTDF_transparentMode)
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.RXSuccessCount++;
}
uint32_t rxMeta1 = *FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_RX_META_1, (intptr_t)readBuf);
FTDF_LinkQuality lqi = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_QUALITY_INDICATOR, readBuf);
FTDF_Bitmap32 status = FTDF_TRANSPARENT_RCV_SUCCESSFUL;
status |= rxMeta1 & MSK_F_FTDF_RETENTION_RAM_CRC16_ERROR ? FTDF_TRANSPARENT_RCV_CRC_ERROR : 0;
status |= rxMeta1 & MSK_F_FTDF_RETENTION_RAM_RES_FRM_TYPE_ERROR ? FTDF_TRANSPARENT_RCV_RES_FRAMETYPE : 0;
status |= rxMeta1 & MSK_F_FTDF_RETENTION_RAM_RES_FRM_VERSION_ERROR ? FTDF_TRANSPARENT_RCV_RES_FRAME_VERSION : 0;
status |= rxMeta1 & MSK_F_FTDF_RETENTION_RAM_DPANID_ERROR ? FTDF_TRANSPARENT_RCV_UNEXP_DST_PAN_ID : 0;
status |= rxMeta1 & MSK_F_FTDF_RETENTION_RAM_DADDR_ERROR ? FTDF_TRANSPARENT_RCV_UNEXP_DST_ADDR : 0;
FTDF_RCV_FRAME_TRANSPARENT(frameLen, rxPtr, status, lqi);
#if FTDF_TRANSPARENT_USE_WAIT_FOR_ACK
if ((FTDF_transparentModeOptions & FTDF_TRANSPARENT_WAIT_FOR_ACK))
{
FTDF_getFrameHeader(rxPtr, frameHeader);
if (frameHeader->frameType == FTDF_ACKNOWLEDGEMENT_FRAME &&
(status == FTDF_TRANSPARENT_RCV_SUCCESSFUL))
{
#ifndef FTDF_PHY_API
volatile uint32_t *txFlagS = FTDF_GET_REG_ADDR_INDEXED(ON_OFF_REGMAP_TX_FLAG_S, FTDF_TX_DATA_BUFFER);
while (*txFlagS & MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_STAT)
{ }
// It is required to call FTDF_processTxEvent here because an RX ack generates two events
// The RX event is raised first, then after an IFS the TX event is raised. However,
// the FTDF_processNextRequest requires that both events have been handled.
FTDF_processTxEvent();
#endif /* !FTDF_PHY_API */
FTDF_SN SN = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_MACSN, FTDF_TX_DATA_BUFFER);
#ifdef FTDF_PHY_API
FTDF_criticalVar();
FTDF_enterCritical();
if (FTDF_txInProgress &&
frameHeader->SN == SN)
{
FTDF_exitCritical();
return;
}
FTDF_exitCritical();
#else
if (FTDF_reqCurrent &&
frameHeader->SN == SN)
{
FTDF_TransparentRequest *transparentRequest = (FTDF_TransparentRequest *) FTDF_reqCurrent;
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_reqCurrent = NULL;
FTDF_exitCritical();
FTDF_SEND_FRAME_TRANSPARENT_CONFIRM(transparentRequest->handle, FTDF_TRANSPARENT_SEND_SUCCESSFUL);
FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) transparentRequest);
return;
}
#endif /* FTDF_PHY_API */
}
}
#endif /* FTDF_TRANSPARENT_USE_WAIT_FOR_ACK */
return;
}
#ifndef FTDF_LITE
rxPtr = FTDF_getFrameHeader(rxPtr, frameHeader);
#if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_MANUAL
if (frameHeader->options & FTDF_OPT_ACK_REQUESTED)
{
int n;
FTDF_Boolean addressFound = FTDF_FALSE;
for (n = 0; n < FTDF_NR_OF_REQ_BUFFERS; n++)
{
if (FTDF_txPendingList[ n ].addrMode == frameHeader->srcAddrMode &&
FTDF_txPendingList[ n ].PANId == frameHeader->srcPANId)
{
if (frameHeader->srcAddrMode == FTDF_SHORT_ADDRESS)
{
if (FTDF_txPendingList[ n ].addr.shortAddress ==
frameHeader->srcAddr.shortAddress)
{
addressFound = FTDF_TRUE;
break;
}
}
else if (frameHeader->srcAddrMode == FTDF_EXTENDED_ADDRESS)
{
if (FTDF_txPendingList[ n ].addr.extAddress ==
frameHeader->srcAddr.extAddress)
{
addressFound = FTDF_TRUE;
break;
}
}
else
{
// Invalid srcAddrMode
return;
}
}
}
if (addressFound)
{
FTDF_fpprSetMode(FTDF_FALSE, FTDF_TRUE, FTDF_TRUE);
}
else
{
FTDF_fpprSetMode(FTDF_FALSE, FTDF_TRUE, FTDF_FALSE);
}
}
#endif
if (frameHeader->frameVersion == FTDF_FRAME_VERSION_NOT_SUPPORTED)
{
return;
}
#if defined(FTDF_NO_CSL) && defined(FTDF_NO_TSCH)
else if (frameHeader->frameVersion == FTDF_FRAME_VERSION_E ||
frameHeader->frameType == FTDF_MULTIPURPOSE_FRAME)
{
return;
}
#endif /* FTDF_NO_CSL && FTDF_NO_TSCH */
FTDF_FrameType frameType = frameHeader->frameType;
FTDF_Boolean duplicate = FTDF_FALSE;
if ((frameHeader->options & FTDF_OPT_SEQ_NR_SUPPRESSED) == 0 &&
frameHeader->srcAddrMode != FTDF_NO_ADDRESS)
{
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP, readBuf);
FTDF_SNSel snSel = FTDF_SN_SEL_DSN;
FTDF_Boolean drop;
if ((FTDF_pib.tschEnabled || frameHeader->frameVersion == FTDF_FRAME_VERSION_E) &&
(frameHeader->options & FTDF_OPT_ACK_REQUESTED))
{
drop = FTDF_FALSE;
}
else
{
drop = FTDF_TRUE;
}
if (frameType == FTDF_BEACON_FRAME)
{
snSel = frameHeader->frameVersion == FTDF_FRAME_VERSION_E ? FTDF_SN_SEL_EBSN : FTDF_SN_SEL_BSN;
}
uint8_t i;
for (i = 0; i < FTDF_NR_OF_RX_ADDRS; i++)
{
// Check if entry is empty or matches
if (FTDF_rxa[ i ].addrMode == FTDF_NO_ADDRESS ||
(FTDF_rxa[ i ].addrMode == frameHeader->srcAddrMode &&
((frameHeader->srcAddrMode == FTDF_SHORT_ADDRESS &&
frameHeader->srcAddr.shortAddress == FTDF_rxa[ i ].addr.shortAddress) ||
(frameHeader->srcAddrMode == FTDF_EXTENDED_ADDRESS &&
frameHeader->srcAddr.extAddress == FTDF_rxa[ i ].addr.extAddress))))
{
break;
}
}
if (i < FTDF_NR_OF_RX_ADDRS)
{
if (FTDF_rxa[ i ].addrMode != FTDF_NO_ADDRESS)
{
switch (snSel)
{
case FTDF_SN_SEL_DSN:
if (FTDF_rxa[ i ].dsnValid == FTDF_TRUE)
{
if (frameHeader->SN == FTDF_rxa[ i ].dsn)
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.duplicateFrameCount++;
}
if (drop)
{
return;
}
duplicate = FTDF_TRUE;
}
}
else
{
FTDF_rxa[ i ].dsnValid = FTDF_TRUE;
}
FTDF_rxa[ i ].dsn = frameHeader->SN;
break;
case FTDF_SN_SEL_BSN:
if (FTDF_rxa[ i ].bsnValid == FTDF_TRUE)
{
if (frameHeader->SN == FTDF_rxa[ i ].bsn)
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.duplicateFrameCount++;
}
if (drop)
{
return;
}
duplicate = FTDF_TRUE;
}
}
else
{
FTDF_rxa[ i ].bsnValid = FTDF_TRUE;
}
FTDF_rxa[ i ].bsn = frameHeader->SN;
break;
case FTDF_SN_SEL_EBSN:
if (FTDF_rxa[ i ].ebsnValid == FTDF_TRUE)
{
if (frameHeader->SN == FTDF_rxa[ i ].ebsn)
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.duplicateFrameCount++;
}
if (drop)
{
return;
}
duplicate = FTDF_TRUE;
}
}
else
{
FTDF_rxa[ i ].ebsnValid = FTDF_TRUE;
}
FTDF_rxa[ i ].ebsn = frameHeader->SN;
break;
}
}
else
{
FTDF_rxa[ i ].addrMode = frameHeader->srcAddrMode;
FTDF_rxa[ i ].addr = frameHeader->srcAddr;
switch (snSel)
{
case FTDF_SN_SEL_DSN:
FTDF_rxa[ i ].dsnValid = FTDF_TRUE;
FTDF_rxa[ i ].dsn = frameHeader->SN;
break;
case FTDF_SN_SEL_BSN:
FTDF_rxa[ i ].bsnValid = FTDF_TRUE;
FTDF_rxa[ i ].bsn = frameHeader->SN;
break;
case FTDF_SN_SEL_EBSN:
FTDF_rxa[ i ].ebsnValid = FTDF_TRUE;
FTDF_rxa[ i ].ebsn = frameHeader->SN;
break;
}
}
FTDF_rxa[ i ].timestamp = timestamp;
}
else
{
// find oldest entry and overwrite it
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_Time delta, greatestDelta = 0;
uint8_t entry = 0;
for (i = 0; i < FTDF_NR_OF_RX_ADDRS; i++)
{
delta = curTime - FTDF_rxa[ i ].timestamp;
if (delta > greatestDelta)
{
greatestDelta = delta;
entry = i;
}
}
FTDF_rxa[ entry ].addrMode = frameHeader->srcAddrMode;
FTDF_rxa[ entry ].addr = frameHeader->srcAddr;
switch (snSel)
{
case FTDF_SN_SEL_DSN:
FTDF_rxa[ entry ].bsnValid = FTDF_FALSE;
FTDF_rxa[ entry ].ebsnValid = FTDF_FALSE;
FTDF_rxa[ entry ].dsnValid = FTDF_TRUE;
FTDF_rxa[ entry ].dsn = frameHeader->SN;
break;
case FTDF_SN_SEL_BSN:
FTDF_rxa[ entry ].dsnValid = FTDF_FALSE;
FTDF_rxa[ entry ].ebsnValid = FTDF_FALSE;
FTDF_rxa[ entry ].bsnValid = FTDF_TRUE;
FTDF_rxa[ entry ].bsn = frameHeader->SN;
break;
case FTDF_SN_SEL_EBSN:
FTDF_rxa[ entry ].dsnValid = FTDF_FALSE;
FTDF_rxa[ entry ].bsnValid = FTDF_FALSE;
FTDF_rxa[ entry ].ebsnValid = FTDF_TRUE;
FTDF_rxa[ entry ].ebsn = frameHeader->SN;
break;
}
}
}
if (frameHeader->options & FTDF_OPT_SECURITY_ENABLED)
{
rxPtr = FTDF_getSecurityHeader(rxPtr, frameHeader->frameVersion, securityHeader);
}
else
{
securityHeader->securityLevel = 0;
securityHeader->keyIdMode = 0;
}
FTDF_IEList *headerIEList = NULL;
FTDF_IEList *payloadIEList = NULL;
int micLength = FTDF_getMicLength(securityHeader->securityLevel);
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (frameHeader->options & FTDF_OPT_IES_PRESENT)
{
rxPtr =
FTDF_getIes(rxPtr, rxBuffer + (frameLen - micLength - FTDF_FCS_LENGTH), &headerIEList, &payloadIEList);
}
#endif /* !FTDF_NO_CSL || !FTDF_NO_TSCH */
// Get start of private data (needed to unsecure a frame)
if (frameType == FTDF_MAC_COMMAND_FRAME)
{
frameHeader->commandFrameId = *rxPtr++;
}
else if (frameType == FTDF_BEACON_FRAME)
{
PANDescriptor.coordAddrMode = frameHeader->srcAddrMode;
PANDescriptor.coordPANId = frameHeader->srcPANId;
PANDescriptor.coordAddr = frameHeader->srcAddr;
PANDescriptor.channelNumber = ((FTDF_GET_FIELD(ON_OFF_REGMAP_PHYRXATTR) >> 4) & 0xf) + 11;
PANDescriptor.channelPage = 0;
PANDescriptor.timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP, readBuf);
PANDescriptor.linkQuality = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_QUALITY_INDICATOR, readBuf);
FTDF_Octet *superframeSpecPtr = (FTDF_Octet *) &PANDescriptor.superframeSpec;
*superframeSpecPtr++ = *rxPtr++;
*superframeSpecPtr = *rxPtr++;
uint8_t gtsSpec = *rxPtr++;
PANDescriptor.GTSPermit = (gtsSpec & 0x08) ? FTDF_TRUE : FTDF_FALSE;
uint8_t gtsDescrCount = gtsSpec & 0x7;
if (gtsDescrCount != 0)
{
// GTS is not supported, so just skip the GTS direction and GTS list fields if present
rxPtr += (1 + (3 * gtsDescrCount));
}
pendAddrSpec = *rxPtr++;
uint8_t nrOfShortAddrs = pendAddrSpec & 0x07;
uint8_t nrOfExtAddrs = (pendAddrSpec & 0x70) >> 4;
int n;
for (n = 0; n < (nrOfShortAddrs + nrOfExtAddrs); n++)
{
if (n < nrOfShortAddrs)
{
FTDF_Octet *shortAddressPtr = (FTDF_Octet *) &pendAddrList[ n ].shortAddress;
*shortAddressPtr++ = *rxBuffer++;
*shortAddressPtr = *rxBuffer++;
}
else
{
FTDF_Octet *extAddressPtr = (FTDF_Octet *) &pendAddrList[ n ].extAddress;
int m;
for (m = 0; m < 8; m++)
{
*extAddressPtr++ = *rxBuffer++;
}
}
}
}
else if (frameType == FTDF_ACKNOWLEDGEMENT_FRAME &&
securityHeader->securityLevel != 0)
{
if (FTDF_reqCurrent)
{
switch (FTDF_reqCurrent->msgId)
{
case FTDF_DATA_REQUEST:
{
FTDF_DataRequest *dataRequest = (FTDF_DataRequest *) FTDF_reqCurrent;
frameHeader->srcPANId = dataRequest->dstPANId;
frameHeader->srcAddrMode = dataRequest->dstAddrMode;
frameHeader->srcAddr = dataRequest->dstAddr;
break;
}
case FTDF_POLL_REQUEST:
{
FTDF_PollRequest *pollRequest = (FTDF_PollRequest *) FTDF_reqCurrent;
frameHeader->srcPANId = pollRequest->coordPANId;
frameHeader->srcAddrMode = pollRequest->coordAddrMode;
frameHeader->srcAddr = pollRequest->coordAddr;
break;
}
case FTDF_ASSOCIATE_REQUEST:
{
FTDF_AssociateRequest *associateRequest = (FTDF_AssociateRequest *) FTDF_reqCurrent;
frameHeader->srcPANId = associateRequest->coordPANId;
frameHeader->srcAddrMode = associateRequest->coordAddrMode;
frameHeader->srcAddr = associateRequest->coordAddr;
break;
}
case FTDF_DISASSOCIATE_REQUEST:
{
FTDF_DisassociateRequest *disassociateRequest =
(FTDF_DisassociateRequest *) FTDF_reqCurrent;
frameHeader->srcPANId = disassociateRequest->devicePANId;
frameHeader->srcAddrMode = disassociateRequest->deviceAddrMode;
frameHeader->srcAddr = disassociateRequest->deviceAddress;
break;
}
case FTDF_ASSOCIATE_RESPONSE:
{
FTDF_AssociateResponse *associateResponse = (FTDF_AssociateResponse *) FTDF_reqCurrent;
frameHeader->srcAddrMode = FTDF_EXTENDED_ADDRESS;
frameHeader->srcAddr.extAddress = associateResponse->deviceAddress;
break;
}
}
}
}
FTDF_Status status = FTDF_unsecureFrame(rxBuffer, rxPtr, frameHeader, securityHeader);
if (status != FTDF_SUCCESS)
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.securityFailureCount++;
}
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
// Since unsecure of acknowledgement frame is always successful,
// nothing special has to be done to get the address information correct.
FTDF_sendCommStatusIndication(FTDF_reqCurrent, status,
FTDF_pib.PANId,
frameHeader->srcAddrMode,
frameHeader->srcAddr,
frameHeader->dstAddrMode,
frameHeader->dstAddr,
securityHeader->securityLevel,
securityHeader->keyIdMode,
securityHeader->keySource,
securityHeader->keyIndex);
if (frameType == FTDF_ACKNOWLEDGEMENT_FRAME && FTDF_reqCurrent)
{
sendConfirm(FTDF_NO_ACK,
FTDF_reqCurrent->msgId);
FTDF_processNextRequest();
}
return;
}
if (FTDF_pib.metricsEnabled && frameType != FTDF_ACKNOWLEDGEMENT_FRAME)
{
FTDF_pib.performanceMetrics.RXSuccessCount++;
}
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled && frameType != FTDF_ACKNOWLEDGEMENT_FRAME)
{
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP, readBuf);
FTDF_correctSlotTime(timestamp);
}
#endif /* FTDF_NO_TSCH */
switch (frameType)
{
case FTDF_ACKNOWLEDGEMENT_FRAME:
if (FTDF_pib.metricsEnabled)
{
if (FTDF_nrOfRetries == 0)
{
FTDF_pib.performanceMetrics.TXSuccessCount++;
}
else if (FTDF_nrOfRetries == 1)
{
FTDF_pib.performanceMetrics.retryCount++;
}
else
{
FTDF_pib.performanceMetrics.multipleRetryCount++;
}
}
if (frameHeader->frameVersion == FTDF_FRAME_VERSION_E)
{
FTDF_pib.trafficCounters.rxEnhAckFrmOkCnt++;
}
break;
case FTDF_BEACON_FRAME:
FTDF_pib.trafficCounters.rxBeaconFrmOkCnt++;
break;
case FTDF_DATA_FRAME:
FTDF_pib.trafficCounters.rxDataFrmOkCnt++;
break;
case FTDF_MAC_COMMAND_FRAME:
FTDF_pib.trafficCounters.rxCmdFrmOkCnt++;
break;
case FTDF_MULTIPURPOSE_FRAME:
FTDF_pib.trafficCounters.rxMultiPurpFrmOkCnt++;
break;
}
if (frameType == FTDF_ACKNOWLEDGEMENT_FRAME)
{
volatile uint32_t *txFlagS = FTDF_GET_REG_ADDR_INDEXED(ON_OFF_REGMAP_TX_FLAG_S, FTDF_TX_DATA_BUFFER);
while (*txFlagS & MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_STAT)
{ }
// It is required to call FTDF_processTxEvent here because an RX ack generates two events
// The RX event is raised first, then after an IFS the TX event is raised. However,
// the FTDF_processNextRequest requires that both events have been handled.
FTDF_processTxEvent();
FTDF_SN SN = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_MACSN, FTDF_TX_DATA_BUFFER);
if (FTDF_reqCurrent &&
frameHeader->SN == SN)
{
#ifndef FTDF_NO_CSL
if (FTDF_pib.leEnabled == FTDF_TRUE)
{
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP,
readBuf);
FTDF_setPeerCslTiming(headerIEList, timestamp);
}
#endif /* FTDF_NO_CSL */
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled == FTDF_TRUE)
{
FTDF_correctSlotTimeFromAck(headerIEList);
FTDF_TschRetry *tschRetry = FTDF_getTschRetry(FTDF_getRequestAddress(FTDF_reqCurrent));
tschRetry->nrOfRetries = 0;
FTDF_tschSlotLink->request = NULL;
}
#endif /* FTDF_NO_TSCH */
switch (FTDF_reqCurrent->msgId)
{
case FTDF_DATA_REQUEST:
{
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_TXTIMESTAMP,
FTDF_TX_DATA_BUFFER);
FTDF_NumOfBackoffs numOfBackoffs = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_CSMACANRRETRIES,
FTDF_TX_DATA_BUFFER);
FTDF_sendDataConfirm((FTDF_DataRequest *)FTDF_reqCurrent,
FTDF_SUCCESS,
timestamp,
SN,
numOfBackoffs,
payloadIEList);
break;
}
case FTDF_POLL_REQUEST:
{
if (!(frameHeader->options & FTDF_OPT_FRAME_PENDING))
{
FTDF_sendPollConfirm((FTDF_PollRequest *)FTDF_reqCurrent, FTDF_NO_DATA);
}
break;
}
case FTDF_ASSOCIATE_REQUEST:
{
FTDF_AssocAdmin *assocAdmin = &FTDF_aa;
if (assocAdmin->fastA == FTDF_TRUE ||
assocAdmin->dataR == FTDF_FALSE)
{
uint32_t timestamp = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIME2THR,
(timestamp + FTDF_pib.responseWaitTime * FTDF_BASE_SUPERFRAME_DURATION));
}
else if (!(frameHeader->options & FTDF_OPT_FRAME_PENDING))
{
FTDF_sendAssociateConfirm((FTDF_AssociateRequest *)FTDF_reqCurrent,
FTDF_NO_DATA,
0xffff);
}
break;
}
case FTDF_ASSOCIATE_RESPONSE:
{
FTDF_AssociateResponse *assocResp = (FTDF_AssociateResponse *)FTDF_reqCurrent;
FTDF_Address srcAddr, dstAddr;
srcAddr.extAddress = FTDF_pib.extAddress;
dstAddr.extAddress = assocResp->deviceAddress;
FTDF_sendCommStatusIndication(FTDF_reqCurrent, FTDF_SUCCESS,
FTDF_pib.PANId,
FTDF_EXTENDED_ADDRESS,
srcAddr,
FTDF_EXTENDED_ADDRESS,
dstAddr,
assocResp->securityLevel,
assocResp->keyIdMode,
assocResp->keySource,
assocResp->keyIndex);
break;
}
case FTDF_ORPHAN_RESPONSE:
{
FTDF_OrphanResponse *orphanResp = (FTDF_OrphanResponse *)FTDF_reqCurrent;
FTDF_Address srcAddr, dstAddr;
srcAddr.extAddress = FTDF_pib.extAddress;
dstAddr.extAddress = orphanResp->orphanAddress;
FTDF_sendCommStatusIndication(FTDF_reqCurrent, FTDF_SUCCESS,
FTDF_pib.PANId,
FTDF_EXTENDED_ADDRESS,
srcAddr,
FTDF_EXTENDED_ADDRESS,
dstAddr,
orphanResp->securityLevel,
orphanResp->keyIdMode,
orphanResp->keySource,
orphanResp->keyIndex);
break;
}
case FTDF_DISASSOCIATE_REQUEST:
{
FTDF_sendDisassociateConfirm((FTDF_DisassociateRequest *)FTDF_reqCurrent, FTDF_SUCCESS);
break;
}
case FTDF_REMOTE_REQUEST:
{
FTDF_RemoteRequest *remoteRequest = (FTDF_RemoteRequest *) FTDF_reqCurrent;
if (remoteRequest->remoteId == FTDF_REMOTE_PAN_ID_CONFLICT_NOTIFICATION)
{
FTDF_sendSyncLossIndication(FTDF_PAN_ID_CONFLICT, securityHeader);
}
FTDF_reqCurrent = NULL;
break;
}
}
if (FTDF_reqCurrent->msgId != FTDF_DATA_REQUEST)
{
// for data request the application owns the memory
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
}
FTDF_processNextRequest();
}
else
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
}
}
else if ((frameHeader->frameVersion == FTDF_FRAME_VERSION_E || FTDF_pib.tschEnabled) &&
(frameHeader->options & FTDF_OPT_ACK_REQUESTED))
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
static FTDF_FrameHeader afh;
FTDF_FrameHeader *ackFrameHeader = &afh;
ackFrameHeader->frameType = FTDF_ACKNOWLEDGEMENT_FRAME;
ackFrameHeader->options =
(frameHeader->options &
(FTDF_OPT_SECURITY_ENABLED | FTDF_OPT_SEQ_NR_SUPPRESSED)) | FTDF_OPT_ENHANCED;
if (FTDF_pib.leEnabled == FTDF_TRUE ||
FTDF_pib.tschEnabled == FTDF_TRUE ||
FTDF_pib.EAckIEList.nrOfIEs != 0)
{
ackFrameHeader->options |= FTDF_OPT_IES_PRESENT;
}
ackFrameHeader->dstAddrMode = FTDF_NO_ADDRESS;
ackFrameHeader->srcAddrMode = FTDF_NO_ADDRESS;
ackFrameHeader->SN = frameHeader->SN;
FTDF_Octet *txPtr = (FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO) +
(FTDF_BUFFER_LENGTH * FTDF_TX_ACK_BUFFER);
// Skip PHY header (= MAC length)
txPtr++;
txPtr = FTDF_addFrameHeader(txPtr,
ackFrameHeader,
0);
if (frameHeader->options & FTDF_OPT_SECURITY_ENABLED)
{
securityHeader->frameCounter = FTDF_pib.frameCounter;
securityHeader->frameCounterMode = FTDF_pib.frameCounterMode;
txPtr = FTDF_addSecurityHeader(txPtr,
securityHeader);
}
#ifndef FTDF_NO_CSL
if (FTDF_pib.leEnabled == FTDF_TRUE)
{
static FTDF_Octet phaseAndPeriod[ 4 ];
static FTDF_IEDescriptor cslIE = { 0x1a, 4, { phaseAndPeriod } };
static FTDF_IEList cslIEList = { 1, &cslIE };
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_Time delta = curTime -
(FTDF_startCslSampleTime - FTDF_pib.CSLPeriod * 10);
*(FTDF_Period *)(phaseAndPeriod + 0) = (FTDF_Period)(delta / 10);
*(FTDF_Period *)(phaseAndPeriod + 2) = FTDF_pib.CSLPeriod;
txPtr = FTDF_addIes(txPtr,
&cslIEList,
&FTDF_pib.EAckIEList,
FTDF_FALSE);
}
#endif /* FTDF_NO_CSL */
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled == FTDF_TRUE)
{
FTDF_Time rxTimestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP, readBuf);
txPtr = FTDF_addCorrTimeIE(txPtr, rxTimestamp);
}
#endif /* FTDF_NO_TSCH */
if (!FTDF_pib.leEnabled && !FTDF_pib.tschEnabled)
{
txPtr = FTDF_addIes(txPtr,
NULL,
&FTDF_pib.EAckIEList,
FTDF_FALSE);
}
FTDF_sendAckFrame(frameHeader,
securityHeader,
txPtr);
#endif /* !FTDF_NO_CSL || !FTDF_NO_TSCH */
if (duplicate)
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
return;
}
}
if (frameType == FTDF_DATA_FRAME || frameType == FTDF_MULTIPURPOSE_FRAME)
{
FTDF_DataLength payloadLength = frameLen -
(rxPtr - rxBuffer) + 1 - micLength - FTDF_FCS_LENGTH;
if (FTDF_reqCurrent &&
FTDF_reqCurrent->msgId == FTDF_POLL_REQUEST)
{
FTDF_PollRequest *pollRequest = (FTDF_PollRequest *) FTDF_reqCurrent;
if (frameHeader->srcAddrMode == pollRequest->coordAddrMode &&
frameHeader->srcPANId == pollRequest->coordPANId &&
((frameHeader->srcAddrMode == FTDF_SHORT_ADDRESS &&
frameHeader->srcAddr.shortAddress == pollRequest->coordAddr.shortAddress) ||
(frameHeader->srcAddrMode == FTDF_EXTENDED_ADDRESS &&
frameHeader->srcAddr.extAddress == pollRequest->coordAddr.extAddress)))
{
if (payloadLength == 0)
{
FTDF_sendPollConfirm(pollRequest, FTDF_NO_DATA);
}
else
{
FTDF_sendPollConfirm(pollRequest, FTDF_SUCCESS);
}
}
}
else if (FTDF_reqCurrent &&
FTDF_reqCurrent->msgId == FTDF_ASSOCIATE_REQUEST &&
payloadLength == 0)
{
sendConfirm(FTDF_NO_DATA, FTDF_ASSOCIATE_REQUEST);
}
if (payloadLength != 0)
{
FTDF_LinkQuality mpduLinkQuality = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_QUALITY_INDICATOR,
readBuf);
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP,
readBuf);
FTDF_sendDataIndication(frameHeader,
securityHeader,
payloadIEList,
payloadLength,
rxPtr,
mpduLinkQuality,
timestamp);
}
#ifndef FTDF_NO_CSL
else if (headerIEList->nrOfIEs == 1 &&
headerIEList->IEs[ 0 ].ID == 0x1d)
{
FTDF_Period rzTime = *(uint16_t *) headerIEList->IEs[ 0 ].content.raw;
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_rzTime = curTime + (FTDF_Time) rzTime * 10 + 260; // 260 length of max frame in symbols
FTDF_Time CSLPeriod = FTDF_pib.CSLPeriod * 10;
FTDF_Time delta = FTDF_rzTime - FTDF_startCslSampleTime;
while (delta < 0x80000000) // A delta larger than 0x80000000 is assumed a negative delta
{
FTDF_startCslSampleTime += CSLPeriod;
delta = FTDF_rzTime - FTDF_startCslSampleTime;
}
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLSTARTSAMPLETIME, FTDF_startCslSampleTime);
FTDF_exitCritical();
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
}
#endif /* FTDF_NO_CSL */
else
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
}
}
else if (frameType == FTDF_MAC_COMMAND_FRAME)
{
FTDF_processCommandFrame(rxPtr, frameHeader, securityHeader, payloadIEList);
}
else if (frameType == FTDF_BEACON_FRAME)
{
FTDF_Octet *superframeSpecPtr = (FTDF_Octet *)&PANDescriptor.superframeSpec;
superframeSpecPtr++;
if (FTDF_isPANCoordinator)
{
if (frameHeader->srcPANId == FTDF_pib.PANId && (*superframeSpecPtr & 0x40))
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
FTDF_sendSyncLossIndication(FTDF_PAN_ID_CONFLICT, securityHeader);
return;
}
}
else if (FTDF_pib.associatedPANCoord)
{
if (frameHeader->srcPANId == FTDF_pib.PANId && (*superframeSpecPtr & 0x40) &&
((frameHeader->srcAddrMode == FTDF_SHORT_ADDRESS &&
frameHeader->srcAddr.shortAddress != FTDF_pib.coordShortAddress) ||
(frameHeader->srcAddrMode == FTDF_EXTENDED_ADDRESS &&
frameHeader->srcAddr.extAddress != FTDF_pib.coordExtAddress)))
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
FTDF_sendPANIdConflictNotification(frameHeader, securityHeader);
return;
}
}
FTDF_DataLength beaconPayloadLength = frameLen - (rxPtr - rxBuffer) + 1 - micLength - FTDF_FCS_LENGTH;
if (FTDF_pib.autoRequest == FTDF_FALSE ||
beaconPayloadLength != 0)
{
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_RX_TIMESTAMP,
readBuf);
FTDF_BeaconNotifyIndication *beaconNotifyIndication =
(FTDF_BeaconNotifyIndication *) FTDF_GET_MSG_BUFFER(
sizeof(FTDF_BeaconNotifyIndication));
beaconNotifyIndication->msgId = FTDF_BEACON_NOTIFY_INDICATION;
beaconNotifyIndication->BSN = frameHeader->SN;
beaconNotifyIndication->PANDescriptor = &PANDescriptor;
beaconNotifyIndication->pendAddrSpec = pendAddrSpec;
beaconNotifyIndication->addrList = pendAddrList;
beaconNotifyIndication->sduLength = beaconPayloadLength;
beaconNotifyIndication->sdu = FTDF_GET_DATA_BUFFER(beaconPayloadLength);
beaconNotifyIndication->EBSN = frameHeader->SN;
beaconNotifyIndication->beaconType =
frameHeader->frameVersion == FTDF_FRAME_VERSION_E ? FTDF_ENHANCED_BEACON : FTDF_NORMAL_BEACON;
beaconNotifyIndication->IEList = payloadIEList;
beaconNotifyIndication->timestamp = timestamp;
memcpy(beaconNotifyIndication->sdu, rxPtr, beaconPayloadLength);
FTDF_RCV_MSG((FTDF_MsgBuffer *) beaconNotifyIndication);
}
else if (FTDF_reqCurrent &&
FTDF_reqCurrent->msgId == FTDF_SCAN_REQUEST)
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
FTDF_addPANdescriptor(&PANDescriptor);
}
else
{
FTDF_REL_DATA_BUFFER((FTDF_Octet *)payloadIEList);
}
}
#if FTDF_USE_LPDP
#if FTDF_FP_BIT_TEST_MODE
if (FTDF_lpdpIsEnabled() && !FTDF_reqCurrent && frameType == FTDF_DATA_FRAME)
{
FTDF_processTxPending(frameHeader, securityHeader);
}
#else /* FTDF_FP_BIT_TEST_MODE */
if (!FTDF_reqCurrent && frameType == FTDF_DATA_FRAME)
{
FTDF_processTxPending(frameHeader, securityHeader);
}
#endif /* FTDF_FP_BIT_TEST_MODE */
#endif /* FTDF_USE_LPDP */
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled == FTDF_TRUE)
{
FTDF_scheduleTsch(NULL);
}
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
}
void FTDF_processRxEvent(void)
{
volatile uint32_t *rxEvent = (volatile uint32_t *) IND_R_FTDF_ON_OFF_REGMAP_RX_EVENT;
if (*rxEvent & MSK_F_FTDF_ON_OFF_REGMAP_RXSOF_E)
{
#ifdef SIMULATOR
*rxEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_RXSOF_E;
#else
*rxEvent = MSK_F_FTDF_ON_OFF_REGMAP_RXSOF_E;
#endif
}
if (*rxEvent & MSK_F_FTDF_ON_OFF_REGMAP_RXBYTE_E)
{
#ifdef SIMULATOR
*rxEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_RXBYTE_E;
#else
*rxEvent = MSK_F_FTDF_ON_OFF_REGMAP_RXBYTE_E;
#endif
}
if (*rxEvent & MSK_F_FTDF_ON_OFF_REGMAP_RX_OVERFLOW_E)
{
// No API defined to report this error to the higher layer, so just clear it.
#ifdef SIMULATOR
*rxEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_RX_OVERFLOW_E;
#else
*rxEvent = MSK_F_FTDF_ON_OFF_REGMAP_RX_OVERFLOW_E;
#endif
}
if (*rxEvent & MSK_F_FTDF_ON_OFF_REGMAP_RX_BUF_AVAIL_E)
{
int readBuf = FTDF_GET_FIELD(ON_OFF_REGMAP_RX_READ_BUF_PTR);
int writeBuf = FTDF_GET_FIELD(ON_OFF_REGMAP_RX_WRITE_BUF_PTR);
while (readBuf != writeBuf)
{
processRxFrame(readBuf % 8);
readBuf = (readBuf + 1) % 16;
}
FTDF_SET_FIELD(ON_OFF_REGMAP_RX_READ_BUF_PTR, readBuf);
#ifdef SIMULATOR
*rxEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_RX_BUF_AVAIL_E;
#else
*rxEvent = MSK_F_FTDF_ON_OFF_REGMAP_RX_BUF_AVAIL_E;
#endif
}
volatile uint32_t *lmacEvent = (volatile uint32_t *) IND_R_FTDF_ON_OFF_REGMAP_LMAC_EVENT;
if (*lmacEvent & MSK_F_FTDF_ON_OFF_REGMAP_EDSCANREADY_E)
{
#ifdef SIMULATOR
*lmacEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_EDSCANREADY_E;
#else
*lmacEvent = MSK_F_FTDF_ON_OFF_REGMAP_EDSCANREADY_E;
#endif
#ifndef FTDF_LITE
FTDF_MsgBuffer *request = FTDF_reqCurrent;
if (request->msgId == FTDF_SCAN_REQUEST)
{
FTDF_scanReady((FTDF_ScanRequest *) request);
}
#endif /* !FTDF_LITE */
}
if (*lmacEvent & MSK_F_FTDF_ON_OFF_REGMAP_RXTIMEREXPIRED_E)
{
#ifdef SIMULATOR
*lmacEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_RXTIMEREXPIRED_E;
#else
*lmacEvent = MSK_F_FTDF_ON_OFF_REGMAP_RXTIMEREXPIRED_E;
#endif
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.RxExpiredCount++;
}
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
FTDF_scheduleTsch(NULL);
}
else
#endif /* FTDF_NO_TSCH */
if (FTDF_reqCurrent)
{
FTDF_MsgId msgId = FTDF_reqCurrent->msgId;
if (msgId == FTDF_POLL_REQUEST)
{
FTDF_sendPollConfirm((FTDF_PollRequest *)FTDF_reqCurrent, FTDF_NO_DATA);
}
else if (msgId == FTDF_SCAN_REQUEST)
{
FTDF_scanReady((FTDF_ScanRequest *) FTDF_reqCurrent);
}
else if (msgId == FTDF_ASSOCIATE_REQUEST)
{
FTDF_sendAssociateConfirm((FTDF_AssociateRequest *)FTDF_reqCurrent,
FTDF_NO_DATA,
0xffff);
}
}
#endif /* !FTDF_LITE */
}
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
if (*lmacEvent & MSK_F_FTDF_ON_OFF_REGMAP_CSMA_CA_BO_THR_E)
{
#ifdef SIMULATOR
*lmacEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_CSMA_CA_BO_THR_E;
#else
*lmacEvent = MSK_F_FTDF_ON_OFF_REGMAP_CSMA_CA_BO_THR_E;
#endif
#if FTDF_USE_SLEEP_DURING_BACKOFF
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.BOIrqCount++;
}
FTDF_sdbFsmBackoffIRQ();
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
}
#endif
}
static void sendConfirm(FTDF_Status status,
FTDF_MsgId msgId)
{
switch (msgId)
{
#ifndef FTDF_LITE
case FTDF_DATA_REQUEST:
{
FTDF_DataRequest *dataRequest = (FTDF_DataRequest *) FTDF_reqCurrent;
FTDF_Time timestamp = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_TXTIMESTAMP,
FTDF_TX_DATA_BUFFER);
FTDF_SN SN = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_MACSN, FTDF_TX_DATA_BUFFER);
FTDF_NumOfBackoffs numOfBackoffs = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_CSMACANRRETRIES,
FTDF_TX_DATA_BUFFER);
FTDF_sendDataConfirm(dataRequest, status,
timestamp,
SN,
numOfBackoffs,
NULL);
break;
}
case FTDF_POLL_REQUEST:
if (status != FTDF_SUCCESS)
{
FTDF_sendPollConfirm((FTDF_PollRequest *)FTDF_reqCurrent, status);
}
break;
case FTDF_ASSOCIATE_REQUEST:
if (status != FTDF_SUCCESS)
{
FTDF_sendAssociateConfirm((FTDF_AssociateRequest *)FTDF_reqCurrent,
status,
0xffff);
}
break;
case FTDF_ASSOCIATE_RESPONSE:
if (status != FTDF_SUCCESS)
{
FTDF_AssociateResponse *assocResp = (FTDF_AssociateResponse *)FTDF_reqCurrent;
FTDF_Address srcAddr, dstAddr;
srcAddr.extAddress = FTDF_pib.extAddress;
dstAddr.extAddress = assocResp->deviceAddress;
FTDF_sendCommStatusIndication(FTDF_reqCurrent, status,
FTDF_pib.PANId,
FTDF_EXTENDED_ADDRESS,
srcAddr,
FTDF_EXTENDED_ADDRESS,
dstAddr,
assocResp->securityLevel,
assocResp->keyIdMode,
assocResp->keySource,
assocResp->keyIndex);
}
break;
case FTDF_ORPHAN_RESPONSE:
if (status != FTDF_SUCCESS)
{
FTDF_OrphanResponse *orphanResp = (FTDF_OrphanResponse *)FTDF_reqCurrent;
FTDF_Address srcAddr, dstAddr;
srcAddr.extAddress = FTDF_pib.extAddress;
dstAddr.extAddress = orphanResp->orphanAddress;
FTDF_sendCommStatusIndication(FTDF_reqCurrent, status,
FTDF_pib.PANId,
FTDF_EXTENDED_ADDRESS,
srcAddr,
FTDF_EXTENDED_ADDRESS,
dstAddr,
orphanResp->securityLevel,
orphanResp->keyIdMode,
orphanResp->keySource,
orphanResp->keyIndex);
}
break;
case FTDF_DISASSOCIATE_REQUEST:
if (status != FTDF_SUCCESS)
{
FTDF_sendDisassociateConfirm((FTDF_DisassociateRequest *)FTDF_reqCurrent, status);
}
break;
case FTDF_SCAN_REQUEST:
if (status != FTDF_SUCCESS)
{
FTDF_sendScanConfirm((FTDF_ScanRequest *)FTDF_reqCurrent, status);
}
break;
case FTDF_BEACON_REQUEST:
FTDF_sendBeaconConfirm((FTDF_BeaconRequest *)FTDF_reqCurrent, status);
break;
case FTDF_REMOTE_REQUEST:
FTDF_reqCurrent = NULL;
break;
#endif /* !FTDF_LITE */
case FTDF_TRANSPARENT_REQUEST:
{
#ifndef FTDF_PHY_API
FTDF_TransparentRequest *transparentRequest = (FTDF_TransparentRequest *) FTDF_reqCurrent;
#endif
FTDF_Bitmap32 transparentStatus = 0;
switch (status)
{
case FTDF_SUCCESS:
transparentStatus = FTDF_TRANSPARENT_SEND_SUCCESSFUL;
break;
case FTDF_CHANNEL_ACCESS_FAILURE:
transparentStatus = FTDF_TRANSPARENT_CSMACA_FAILURE;
break;
#if FTDF_TRANSPARENT_WAIT_FOR_ACK
case FTDF_NO_ACK:
transparentStatus = FTDF_TRANSPARENT_NO_ACK;
break;
#endif
}
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.TXSuccessCount++;
}
#ifdef FTDF_PHY_API
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_txInProgress = FTDF_FALSE;
FTDF_exitCritical();
FTDF_SEND_FRAME_TRANSPARENT_CONFIRM(NULL, transparentStatus);
#else
FTDF_reqCurrent = NULL;
FTDF_SEND_FRAME_TRANSPARENT_CONFIRM(transparentRequest->handle,
transparentStatus);
FTDF_REL_MSG_BUFFER((FTDF_MsgBuffer *) transparentRequest);
#ifndef FTDF_LITE
FTDF_processNextRequest();
#endif /* !FTDF_LITE */
#endif /* FTDF_PHY_API */
break;
}
}
}
void FTDF_processTxEvent(void)
{
volatile uint32_t *txFlagStatE;
FTDF_Status status = FTDF_SUCCESS;
#if FTDF_USE_PTI && !FTDF_USE_AUTO_PTI
/* Restore Rx PTI in case the Tx transaction that just ended interrupted an Rx-always-on
* transaction. */
hw_coex_pti_t tx_pti;
hw_coex_update_ftdf_pti(FTDF_getRxPti(), &tx_pti, true);
#endif
txFlagStatE = FTDF_GET_FIELD_ADDR_INDEXED(ON_OFF_REGMAP_TX_FLAG_CLEAR_E, FTDF_TX_WAKEUP_BUFFER);
if (*txFlagStatE & MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_E)
{
#ifdef SIMULATOR
*txFlagStatE &= ~MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_E;
#else
*txFlagStatE = MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_E;
#endif
volatile uint32_t *txStatus =
FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_RETURN_STATUS_1, FTDF_TX_WAKEUP_BUFFER);
if (*txStatus & MSK_F_FTDF_RETENTION_RAM_CSMACAFAIL)
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.TXFailCount++;
}
status = FTDF_CHANNEL_ACCESS_FAILURE;
}
}
txFlagStatE = FTDF_GET_FIELD_ADDR_INDEXED(ON_OFF_REGMAP_TX_FLAG_CLEAR_E, FTDF_TX_DATA_BUFFER);
if (*txFlagStatE & MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_E)
{
#ifdef SIMULATOR
*txFlagStatE &= ~MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_E;
#else
*txFlagStatE = MSK_F_FTDF_ON_OFF_REGMAP_TX_FLAG_CLEAR_E;
#endif
}
else
{
return;
}
#ifndef FTDF_PHY_API
FTDF_txInProgress = FTDF_FALSE;
if (FTDF_reqCurrent == NULL)
{
return;
}
#else
FTDF_criticalVar();
FTDF_enterCritical();
if (FTDF_txInProgress == FTDF_FALSE)
{
FTDF_exitCritical();
return;
}
FTDF_exitCritical();
#endif
#if FTDF_USE_SLEEP_DURING_BACKOFF
FTDF_sdbFsmTxIRQ();
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
FTDF_Boolean ackTX = FTDF_GET_FIELD_INDEXED(RETENTION_RAM_ACKREQUEST, FTDF_TX_DATA_BUFFER);
if (status == FTDF_SUCCESS)
{
volatile uint32_t *txMeta = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0, FTDF_TX_DATA_BUFFER);
FTDF_FrameType frameType =
(*txMeta & MSK_F_FTDF_RETENTION_RAM_FRAMETYPE) >> OFF_F_FTDF_RETENTION_RAM_FRAMETYPE;
switch (frameType)
{
case FTDF_BEACON_FRAME:
FTDF_pib.trafficCounters.txBeaconFrmCnt++;
break;
case FTDF_DATA_FRAME:
FTDF_pib.trafficCounters.txDataFrmCnt++;
break;
case FTDF_MAC_COMMAND_FRAME:
FTDF_pib.trafficCounters.txCmdFrmCnt++;
break;
case FTDF_MULTIPURPOSE_FRAME:
FTDF_pib.trafficCounters.txMultiPurpFrmCnt++;
break;
}
volatile uint32_t *txStatus =
FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_RETURN_STATUS_1, FTDF_TX_DATA_BUFFER);
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
FTDF_TschRetry *tschRetry = NULL;
if (FTDF_pib.tschEnabled)
{
tschRetry = FTDF_getTschRetry(FTDF_getRequestAddress(FTDF_reqCurrent));
}
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
if (*txStatus & MSK_F_FTDF_RETENTION_RAM_ACKFAIL)
{
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
tschRetry->nrOfRetries++;
FTDF_tschSlotLink->request = NULL;
status = FTDF_scheduleTsch(FTDF_reqCurrent);
if (status == FTDF_SUCCESS)
{
// If FTDF_reqCurrent is not equal to NULL the retried request will be queued
// rather then send again
FTDF_reqCurrent = NULL;
}
}
else
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
if (FTDF_nrOfRetries < FTDF_pib.maxFrameRetries)
{
FTDF_nrOfRetries++;
#ifndef FTDF_LITE
#ifndef FTDF_NO_CSL
if (FTDF_pib.leEnabled)
{
FTDF_setPeerCslTiming(NULL, 0);
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_txInProgress = FTDF_TRUE;
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLSTARTSAMPLETIME, curTime + 5);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACWUPERIOD, FTDF_pib.CSLMaxPeriod);
volatile uint32_t *txFlagSet = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_SET);
*txFlagSet |= ((1 << FTDF_TX_DATA_BUFFER) | (1 << FTDF_TX_WAKEUP_BUFFER));
FTDF_exitCritical();
}
else
#endif /* FTDF_NO_CSL */
#endif /* !FTDF_LITE */
{
#if FTDF_USE_PTI && !FTDF_USE_AUTO_PTI
hw_coex_update_ftdf_pti(tx_pti, NULL, true);
#endif
volatile uint32_t *txFlagSet = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_SET);
*txFlagSet |= (1 << FTDF_TX_DATA_BUFFER);
}
return;
}
else
{
if (FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.TXFailCount++;
}
status = FTDF_NO_ACK;
}
}
else if (*txStatus & MSK_F_FTDF_RETENTION_RAM_CSMACAFAIL)
{
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
tschRetry->nrOfCcaRetries++;
if (tschRetry->nrOfCcaRetries < FTDF_pib.maxCSMABackoffs)
{
FTDF_tschSlotLink->request = NULL;
status = FTDF_scheduleTsch(FTDF_reqCurrent);
if (status == FTDF_SUCCESS)
{
// If FTDF_reqCurrent is not equal to NULL the retried request will be queued
// rather then send again
FTDF_reqCurrent = NULL;
}
}
else
{
status = FTDF_CHANNEL_ACCESS_FAILURE;
}
}
else
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
{
status = FTDF_CHANNEL_ACCESS_FAILURE;
}
if (FTDF_pib.metricsEnabled && status != FTDF_SUCCESS)
{
FTDF_pib.performanceMetrics.TXFailCount++;
}
}
else
{
if (ackTX == FTDF_FALSE && FTDF_pib.metricsEnabled)
{
FTDF_pib.performanceMetrics.TXSuccessCount++;
}
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
tschRetry->nrOfCcaRetries = 0;
}
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
}
}
#ifndef FTDF_PHY_API
if ((ackTX == FTDF_FALSE || status != FTDF_SUCCESS) && FTDF_reqCurrent)
{
sendConfirm(status,
FTDF_reqCurrent->msgId);
#ifndef FTDF_LITE
FTDF_processNextRequest();
#endif /* !FTDF_LITE */
}
#else
if (FTDF_txInProgress)
{
sendConfirm(status, FTDF_TRANSPARENT_REQUEST);
}
#endif
}
void FTDF_processSymbolTimerEvent(void)
{
volatile uint32_t *symbolTimeThrEvent = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_SYMBOLTIMETHR_E);
#ifdef FTDF_PHY_API
volatile uint32_t *lmacReady4sleepEvent = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_LMACREADY4SLEEP_D);
if (*lmacReady4sleepEvent & MSK_F_FTDF_ON_OFF_REGMAP_LMACREADY4SLEEP_D)
{
*lmacReady4sleepEvent = MSK_F_FTDF_ON_OFF_REGMAP_LMACREADY4SLEEP_D;
/* If lmac ready 4 sleep, call respective callback, after disabling the interrupt */
if (FTDF_GET_FIELD(ON_OFF_REGMAP_LMACREADY4SLEEP) == 1)
{
volatile uint32_t *lmacCtrlMask = FTDF_GET_REG_ADDR(ON_OFF_REGMAP_LMAC_CONTROL_MASK);
*lmacCtrlMask &= ~MSK_F_FTDF_ON_OFF_REGMAP_LMACREADY4SLEEP_M;
FTDF_LMACREADY4SLEEP_CB(FTDF_TRUE, 0);
}
}
#endif
// sync timestamp event
if (*symbolTimeThrEvent & MSK_F_FTDF_ON_OFF_REGMAP_SYNCTIMESTAMP_E)
{
#ifdef SIMULATOR
*symbolTimeThrEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_SYNCTIMESTAMP_E;
#else
*symbolTimeThrEvent = MSK_F_FTDF_ON_OFF_REGMAP_SYNCTIMESTAMP_E;
#endif
FTDF_SET_FIELD(ON_OFF_REGMAP_SYNCTIMESTAMPENA, 0);
#ifndef FTDF_LITE
#ifndef FTDF_NO_CSL
FTDF_oldLeEnabled = FTDF_FALSE;
if (FTDF_wakeUpEnableLe)
{
FTDF_pib.leEnabled = FTDF_TRUE;
FTDF_setLeEnabled();
FTDF_wakeUpEnableLe = FTDF_FALSE;
}
#endif /* FTDF_NO_CSL */
#ifndef FTDF_NO_TSCH
if (FTDF_wakeUpEnableTsch)
{
FTDF_setTschEnabled();
}
#endif /* FTDF_NO_TSCH */
FTDF_restoreTxPendingTimer();
#endif /* !FTDF_LITE */
FTDF_WAKE_UP_READY();
}
// miscellaneous event
// - Non-TSCH mode: association timer
// - TSCH mode: next active link timer
if (*symbolTimeThrEvent & MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIME2THR_E)
{
#ifdef SIMULATOR
*symbolTimeThrEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIME2THR_E;
#else
*symbolTimeThrEvent = MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIME2THR_E;
#endif
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
FTDF_tschProcessRequest();
}
else
#endif /* FTDF_NO_TSCH */
if (FTDF_reqCurrent &&
FTDF_reqCurrent->msgId == FTDF_ASSOCIATE_REQUEST)
{
FTDF_AssocAdmin *assocAdmin = &FTDF_aa;
// macResponseWaitTime expired
assocAdmin->dataR = FTDF_TRUE;
FTDF_sendAssociateDataRequest();
}
#endif /* !FTDF_LITE */
}
// pending queue symbol timer event
if (*symbolTimeThrEvent & MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIMETHR_E)
{
#ifdef SIMULATOR
*symbolTimeThrEvent &= ~MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIMETHR_E;
#else
*symbolTimeThrEvent = MSK_F_FTDF_ON_OFF_REGMAP_SYMBOLTIMETHR_E;
#endif
#ifndef FTDF_LITE
FTDF_removeTxPendingTimer(NULL);
#endif /* !FTDF_LITE */
}
}
#ifndef FTDF_LITE
FTDF_Status FTDF_sendFrame(FTDF_ChannelNumber channel,
FTDF_FrameHeader *frameHeader,
FTDF_SecurityHeader *securityHeader,
FTDF_Octet *txPtr,
FTDF_DataLength payloadSize,
FTDF_Octet *payload)
{
FTDF_Octet *txBufPtr = (FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO);
FTDF_DataLength micLength = FTDF_getMicLength(securityHeader->securityLevel);
FTDF_DataLength phyPayloadSize = (txPtr - txBufPtr) - 1 + payloadSize + micLength + FTDF_FCS_LENGTH;
if (phyPayloadSize > (FTDF_BUFFER_LENGTH - 1))
{
return FTDF_FRAME_TOO_LONG;
}
*txBufPtr = phyPayloadSize;
FTDF_Octet *privPtr = txPtr;
int n;
for (n = 0; n < payloadSize; n++)
{
*txPtr++ = *payload++;
}
FTDF_Status status = FTDF_secureFrame(txBufPtr,
privPtr,
frameHeader,
securityHeader);
if (status != FTDF_SUCCESS)
{
return status;
}
FTDF_Bitmap8 options = frameHeader->options;
volatile uint32_t *metaData0 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0, FTDF_TX_DATA_BUFFER);
volatile uint32_t *metaData1 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_1, FTDF_TX_DATA_BUFFER);
uint16_t phyAttr = (FTDF_pib.CCAMode & 0x3) | 0x08 | ((channel - 11) & 0x0F) << 4 |
(FTDF_pib.TXPower & 0x07) << 12;
metaData0 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0, FTDF_TX_DATA_BUFFER);
metaData1 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_1, FTDF_TX_DATA_BUFFER);
*metaData0 =
((phyPayloadSize << OFF_F_FTDF_RETENTION_RAM_FRAME_LENGTH) & MSK_F_FTDF_RETENTION_RAM_FRAME_LENGTH) |
((phyAttr << OFF_F_FTDF_RETENTION_RAM_PHYATTR) & MSK_F_FTDF_RETENTION_RAM_PHYATTR) |
((frameHeader->frameType << OFF_F_FTDF_RETENTION_RAM_FRAMETYPE) & MSK_F_FTDF_RETENTION_RAM_FRAMETYPE) |
MSK_F_FTDF_RETENTION_RAM_CSMACA_ENA |
((options & FTDF_OPT_ACK_REQUESTED) ? MSK_F_FTDF_RETENTION_RAM_ACKREQUEST : 0) |
MSK_F_FTDF_RETENTION_RAM_CRC16_ENA;
*metaData1 =
((frameHeader->SN << OFF_F_FTDF_RETENTION_RAM_MACSN) & MSK_F_FTDF_RETENTION_RAM_MACSN);
uint32_t phyCsmaCaAttr = (FTDF_pib.CCAMode & 0x3) | ((channel - 11) & 0xf) << 4 |
(FTDF_pib.TXPower & 0x07) << 12;
FTDF_SET_FIELD(ON_OFF_REGMAP_PHYCSMACAATTR, phyCsmaCaAttr);
#ifndef FTDF_NO_CSL
if (FTDF_pib.leEnabled == FTDF_TRUE)
{
if (frameHeader->dstAddrMode != FTDF_SHORT_ADDRESS)
{
return FTDF_NO_SHORT_ADDRESS;
}
// Clear CSMACA of data frame buffer
*metaData0 &= ~MSK_F_FTDF_RETENTION_RAM_CSMACA_ENA;
txPtr = txBufPtr = ((FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO)) +
(FTDF_BUFFER_LENGTH * FTDF_TX_WAKEUP_BUFFER);
*txPtr++ = 0x0d;
*txPtr++ = 0x2d;
*txPtr++ = 0x81;
*txPtr++ = frameHeader->SN;
*(FTDF_PANId *) txPtr = frameHeader->dstPANId;
txPtr += 2;
*(FTDF_ShortAddress *) txPtr = frameHeader->dstAddr.shortAddress;
txPtr += 2;
*txPtr++ = 0x82;
*txPtr++ = 0x0e;
metaData0 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0, FTDF_TX_WAKEUP_BUFFER);
metaData1 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_1, FTDF_TX_WAKEUP_BUFFER);
volatile uint32_t *txPriority =
FTDF_GET_REG_ADDR_INDEXED(ON_OFF_REGMAP_TX_PRIORITY, FTDF_TX_WAKEUP_BUFFER);
*metaData0 =
((0x0d << OFF_F_FTDF_RETENTION_RAM_FRAME_LENGTH) & MSK_F_FTDF_RETENTION_RAM_FRAME_LENGTH) |
((phyAttr << OFF_F_FTDF_RETENTION_RAM_PHYATTR) & MSK_F_FTDF_RETENTION_RAM_PHYATTR) |
((FTDF_MULTIPURPOSE_FRAME << OFF_F_FTDF_RETENTION_RAM_FRAMETYPE) & MSK_F_FTDF_RETENTION_RAM_FRAMETYPE) |
MSK_F_FTDF_RETENTION_RAM_CSMACA_ENA |
MSK_F_FTDF_RETENTION_RAM_CRC16_ENA;
*metaData1 =
((frameHeader->SN << OFF_F_FTDF_RETENTION_RAM_MACSN) & MSK_F_FTDF_RETENTION_RAM_MACSN);
#if FTDF_USE_PTI && FTDF_USE_AUTO_PTI
*txPriority |= MSK_F_FTDF_ON_OFF_REGMAP_ISWAKEUP;
#else
*txPriority = MSK_F_FTDF_ON_OFF_REGMAP_ISWAKEUP;
#endif
}
#endif /* FTDF_NO_CSL */
volatile uint32_t *txFlagSet = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_SET);
#ifndef FTDF_NO_CSL
if (FTDF_pib.leEnabled == FTDF_TRUE)
{
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_Time delta = curTime - FTDF_rzTime;
if (delta > 0x80000000)
{
// Receiving an wakeup frame sequence, delay sending until RZ has passed.
FTDF_sendFramePending = frameHeader->dstAddr.shortAddress;
}
else
{
FTDF_Time wakeupStartTime;
FTDF_Period wakeupPeriod;
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_getWakeupParams(frameHeader->dstAddr.shortAddress, &wakeupStartTime, &wakeupPeriod);
FTDF_txInProgress = FTDF_TRUE;
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLSTARTSAMPLETIME, wakeupStartTime);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACWUPERIOD, wakeupPeriod);
*txFlagSet |= ((1 << FTDF_TX_DATA_BUFFER) | (1 << FTDF_TX_WAKEUP_BUFFER));
FTDF_exitCritical();
}
}
else
#endif /* FTDF_NO_CSL */
if (!FTDF_pib.tschEnabled)
{
*txFlagSet |= (1 << FTDF_TX_DATA_BUFFER);
// SetWord16(P2_SET_DATA_REG, (1 << 3));
// SetWord16(P23_MODE_REG, 0x300); // SW trigger - output
// for (volatile int k = 0; k < 100; k++) {
// }
// SetWord16(P23_MODE_REG, 0x000);// SW trigger - high Z
}
return FTDF_SUCCESS;
}
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
FTDF_Status FTDF_sendAckFrame(FTDF_FrameHeader *frameHeader,
FTDF_SecurityHeader *securityHeader,
FTDF_Octet *txPtr)
{
FTDF_Octet *txBufPtr = ((FTDF_Octet *) FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO)) +
2 * FTDF_BUFFER_LENGTH;
FTDF_DataLength micLength = FTDF_getMicLength(securityHeader->securityLevel);
FTDF_DataLength phyPayloadSize = (txPtr - txBufPtr) - 1 + micLength + FTDF_FCS_LENGTH;
*txBufPtr = phyPayloadSize;
FTDF_Status status = FTDF_secureFrame(txBufPtr,
txPtr,
frameHeader,
securityHeader);
if (status != FTDF_SUCCESS)
{
return status;
}
volatile uint32_t *metaData0 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0, FTDF_TX_ACK_BUFFER);
volatile uint32_t *metaData1 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_1, FTDF_TX_ACK_BUFFER);
volatile uint32_t *txPriority = FTDF_GET_REG_ADDR_INDEXED(ON_OFF_REGMAP_TX_PRIORITY, FTDF_TX_ACK_BUFFER);
uint16_t phyAttr =
(FTDF_pib.CCAMode & 0x3) | 0x08 | (FTDF_GET_FIELD(ON_OFF_REGMAP_PHYRXATTR) & 0x00f0) |
(FTDF_pib.TXPower & 0x07) << 12;
*metaData0 =
((phyPayloadSize << OFF_F_FTDF_RETENTION_RAM_FRAME_LENGTH) & MSK_F_FTDF_RETENTION_RAM_FRAME_LENGTH) |
((phyAttr << OFF_F_FTDF_RETENTION_RAM_PHYATTR) & MSK_F_FTDF_RETENTION_RAM_PHYATTR) |
((FTDF_ACKNOWLEDGEMENT_FRAME << OFF_F_FTDF_RETENTION_RAM_FRAMETYPE) & MSK_F_FTDF_RETENTION_RAM_FRAMETYPE) |
MSK_F_FTDF_RETENTION_RAM_CRC16_ENA;
*metaData1 =
((frameHeader->SN << OFF_F_FTDF_RETENTION_RAM_MACSN) & MSK_F_FTDF_RETENTION_RAM_MACSN);
#if FTDF_USE_PTI && FTDF_USE_AUTO_PTI
*txPriority |= 1;
#else
*txPriority = 1;
#endif
volatile uint32_t *txFlagSet = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_SET);
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_Period txAckDelayVal = FTDF_GET_FIELD(ON_OFF_REGMAP_MACTSTXACKDELAYVAL);
if (txAckDelayVal > 20)
{
*txFlagSet |= 1 << FTDF_TX_ACK_BUFFER;
}
FTDF_exitCritical();
}
else
#endif /* FTDF_NO_TSCH */
{
*txFlagSet |= 1 << FTDF_TX_ACK_BUFFER;
}
FTDF_pib.trafficCounters.txEnhAckFrmCnt++;
return FTDF_SUCCESS;
}
#endif /* !FTDF_NO_CSL || !FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
void FTDF_sendTransparentFrame(FTDF_DataLength frameLength,
FTDF_Octet *frame,
FTDF_ChannelNumber channel,
FTDF_PTI pti,
FTDF_Boolean cmsaSuppress)
{
volatile uint32_t *metaData0 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0, FTDF_TX_DATA_BUFFER);
volatile uint32_t *metaData1 = FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_1, FTDF_TX_DATA_BUFFER);
volatile uint32_t *txPriority = FTDF_GET_REG_ADDR_INDEXED(ON_OFF_REGMAP_TX_PRIORITY, FTDF_TX_DATA_BUFFER);
#if FTDF_TRANSPARENT_USE_WAIT_FOR_ACK
FTDF_Boolean useAck = FTDF_FALSE;
//FTDF_FrameHeader* frameHeader = &FTDF_fh;
FTDF_FrameHeader frameHeader;
FTDF_SN SN;
#endif
uint16_t phyAttr = (FTDF_pib.CCAMode & 0x3) | 0x08 | ((channel - 11) & 0x0F) << 4 |
(FTDF_pib.TXPower & 0x07) << 12;
#if FTDF_TRANSPARENT_USE_WAIT_FOR_ACK
if (FTDF_transparentModeOptions & FTDF_TRANSPARENT_WAIT_FOR_ACK)
{
FTDF_getFrameHeader(frame, &frameHeader);
if (frameHeader.options & FTDF_OPT_ACK_REQUESTED)
{
useAck = FTDF_TRUE;
}
SN = frameHeader.SN;
}
#endif
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
*txPriority = ((pti << OFF_F_FTDF_ON_OFF_REGMAP_PTI_TX) &
MSK_F_FTDF_ON_OFF_REGMAP_PTI_TX) | 1;
#endif
*metaData0 =
((frameLength << OFF_F_FTDF_RETENTION_RAM_FRAME_LENGTH) & MSK_F_FTDF_RETENTION_RAM_FRAME_LENGTH) |
((phyAttr << OFF_F_FTDF_RETENTION_RAM_PHYATTR) & MSK_F_FTDF_RETENTION_RAM_PHYATTR) |
(((*frame & 0x7) << OFF_F_FTDF_RETENTION_RAM_FRAMETYPE) & MSK_F_FTDF_RETENTION_RAM_FRAMETYPE) |
((cmsaSuppress) ? 0 : MSK_F_FTDF_RETENTION_RAM_CSMACA_ENA) |
#if FTDF_TRANSPARENT_USE_WAIT_FOR_ACK
((useAck) ? MSK_F_FTDF_RETENTION_RAM_ACKREQUEST : 0) |
#endif
((FTDF_transparentModeOptions &
FTDF_TRANSPARENT_ENABLE_FCS_GENERATION) ? MSK_F_FTDF_RETENTION_RAM_CRC16_ENA : 0);
#if FTDF_TRANSPARENT_USE_WAIT_FOR_ACK
if (useAck)
{
*metaData1 = ((SN << OFF_F_FTDF_RETENTION_RAM_MACSN) & MSK_F_FTDF_RETENTION_RAM_MACSN);
}
else
{
*metaData1 = ((0 << OFF_F_FTDF_RETENTION_RAM_MACSN) & MSK_F_FTDF_RETENTION_RAM_MACSN);
}
#else
*metaData1 =
((0 << OFF_F_FTDF_RETENTION_RAM_MACSN) & MSK_F_FTDF_RETENTION_RAM_MACSN);
#endif
uint32_t phyCsmaCaAttr = (FTDF_pib.CCAMode & 0x3) | ((channel - 11) & 0xf) << 4 |
(FTDF_pib.TXPower & 0x07) << 12;
FTDF_SET_FIELD(ON_OFF_REGMAP_PHYCSMACAATTR, phyCsmaCaAttr);
#if FTDF_USE_PTI && !FTDF_USE_AUTO_PTI
hw_coex_update_ftdf_pti((hw_coex_pti_t) pti, NULL, true);
#else
// FTDF_SET_FIELD(ON_OFF_REGMAP_PTI_TX, pti);
#endif
volatile uint32_t *txFlagSet = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_SET);
*txFlagSet |= (1 << FTDF_TX_DATA_BUFFER);
}
void FTDF_initQueues(void)
{
#ifndef FTDF_LITE
FTDF_initQueue(&FTDF_freeQueue);
FTDF_initQueue(&FTDF_reqQueue);
int n;
for (n = 0; n < FTDF_NR_OF_REQ_BUFFERS; n++)
{
FTDF_queueBufferHead(&FTDF_reqBuffers[ n ], &FTDF_freeQueue);
FTDF_txPendingList[ n ].addr.extAddress = 0xFFFFFFFFFFFFFFFFLL;
FTDF_txPendingList[ n ].addrMode = FTDF_NO_ADDRESS;
FTDF_txPendingList[ n ].PANId = 0xFFFF;
FTDF_initQueue(&FTDF_txPendingList[ n ].queue);
FTDF_txPendingTimerList[ n ].free = FTDF_TRUE;
FTDF_txPendingTimerList[ n ].next = NULL;
}
FTDF_txPendingTimerHead = FTDF_txPendingTimerList;
FTDF_txPendingTimerTime = 0;
#endif /* !FTDF_LITE */
#ifndef FTDF_PHY_API
FTDF_reqCurrent = NULL;
#endif
}
#ifndef FTDF_LITE
void FTDF_initQueue(FTDF_Queue *queue)
{
queue->head.next = (FTDF_Buffer *) &queue->tail;
queue->head.prev = NULL;
queue->tail.next = NULL;
queue->tail.prev = (FTDF_Buffer *) &queue->head;
}
void FTDF_queueBufferHead(FTDF_Buffer *buffer, FTDF_Queue *queue)
{
FTDF_Buffer *next = queue->head.next;
queue->head.next = buffer;
next->header.prev = buffer;
buffer->header.next = next;
buffer->header.prev = (FTDF_Buffer *) &queue->head;
}
FTDF_Buffer *FTDF_dequeueBufferTail(FTDF_Queue *queue)
{
FTDF_Buffer *buffer = queue->tail.prev;
if (buffer->header.prev == NULL)
{
return NULL;
}
queue->tail.prev = buffer->header.prev;
buffer->header.prev->header.next = (FTDF_Buffer *) &queue->tail;
return buffer;
}
FTDF_Status FTDF_queueReqHead(FTDF_MsgBuffer *request, FTDF_Queue *queue)
{
FTDF_Buffer *buffer = FTDF_dequeueBufferTail(&FTDF_freeQueue);
if (buffer == NULL)
{
return FTDF_TRANSACTION_OVERFLOW;
}
FTDF_Buffer *next = queue->head.next;
queue->head.next = buffer;
next->header.prev = buffer;
buffer->header.next = next;
buffer->header.prev = (FTDF_Buffer *) &queue->head;
buffer->request = request;
return FTDF_SUCCESS;
}
FTDF_MsgBuffer *FTDF_dequeueReqTail(FTDF_Queue *queue)
{
FTDF_Buffer *buffer = queue->tail.prev;
if (buffer->header.prev == NULL)
{
return NULL;
}
queue->tail.prev = buffer->header.prev;
buffer->header.prev->header.next = (FTDF_Buffer *) &queue->tail;
FTDF_MsgBuffer *request = buffer->request;
FTDF_queueBufferHead(buffer, &FTDF_freeQueue);
return request;
}
FTDF_MsgBuffer *FTDF_dequeueByHandle(FTDF_Handle handle, FTDF_Queue *queue)
{
FTDF_Buffer *buffer = queue->head.next;
while (buffer->header.next != NULL)
{
if (buffer->request &&
buffer->request->msgId == FTDF_DATA_REQUEST &&
((FTDF_DataRequest *) buffer->request)->msduHandle == handle)
{
buffer->header.prev->header.next = buffer->header.next;
buffer->header.next->header.prev = buffer->header.prev;
FTDF_MsgBuffer *request = buffer->request;
FTDF_queueBufferHead(buffer, &FTDF_freeQueue);
return request;
}
buffer = buffer->header.next;
}
return NULL;
}
FTDF_MsgBuffer *FTDF_dequeueByRequest(FTDF_MsgBuffer *request, FTDF_Queue *queue)
{
FTDF_Buffer *buffer = queue->head.next;
while (buffer->header.next != NULL)
{
if (buffer->request == request)
{
buffer->header.prev->header.next = buffer->header.next;
buffer->header.next->header.prev = buffer->header.prev;
FTDF_MsgBuffer *req = buffer->request;
FTDF_queueBufferHead(buffer, &FTDF_freeQueue);
return req;
}
buffer = buffer->header.next;
}
return NULL;
}
FTDF_Boolean FTDF_isQueueEmpty(FTDF_Queue *queue)
{
if (queue->head.next->header.next == NULL)
{
return FTDF_TRUE;
}
else
{
return FTDF_FALSE;
}
}
static FTDF_PendingTL *FTDF_findFreePendingTimer(void)
{
uint8_t i;
for (i = 0; i < FTDF_NR_OF_REQ_BUFFERS; i++)
{
if (FTDF_txPendingTimerList[ i ].free == FTDF_TRUE)
{
break;
}
}
return &FTDF_txPendingTimerList[ i ];
}
void FTDF_addTxPendingTimer(FTDF_MsgBuffer *request, uint8_t pendListNr, FTDF_Time delta, void (* func)(
FTDF_PendingTL *))
{
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_PendingTL *ptr = FTDF_txPendingTimerHead;
FTDF_Time timestamp = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
if (ptr->free == FTDF_FALSE)
{
while (ptr)
{
ptr->delta -= timestamp - FTDF_txPendingTimerLT;
ptr = ptr->next;
}
}
FTDF_txPendingTimerLT = timestamp;
ptr = FTDF_txPendingTimerHead;
if (ptr->free == FTDF_TRUE)
{
ptr->free = FTDF_FALSE;
ptr->next = NULL;
ptr->request = request;
ptr->delta = delta;
ptr->pendListNr = pendListNr;
ptr->func = func;
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, delta + timestamp);
FTDF_txPendingTimerTime = delta + timestamp;
FTDF_exitCritical();
return;
}
if (ptr->delta > delta)
{
FTDF_txPendingTimerHead = FTDF_findFreePendingTimer();
FTDF_txPendingTimerHead->free = FTDF_FALSE;
FTDF_txPendingTimerHead->next = ptr;
FTDF_txPendingTimerHead->request = request;
FTDF_txPendingTimerHead->delta = delta;
FTDF_txPendingTimerHead->pendListNr = pendListNr;
FTDF_txPendingTimerHead->func = func;
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, delta + timestamp);
FTDF_txPendingTimerTime = delta + timestamp;
FTDF_exitCritical();
return;
}
else if (ptr->delta == delta)
{
delta++;
}
FTDF_PendingTL *prev;
while (ptr->next)
{
prev = ptr;
ptr = ptr->next;
if (ptr->delta == delta)
{
delta++;
}
if (prev->delta < delta && ptr->delta > delta)
{
prev->next = FTDF_findFreePendingTimer();
prev->next->next = ptr;
ptr = prev->next;
ptr->free = FTDF_FALSE;
ptr->request = request;
ptr->delta = delta;
ptr->pendListNr = pendListNr;
ptr->func = func;
FTDF_exitCritical();
return;
}
}
ptr->next = FTDF_findFreePendingTimer();
ptr = ptr->next;
ptr->free = FTDF_FALSE;
ptr->next = NULL;
ptr->request = request;
ptr->delta = delta;
ptr->pendListNr = pendListNr;
ptr->func = func;
FTDF_exitCritical();
}
void FTDF_removeTxPendingTimer(FTDF_MsgBuffer *request)
{
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_PendingTL *ptr = FTDF_txPendingTimerHead;
FTDF_Time timestamp = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
if (ptr->free == FTDF_TRUE)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, timestamp - 1);
FTDF_txPendingTimerTime = timestamp - 1;
FTDF_exitCritical();
return;
}
while (ptr)
{
ptr->delta -= timestamp - FTDF_txPendingTimerLT;
ptr = ptr->next;
}
FTDF_txPendingTimerLT = timestamp;
ptr = FTDF_txPendingTimerHead;
if (!request || ptr->request == request)
{
if (ptr->next)
{
FTDF_PendingTL *temp = ptr;
if (ptr->next->delta < 75)
{
while (temp)
{
temp->delta += 75;
temp = temp->next;
}
}
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, timestamp + ptr->next->delta);
FTDF_txPendingTimerTime = timestamp + ptr->next->delta;
FTDF_txPendingTimerHead = ptr->next;
ptr->free = FTDF_TRUE;
ptr->next = NULL;
}
else
{
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, timestamp - 1);
FTDF_txPendingTimerTime = timestamp - 1;
ptr->free = FTDF_TRUE;
ptr->next = NULL;
}
FTDF_exitCritical();
if (!request)
{
if (ptr->func)
{
ptr->func(ptr);
}
}
return;
}
FTDF_PendingTL *prev = ptr;
while (ptr->next)
{
prev = ptr;
ptr = ptr->next;
if (ptr->request == request)
{
prev->next = ptr->next;
ptr->free = FTDF_TRUE;
ptr->next = NULL;
FTDF_exitCritical();
return;
}
}
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, timestamp - 1);
FTDF_txPendingTimerTime = timestamp - 1;
FTDF_exitCritical();
}
void FTDF_restoreTxPendingTimer(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_SYMBOLTIMETHR, FTDF_txPendingTimerTime);
}
FTDF_Boolean FTDF_getTxPendingTimerHead(FTDF_Time *time)
{
FTDF_PendingTL *ptr = FTDF_txPendingTimerHead;
if (ptr->free == FTDF_TRUE)
{
return FTDF_FALSE;
}
*time = FTDF_txPendingTimerTime;
return FTDF_TRUE;
}
#ifndef FTDF_NO_TSCH
void FTDF_processKeepAliveTimerExp(FTDF_PendingTL *ptr)
{
FTDF_RemoteRequest *remoteRequest = (FTDF_RemoteRequest *)ptr->request;
remoteRequest->msgId = FTDF_REMOTE_REQUEST;
remoteRequest->remoteId = FTDF_REMOTE_KEEP_ALIVE;
remoteRequest->dstAddr = FTDF_neighborTable[ ptr->pendListNr ].dstAddr;
FTDF_processRemoteRequest(remoteRequest);
}
#endif /* FTDF_NO_TSCH */
void FTDF_sendTransactionExpired(FTDF_PendingTL *ptr)
{
FTDF_MsgBuffer *req =
FTDF_dequeueByRequest(ptr->request, &FTDF_txPendingList[ ptr->pendListNr ].queue);
if (!req)
{
return;
}
if (FTDF_isQueueEmpty(&FTDF_txPendingList[ ptr->pendListNr ].queue))
{
#ifndef FTDF_NO_TSCH
if (FTDF_pib.tschEnabled)
{
FTDF_txPendingList[ ptr->pendListNr ].addr.shortAddress = 0xfffe;
}
else
#endif /* FTDF_NO_TSCH */
{
#if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO
if (FTDF_txPendingList[ ptr->pendListNr ].addrMode == FTDF_SHORT_ADDRESS)
{
uint8_t entry, shortAddrIdx;
FTDF_Boolean found = FTDF_fpprLookupShortAddress(
FTDF_txPendingList[ ptr->pendListNr ].addr.shortAddress, &entry,
&shortAddrIdx);
ASSERT_WARNING(found);
FTDF_fpprSetShortAddressValid(entry, shortAddrIdx, FTDF_FALSE);
}
else if (FTDF_txPendingList[ ptr->pendListNr ].addrMode == FTDF_EXTENDED_ADDRESS)
{
uint8_t entry;
FTDF_Boolean found = FTDF_fpprLookupExtAddress(
FTDF_txPendingList[ ptr->pendListNr ].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 */
FTDF_txPendingList[ ptr->pendListNr ].addrMode = FTDF_NO_ADDRESS;
}
}
switch (req->msgId)
{
case FTDF_DATA_REQUEST:
{
FTDF_DataRequest *dataRequest = (FTDF_DataRequest *)req;
FTDF_sendDataConfirm(dataRequest, FTDF_TRANSACTION_EXPIRED, 0, 0, 0, NULL);
break;
}
case FTDF_ASSOCIATE_REQUEST:
{
FTDF_AssociateRequest *associateRequest = (FTDF_AssociateRequest *)req;
FTDF_sendAssociateConfirm(associateRequest, FTDF_TRANSACTION_EXPIRED, 0xffff);
break;
}
case FTDF_ASSOCIATE_RESPONSE:
{
FTDF_AssociateResponse *assocResp = (FTDF_AssociateResponse *)req;
FTDF_Address srcAddr, dstAddr;
srcAddr.extAddress = FTDF_pib.extAddress;
dstAddr.extAddress = assocResp->deviceAddress;
FTDF_sendCommStatusIndication(req, FTDF_TRANSACTION_EXPIRED,
FTDF_pib.PANId,
FTDF_EXTENDED_ADDRESS,
srcAddr,
FTDF_EXTENDED_ADDRESS,
dstAddr,
assocResp->securityLevel,
assocResp->keyIdMode,
assocResp->keySource,
assocResp->keyIndex);
break;
}
case FTDF_DISASSOCIATE_REQUEST:
{
FTDF_DisassociateRequest *disReq = (FTDF_DisassociateRequest *)req;
FTDF_sendDisassociateConfirm(disReq, FTDF_TRANSACTION_EXPIRED);
break;
}
case FTDF_BEACON_REQUEST:
{
FTDF_BeaconRequest *beaconRequest = (FTDF_BeaconRequest *)req;
FTDF_sendBeaconConfirm(beaconRequest, FTDF_TRANSACTION_EXPIRED);
break;
}
}
}
#ifndef FTDF_NO_TSCH
void FTDF_resetKeepAliveTimer(FTDF_ShortAddress dstAddr)
{
uint8_t n;
for (n = 0; n < FTDF_NR_OF_NEIGHBORS; n++)
{
if (FTDF_neighborTable[ n ].dstAddr == dstAddr)
{
break;
}
}
if (n == FTDF_NR_OF_NEIGHBORS)
{
return;
}
FTDF_removeTxPendingTimer((FTDF_MsgBuffer *)&FTDF_neighborTable[ n ].msg);
FTDF_Time tsTimeslotLength = (FTDF_Time) FTDF_pib.timeslotTemplate.tsTimeslotLength / 16;
FTDF_Time delta = tsTimeslotLength * FTDF_neighborTable[ n ].period;
FTDF_addTxPendingTimer((FTDF_MsgBuffer *)&FTDF_neighborTable[ n ].msg, n, delta, FTDF_processKeepAliveTimerExp);
}
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
void FTDF_enableTransparentMode(FTDF_Boolean enable,
FTDF_Bitmap32 options)
{
#ifndef FTDF_LITE
if (FTDF_pib.leEnabled == FTDF_TRUE ||
FTDF_pib.tschEnabled == FTDF_TRUE)
{
return;
}
#endif /* !FTDF_LITE */
FTDF_transparentMode = enable;
FTDF_transparentModeOptions = options;
if (enable)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSFRMTYPE,
(options & FTDF_TRANSPARENT_PASS_ALL_FRAME_TYPES));
FTDF_SET_FIELD(ON_OFF_REGMAP_DISRXACKREQUESTCA, (options & FTDF_TRANSPARENT_AUTO_ACK ? 0 : 1));
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSCRCERROR, (options & FTDF_TRANSPARENT_PASS_CRC_ERROR ? 1 : 0));
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSRESFRAMEVERSION,
(options & FTDF_TRANSPARENT_PASS_ALL_FRAME_VERSION ? 1 : 0));
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSWRONGDPANID,
(options & FTDF_TRANSPARENT_PASS_ALL_PAN_ID ? 1 : 0));
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSWRONGDADDR, (options & FTDF_TRANSPARENT_PASS_ALL_ADDR ? 1 : 0));
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSBEACONWRONGPANID,
(options & FTDF_TRANSPARENT_PASS_ALL_BEACON ? 1 : 0));
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSTOPANCOORDINATOR,
(options & FTDF_TRANSPARENT_PASS_ALL_NO_DEST_ADDR ? 1 : 0));
}
else
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSFRMTYPE, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_DISRXACKREQUESTCA, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSCRCERROR, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSRESFRAMEVERSION, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSWRONGDPANID, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSWRONGDADDR, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSBEACONWRONGPANID, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACALWAYSPASSTOPANCOORDINATOR, 0);
}
}
#if FTDF_DBG_BUS_ENABLE
void FTDF_checkDbgMode(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_DBG_CONTROL, FTDF_dbgMode);
if (FTDF_dbgMode)
{
FTDF_DBG_BUS_GPIO_CONFIG();
}
}
void FTDF_setDbgMode(FTDF_DbgMode dbgMode)
{
FTDF_dbgMode = dbgMode;
FTDF_checkDbgMode();
}
#endif /* FTDF_DBG_BUS_ENABLE */
#ifndef FTDF_LITE
#ifndef FTDF_NO_CSL
void FTDF_setPeerCslTiming(FTDF_IEList *headerIEList, FTDF_Time timeStamp)
{
if (FTDF_reqCurrent->msgId != FTDF_DATA_REQUEST)
{
// Only use the CSL timing of data frame acks
return;
}
FTDF_DataRequest *dataRequest = (FTDF_DataRequest *) FTDF_reqCurrent;
FTDF_ShortAddress dstAddr = dataRequest->dstAddr.shortAddress;
if (dataRequest->dstAddrMode != FTDF_SHORT_ADDRESS ||
dstAddr == 0xffff)
{
return;
}
int n;
// Search for an existing entry
for (n = 0; n < FTDF_NR_OF_CSL_PEERS; n++)
{
if (FTDF_peerCslTiming[ n ].addr == dstAddr)
{
break;
}
}
if (headerIEList == NULL)
{
if (n < FTDF_NR_OF_CSL_PEERS)
{
// Delete entry
FTDF_peerCslTiming[ n ].addr = 0xffff;
}
return;
}
int ieNr = 0;
while (ieNr < headerIEList->nrOfIEs &&
headerIEList->IEs[ ieNr ].ID != 0x1a)
{
ieNr++;
}
if (ieNr == headerIEList->nrOfIEs)
{
return;
}
if (n == FTDF_NR_OF_CSL_PEERS)
{
// Search for an empty entry
for (n = 0; n < FTDF_NR_OF_CSL_PEERS; n++)
{
if (FTDF_peerCslTiming[ n ].addr == 0xffff)
{
break;
}
}
}
if (n == FTDF_NR_OF_CSL_PEERS)
{
// No free entry, search for the least recently used entry
FTDF_Time maxDelta = 0;
int lru = 0;
for (n = 0; n < FTDF_NR_OF_CSL_PEERS; n++)
{
FTDF_Time delta = timeStamp - FTDF_peerCslTiming[ n ].time;
if (delta > maxDelta)
{
maxDelta = delta;
lru = n;
}
}
n = lru;
}
FTDF_Period phase = (*(FTDF_Period *)(headerIEList->IEs[ 0 ].content.raw + 0));
FTDF_Period period = (*(FTDF_Period *)(headerIEList->IEs[ 0 ].content.raw + 2));
FTDF_peerCslTiming[ n ].addr = dstAddr;
FTDF_peerCslTiming[ n ].time = timeStamp - (phase * 10);
FTDF_peerCslTiming[ n ].period = period;
}
void FTDF_getWakeupParams(FTDF_ShortAddress dstAddr,
FTDF_Time *wakeupStartTime,
FTDF_Period *wakeupPeriod)
{
int n;
for (n = 0; n < FTDF_NR_OF_CSL_PEERS; n++)
{
if (FTDF_peerCslTiming[ n ].addr == dstAddr)
{
break;
}
}
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
if (dstAddr == 0xffff ||
n == FTDF_NR_OF_CSL_PEERS)
{
*wakeupStartTime = curTime + 5;
*wakeupPeriod = FTDF_pib.CSLMaxPeriod;
return;
}
FTDF_Time peerTime = FTDF_peerCslTiming[ n ].time;
FTDF_Time peerPeriod = FTDF_peerCslTiming[ n ].period * 10;
FTDF_Time delta = curTime - peerTime;
if (delta > (uint32_t)(FTDF_pib.CSLMaxAgeRemoteInfo * 10))
{
*wakeupStartTime = curTime + 5;
*wakeupPeriod = FTDF_pib.CSLMaxPeriod;
return;
}
FTDF_Time wStart = peerTime + (((delta / peerPeriod) + 1) * peerPeriod) - FTDF_pib.CSLSyncTxMargin;
delta = wStart - curTime;
if (delta < 3 || delta > 0x80000000) // A delta larger than 0x80000000 is assumed a negative delta
{
wStart += peerPeriod;
}
*wakeupPeriod = (FTDF_pib.CSLSyncTxMargin / 10) * 2;
*wakeupStartTime = wStart;
}
void FTDF_setCslSampleTime(void)
{
FTDF_Time CSLPeriod = FTDF_pib.CSLPeriod * 10;
FTDF_criticalVar();
FTDF_enterCritical();
FTDF_Time curTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_Time delta = (curTime - FTDF_startCslSampleTime);
// A delta larger than 0x80000000 is assumed a negative delta, in this case the sample time does
// not need to be updated.
if (delta < 0x80000000)
{
if (delta < CSLPeriod)
{
FTDF_startCslSampleTime += CSLPeriod;
if (delta < 3)
{
// To avoid to set the CSL sample time to a time stamp in the past set it to a sample period later
// if the next sample would be within 3 symbols.
FTDF_startCslSampleTime += CSLPeriod;
}
}
else
{
FTDF_startCslSampleTime = FTDF_startCslSampleTime + ((delta / CSLPeriod) + 1) * CSLPeriod;
}
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLSTARTSAMPLETIME, FTDF_startCslSampleTime);
}
FTDF_exitCritical();
}
#endif /* FTDF_NO_CSL */
#endif /* !FTDF_LITE */
FTDF_Time64 FTDF_getCurTime64(void)
{
FTDF_Time newTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
if (newTime < FTDF_curTime[ 0 ])
{
FTDF_curTime[ 1 ]++;
}
FTDF_curTime[ 0 ] = newTime;
return *(FTDF_Time64 *)FTDF_curTime;
}
void FTDF_initCurTime64(void)
{
FTDF_curTime[ 0 ] = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_curTime[ 1 ] = 0;
}
void FTDF_getExtAddress(void)
{
uint32_t *extAddress = (uint32_t *) &FTDF_pib.extAddress;
extAddress[ 0 ] = FTDF_GET_FIELD(ON_OFF_REGMAP_AEXTENDEDADDRESS_L);
extAddress[ 1 ] = FTDF_GET_FIELD(ON_OFF_REGMAP_AEXTENDEDADDRESS_H);
}
void FTDF_setExtAddress(void)
{
uint32_t *extAddress = (uint32_t *) &FTDF_pib.extAddress;
FTDF_SET_FIELD(ON_OFF_REGMAP_AEXTENDEDADDRESS_L, extAddress[ 0 ]);
FTDF_SET_FIELD(ON_OFF_REGMAP_AEXTENDEDADDRESS_H, extAddress[ 1 ]);
}
void FTDF_getAckWaitDuration(void)
{
FTDF_pib.ackWaitDuration = FTDF_GET_FIELD(ON_OFF_REGMAP_MACACKWAITDURATION);
}
#ifndef FTDF_LITE
void FTDF_getEnhAckWaitDuration(void)
{
FTDF_pib.enhAckWaitDuration = FTDF_GET_FIELD(ON_OFF_REGMAP_MACENHACKWAITDURATION);
}
void FTDF_setEnhAckWaitDuration(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACENHACKWAITDURATION, FTDF_pib.enhAckWaitDuration);
}
void FTDF_getImplicitBroadcast(void)
{
FTDF_pib.implicitBroadcast = FTDF_GET_FIELD(ON_OFF_REGMAP_MACIMPLICITBROADCAST);
}
void FTDF_setImplicitBroadcast(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACIMPLICITBROADCAST, FTDF_pib.implicitBroadcast);
}
#endif /* !FTDF_LITE */
void FTDF_setShortAddress(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACSHORTADDRESS, FTDF_pib.shortAddress);
}
#ifndef FTDF_LITE
void FTDF_setSimpleAddress(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACSIMPLEADDRESS, FTDF_pib.simpleAddress);
}
#endif /* !FTDF_LITE */
void FTDF_getRxOnWhenIdle(void)
{
FTDF_pib.rxOnWhenIdle = FTDF_GET_FIELD(ON_OFF_REGMAP_RXALWAYSON);
}
void FTDF_setRxOnWhenIdle(void)
{
#if FTDF_USE_PTI && !FTDF_USE_AUTO_PTI
/* We do not force decision here. It will be automatically made when FTDF begins
* transaction.
*/
hw_coex_update_ftdf_pti((hw_coex_pti_t) FTDF_getRxPti(), NULL, false);
#endif /* FTDF_USE_PTI && !FTDF_USE_AUTO_PTI */
FTDF_SET_FIELD(ON_OFF_REGMAP_RXENABLE, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_RXALWAYSON, FTDF_pib.rxOnWhenIdle);
FTDF_SET_FIELD(ON_OFF_REGMAP_RXENABLE, 1);
}
void FTDF_getPANId(void)
{
FTDF_pib.PANId = FTDF_GET_FIELD(ON_OFF_REGMAP_MACPANID);
}
void FTDF_setPANId(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACPANID, FTDF_pib.PANId);
}
void FTDF_getCurrentChannel(void)
{
FTDF_pib.currentChannel = ((FTDF_GET_FIELD(ON_OFF_REGMAP_PHYRXATTR) & 0x00f0) >> 4) + 11;
}
void FTDF_setCurrentChannel(void)
{
uint32_t phyAckAttr = 0x08 | ((FTDF_pib.currentChannel - 11) & 0xf) << 4 | (FTDF_pib.TXPower & 0x7) << 12;
FTDF_SET_FIELD(ON_OFF_REGMAP_PHYRXATTR, (((FTDF_pib.currentChannel - 11) & 0xf) << 4));
FTDF_SET_FIELD(ON_OFF_REGMAP_PHYACKATTR, phyAckAttr);
}
void FTDF_setTXPower(void)
{
/* Just like setCurrentChannel, this sets pyAckAttr */
uint32_t phyAckAttr = 0x08 | ((FTDF_pib.currentChannel - 11) & 0xf) << 4 | (FTDF_pib.TXPower & 0x7) << 12;
FTDF_SET_FIELD(ON_OFF_REGMAP_PHYACKATTR, phyAckAttr);
}
void FTDF_getMaxFrameTotalWaitTime(void)
{
FTDF_pib.maxFrameTotalWaitTime = FTDF_GET_FIELD(ON_OFF_REGMAP_MACMAXFRAMETOTALWAITTIME);
}
void FTDF_setMaxFrameTotalWaitTime(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMAXFRAMETOTALWAITTIME, FTDF_pib.maxFrameTotalWaitTime);
}
void FTDF_setMaxCSMABackoffs(void)
{
#ifndef FTDF_LITE
if (FTDF_pib.leEnabled == FTDF_FALSE && FTDF_pib.tschEnabled == FTDF_FALSE)
#endif /* !FTDF_LITE */
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMAXCSMABACKOFFS, FTDF_pib.maxCSMABackoffs);
}
}
void FTDF_setMaxBE(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMAXBE, FTDF_pib.maxBE);
}
void FTDF_setMinBE(void)
{
#ifndef FTDF_LITE
if (FTDF_pib.leEnabled == FTDF_FALSE && FTDF_pib.tschEnabled == FTDF_FALSE)
#endif /* !FTDF_LITE */
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMINBE, FTDF_pib.minBE);
}
}
#ifndef FTDF_LITE
#ifndef FTDF_NO_CSL
void FTDF_setLeEnabled(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLSAMPLEPERIOD, 66);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLDATAPERIOD, 66);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLMARGINRZ, 1);
if (FTDF_pib.leEnabled)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMAXCSMABACKOFFS, 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMINBE, 0);
if (FTDF_oldLeEnabled == FTDF_FALSE)
{
if (FTDF_wakeUpEnableLe == FTDF_FALSE)
{
FTDF_startCslSampleTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_setCslSampleTime();
}
else
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLSTARTSAMPLETIME, FTDF_startCslSampleTime);
}
}
}
else
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMAXCSMABACKOFFS, FTDF_pib.maxCSMABackoffs);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACMINBE, FTDF_pib.minBE);
}
FTDF_SET_FIELD(ON_OFF_REGMAP_MACLEENABLED, FTDF_pib.leEnabled);
FTDF_oldLeEnabled = FTDF_pib.leEnabled;
}
void FTDF_getCslFramePendingWaitT(void)
{
FTDF_pib.CSLFramePendingWaitT = FTDF_GET_FIELD(ON_OFF_REGMAP_MACCSLFRAMEPENDINGWAITT);
}
void FTDF_setCslFramePendingWaitT(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACCSLFRAMEPENDINGWAITT, FTDF_pib.CSLFramePendingWaitT);
}
#endif /* FTDF_NO_CSL */
#endif /* !FTDF_LITE */
void FTDF_getLmacPmData(void)
{
FTDF_pib.performanceMetrics.FCSErrorCount = FTDF_GET_FIELD(ON_OFF_REGMAP_MACFCSERRORCOUNT) +
FTDF_lmacCounters.fcsErrorCnt;
}
void FTDF_getLmacTrafficCounters(void)
{
FTDF_pib.trafficCounters.txStdAckFrmCnt = FTDF_GET_FIELD(ON_OFF_REGMAP_MACTXSTDACKFRMCNT) +
FTDF_lmacCounters.txStdAckCnt;
FTDF_pib.trafficCounters.rxStdAckFrmOkCnt = FTDF_GET_FIELD(ON_OFF_REGMAP_MACRXSTDACKFRMOKCNT) +
FTDF_lmacCounters.rxStdAckCnt;
}
void FTDF_getKeepPhyEnabled(void)
{
FTDF_pib.keepPhyEnabled = FTDF_GET_FIELD(ON_OFF_REGMAP_KEEP_PHY_EN);
}
void FTDF_setKeepPhyEnabled(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_KEEP_PHY_EN, FTDF_pib.keepPhyEnabled);
}
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
void FTDF_setBoIrqThreshold(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_BO_THRESHOLD, FTDF_pib.boIrqThreshold);
}
void FTDF_getBoIrqThreshold(void)
{
FTDF_pib.boIrqThreshold = FTDF_GET_FIELD(ON_OFF_REGMAP_CSMA_CA_BO_THRESHOLD);
}
void FTDF_setPtiConfig(void)
{
FTDF_SET_FIELD_INDEXED(ON_OFF_REGMAP_PTI_TX, FTDF_pib.ptiConfig.ptis[FTDF_PTI_CONFIG_TX],
FTDF_TX_DATA_BUFFER);
FTDF_SET_FIELD_INDEXED(ON_OFF_REGMAP_PTI_TX, FTDF_pib.ptiConfig.ptis[FTDF_PTI_CONFIG_TX],
FTDF_TX_WAKEUP_BUFFER);
FTDF_SET_FIELD_INDEXED(ON_OFF_REGMAP_PTI_TX, FTDF_pib.ptiConfig.ptis[FTDF_PTI_CONFIG_RX],
FTDF_TX_ACK_BUFFER);
FTDF_SET_FIELD(ON_OFF_REGMAP_PTI_RX, FTDF_pib.ptiConfig.ptis[FTDF_PTI_CONFIG_RX]);
}
#endif /* #if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A */
#ifndef FTDF_LITE
#ifndef FTDF_NO_TSCH
void FTDF_setTimeslotTemplate(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_MACTSTXACKDELAY, FTDF_pib.timeslotTemplate.tsTxAckDelay);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACTSRXWAIT, FTDF_pib.timeslotTemplate.tsRxWait);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACTSRXACKDELAY, FTDF_pib.timeslotTemplate.tsRxAckDelay);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACTSACKWAIT, FTDF_pib.timeslotTemplate.tsAckWait);
FTDF_SET_FIELD(ON_OFF_REGMAP_MACTSRXTX, FTDF_pib.timeslotTemplate.tsRxTx -
FTDF_PHYTRXWAIT - FTDF_PHYTXSTARTUP - FTDF_PHYTXLATENCY);
}
#endif /* FTDF_NO_TSCH */
#endif /* !FTDF_LITE */
#if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A
#if FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO
/************************************ FPPR common functions ***************************************/
#ifndef FTDF_LITE
FTDF_Boolean FTDF_fpFsmShortAddressNew(FTDF_PANId panId, FTDF_ShortAddress shortAddress)
{
uint8_t entry;
uint8_t shortAddrIdx;
if (FTDF_fpprGetFreeShortAddress(&entry, &shortAddrIdx) == FTDF_FALSE)
{
return FTDF_FALSE;
}
FTDF_fpprSetShortAddress(entry, shortAddrIdx, shortAddress);
FTDF_fpprSetShortAddressValid(entry, shortAddrIdx, FTDF_TRUE);
return FTDF_TRUE;
}
FTDF_Boolean FTDF_fpFsmExtAddressNew(FTDF_PANId panId, FTDF_ExtAddress extAddress)
{
uint8_t entry;
if (FTDF_fpprGetFreeExtAddress(&entry) == FTDF_FALSE)
{
return FTDF_FALSE;
}
FTDF_fpprSetExtAddress(entry, extAddress);
FTDF_fpprSetExtAddressValid(entry, FTDF_TRUE);
return FTDF_TRUE;
}
void FTDF_fpFsmShortAddressLastFramePending(FTDF_PANId PANId, FTDF_ShortAddress shortAddress)
{
#if FTDF_FPPR_DEFER_INVALIDATION
FTDF_fpprPending.addrMode = FTDF_SHORT_ADDRESS;
FTDF_fpprPending.PANId = PANId;
FTDF_fpprPending.addr.shortAddress = shortAddress;
#else /* FTDF_FPPR_DEFER_INVALIDATION */
uint8_t entry;
uint8_t shortAddrIdx;
FTDF_Boolean found = FTDF_fpprLookupShortAddress(shortAddress, &entry, &shortAddrIdx);
ASSERT_WARNING(found);
FTDF_fpprSetShortAddressValid(entry, shortAddrIdx, FTDF_FALSE);
#endif /* FTDF_FPPR_DEFER_INVALIDATION */
}
void FTDF_fpFsmExtAddressLastFramePending(FTDF_PANId PANId, FTDF_ExtAddress extAddress)
{
#if FTDF_FPPR_DEFER_INVALIDATION
FTDF_fpprPending.addrMode = FTDF_EXTENDED_ADDRESS;
FTDF_fpprPending.PANId = PANId;
FTDF_fpprPending.addr.extAddress = extAddress;
#else /* FTDF_FPPR_DEFER_INVALIDATION */
uint8_t entry;
FTDF_Boolean found = FTDF_fpprLookupExtAddress(extAddress, &entry);
ASSERT_WARNING(found);
FTDF_fpprSetExtAddressValid(entry, FTDF_FALSE);
#endif /* FTDF_FPPR_DEFER_INVALIDATION */
}
void FTDF_fpFsmClearPending(void)
{
#if FTDF_FPPR_DEFER_INVALIDATION
int n;
if (FTDF_fpprPending.addrMode == FTDF_NO_ADDRESS)
{
return;
}
if (FTDF_fpprPending.addrMode == FTDF_SHORT_ADDRESS)
{
for (n = 0; n < FTDF_NR_OF_REQ_BUFFERS; n++)
{
if (FTDF_txPendingList[ n ].addrMode == FTDF_SHORT_ADDRESS)
{
if ((FTDF_txPendingList[ n ].PANId == FTDF_fpprPending.PANId) &&
(FTDF_txPendingList[ n ].addr.shortAddress ==
FTDF_fpprPending.addr.shortAddress))
{
return;
}
}
}
// Address not found.
uint8_t entry;
uint8_t shortAddrIdx;
FTDF_Boolean found = FTDF_fpprLookupShortAddress(
FTDF_fpprPending.addr.shortAddress, &entry, &shortAddrIdx);
ASSERT_WARNING(found);
FTDF_fpprSetShortAddressValid(entry, shortAddrIdx, FTDF_FALSE);
}
else if (FTDF_fpprPending.addrMode == FTDF_EXTENDED_ADDRESS)
{
for (n = 0; n < FTDF_NR_OF_REQ_BUFFERS; n++)
{
if (FTDF_txPendingList[ n ].addrMode == FTDF_EXTENDED_ADDRESS)
{
if (FTDF_txPendingList[ n ].addr.extAddress ==
FTDF_fpprPending.addr.extAddress)
{
return;
}
}
}
// Address not found.
uint8_t entry;
FTDF_Boolean found = FTDF_fpprLookupExtAddress(FTDF_fpprPending.addr.extAddress,
&entry);
ASSERT_WARNING(found);
FTDF_fpprSetExtAddressValid(entry, FTDF_FALSE);
}
else
{
}
FTDF_fpprPending.addrMode = FTDF_NO_ADDRESS;
#endif /* FTDF_FPPR_DEFER_INVALIDATION */
}
#endif /* #ifndef FTDF_LITE */
/*********************************** FPPR low-level access ****************************************/
void FTDF_fpprReset(void)
{
unsigned int i;
for (i = 0; i < FTDF_FPPR_TABLE_ENTRIES; i++)
{
*FTDF_GET_REG_ADDR_INDEXED(FP_PROCESSING_RAM_SIZE_AND_VAL, i) = 0;
}
}
FTDF_ShortAddress FTDF_fpprGetShortAddress(uint8_t entry, uint8_t shortAddrIdx)
{
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
switch (shortAddrIdx)
{
case 0:
return (FTDF_ShortAddress)
* FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry) &
0x0000ffff;
case 1:
return (FTDF_ShortAddress)
(*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry) >> 16) &
0x0000ffff;
case 2:
return (FTDF_ShortAddress)
* FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry) &
0x0000ffff;
case 3:
return (FTDF_ShortAddress)
(*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry) >> 16) &
0x0000ffff;
default:
ASSERT_WARNING(0);
}
}
void FTDF_fpprSetShortAddress(uint8_t entry, uint8_t shortAddrIdx,
FTDF_ShortAddress shortAddress)
{
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
uint32_t val32;
switch (shortAddrIdx)
{
case 0:
val32 = *FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry);
val32 &= 0xffff0000;
val32 |= (shortAddress & 0x0000ffff);
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry) = val32;
break;
case 1:
val32 = *FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry);
val32 &= 0x0000ffff;
val32 |= (shortAddress & 0x0000ffff) << 16;
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry) = val32;
break;
case 2:
val32 = *FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry);
val32 &= 0xffff0000;
val32 |= (shortAddress & 0x0000ffff);
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry) = val32;
break;
case 3:
val32 = *FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry);
val32 &= 0x0000ffff;
val32 |= (shortAddress & 0x0000ffff) << 16;
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry) = val32;
break;
default:
ASSERT_WARNING(0);
}
}
FTDF_Boolean FTDF_fpprGetShortAddressValid(uint8_t entry, uint8_t shortAddrIdx)
{
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
ASSERT_WARNING(shortAddrIdx < 4);
uint32_t val32;
val32 = *FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_VALID_SA, entry);
return ((val32 & (MSK_F_FTDF_FP_PROCESSING_RAM_SHORT_LONGNOT | (1 << shortAddrIdx))) ==
(MSK_F_FTDF_FP_PROCESSING_RAM_SHORT_LONGNOT | (1 << shortAddrIdx))) ?
FTDF_TRUE : FTDF_FALSE;
}
void FTDF_fpprSetShortAddressValid(uint8_t entry, uint8_t shortAddrIdx,
FTDF_Boolean valid)
{
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
ASSERT_WARNING(shortAddrIdx < 4);
uint32_t val32;
val32 = *FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_VALID_SA, entry);
if (valid)
{
val32 |= MSK_F_FTDF_FP_PROCESSING_RAM_SHORT_LONGNOT | (1 << shortAddrIdx); /* Also indicate short address. */
}
else
{
val32 &= ~(1 << shortAddrIdx);
}
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_VALID_SA, entry) = val32;
}
FTDF_ExtAddress FTDF_fpprGetExtAddress(uint8_t entry)
{
FTDF_ExtAddress extAddress;
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
extAddress = (FTDF_ExtAddress) * FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H,
entry) << 32;
extAddress |= (FTDF_ExtAddress) * FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L,
entry);
return extAddress;
}
void FTDF_fpprSetExtAddress(uint8_t entry, FTDF_ExtAddress extAddress)
{
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, entry) =
(uint32_t)(extAddress);
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, entry) =
(uint32_t)((extAddress >> 32));
}
FTDF_Boolean FTDF_fpprGetExtAddressValid(uint8_t entry)
{
return (*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_VALID_SA, entry) == 0x1) ?
FTDF_TRUE : FTDF_FALSE;
}
void FTDF_fpprSetExtAddressValid(uint8_t entry, FTDF_Boolean valid)
{
ASSERT_WARNING(entry < FTDF_FPPR_TABLE_ENTRIES);
if (valid)
{
/* Also indicate ext address. */
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_VALID_SA, entry) = 0x1;
}
else
{
*FTDF_GET_FIELD_ADDR_INDEXED(FP_PROCESSING_RAM_VALID_SA, entry) = 0x0;
}
}
FTDF_Boolean FTDF_fpprGetFreeShortAddress(uint8_t *entry, uint8_t *shortAddrIdx)
{
int i, j;
uint32_t sizeAndVal;
int emptyEntry;
bool emptyFound = false, nonEmptyFound = false;
for (i = 0; i < FTDF_FPPR_TABLE_ENTRIES; i++)
{
sizeAndVal = *FTDF_GET_REG_ADDR_INDEXED(FP_PROCESSING_RAM_SIZE_AND_VAL, i);
if (sizeAndVal == 0x1)
{
/* Check if there is a valid extended address. */
continue;
}
else if ((sizeAndVal & MSK_F_FTDF_FP_PROCESSING_RAM_SHORT_LONGNOT) == 0)
{
/* There is an invalid extended address, ignore SA valid bits */
sizeAndVal = 0;
}
else
{
/* There is a SA. We are interested in bits V0 - V3. */
sizeAndVal &= 0xf;
}
/* Check if entire entry is free. */
if (sizeAndVal == 0)
{
/* We prefer to use partially full entries. Make note of this and
* continue. */
if (!emptyFound)
{
emptyEntry = i;
emptyFound = true;
}
continue;
}
/* Check for free short address entries. */
sizeAndVal = (~sizeAndVal) & 0xf;
j = 0;
while (sizeAndVal)
{
if (sizeAndVal & 0x1)
{
nonEmptyFound = true;
break;
}
sizeAndVal >>= 1;
j++;
}
if (nonEmptyFound)
{
break;
}
}
if (nonEmptyFound)
{
*entry = i;
*shortAddrIdx = j;
}
else if (emptyFound)
{
*entry = emptyEntry;
*shortAddrIdx = 0;
}
else
{
return FTDF_FALSE;
}
return FTDF_TRUE;
}
FTDF_Boolean FTDF_fpprGetFreeExtAddress(uint8_t *entry)
{
int i;
uint32_t sizeAndVal;
bool found = false;
for (i = 0; i < FTDF_FPPR_TABLE_ENTRIES; i++)
{
sizeAndVal = *FTDF_GET_REG_ADDR_INDEXED(FP_PROCESSING_RAM_SIZE_AND_VAL, i);
/* Check if there is no valid extended or short address. */
if (!sizeAndVal || (sizeAndVal == MSK_F_FTDF_FP_PROCESSING_RAM_SHORT_LONGNOT))
{
found = true;
break;
}
}
if (found)
{
*entry = i;
}
else
{
return FTDF_FALSE;
}
return FTDF_TRUE;
}
FTDF_Boolean FTDF_fpprLookupShortAddress(FTDF_ShortAddress shortAddr, uint8_t *entry,
uint8_t *shortAddrIdx)
{
uint8_t i;
uint32_t sizeAndVal;
uint32_t saPart;
for (i = 0; i < FTDF_FPPR_TABLE_ENTRIES; i++)
{
sizeAndVal = *FTDF_GET_REG_ADDR_INDEXED(FP_PROCESSING_RAM_SIZE_AND_VAL, i);
/* Check if there is a valid short address. */
if (!(sizeAndVal & MSK_F_FTDF_FP_PROCESSING_RAM_SHORT_LONGNOT) ||
!(sizeAndVal & MSK_F_FTDF_FP_PROCESSING_RAM_VALID_SA))
{
continue;
}
saPart = FTDF_GET_FIELD_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, i);
if (sizeAndVal & 0x1)
{
if (shortAddr == (FTDF_ShortAddress)(saPart & 0x0000ffff))
{
*entry = i;
*shortAddrIdx = 0;
return FTDF_TRUE;
}
}
if (sizeAndVal & 0x2)
{
if (shortAddr == (FTDF_ShortAddress)((saPart >> 16) & 0x0000ffff))
{
*entry = i;
*shortAddrIdx = 1;
return FTDF_TRUE;
}
}
saPart = FTDF_GET_FIELD_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, i);
if (sizeAndVal & 0x4)
{
if (shortAddr == (FTDF_ShortAddress)(saPart & 0x0000ffff))
{
*entry = i;
*shortAddrIdx = 2;
return FTDF_TRUE;
}
}
if (sizeAndVal & 0x8)
{
if (shortAddr == ((FTDF_ShortAddress)(saPart >> 16) & 0x0000ffff))
{
*entry = i;
*shortAddrIdx = 3;
return FTDF_TRUE;
}
}
}
return FTDF_FALSE;
}
FTDF_Boolean FTDF_fpprLookupExtAddress(FTDF_ExtAddress extAddr, uint8_t *entry)
{
uint8_t i;
uint32_t sizeAndVal;
uint32_t extAddrHi, extAddrLo;
extAddrHi = (uint32_t)((extAddr >> 32) & 0xffffffff);
extAddrLo = (uint32_t)(extAddr & 0xffffffff);
for (i = 0; i < FTDF_FPPR_TABLE_ENTRIES; i++)
{
sizeAndVal = *FTDF_GET_REG_ADDR_INDEXED(FP_PROCESSING_RAM_SIZE_AND_VAL, i);
/* Check if there is a valid extended address. */
if (sizeAndVal != 0x1)
{
continue;
}
if ((extAddrLo == FTDF_GET_FIELD_INDEXED(FP_PROCESSING_RAM_EXP_SA_L, i)) &&
(extAddrHi == FTDF_GET_FIELD_INDEXED(FP_PROCESSING_RAM_EXP_SA_H, i)))
{
*entry = i;
return FTDF_TRUE;
}
}
return FTDF_FALSE;
}
#endif /* FTDF_FP_BIT_MODE == FTDF_FP_BIT_MODE_AUTO */
void FTDF_fpprSetMode(FTDF_Boolean matchFp, FTDF_Boolean fpOverride, FTDF_Boolean fpForce)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_ADDR_TAB_MATCH_FP_VALUE, matchFp ? 1 : 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_FP_OVERRIDE, fpOverride ? 1 : 0);
FTDF_SET_FIELD(ON_OFF_REGMAP_FP_FORCE_VALUE, fpForce ? 1 : 0);
}
#if FTDF_FP_BIT_TEST_MODE
void FTDF_fpprGetMode(FTDF_Boolean *matchFp, FTDF_Boolean *fpOverride, FTDF_Boolean *fpForce)
{
*matchFp = FTDF_GET_FIELD(ON_OFF_REGMAP_ADDR_TAB_MATCH_FP_VALUE) ? FTDF_TRUE : FTDF_FALSE;
*fpOverride = FTDF_GET_FIELD(ON_OFF_REGMAP_FP_OVERRIDE) ? FTDF_TRUE : FTDF_FALSE;
*fpForce = FTDF_GET_FIELD(ON_OFF_REGMAP_FP_FORCE_VALUE) ? FTDF_TRUE : FTDF_FALSE;
}
#endif // FTDF_FP_BIT_TEST_MODE
void FTDF_lpdpEnable(FTDF_Boolean enable)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_FTDF_LPDP_ENABLE, enable ? 1 : 0);
}
#if FTDF_FP_BIT_TEST_MODE
FTDF_Boolean FTDF_lpdpIsEnabled(void)
{
return FTDF_GET_FIELD(ON_OFF_REGMAP_FTDF_LPDP_ENABLE) ? FTDF_TRUE : FTDF_FALSE;
}
#endif
#if FTDF_USE_SLEEP_DURING_BACKOFF
static inline void FTDF_sdbSaveState(void)
{
volatile uint32_t *txFifoPtr = FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO);
uint32_t *dstPtr = (uint32_t *) FTDF_sdb.buffer;
uint8_t word_length_rem;
FTDF_sdb.nrOfBackoffs = FTDF_GET_FIELD(ON_OFF_REGMAP_CSMA_CA_NB_STAT);
/* Read first 4 bytes. */
*dstPtr++ = *txFifoPtr++;
ASSERT_WARNING((FTDF_sdb.buffer[0] >= 3) && (FTDF_sdb.buffer[0] < FTDF_BUFFER_LENGTH));
/* The length is the buffer length excluding the length byte itself */
word_length_rem = (FTDF_sdb.buffer[0] + 4) / 4 - 1; /* 1 word we already read */
while (word_length_rem--)
{
*dstPtr++ = *txFifoPtr++;
}
FTDF_sdb.metadata0 = *FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_0,
FTDF_TX_DATA_BUFFER);
FTDF_sdb.metadata1 = *FTDF_GET_REG_ADDR_INDEXED(RETENTION_RAM_TX_META_DATA_1,
FTDF_TX_DATA_BUFFER);
FTDF_sdb.phyCsmaCaAttr = FTDF_GET_FIELD(ON_OFF_REGMAP_PHYCSMACAATTR);
}
static inline void FTDF_sdbResume(void)
{
volatile uint32_t *txFifoPtr = FTDF_GET_REG_ADDR(RETENTION_RAM_TX_FIFO);
volatile uint32_t *txFlagSet = FTDF_GET_FIELD_ADDR(ON_OFF_REGMAP_TX_FLAG_SET);
uint32_t *srcPtr = (uint32_t *) FTDF_sdb.buffer;
uint8_t word_length_rem;
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_NB_VAL, FTDF_sdb.nrOfBackoffs);
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_RESUME_SET, 1);
ASSERT_WARNING((FTDF_sdb.buffer[0] >= 3) && (FTDF_sdb.buffer[0] < FTDF_BUFFER_LENGTH));
/* The length is the buffer length excluding the length byte itself */
word_length_rem = (FTDF_sdb.buffer[0] + 4) / 4;
while (word_length_rem--)
{
*txFifoPtr++ = *srcPtr++;
}
FTDF_SET_FIELD(ON_OFF_REGMAP_PHYCSMACAATTR, FTDF_sdb.phyCsmaCaAttr);
*FTDF_GET_REG_ADDR(RETENTION_RAM_TX_META_DATA_0) = FTDF_sdb.metadata0;
*FTDF_GET_REG_ADDR(RETENTION_RAM_TX_META_DATA_1) = FTDF_sdb.metadata1;
*txFlagSet |= (1 << FTDF_TX_DATA_BUFFER);
}
static inline void FTDF_sdbReset(void)
{
FTDF_SET_FIELD(ON_OFF_REGMAP_CSMA_CA_RESUME_CLEAR, 1);
}
static inline void FTDF_sdbSetCCARetryTime(void)
{
FTDF_Time timestamp = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
FTDF_Time boStat = FTDF_GET_FIELD(ON_OFF_REGMAP_CSMA_CA_BO_STAT) *
FTDF_UNIT_BACKOFF_PERIOD;
FTDF_sdb.ccaRetryTime = timestamp + boStat;
}
void FTDF_sdbFsmReset(void)
{
FTDF_sdbReset();
FTDF_sdb.state = FTDF_SDB_STATE_INIT;
}
void FTDF_sdbFsmBackoffIRQ(void)
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_RESUMING:
FTDF_sdbReset();
case FTDF_SDB_STATE_INIT:
case FTDF_SDB_STATE_BACKING_OFF:
FTDF_sdbSetCCARetryTime();
FTDF_sdb.state = FTDF_SDB_STATE_BACKING_OFF;
break;
default:
ASSERT_WARNING(0);
}
}
void FTDF_sdbFsmSleep(void)
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_BACKING_OFF:
FTDF_sdbSaveState();
FTDF_sdb.state = FTDF_SDB_STATE_WAITING_WAKE_UP_IRQ;
break;
case FTDF_SDB_STATE_INIT:
break;
default:
ASSERT_WARNING(0);
}
}
void FTDF_sdbFsmAbortSleep(void)
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_BACKING_OFF:
FTDF_sdb.state = FTDF_SDB_STATE_INIT;
break;
case FTDF_SDB_STATE_INIT:
case FTDF_SDB_STATE_WAITING_WAKE_UP_IRQ:
case FTDF_SDB_STATE_RESUMING:
break;
default:
ASSERT_WARNING(0);
}
}
void FTDF_sdbFsmWakeUpIRQ(void)
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_WAITING_WAKE_UP_IRQ:
FTDF_sdb.state = FTDF_SDB_STATE_RESUMING;
break;
case FTDF_SDB_STATE_INIT:
break;
default:
ASSERT_WARNING(0);
}
}
void FTDF_sdbFsmWakeUp(void)
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_RESUMING:
FTDF_sdbResume();
break;
case FTDF_SDB_STATE_WAITING_WAKE_UP_IRQ:
break;
case FTDF_SDB_STATE_INIT:
break;
default:
ASSERT_WARNING(0);
}
}
void FTDF_sdbFsmTxIRQ(void)
{
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_RESUMING:
FTDF_sdbReset();
FTDF_sdb.state = FTDF_SDB_STATE_INIT;
break;
case FTDF_SDB_STATE_BACKING_OFF:
FTDF_sdb.state = FTDF_SDB_STATE_INIT;
break;
case FTDF_SDB_STATE_INIT:
break;
default:
ASSERT_WARNING(0);
}
}
FTDF_USec FTDF_sdbGetSleepTime(void)
{
FTDF_USec sleepTime = ~((FTDF_USec) 0);
#if !defined(FTDF_NO_CSL) || !defined(FTDF_NO_TSCH)
if (FTDF_pib.leEnabled || FTDF_pib.tschEnabled)
{
return sleepTime;
}
#endif
switch (FTDF_sdb.state)
{
case FTDF_SDB_STATE_INIT:
{
if ((FTDF_GET_FIELD(ON_OFF_REGMAP_LMACREADY4SLEEP) == 0) || FTDF_reqCurrent)
{
sleepTime = 0;
}
else
{
sleepTime = ~((FTDF_USec) 0);
}
break;
}
case FTDF_SDB_STATE_BACKING_OFF:
{
FTDF_Time currentTime = FTDF_GET_FIELD(ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL);
if (currentTime <= FTDF_sdb.ccaRetryTime)
{
sleepTime = (FTDF_sdb.ccaRetryTime - currentTime) * 16;
}
else
{
sleepTime = (1 << SIZE_F_FTDF_ON_OFF_REGMAP_SYMBOLTIMESNAPSHOTVAL - 1) -
(currentTime + FTDF_sdb.ccaRetryTime) * 16;
}
if (sleepTime > 256 * FTDF_UNIT_BACKOFF_PERIOD * 16)
{
/* We have exceeded the CCA retry time. Abort sleep and wait for Tx IRQ. */
sleepTime = 0;
}
break;
}
case FTDF_SDB_STATE_RESUMING:
sleepTime = 0;
break;
case FTDF_SDB_STATE_WAITING_WAKE_UP_IRQ:
sleepTime = ~((FTDF_USec) 0);
break;
default:
ASSERT_WARNING(0);
}
return sleepTime;
}
#endif /* FTDF_USE_SLEEP_DURING_BACKOFF */
#endif /* #if dg_configBLACK_ORCA_IC_REV != BLACK_ORCA_IC_REV_A */
#if dg_configUSE_FTDF_DDPHY == 1
void FTDF_ddphySet(uint16_t ccaReg)
{
FTDF_criticalVar();
FTDF_enterCritical();
/* We use the critical section here as protection for the global variable and the HW sleep
* state. */
FTDF_ddphyCcaReg = ccaReg;
/* Apply immediately if block is up. */
if (REG_GETF(CRG_TOP, PMU_CTRL_REG, FTDF_SLEEP) == 0x0)
{
FTDF_DPHY->DDPHY_CCA_REG = FTDF_ddphyCcaReg;
}
FTDF_exitCritical();
}
void FTDF_ddphyRestore(void)
{
if (FTDF_ddphyCcaReg)
{
/* Apply immediately if block is up. */
FTDF_criticalVar();
FTDF_enterCritical();
ASSERT_WARNING(REG_GETF(CRG_TOP, PMU_CTRL_REG, FTDF_SLEEP) == 0x0);
FTDF_DPHY->DDPHY_CCA_REG = FTDF_ddphyCcaReg;
FTDF_exitCritical();
}
}
void FTDF_ddphySave(void)
{
/* Apply immediately if block is up. */
FTDF_criticalVar();
FTDF_enterCritical();
ASSERT_WARNING(REG_GETF(CRG_TOP, PMU_CTRL_REG, FTDF_SLEEP) == 0x0);
FTDF_ddphyCcaReg = FTDF_DPHY->DDPHY_CCA_REG;
FTDF_exitCritical();
}
#endif