/** * @file HwA_enet.h * @author Flagchip * @brief ENET hardware access layer * @version 2.0.0 * @date 2024-10-12 * * SDK Version: 2.6.0 * * @copyright Copyright (c) 2020-2024 Flagchip Semiconductors Co., Ltd. * */ /* ******************************************************************************** * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- ------------ ---------- --------------- * 0.1.0 2023-12-15 Flagchip085 N/A First version for FC7300 * 2.0.0 2024-10-12 Flagchip085 N/A Change version and release ******************************************************************************** */ #ifndef _HWA_ENET_H_ #define _HWA_ENET_H_ #include "device_header.h" #if ENET_INSTANCE_COUNT > 0u /** * @defgroup HwA_enet HwA_enet * @ingroup module_driver_enet * @{ */ /** * @brief ENE MAC status type definition * */ typedef enum { ENET_MAC_STATUS_IDLE = 0u, ENET_MAC_STATUS_BUSY = 1u } ENET_MAC_StatusType; /** * @brief ENET MAC source address insertion control type definition * */ typedef enum { ENET_MAC_SRC_ADDR_CTRL_BY_INPUT_SIGNAL = 0u, ENET_MAC_SRC_ADDR_INSERT_BY_MAC_ADDR_IDX_0 = 2u, ENET_MAC_SRC_ADDR_REPLACE_BY_MAC_ADDR_IDX_0 = 3u, ENET_MAC_SRC_ADDR_INSERT_BY_MAC_ADDR_IDX_1 = 6u, ENET_MAC_SRC_ADDR_REPLACE_BY_MAC_ADDR_IDX_1 = 7u } ENET_MAC_SrcAddrCtrlType; /** * @brief MAC inter packet gap type definition * */ typedef enum { ENET_MAC_INTER_PACKET_GAP_96_BIT = 0u, ENET_MAC_INTER_PACKET_GAP_88_BIT = 1u, ENET_MAC_INTER_PACKET_GAP_80_BIT = 2u, ENET_MAC_INTER_PACKET_GAP_72_BIT = 3u, ENET_MAC_INTER_PACKET_GAP_64_BIT = 4u, ENET_MAC_INTER_PACKET_GAP_56_BIT = 5u, ENET_MAC_INTER_PACKET_GAP_48_BIT = 6u, ENET_MAC_INTER_PACKET_GAP_40_BIT = 7u } ENET_MAC_InterPacketGapType; /** * @brief MAC extend inner packet gap type definition * */ typedef enum { ENET_MAC_EXT_INTER_PACKET_GAP_104_BIT = 0u, ENET_MAC_EXT_INTER_PACKET_GAP_112_BIT = 1u, ENET_MAC_EXT_INTER_PACKET_GAP_120_BIT = 2u, ENET_MAC_EXT_INTER_PACKET_GAP_128_BIT = 3u, ENET_MAC_EXT_INTER_PACKET_GAP_136_BIT = 4u, ENET_MAC_EXT_INTER_PACKET_GAP_144_BIT = 5u, ENET_MAC_EXT_INTER_PACKET_GAP_152_BIT = 6u, ENET_MAC_EXT_INTER_PACKET_GAP_160_BIT = 7u, ENET_MAC_EXT_INTER_PACKET_GAP_168_BIT = 8u, ENET_MAC_EXT_INTER_PACKET_GAP_176_BIT = 9u, ENET_MAC_EXT_INTER_PACKET_GAP_184_BIT = 10u, ENET_MAC_EXT_INTER_PACKET_GAP_192_BIT = 11u, ENET_MAC_EXT_INTER_PACKET_GAP_200_BIT = 12u, ENET_MAC_EXT_INTER_PACKET_GAP_208_BIT = 13u, ENET_MAC_EXT_INTER_PACKET_GAP_216_BIT = 14u, ENET_MAC_EXT_INTER_PACKET_GAP_224_BIT = 15u, ENET_MAC_EXT_INTER_PACKET_GAP_232_BIT = 16u, ENET_MAC_EXT_INTER_PACKET_GAP_240_BIT = 17u, ENET_MAC_EXT_INTER_PACKET_GAP_248_BIT = 18u, ENET_MAC_EXT_INTER_PACKET_GAP_256_BIT = 19u, ENET_MAC_EXT_INTER_PACKET_GAP_264_BIT = 20u, ENET_MAC_EXT_INTER_PACKET_GAP_272_BIT = 21u, ENET_MAC_EXT_INTER_PACKET_GAP_280_BIT = 22u, ENET_MAC_EXT_INTER_PACKET_GAP_288_BIT = 23u, ENET_MAC_EXT_INTER_PACKET_GAP_296_BIT = 24u, ENET_MAC_EXT_INTER_PACKET_GAP_304_BIT = 25u, ENET_MAC_EXT_INTER_PACKET_GAP_312_BIT = 26u, ENET_MAC_EXT_INTER_PACKET_GAP_320_BIT = 27u, ENET_MAC_EXT_INTER_PACKET_GAP_328_BIT = 28u, ENET_MAC_EXT_INTER_PACKET_GAP_336_BIT = 29u, ENET_MAC_EXT_INTER_PACKET_GAP_344_BIT = 30u, ENET_MAC_EXT_INTER_PACKET_GAP_352_BIT = 31u } ENET_MAC_ExtInterPacketGapType; /** * @brief MAC speed mode type definition * */ typedef enum { ENET_MAC_SPEED_1000MBPS = 0u, ENET_MAC_SPEED_2500MBPS = 1u, ENET_MAC_SPEED_10MBPS = 2u, ENET_MAC_SPEED_100MBPS = 3u } ENET_MAC_SpeedType; /** * @brief MAC duplex mode type definition * */ typedef enum { ENET_MAC_HALF_DUPLEX = 0u, ENET_MAC_FULL_DUPLEX = 1u } ENET_MAC_DuplexModeType; /** * @brief MAC back off limit type definition * */ typedef enum { ENET_MAC_BACK_OFF_LIMIT_10_SLOT = 0u, ENET_MAC_BACK_OFF_LIMIT_8_SLOT = 1u, ENET_MAC_BACK_OFF_LIMIT_4_SLOT = 2u, ENET_MAC_BACK_OFF_LIMIT_1_SLOT = 3u } ENET_MAC_BackOffLimitType; /** * @brief MAC slow protocol detect type definition * */ typedef enum { ENET_MAC_SLOW_PROTOCOL_DETECT_STANDARD = 0u, ENET_MAC_SLOW_PROTOCOL_DETECT_EXTENDED = 1u } ENET_MAC_SlowProtocolDetectType; /** * @brief MAC address filter mode type definition * */ typedef enum { ENET_MAC_ADDR_FILTER_DIRECT = 0u, ENET_MAC_ADDR_FILTER_INVERSE = 1u } ENET_MAC_AddrFilterModeType; /** * @brief MAC control packets filter mode type definition * */ typedef enum { ENET_MAC_CTRL_PACKET_FILTER_ALL = 0u, ENET_MAC_CTRL_PACKET_FILTER_PAUSE_PACKET = 1u, ENET_MAC_CTRL_PACKET_FORWARD_ALL = 2u, ENET_MAC_CTRL_PACKET_ADDR_FILTER = 3u } ENET_MAC_CtrlPacketFilterModeType; /** * @brief MAC perfect or hash filter mode type definition * */ typedef enum { ENET_MAC_USE_PERFECT_FILTER = 0u, ENET_MAC_USE_HASH_FILTER = 1u } ENET_MAC_HashOrPerfectModeType; /** * @brief MAC watchdog timer type definition * */ typedef enum { ENET_MAC_WDG_TIMER_SIZE_2KB = 0u, ENET_MAC_WDG_TIMER_SIZE_3KB = 1u, ENET_MAC_WDG_TIMER_SIZE_4KB = 2u, ENET_MAC_WDG_TIMER_SIZE_5KB = 3u, ENET_MAC_WDG_TIMER_SIZE_6KB = 4u, ENET_MAC_WDG_TIMER_SIZE_7KB = 5u, ENET_MAC_WDG_TIMER_SIZE_8KB = 6u, ENET_MAC_WDG_TIMER_SIZE_9KB = 7u, ENET_MAC_WDG_TIMER_SIZE_10KB = 8u, ENET_MAC_WDG_TIMER_SIZE_11KB = 9u, ENET_MAC_WDG_TIMER_SIZE_12KB = 10u, ENET_MAC_WDG_TIMER_SIZE_13KB = 11u, ENET_MAC_WDG_TIMER_SIZE_14KB = 12u, ENET_MAC_WDG_TIMER_SIZE_15KB = 13u } ENET_MAC_WDGTimerSizeType; /** * @brief MAC VLAN tag strip type * */ typedef enum { ENET_MAC_VLAN_TAG_STRIP_NEVER = 0u, ENET_MAC_VLAN_TAG_STRIP_FILTER_PASS = 1u, ENET_MAC_VLAN_TAG_STRIP_FILTER_FAIL = 2u, ENET_MAC_VLAN_TAG_STRIP_ALWAYS = 3u } ENET_MAC_VLANTagStripModeType; /** * @brief MAC VLAN indirect registers access command type * */ typedef enum { ENET_MAC_VLAN_COMMAND_WRITE = 0u, ENET_MAC_VLAN_COMMAND_READ = 1u } ENET_MAC_VLANCommandType; /** * @brief MAC VLAN incl indirect registers access command type * */ typedef enum { ENET_MAC_VLAN_INCL_COMMAND_READ = 0u, ENET_MAC_VLAN_INCL_COMMAND_WRITE = 1u } ENET_MAC_VLANInclCommandType; /** * @brief MAC VLAN tag control type * */ typedef enum { ENET_MAC_VLAN_TAG_NO_OPERATION = 0u, ENET_MAC_VLAN_TAG_DELETION = 1u, ENET_MAC_VLAN_TAG_INSERTION = 2u, ENET_MAC_VLAN_TAG_REPLACEMENT = 3u } ENET_MAC_VLANTagCtrlType; /** * @brief MAC VLAN tag type * S-VLAN IEEE802.1ad (Q-in-Q) * C-VLAN IEEE802.1Q */ typedef enum { ENET_MAC_VLAN_TYPE_C_VLAN = 0u, ENET_MAC_VLAN_TYPE_S_VLAN = 1u } ENET_MAC_VLANType; /** * @brief MAC VLAN compare mode type * */ typedef enum { ENET_MAC_VLAN_16BITS_COMPARE = 0u, ENET_MAC_VLAN_12BITS_COMPARE = 1u } ENET_MAC_VLANCompareType; /** * @brief MAC VLAN perfect filter group index type * */ typedef enum { ENET_MAC_VLAN_FILTER_GROUP_0 = 0u, ENET_MAC_VLAN_FILTER_GROUP_1 = 1u, ENET_MAC_VLAN_FILTER_GROUP_2 = 2u, ENET_MAC_VLAN_FILTER_GROUP_3 = 3u } ENET_MAC_VLANFilterGroupType; /** * @brief ENET flow control pause threshold type * */ typedef enum { ENET_MAC_PAUSE_THRESHOLD_4SLOT_TIMES = 0u, ENET_MAC_PAUSE_THRESHOLD_28SLOT_TIMES = 1u, ENET_MAC_PAUSE_THRESHOLD_36SLOT_TIMES = 2u, ENET_MAC_PAUSE_THRESHOLD_144SLOT_TIMES = 3u, ENET_MAC_PAUSE_THRESHOLD_256SLOT_TIMES = 4u, ENET_MAC_PAUSE_THRESHOLD_512SLOT_TIMES = 5u } ENET_MAC_PauseThresholdType; /** * @brief MAC TX packet controller status type * */ typedef enum { ENET_MAC_TX_PACKET_CONTROLLER_IDLE = 0u, ENET_MAC_TX_PACKET_CONTROLLER_WAIT = 1u, ENET_MAC_TX_PACKET_CONTROLLER_TRANSFER_PAUSE_PACKET = 2u, ENET_MAC_TX_PACKET_CONTROLLER_TRANSFER_INPUT_PACKET = 3u } ENET_MAC_TxPacketControllerStatusType; /** * @brief MTL queue enable type * */ typedef enum { ENET_MTL_QUEUE_DISABLE = 0u, ENET_MTL_QUEUE_ENABLE_AV_MODE = 1u, ENET_MTL_QUEUE_ENABLE_GENERIC = 2u } ENET_MTL_QueueEnableType; /** * @brief Tagged PTP over Ethernet packets queuing control type * */ typedef enum { ENET_MAC_VLAN_PTPOE_ROUTED_AS_GENERIC = 0u, ENET_MAC_VLAN_PTPOE_ROUTED_TO_PTP_QUEUE = 1u, ENET_MAC_VLAN_PTPOE_ROUTED_BY_PRIORITY = 2u } ENET_MAC_PTPoEQueueCtrlType; #if ENET_SUPPORT_RGMII /** * @brief MAC RGMII clock select type * */ typedef enum { ENET_MAC_RGMII_CLK_SEL_DISABLE = 0u, ENET_MAC_RGMII_CLK_SEL_ENET_REF_CLK = 1u, ENET_MAC_RGMII_CLK_SEL_PLL0DIVH = 2u, ENET_MAC_RGMII_CLK_SEL_PLL1DIVH = 3u } ENET_MAC_RGMIIClkSelType; #endif /** * @brief MAC TX clock select type * */ typedef enum { ENET_MAC_TX_CLK_SEL_DISABLE = 0u, ENET_MAC_TX_CLK_SEL_PLL0DIVL = 1u, ENET_MAC_TX_CLK_SEL_FOSC = 2u, ENET_MAC_TX_CLK_SEL_ENET_TX_CLK = 3u } ENET_MAC_TxClkSelType; /** * @brief MAC PHY interface mode type * */ typedef enum { ENET_MAC_PHY_MII = 0u, ENET_MAC_PHY_RGMII = 1u, ENET_MAC_PHY_RMII = 4u } ENET_MAC_MiiModeType; /** * @brief MAC MDIO access clock source range type * */ typedef enum { ENET_MAC_CSR_CLOCK_RANGE_60_100MHZ = 0u, ENET_MAC_CSR_CLOCK_RANGE_100_150MHZ = 1u, ENET_MAC_CSR_CLOCK_RANGE_20_35MHZ = 2u, ENET_MAC_CSR_CLOCK_RANGE_35_60MHZ = 3u, ENET_MAC_CSR_CLOCK_RANGE_150_250MHZ = 4u, ENET_MAC_CSR_CLOCK_RANGE_250_300MHZ = 5u } ENET_MAC_CSRClockRangeType; /** * @brief MAC MDIO bus operation command type * */ typedef enum { ENET_MAC_PHY_OPERATION_WRITE = 1u, ENET_MAC_PHY_OPERATION_POST_READ_INCR_ADDR_FOR_CLAUSE_45 = 2u, ENET_MAC_PHY_OPERATION_READ = 3u } ENET_MAC_PhyOperationCmdType; /** * @brief MAC MDIO bus clause type * */ typedef enum { ENET_MAC_PHY_CLAUSE_22 = 0u, ENET_MAC_PHY_CLAUSE_45 = 1u } ENET_MAC_PhyClauseVersionType; /** * @brief MAC address destination or source type * */ typedef enum { ENET_MAC_ADDR_TYPE_DEST = 0u, ENET_MAC_ADDR_TYPE_SRC = 1u } ENET_MAC_AddrType; /** * @brief MMC counter present level type * */ typedef enum { ENET_MAC_MMC_COUNTER_PRESET_LEVEL_HALF = 0u, ENET_MAC_MMC_COUNTER_PRESET_LEVEL_FULL = 1u } ENET_MAC_MmcCntPresetLevelType; /** * @brief MAC layer 4 filter protocol type * */ typedef enum { ENET_MAC_LAYER_4_PROTOCOL_TCP = 0u, ENET_MAC_LAYER_4_PROTOCOL_UDP = 1u } ENET_MAC_Layer4ProtocolType; /** * @brief MAC layer 3 filter protocol type * */ typedef enum { ENET_MAC_LAYER_3_PROTOCOL_IPV4 = 0u, ENET_MAC_LAYER_3_PROTOCOL_IPV6 = 1u } ENET_MAC_Layer3ProtocolType; /** * @brief MAC layer3 layer 4 filter group index type * */ typedef enum { ENET_MAC_L3_L4_FILTER_GROUP_0 = 0u, ENET_MAC_L3_L4_FILTER_GROUP_1 = 1u, ENET_MAC_L3_L4_FILTER_GROUP_2 = 2u, ENET_MAC_L3_L4_FILTER_GROUP_3 = 3u } ENET_MAC_L3L4FilterGroupType; /** * @brief MAC MMC transmit statistics counter type * */ typedef enum { ENET_CTR_TX_OCTET_COUNT_GOOD_BAD = 0u, ENET_CTR_TX_PACKET_COUNT_GOOD_BAD, ENET_CTR_TX_BROADCAST_PACKETS_GOOD, ENET_CTR_TX_MULTICAST_PACKETS_GOOD, ENET_CTR_TX_64OCTETS_PACKETS_GOOD_BAD, ENET_CTR_TX_65TO127OCTETS_PACKETS_GOOD_BAD, ENET_CTR_TX_128TO255OCTETS_PACKETS_GOOD_BAD, ENET_CTR_TX_256TO511OCTETS_PACKETS_GOOD_BAD, ENET_CTR_TX_512TO1023OCTETS_PACKETS_GOOD_BAD, ENET_CTR_TX_1024TOMAXOCTETS_PACKETS_GOOD_BAD, ENET_CTR_TX_UNICAST_PACKETS_GOOD_BAD, ENET_CTR_TX_MULTICAST_PACKETS_GOOD_BAD, ENET_CTR_TX_BROADCAST_PACKETS_GOOD_BAD, ENET_CTR_TX_UNDERFLOW_ERROR_PACKETS, ENET_CTR_TX_SINGLE_COLLISION_GOOD_PACKETS, ENET_CTR_TX_MULTIPLE_COLLISION_GOOD_PACKETS, ENET_CTR_TX_DEFERRED_PACKETS, ENET_CTR_TX_LATE_COLLISION_PACKETS, ENET_CTR_TX_EXCESSIVE_COLLISION_PACKETS, ENET_CTR_TX_CARRIER_ERROR_PACKETS, ENET_CTR_TX_OCTET_COUNT_GOOD, ENET_CTR_TX_PACKET_COUNT_GOOD, ENET_CTR_TX_EXCESSIVE_DEFERRAL_ERROR, ENET_CTR_TX_PAUSE_PACKETS, ENET_CTR_TX_VLAN_PACKETS_GOOD, ENET_CTR_TX_OSIZE_PACKETS_GOOD, } Enet_MMCTxCounterType; /** * @brief MAC receive statistics counter type * */ typedef enum { ENET_CTR_RX_PACKETS_COUNT_GOOD_BAD = 0u, ENET_CTR_RX_OCTET_COUNT_GOOD_BAD, ENET_CTR_RX_OCTET_COUNT_GOOD, ENET_CTR_RX_BROADCAST_PACKETS_GOOD, ENET_CTR_RX_MULTICAST_PACKETS_GOOD, ENET_CTR_RX_CRC_ERROR_PACKETS, ENET_CTR_RX_ALIGNMENT_ERROR_PACKETS, ENET_CTR_RX_RUNT_ERROR_PACKETS, ENET_CTR_RX_JABBER_ERROR_PACKETS, ENET_CTR_RX_UNDERSIZE_PACKETS_GOOD, ENET_CTR_RX_OVERSIZE_PACKETS_GOOD, ENET_CTR_RX_64OCTETS_PACKETS_GOOD_BAD, ENET_CTR_RX_65TO127OCTETS_PACKETS_GOOD_BAD, ENET_CTR_RX_128TO255OCTETS_PACKETS_GOOD_BAD, ENET_CTR_RX_256TO511OCTETS_PACKETS_GOOD_BAD, ENET_CTR_RX_512TO1023OCTETS_PACKETS_GOOD_BAD, ENET_CTR_RX_1024TOMAXOCTETS_PACKETS_GOOD_BAD, ENET_CTR_RX_UNICAST_PACKETS_GOOD, ENET_CTR_RX_LENGTH_ERROR_PACKETS, ENET_CTR_RX_OUT_OF_RANGE_TYPE_PACKETS, ENET_CTR_RX_PAUSE_PACKETS, ENET_CTR_RX_FIFO_OVERFLOW_PACKETS, ENET_CTR_RX_VLAN_PACKETS_GOOD_BAD, ENET_CTR_RX_WATCHDOG_ERROR_PACKETS, ENET_CTR_RX_RECEIVE_ERROR_PACKETS, ENET_CTR_RX_CONTROL_PACKETS_GOOD, } Enet_MMCRxCounterType; /** * @brief PTP TX status mode type * */ typedef enum { ENET_MAC_TX_TIMESTAMP_STATUS_MODE_PRESERVE = 0u, ENET_MAC_TX_TIMESTAMP_STATUS_MODE_OVERWRITE = 1u } ENET_MAC_TxTimestampStatusModeType; /** * @brief PTP system time input source type * */ typedef enum { ENET_MAC_SYSTEM_TIME_INPUT_INTERNAL = 0u, ENET_MAC_SYSTEM_TIME_INPUT_EXTERNAL = 1u } ENET_MAC_SystemTimeInputType; /** * @brief PTP IEEE1588 version type * */ typedef enum { ENET_MAC_PTP_IEEE_1588_V1 = 0u, ENET_MAC_PTP_IEEE_1588_V2 = 1u, } ENET_MAC_PTPVersionType; /** * @brief PTP counter rollover mode type * */ typedef enum { ENET_MAC_TIMESTAMP_ROLLOVER_BINARY = 0u, ENET_MAC_TIMESTAMP_ROLLOVER_DIGITAL = 1u, } ENET_MAC_TimestampRolloverType; /** * @brief PTP timestamp update mode type * */ typedef enum { ENET_MAC_TIMESTAMP_UPDATE_COARSE = 0u, ENET_MAC_TIMESTAMP_UPDATE_FINE = 1u } ENET_MAC_TimestampUpdateMethodType; /** * @brief PTP system time offset update operation type * */ typedef enum { ENET_MAC_SYSTEM_TIME_ADD_TIME = 0u, ENET_MAC_SYSTEM_TIME_SUBTRACT_TIME = 1u } ENET_MAC_SystemTimeOperationType; /** * @brief PTP PPS channel type * */ typedef enum { ENET_MAC_PPS_CHANNEL_0 = 0u, ENET_MAC_PPS_CHANNEL_1 = 1u, ENET_MAC_PPS_CHANNEL_2 = 2u, ENET_MAC_PPS_CHANNEL_3 = 3u } ENET_MAC_PPSChannelType; /** * @brief PTP PPS channel operation mode type * */ typedef enum { ENET_MAC_PPS_MODE_PPS = 0u, ENET_MAC_PPS_MODE_MCGR = 1u } ENET_MAC_PPSModeType; /** * @brief PPS target time mode type * */ typedef enum { ENET_MAC_PPS_TARGET_TIME_ONLY_INT = 0u, ENET_MAC_PPS_TARGET_TIME_MCGR = 1u, ENET_MAC_PPS_TARGET_TIME_INT_ST = 2u, ENET_MAC_PPS_TARGET_TIME_ONLY_ST = 3u } ENET_MAC_PPSTargetTimeModeType; /** * @brief PTP fixed PPS output frequency control type * */ typedef enum { ENET_MAC_PPS_BINARY_1HZ_DIGITAL_NONE = 0u, /**< Fixed PPS output 1HZ in binary rollover mode, no output in digital mode. */ ENET_MAC_PPS_BINARY_2HZ_DIGITAL_1HZ = 1u, /**< Fixed PPS output 2HZ in binary rollover mode, 1HZ in digital mode. */ ENET_MAC_PPS_BINARY_4HZ_DIGITAL_2HZ = 2u, /**< Fixed PPS output 4HZ in binary rollover mode, 2HZ in digital mode. */ ENET_MAC_PPS_BINARY_8HZ_DIGITAL_4HZ = 3u, /**< Fixed PPS output 8HZ in binary rollover mode, 4HZ in digital mode. */ ENET_MAC_PPS_BINARY_16HZ_DIGITAL_8HZ = 4u, /**< Fixed PPS output 16HZ in binary rollover mode, 8HZ in digital mode. */ ENET_MAC_PPS_BINARY_32HZ_DIGITAL_16HZ = 5u, /**< Fixed PPS output 32HZ in binary rollover mode, 16HZ in digital mode. */ ENET_MAC_PPS_BINARY_64HZ_DIGITAL_32HZ = 6u, /**< Fixed PPS output 64HZ in binary rollover mode, 32HZ in digital mode. */ ENET_MAC_PPS_BINARY_128HZ_DIGITAL_64HZ = 7u, /**< Fixed PPS output 128HZ in binary rollover mode, 64HZ in digital mode. */ ENET_MAC_PPS_BINARY_256HZ_DIGITAL_128HZ = 8u, /**< Fixed PPS output 256HZ in binary rollover mode, 128HZ in digital mode. */ ENET_MAC_PPS_BINARY_512HZ_DIGITAL_256HZ = 9u, /**< Fixed PPS output 512HZ in binary rollover mode, 256HZ in digital mode. */ ENET_MAC_PPS_BINARY_1024HZ_DIGITAL_512HZ = 10u, /**< Fixed PPS output 1024HZ in binary rollover mode, 512HZ in digital mode. */ ENET_MAC_PPS_BINARY_2048HZ_DIGITAL_1024HZ = 11u, /**< Fixed PPS output 2048HZ in binary rollover mode, 1024HZ in digital mode. */ ENET_MAC_PPS_BINARY_4096HZ_DIGITAL_2048HZ = 12u, /**< Fixed PPS output 4096HZ in binary rollover mode, 2048HZ in digital mode. */ ENET_MAC_PPS_BINARY_8192HZ_DIGITAL_4096HZ = 13u, /**< Fixed PPS output 8192HZ in binary rollover mode, 4096HZ in digital mode. */ ENET_MAC_PPS_BINARY_16384HZ_DIGITAL_8192HZ = 14u, /**< Fixed PPS output 16384HZ in binary rollover mode, 8192HZ in digital mode. */ ENET_MAC_PPS_BINARY_32768HZ_DIGITAL_16384HZ = 15u /**< Fixed PPS output 32768HZ in binary rollover mode, 16384HZ in digital mode. */ } ENET_MAC_PPSFreqCtrlType; /** * @brief PTP flexible PPS output command type * */ typedef enum { ENET_MAC_PPS_NO_COMMAND = 0u, ENET_MAC_PPS_START_SINGLE_PULSE = 1u, ENET_MAC_PPS_START_PULSE_TRAIN = 2u, ENET_MAC_PPS_CANCEL_START = 3u, ENET_MAC_PPS_STOP_PULSE_TRAIN_AT_TIME = 4u, ENET_MAC_PPS_STOP_PULSE_TRAIN_IMMEDIATELY = 5u, ENET_MAC_PPS_CANCEL_STOP_PULSE_TRAIN = 6u } ENET_MAC_PPSCmdType; /** * @brief PTP flexible MCGR command type * */ typedef enum { ENET_MAC_MCGR_OPERATION_NOT_CARRIED_OUT = 0u, ENET_MAC_MCGR_CAPTURE_RISING_EDGE = 1u, ENET_MAC_MCGR_CAPTURE_FALLING_EDGE = 2u, ENET_MAC_MCGR_CAPTURE_BOTH_EDGE = 3u, ENET_MAC_MCGR_TOGGLE_OUTPUT_ON_COMPARE = 9u, ENET_MAC_MCGR_PULSE_OUTPUT_LOW_ON_COMPARE = 10u, ENET_MAC_MCGR_PULSE_OUTPUT_HIGH_ON_COMPARE = 11u } ENET_MAC_MCGRCmdType; /** * @brief PTP snapshot packet select type * */ typedef enum { ENET_MAC_PTP_SNAPSHOT_FOR_E2E = (0x0u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_SYNC = (0x1u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_DELAYREQ = (0x3u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_ALL_PTP = (0x4u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_SLAVE_NODE_EVENT = (0x5u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_MASTER_NODE_EVENT = (0x7u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_E2E_EVENT = (0x8u << 14u), ENET_MAC_PTP_SNAPSHOT_FOR_P2P_EVENT = (0xCu << 14u), } ENET_MAC_PTPSnapshotMsgType; /** * @brief PTP snapshot network layer select type * */ typedef enum { ENET_MAC_PTP_OVER_ETHERNET = ENET_MAC_TIMESTAMP_CONTROL_TSIPENA_MASK, ENET_MAC_PTP_OVER_IPV4 = ENET_MAC_TIMESTAMP_CONTROL_TSIPV4ENA_MASK, ENET_MAC_PTP_OVER_IPV6 = ENET_MAC_TIMESTAMP_CONTROL_TSIPV6ENA_MASK, } ENET_MAC_PTPPacketLayerType; /** * @brief MAC PTP clock select type * */ typedef enum { ENET_MAC_PTP_CLK_SEL_PCC = 0u, ENET_MAC_PTP_CLK_SEL_TX_CLK = 1u #if ENET_SUPPORT_REFCLK_PIN , ENET_MAC_PTP_CLK_SEL_REFCLK_PIN = 2u #endif } ENET_MAC_PTPClkSelType; /** * @brief PTP PPS channel direction type * */ typedef enum { ENET_PTP_PPS_DIR_INPUT = 0u, ENET_PTP_PPS_DIR_OUTPUT = 1u } ENET_MAC_PPSPinDirType; /** * @brief ENET MTL queue type * */ typedef enum { ENET_MTL_QUEUE_0 = 0u, ENET_MTL_QUEUE_1 = 1u } ENET_MTL_QueueType; /** * @brief ENET TX schedule algorithm type * */ typedef enum { ENET_MTL_SCHED_ALGO_WRR = 0u, /**< Weighted round robin algorithm. */ ENET_MTL_SCHED_ALGO_SP = 3u /**< Strict priority algorithm. */ } ENET_MTL_TxScheduleAlgorithmType; /** * @brief ENET RX arbitration type * */ typedef enum { ENET_MTL_RX_ARBITRATION_STRICT_POLICY = 0u, ENET_MTL_RX_ARBITRATION_WEIGHTED_STRICT_POLICY = 1u } ENET_MTL_RxArbitrationAlgorithmType; /** * @brief MTL debug access type * */ typedef enum { ENET_MTL_DEBUG_ACCESS_TX_FIFO = 0u, ENET_MTL_DEBUG_ACCESS_TX_STATUS_FIFO = 1u, ENET_MTL_DEBUG_ACCESS_TSO_FIFO = 2u, ENET_MTL_DEBUG_ACCESS_RX_FIFO = 3u } ENET_MTL_DebugAccessFIFOType; /** * @brief MTL fifo packet status type * */ typedef enum { ENET_MTL_PACKET_STATE_PACKET_DATA = 0u, ENET_MTL_PACKET_STATE_TX_CTRL_WORD_RX_NORMAL_STATUS = 1u, ENET_MTL_PACKET_STATE_TX_SOP_DATA_RX_LAST_STATUS = 2u, ENET_MTL_PACKET_STATE_TX_EOP_DATA_RX_EOP = 3u } ENET_MTL_FIFOPacketStatusType; /** * @brief MTL byte enable type * */ typedef enum { ENET_MTL_BYTE_0_VALID = 0u, ENET_MTL_BYTE_0_1_VALID = 1u, ENET_MTL_BYTE_0_1_2_VALID = 2u, ENET_MTL_BYTE_ALL_VALID = 3u } ENET_MTL_ByteEnableType; /** * @brief MTL fifo debug access type * */ typedef enum { ENET_MTL_FIFO_DEBUG_ACCESS_RESTRICTED = 0u, ENET_MTL_FIFO_DEBUG_ACCESS_UNRESTRICTED = 1u } ENET_MTL_FIFODebugAccessType; /** * @brief MTL TX threshold type * */ typedef enum { ENET_MTL_TX_THRESHOLD_32B = 0u, ENET_MTL_TX_THRESHOLD_64B = 1u, ENET_MTL_TX_THRESHOLD_96B = 2u, ENET_MTL_TX_THRESHOLD_128B = 3u, ENET_MTL_TX_THRESHOLD_192B = 4u, ENET_MTL_TX_THRESHOLD_256B = 5u, ENET_MTL_TX_STORE_FORWARD = (1u << ENET_MTL_TXQn_OPERATION_MODE_TTC_WIDTH) } ENET_MTL_TxThresholdType; /** * @brief MTL write controller status type * */ typedef enum { ENET_MTL_WRITE_CONTROLLER_IDLE = 0u, ENET_MTL_WRITE_CONTROLLER_ACTIVE = 1u } ENET_MTL_WriteControllerStatusType; /** * @brief MTL read controller status type * */ typedef enum { ENET_MTL_READ_CONTROLLER_IDLE = 0u, ENET_MTL_READ_CONTROLLER_READ = 1u, ENET_MTL_READ_CONTROLLER_WAIT = 2u, ENET_MTL_READ_CONTROLLER_FLUSH = 3u } ENET_MTL_ReadControllerStatusType; /** * @brief MTL RX flow control threshold type * */ typedef enum { ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_1_KB = 0u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_1_5_KB = 1u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_2_KB = 2u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_2_5_KB = 3u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_3_KB = 4u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_3_5_KB = 5u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_4_KB = 6u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_4_5_KB = 7u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_5_KB = 8u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_5_5_KB = 9u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_6_KB = 10u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_6_5_KB = 11u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_7_KB = 12u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_7_5_KB = 13u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_8_KB = 14u, ENET_MTL_RX_FLOWCTRL_THRESHOLD_FULL_8_5_KB = 15u } ENET_MTL_RxFlowCtrlThresholdType; /** * @brief MTL RX threshold type * */ typedef enum { ENET_MTL_RX_THRESHOLD_64B = 0u, ENET_MTL_RX_THRESHOLD_32B = 1u, ENET_MTL_RX_THRESHOLD_96B = 2u, ENET_MTL_RX_THRESHOLD_128B = 3u, ENET_MTL_RX_STORE_FORWARD = (1u << ENET_MTL_RXQn_OPERATION_MODE_RTC_WIDTH) } ENET_MTL_RxThresholdType; /** * @brief MTL RX queue status type * */ typedef enum { ENET_MTL_RX_QUEUE_EMPTY = 0u, ENET_MTL_RX_QUEUE_BELOW_FLOW_CTRL_DEACTIVATE_THRES = 1u, ENET_MTL_RX_QUEUE_ABOVE_FLOW_CTRL_ACTIVATE_THRES = 2u, ENET_MTL_RX_QUEUE_FULL = 3u } ENET_MTL_RxQueueStatusType; #if ENET_SUPPORT_TIME_SENSITIVE_NETWORK /** * @brief Multiple of gate control list interval time * */ typedef enum { ENET_MTL_GCL_INTERVAL_X_1 = 0x0u, ENET_MTL_GCL_INTERVAL_X_2 = 0x1u, ENET_MTL_GCL_INTERVAL_X_4 = 0x2u, ENET_MTL_GCL_INTERVAL_X_8 = 0x3u, ENET_MTL_GCL_INTERVAL_X_16 = 0x4u, ENET_MTL_GCL_INTERVAL_X_32 = 0x5u, ENET_MTL_GCL_INTERVAL_X_64 = 0x6u, ENET_MTL_GCL_INTERVAL_X_128 = 0x7u } ENET_MTL_GCLIntervalMultipleType; /** * @brief Loop count to report Scheduling Error * */ typedef enum { ENET_MTL_GCL_4_ITERATIONS = 0x0u, ENET_MTL_GCL_8_ITERATIONS = 0x1u, ENET_MTL_GCL_16_ITERATIONS = 0x2u, ENET_MTL_GCL_32_ITERATIONS = 0x3u } ENET_MTL_ScheduleErrorLoopCountType; /** * @brief Gcl related registers * */ typedef enum { ENET_MTL_GCL_BTR_LOW = 0x0u, ENET_MTL_GCL_BTR_HIGH = 0x1u, ENET_MTL_GCL_CTR_LOW = 0x2u, ENET_MTL_GCL_CTR_HIGH = 0x3u, ENET_MTL_GCL_TER = 0x4u, ENET_MTL_GCL_LLR = 0x5 } ENET_MTL_GclRegistersType; /** * @brief Gcl operation type * */ typedef enum { ENET_MTL_GCL_WRITE = 0x0u, ENET_MTL_GCL_READ = 0x1u } ENET_MTL_GclOperationType; /** * @brief MTL gate control list index type * */ typedef enum { ENET_MTL_GCL_NUMBER_0 = 0x0u, ENET_MTL_GCL_NUMBER_1 = 0x1u } ENET_MTL_GateControlListType; #endif /* ENET_SUPPORT_TIME_SENSITIVE_NETWORK */ /** * @brief ENET DMA channel index type * */ typedef enum { ENET_DMA_CHANNEL_0 = 0x0u, ENET_DMA_CHANNEL_1 = 0x1u } ENET_DMA_ChannelType; /** * @brief ENET DMA running status * */ typedef enum { ENET_DMA_STATUS_IDLE = 0x0u, /**< The ENET DMA engine is stoppeed */ ENET_DMA_STATUS_ACTIVE = 0x1u /**< The ENET DMA engine is running */ } ENET_DMA_StatusType; /** * @brief The interrupt mode of ENET DMA * */ typedef enum { ENET_DMA_INTM_SBD_PERCH_PULSE = 0u, /**< sbd_perch_* are pulse signals and sbd_inter_o will assert */ ENET_DMA_INTM_SBD_PERCH_LEVEL = 1u, /**< sbd_perch_* are level signals and sbd_inter_o will not assert */ ENET_DMA_INTM_SBD_PERCH_LEVEL_REENTRANT = 2u /**< sbd_perch_* are level signals and will regenerate if the same event occur again before the signals cleared. sbd_inter_o will not assert */ } ENET_DMA_IntModeType; /** * @brief ENET DMA priority ratio type * */ typedef enum { ENET_DMA_PRIORITY_RATIO_1_1 = 0u, /**< The priority ratio is 1:1 */ ENET_DMA_PRIORITY_RATIO_2_1 = 1u, /**< The priority ratio is 2:1 */ ENET_DMA_PRIORITY_RATIO_3_1 = 2u, /**< The priority ratio is 3:1 */ ENET_DMA_PRIORITY_RATIO_4_1 = 3u, /**< The priority ratio is 4:1 */ ENET_DMA_PRIORITY_RATIO_5_1 = 4u, /**< The priority ratio is 5:1 */ ENET_DMA_PRIORITY_RATIO_6_1 = 5u, /**< The priority ratio is 6:1 */ ENET_DMA_PRIORITY_RATIO_7_1 = 6u, /**< The priority ratio is 7:1 */ ENET_DMA_PRIORITY_RATIO_8_1 = 7u /**< The priority ratio is 8:1 */ } ENET_DMA_PriorityRatioType; /** * @brief ENET DMA priority mode type * */ typedef enum { ENET_DMA_PRIORITY_MODE_RX_TX = 0u, /**< The priority ratio is RX:TX */ ENET_DMA_PRIORITY_MODE_TX_RX = 1u /**< The priority ratio is TX:RX */ } ENET_DMA_PriorityModeType; /** * @brief ENET DMA arbitration algorithm between transmit channels * */ typedef enum { ENET_DMA_TX_ARBITRATION_ALGORITHM_FIXED_PRIORITY = 0u, /**< Use the fixed priority for arbitration */ ENET_DMA_TX_ARBITRATION_ALGORITHM_WEIGHTED_FIXED_PRIORITY = 1u, /**< Use the weighted fixed priority for arbitration */ ENET_DMA_TX_ARBITRATION_ALGORITHM_WEIGHTED_ROUND_ROBIN = 2u /**< Use the weighted round-robin for arbitration */ } ENET_DMA_TxArbitrationAlgorithmType; /** * @brief ENET DMA arbitration scheme between the transmit and receive paths * */ typedef enum { ENET_DMA_TXRX_ARBITRATION_SCHEME_WEIGHTED_ROUND_ROBIN = 0u, /**< Use the weighted round-robin for arbitration */ ENET_DMA_TXRX_ARBITRATION_SCHEME_FIXED_PRIORITY = 1u /**< Use the fixed priority for arbitration */ } ENET_DMA_ArbitrationSchemeType; /** * @brief ENET DMA burst mode type * */ typedef enum { ENET_BURSTLENGTH_FIXED = ENET_DMA_SYSBUS_MODE_FB_MASK, /**< Use the fixed burst */ ENET_BURSTLENGTH_MIXED = ENET_DMA_SYSBUS_MODE_MB_MASK /**< Use the mixed burst Length */ } ENET_DMA_BurstModeType; /** * @brief ENET DMA interrupt flag type * */ typedef enum { ENET_DMA_TX_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_TIE_MASK, ENET_DMA_TX_STOPPED_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_TXSE_MASK, ENET_DMA_TX_BUFFER_UNAVAILABLE_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_TBUE_MASK, ENET_DMA_RX_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_RIE_MASK, ENET_DMA_RX_BUFFER_UNAVAILABLE_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_RBUE_MASK, ENET_DMA_RX_STOPPED_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_RSE_MASK, ENET_DMA_RX_WATCHDOG_TIMEOUT_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_RWTE_MASK, ENET_DMA_EARLY_TX_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_ETIE_MASK, ENET_DMA_EARLY_RX_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_ERIE_MASK, ENET_DMA_FATAL_BUS_ERROR_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_FBEE_MASK, ENET_DMA_CONTEXT_DESCRIPTOR_ERROR_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_CDEE_MASK, ENET_DMA_ABNORMAL_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_AIE_MASK, ENET_DMA_NORMAL_INTERRUPT = ENET_DMA_CHn_INTERRUPT_ENABLE_NIE_MASK } ENET_DMA_InterruptFlagType; /** * @brief ENET DMA watchdog counter unit type * */ typedef enum { ENET_DMA_WDG_COUNTER_UNIT_256_CYCLE = 0x0u, ENET_DMA_WDG_COUNTER_UNIT_512_CYCLE = 0x1u, ENET_DMA_WDG_COUNTER_UNIT_1024_CYCLE = 0x2u, ENET_DMA_WDG_COUNTER_UNIT_2048_CYCLE = 0x3u } ENET_DMA_WDGCounterUnitType; /** * @brief ENET DMA RX error type * */ typedef enum { ENET_DMA_RX_NO_ERROR = 0x0u, ENET_DMA_RX_READ_DESCRIPTER_ERROR = 0x7u, ENET_DMA_RX_WRITE_DESCRIPTER_ERROR = 0x6u, ENET_DMA_RX_READ_BUFFER_ERROR = 0x5u, ENET_DMA_RX_WRITE_BUFFER_ERROR = 0x4u } ENET_DMA_RxErrorType; /** * @brief ENET DMA TX error type * */ typedef enum { ENET_DMA_TX_NO_ERROR = 0x0u, ENET_DMA_TX_READ_DESCRIPTER_ERROR = 0x7u, ENET_DMA_TX_WRITE_DESCRIPTER_ERROR = 0x6u, ENET_DMA_TX_READ_BUFFER_ERROR = 0x5u, ENET_DMA_TX_WRITE_BUFFER_ERROR = 0x4u } ENET_DMA_TxErrorType; /** ================================================================ * * ENET system control * ================================================================ */ #if ENET_SYSTEM_CONTROL_SMISC /** * @brief Get the Core Id. * * @return The Core Id number */ LOCAL_INLINE uint8_t ENET_HWA_Sysctrl_GetCoreId(void) { return (uint8_t)0u; } /** * @brief Set ENET clock software reset * */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetEnetClkSoftwareResetEnFlag(void) { SMISC->PERICTLR |= SMISC_PERICTLR_ENET_CLK_SW_RESET_MASK; } /** * @brief Set PHY interface mode * * @param [in] eMode PHY interface mode */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetPhyMiiMode(ENET_MAC_MiiModeType eMode) { SMISC->PERICTLR = (SMISC->PERICTLR & ~SMISC_PERICTLR_ENET_RMIIEN_MASK) | SMISC_PERICTLR_ENET_RMIIEN((eMode == ENET_MAC_PHY_RMII) ? 1u : 0u); } /** * @brief Get TX clock select source * * @return ENET_MAC_TxClkSelType */ LOCAL_INLINE ENET_MAC_TxClkSelType ENET_HWA_Sysctrl_GetTxClockSrc(void) { uint32_t u32TmpVal = 0u; u32TmpVal = (SMISC->PERICTLR & SMISC_PERICTLR_RMII_CLK_SEL_MASK) >> SMISC_PERICTLR_RMII_CLK_SEL_SHIFT; return (ENET_MAC_TxClkSelType)(u32TmpVal + 1u); } /** * @brief Set TX clock select source * * @param [in] eClkSrc TX clock source */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetTxClockSrc(ENET_MAC_TxClkSelType eClkSrc) { uint32_t u32TmpVal = (uint32_t)eClkSrc - 1u; SMISC->PERICTLR = (SMISC->PERICTLR & ~SMISC_PERICTLR_RMII_CLK_SEL_MASK) | SMISC_PERICTLR_RMII_CLK_SEL(u32TmpVal); } /** * @brief Select the clock source of PTP module. * * @param [in] eClkSrc The clock source type */ LOCAL_INLINE ENET_MAC_PTPClkSelType ENET_HWA_Sysctrl_GetPTPClkSrc(void) { return (ENET_MAC_PTPClkSelType)((SMISC->PERICTLR & SMISC_PERICTLR_ENET_TS_CLKSEL_MASK) >> SMISC_PERICTLR_ENET_TS_CLKSEL_SHIFT); } /** * @brief Select the clock source of PTP module. * * @param [in] eClkSrc The clock source type */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetPTPClkSrc(ENET_MAC_PTPClkSelType eClkSrc) { SMISC->PERICTLR = (SMISC->PERICTLR & ~SMISC_PERICTLR_ENET_TS_CLKSEL_MASK) | SMISC_PERICTLR_ENET_TS_CLKSEL(eClkSrc); } /** * @brief Get MAC 5M mode enable flag * * @return true 5M mode is enabled * @return false 5M mode is disabled */ LOCAL_INLINE bool ENET_HWA_Sysctrl_Get5MModeEnFlag(void) { return ((SMISC->PERICTLR & SMISC_PERICTLR_ENET_5M_MODE_MASK) != 0u) ? true : false; } /** * @brief Set MAC 5M mode enable flag * * @param [in] bEnable enable or disable 5M mode */ LOCAL_INLINE void ENET_HWA_Sysctrl_Set5MModeEnFlag(bool bEnable) { SMISC->PERICTLR = (SMISC->PERICTLR & ~SMISC_PERICTLR_ENET_5M_MODE_MASK) | SMISC_PERICTLR_ENET_5M_MODE(bEnable); } /** * @brief Get PPS IO port direction * * @param [in] eChannel PPS channel * @return ENET_MAC_PPSPinDirType */ LOCAL_INLINE ENET_MAC_PPSPinDirType ENET_HWA_Sysctrl_GetPPSPinDirection(ENET_MAC_PPSChannelType eChannel) { uint32_t u32TmpVal; u32TmpVal = (SMISC->PERICTLR & (1u << (SMISC_PERICTLR_ENET_PPS0_OBECTL_SHIFT + eChannel))); return (u32TmpVal != 0u) ? ENET_PTP_PPS_DIR_OUTPUT : ENET_PTP_PPS_DIR_INPUT; } /** * @brief Set PPS IO port direction * * @param [in] eChannel PPS channel * @param [in] eDir IO port direction */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetPPSPinDirection(ENET_MAC_PPSChannelType eChannel, ENET_MAC_PPSPinDirType eDir) { SMISC->PERICTLR = (SMISC->PERICTLR & (~(1u << (SMISC_PERICTLR_ENET_PPS0_OBECTL_SHIFT + eChannel)))) | ((uint32_t)(((uint32_t)(eDir)) << (SMISC_PERICTLR_ENET_PPS0_OBECTL_SHIFT + eChannel))); } #endif /* ENET_SYSTEM_CONTROL_SMISC */ #if ENET_SYSTEM_CONTROL_SCM /** * @brief Get the Core Id. * * @return The Core Id number */ LOCAL_INLINE uint8_t ENET_HWA_Sysctrl_GetCoreId(void) { return (uint8_t)Cpm_HWA_GetCoreId(); } /** * @brief Set ENET clock software reset * */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetEnetClkSoftwareResetEnFlag(void) { SCM->ENET_CTRL |= SCM_ENET_CTRL_ENET_CLK_SWRST_MASK; } /** * @brief Set PHY interface mode * * @param [in] eMode PHY interface mode */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetPhyMiiMode(ENET_MAC_MiiModeType eMode) { SCM->ENET_CTRL = (SCM->ENET_CTRL & (~SCM_ENET_CTRL_PHY_SEL_MASK)) | SCM_ENET_CTRL_PHY_SEL(eMode); } #if ENET_SUPPORT_RGMII /** * @brief Get RGMII clock select source * * @return ENET_MAC_RGMIIClkSelType */ LOCAL_INLINE ENET_MAC_RGMIIClkSelType ENET_HWA_Sysctrl_GetRGMIIClockSrc(void) { return (ENET_MAC_RGMIIClkSelType)((SCM->ENET_CTRL & SCM_ENET_CTRL_ENET_RGMII_CLK_SEL_MASK) >> SCM_ENET_CTRL_ENET_RGMII_CLK_SEL_SHIFT); } /** * @brief Set RGMII clock select source * * @param [in] pEnet the base address of the ENET instance * @param [in] eClkSrc RGMII clock source */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetRGMIIClockSrc(ENET_MAC_RGMIIClkSelType eClkSrc) { SCM->ENET_CTRL = (SCM->ENET_CTRL & ~SCM_ENET_CTRL_ENET_RGMII_CLK_SEL_MASK) | SCM_ENET_CTRL_ENET_RGMII_CLK_SEL(eClkSrc); } #endif /** * @brief Get TX clock select source * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_TxClkSelType */ LOCAL_INLINE ENET_MAC_TxClkSelType ENET_HWA_Sysctrl_GetTxClockSrc(void) { return (ENET_MAC_TxClkSelType)((SCM->ENET_CTRL & SCM_ENET_CTRL_ENET_TXCLK_SEL_MASK) >> SCM_ENET_CTRL_ENET_TXCLK_SEL_SHIFT); } /** * @brief Set TX clock select source * * @param [in] pEnet the base address of the ENET instance * @param [in] eClkSrc TX clock source */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetTxClockSrc(ENET_MAC_TxClkSelType eClkSrc) { SCM->ENET_CTRL = (SCM->ENET_CTRL & ~SCM_ENET_CTRL_ENET_TXCLK_SEL_MASK) | SCM_ENET_CTRL_ENET_TXCLK_SEL(eClkSrc); } /** * @brief Select the clock source of PTP module. * * @return eClkSrc The clock source type */ LOCAL_INLINE ENET_MAC_PTPClkSelType ENET_HWA_Sysctrl_GetPTPClkSrc(void) { return (ENET_MAC_PTPClkSelType)((SCM->ENET_CTRL & SCM_ENET_CTRL_PTPCLK_SEL_MASK) >> SCM_ENET_CTRL_PTPCLK_SEL_SHIFT); } /** * @brief Select the clock source of PTP module. * * @param [in] eClkSrc The PTP clock source */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetPTPClkSrc(ENET_MAC_PTPClkSelType eClkSrc) { SCM->ENET_CTRL = (SCM->ENET_CTRL & ~SCM_ENET_CTRL_PTPCLK_SEL_MASK) | SCM_ENET_CTRL_PTPCLK_SEL(eClkSrc); } /** * @brief Get MAC 5M mode enable flag * * @return true 5M mode is enabled * @return false 5M mode is disabled */ LOCAL_INLINE bool ENET_HWA_Sysctrl_Get5MModeEnFlag(void) { return ((SCM->ENET_CTRL & SCM_ENET_CTRL_RMII_5M_MASK) != 0u) ? true : false; } /** * @brief Set MAC 5M mode enable flag * * @param [in] bEnable enable or disable 5M mode */ LOCAL_INLINE void ENET_HWA_Sysctrl_Set5MModeEnFlag(bool bEnable) { SCM->ENET_CTRL = (SCM->ENET_CTRL & ~SCM_ENET_CTRL_RMII_5M_MASK) | SCM_ENET_CTRL_RMII_5M(bEnable); } /** * @brief Get PPS IO port direction * * @param [in] eChannel PPS channel * @return ENET_MAC_PPSPinDirType */ LOCAL_INLINE ENET_MAC_PPSPinDirType ENET_HWA_Sysctrl_GetPPSPinDirection(ENET_MAC_PPSChannelType eChannel) { uint32_t u32TmpVal; u32TmpVal = SCM->ENET_CTRL & (1u << (SCM_ENET_CTRL_ENET_TIMER_OBE_SHIFT + (uint32_t)eChannel)); return (u32TmpVal != 0u) ? ENET_PTP_PPS_DIR_OUTPUT : ENET_PTP_PPS_DIR_INPUT; } /** * @brief Set PPS IO port direction * * @param [in] eChannel PPS channel * @param [in] eDir IO port direction */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetPPSPinDirection(ENET_MAC_PPSChannelType eChannel, ENET_MAC_PPSPinDirType eDir) { SCM->ENET_CTRL = (SCM->ENET_CTRL & (~(1u << (SCM_ENET_CTRL_ENET_TIMER_OBE_SHIFT + (uint32_t) eChannel)))) | SCM_ENET_CTRL_ENET_TIMER_OBE((uint32_t)eDir << (uint32_t)eChannel); } /** * @brief Get Mii TX clock output enable flag * * @return true Mii TX clock output is enabled * @return false Mii TX clock output is disabled */ LOCAL_INLINE bool ENET_HWA_Sysctrl_GetMiiTxClkOutputEnFlag(void) { return ((SCM->ENET_CTRL & SCM_ENET_CTRL_MII_TX_CLK_OBE_MASK) != 0u) ? true : false; } /** * @brief Set Mii TX clock output enable flag * * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_Sysctrl_SetMiiTxClkOutputEnFlag(bool bEnable) { SCM->ENET_CTRL = (SCM->ENET_CTRL & ~SCM_ENET_CTRL_MII_TX_CLK_OBE_MASK) | SCM_ENET_CTRL_MII_TX_CLK_OBE(bEnable); } #if ENET_SUPPORT_TCM_SMP_MODE /** * @brief Get SMP mode enable flag * * @return true SMP mode is enabled * @return false SMP mode is disabled */ LOCAL_INLINE bool ENET_HWA_Sysctrl_GetTcmSMPModeEnFlag(void) { return ((SCM->CHIPCFG2 & SCM_CHIPCFG2_SMP_EN_MASK) != 0u) ? true : false; } #endif #endif /* ENET_SYSTEM_CONTROL_SCM */ /** ================================================================ * * ENET MAC Configuration and Status * * ================================================================ */ /** * @brief Get the MAC Configuration Register value. * * @param [in] pEnet The base address of the ENET instance * @return The Register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetConfiguration(const ENET_Type *const pEnet) { return pEnet->MAC_CONFIGURATION; } /** * @brief Set the MAC Configuration Register value. * * @param [in] pEnet The base address of the ENET instance * @param [in] u32Config The Configuration Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetConfiguration(ENET_Type *const pEnet, uint32_t u32Config) { pEnet->MAC_CONFIGURATION = u32Config; } /** * @brief Get the source address insertion or replacement control type * * @param [in] pEnet the base address of the Ethernet instance * @return source address insertion or replacement control type */ LOCAL_INLINE ENET_MAC_SrcAddrCtrlType ENET_HWA_MAC_GetSrcAddrInsertReplaceCtrl(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_SARC_MASK) >> ENET_MAC_CONFIGURATION_SARC_SHIFT; return (ENET_MAC_SrcAddrCtrlType)u32TmpVal; } /** * @brief Set the source address insertion or replacement control type * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eInsertReplaceCtrl source address insertion or replacement control type */ LOCAL_INLINE void ENET_HWA_MAC_SetSrcAddrInsertReplaceCtrl(ENET_Type *const pEnet, ENET_MAC_SrcAddrCtrlType eInsertReplaceCtrl) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_SARC_MASK) | ENET_MAC_CONFIGURATION_SARC(eInsertReplaceCtrl); } /** * @brief Get checksum offload function enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Checksum offload function is enabled * @return false Checksum offload function is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetIPChecksumOffloadEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_IPC_MASK) >> ENET_MAC_CONFIGURATION_IPC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set checksum offload function enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetIPChecksumOffloadEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_IPC_MASK) | ENET_MAC_CONFIGURATION_IPC(bEnable ? 1u : 0u); } /** * @brief Get the minimum Inter-Packet Gap * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_InterPacketGapType. */ LOCAL_INLINE ENET_MAC_InterPacketGapType ENET_HWA_MAC_GetMinInterPacketGap(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_IPG_MASK) >> ENET_MAC_CONFIGURATION_IPG_SHIFT; return (ENET_MAC_InterPacketGapType)u32TmpVal; } /** * @brief Set the minimum Inter-Packet Gap value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eGap Inter-Packet Gap value */ LOCAL_INLINE void ENET_HWA_MAC_SetMinInterPacketGap(ENET_Type *const pEnet, ENET_MAC_InterPacketGapType eGap) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_IPG_MASK) | ENET_MAC_CONFIGURATION_IPG(eGap); } /** * @brief Get giant packet size Limit control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Giant packet size Limit control is enabled * @return false Giant packet size Limit control is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetGiantPacketSizeLimitCtrlEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_GPSLCE_MASK) >> ENET_MAC_CONFIGURATION_GPSLCE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set giant packet size Limit control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetGiantPacketSizeLimitCtrlEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_GPSLCE_MASK) | ENET_MAC_CONFIGURATION_GPSLCE(bEnable ? 1u : 0u); } /** * @brief Get 2K packet support enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true 2K packet support is enabled * @return false 2K packet support is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_Get2KPacketSupportFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_S2KP_MASK) >> ENET_MAC_CONFIGURATION_S2KP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set 2K packet support enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_Set2KPacketSupportFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_S2KP_MASK) | ENET_MAC_CONFIGURATION_S2KP(bEnable ? 1u : 0u); } /** * @brief Get CRC stripping for type packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true CRC stripping for type packets is enabled * @return false CRC stripping for type packets is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetStripTypePacketCRCEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_CST_MASK) >> ENET_MAC_CONFIGURATION_CST_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set CRC stripping for type packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetStripTypePacketCRCEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_CST_MASK) | ENET_MAC_CONFIGURATION_CST(bEnable ? 1u : 0u); } /** * @brief Get automatic Pad or CRC stripping enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Automatic Pad or CRC stripping is enabled * @return false Automatic Pad or CRC stripping is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetAutoStripPadOrCRCEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_ACS_MASK) >> ENET_MAC_CONFIGURATION_ACS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set automatic Pad or CRC stripping enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetAutoStripPadOrCRCEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_ACS_MASK) | ENET_MAC_CONFIGURATION_ACS(bEnable ? 1u : 0u); } /** * @brief Get receiver watchdog timer disabled flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Receiver watchdog timer is disabled * @return false Receiver watchdog timer is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetWatchdogDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_WD_MASK) >> ENET_MAC_CONFIGURATION_WD_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receiver watchdog timer disabled flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetWatchdogDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_WD_MASK) | ENET_MAC_CONFIGURATION_WD(bDisable ? 1u : 0u); } /** * @brief Get transmitter jabber timer disabled flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Transmitter jabber timer is disabled * @return false Transmitter jabber timer is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetJabberTimerDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_JD_MASK) >> ENET_MAC_CONFIGURATION_JD_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmitter jabber timer disabled flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetJabberTimerDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_JD_MASK) | ENET_MAC_CONFIGURATION_JD(bDisable ? 1u : 0u); } /** * @brief Get jumbo packet enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Jumbo packet is enabled * @return false Jumbo packet is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetJumboPacketEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_JE_MASK) >> ENET_MAC_CONFIGURATION_JE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set jumbo packet enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetJumboPacketEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_JE_MASK) | ENET_MAC_CONFIGURATION_JE(bEnable ? 1u : 0u); } /** * @brief Get ethernet line speed * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_SpeedType */ LOCAL_INLINE ENET_MAC_SpeedType ENET_HWA_MAC_GetSpeed(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & (ENET_MAC_CONFIGURATION_FES_MASK | ENET_MAC_CONFIGURATION_PS_MASK)) >> ENET_MAC_CONFIGURATION_FES_SHIFT; return (ENET_MAC_SpeedType)u32TmpVal; } /** * @brief Set ethernet line speed * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eSpeed Ethernet line speed */ LOCAL_INLINE void ENET_HWA_MAC_SetSpeed(ENET_Type *const pEnet, ENET_MAC_SpeedType eSpeed) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~(ENET_MAC_CONFIGURATION_FES_MASK | ENET_MAC_CONFIGURATION_PS_MASK)) | (((uint32_t)eSpeed << ENET_MAC_CONFIGURATION_FES_SHIFT) & (ENET_MAC_CONFIGURATION_FES_MASK | ENET_MAC_CONFIGURATION_PS_MASK)); } /** * @brief Get ethernet duplex mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_DuplexModeType */ LOCAL_INLINE ENET_MAC_DuplexModeType ENET_HWA_MAC_GetDuplexMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_DM_MASK) >> ENET_MAC_CONFIGURATION_DM_SHIFT; return (ENET_MAC_DuplexModeType)u32TmpVal; } /** * @brief Set ethernet duplex mode * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eMode Ethernet duplex mode */ LOCAL_INLINE void ENET_HWA_MAC_SetDuplexMode(ENET_Type *const pEnet, ENET_MAC_DuplexModeType eMode) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_DM_MASK) | ENET_MAC_CONFIGURATION_DM(eMode); } /** * @brief Get loopback mode enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Loopback mode is enabled * @return false Loopback mode is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLoopbackModeEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_LM_MASK) >> ENET_MAC_CONFIGURATION_LM_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set loopback mode enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLoopbackModeEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_LM_MASK) | ENET_MAC_CONFIGURATION_LM(bEnable ? 1u : 0u); } /** * @brief Get carrier sense before transmission enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Carrier sense before transmission is enabled * @return false Carrier sense before transmission is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetFullDuplexCRSEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_ECRSFD_MASK) >> ENET_MAC_CONFIGURATION_ECRSFD_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set carrier sense before transmission enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetFullDuplexCRSEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_ECRSFD_MASK) | ENET_MAC_CONFIGURATION_ECRSFD(bEnable ? 1u : 0u); } /** * @brief Get receive own disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Receive own is disabled * @return false Receive own is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetReceiveOwnDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_DO_MASK) >> ENET_MAC_CONFIGURATION_DO_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive own disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetReceiveOwnDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_DO_MASK) | ENET_MAC_CONFIGURATION_DO(bDisable ? 1u : 0u); } /** * @brief Get carrier sense during transmission disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Carrier sense during transmission is disabled * @return false Carrier sense during transmission is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetHalfDuplexCRSDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_DCRS_MASK) >> ENET_MAC_CONFIGURATION_DCRS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set carrier sense during transmission disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetHalfDuplexCRSDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_DCRS_MASK) | ENET_MAC_CONFIGURATION_DCRS(bDisable ? 1u : 0u); } /** * @brief Get transmission retry disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Ttransmission retry is disabled * @return false Transmission retry is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRetryDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_DR_MASK) >> ENET_MAC_CONFIGURATION_DR_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmission retry disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetRetryDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_DR_MASK) | ENET_MAC_CONFIGURATION_DR(bDisable ? 1u : 0u); } /** * @brief Get back-off limit * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_BackOffLimitType */ LOCAL_INLINE ENET_MAC_BackOffLimitType ENET_HWA_MAC_GetBackOffLimit(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_BL_MASK) >> ENET_MAC_CONFIGURATION_BL_SHIFT; return (ENET_MAC_BackOffLimitType)u32TmpVal; } /** * @brief Set back-off limit * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eLimit Back-off limit type value */ LOCAL_INLINE void ENET_HWA_MAC_SetBackOffLimit(ENET_Type *const pEnet, ENET_MAC_BackOffLimitType eLimit) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_BL_MASK) | ENET_MAC_CONFIGURATION_BL(eLimit); } /** * @brief Get deferral check enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Deferral check is enabled * @return false Deferral check is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetDeferralCheckEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_DC_MASK) >> ENET_MAC_CONFIGURATION_DC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set deferral check enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetDeferralCheckEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_DC_MASK) | ENET_MAC_CONFIGURATION_DC(bEnable ? 1u : 0u); } /** * @brief Get transmitter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Transmitter is enabled * @return false Transmitter is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_TE_MASK) >> ENET_MAC_CONFIGURATION_TE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmitter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetTxEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_TE_MASK) | ENET_MAC_CONFIGURATION_TE(bEnable ? 1u : 0u); } /** * @brief Get receiver enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Receiver is enabled * @return false Receiver is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_CONFIGURATION & ENET_MAC_CONFIGURATION_RE_MASK) >> ENET_MAC_CONFIGURATION_RE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receiver enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_CONFIGURATION = (pEnet->MAC_CONFIGURATION & ~ENET_MAC_CONFIGURATION_RE_MASK) | ENET_MAC_CONFIGURATION_RE(bEnable ? 1u : 0u); } /** * @brief Get the MAC extended configuration register value * * @param [in] pEnet the base address of the Ethernet instance * @return The register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetExtConfiguration(const ENET_Type *const pEnet) { return pEnet->MAC_EXT_CONFIGURATION; } /** * @brief Set the MAC extended configuration register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Configuration The configuration register value */ LOCAL_INLINE void ENET_HWA_MAC_SetExtConfiguration(ENET_Type *const pEnet, uint32_t u32Configuration) { pEnet->MAC_EXT_CONFIGURATION = u32Configuration; } /** * @brief Get the MAC extended inter-packet gap * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_ExtInterPacketGapType */ LOCAL_INLINE ENET_MAC_ExtInterPacketGapType ENET_HWA_MAC_GetExtInterPacketGap(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_EIPG_MASK) >> ENET_MAC_EXT_CONFIGURATION_EIPG_SHIFT; return (ENET_MAC_ExtInterPacketGapType)u32TmpVal; } /** * @brief Set the MAC extended inter-packet gap * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eGap The MAC extended inter-packet gap value */ LOCAL_INLINE void ENET_HWA_MAC_SetExtInterPacketGap(ENET_Type *const pEnet, ENET_MAC_ExtInterPacketGapType eGap) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_EIPG_MASK) | ENET_MAC_EXT_CONFIGURATION_EIPG(eGap); } /** * @brief Get extended inter-packet gap enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Extended inter-packet gapis enabled * @return false Extended inter-packet gap is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetExtInterPacketGapEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_EIPGEN_MASK) >> ENET_MAC_EXT_CONFIGURATION_EIPGEN_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set extended inter-packet gap enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetExtInterPacketGapEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_EIPGEN_MASK) | ENET_MAC_EXT_CONFIGURATION_EIPGEN(bEnable ? 1u : 0u); } /** * @brief Get packet duplication control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Packet duplication control enabled * @return false Packet duplication control is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetPacketDuplicationCtrlEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_PDC_MASK) >> ENET_MAC_EXT_CONFIGURATION_PDC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set packet duplication control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPacketDuplicationCtrlEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_PDC_MASK) | ENET_MAC_EXT_CONFIGURATION_PDC(bEnable ? 1u : 0u); } /** * @brief Get unicast slow protocol packet detect method * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_SlowProtocolDetectType */ LOCAL_INLINE ENET_MAC_SlowProtocolDetectType ENET_HWA_MAC_GetUnicastSlowProtocolPacketDetectMethod( const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_USP_MASK) >> ENET_MAC_EXT_CONFIGURATION_USP_SHIFT; return (ENET_MAC_SlowProtocolDetectType)u32TmpVal; } /** * @brief Set unicast slow protocol packet detect method * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eMethod Unicast slow protocol packet detect method value */ LOCAL_INLINE void ENET_HWA_MAC_SetUnicastSlowProtocolPacketDetectMethod(ENET_Type *const pEnet, ENET_MAC_SlowProtocolDetectType eMethod) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_USP_MASK) | ENET_MAC_EXT_CONFIGURATION_USP(eMethod); } /** * @brief Get slow protocol detection enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Slow protocol detection enabled * @return false Slow protocol detection is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetSlowDetectEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_SPEN_MASK) >> ENET_MAC_EXT_CONFIGURATION_SPEN_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set slow protocol detection enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetSlowDetectEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_SPEN_MASK) | ENET_MAC_EXT_CONFIGURATION_SPEN(bEnable ? 1u : 0u); } /** * @brief Get CRC checking for Received packets disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true CRC checking for rReceived packets is disabled * @return false CRC checking for rReceived packets is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxCRCCheckDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_DCRCC_MASK) >> ENET_MAC_EXT_CONFIGURATION_DCRCC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set CRC checking for rReceived packets disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxCRCCheckDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_DCRCC_MASK) | ENET_MAC_EXT_CONFIGURATION_DCRCC(bDisable ? 1u : 0u); } /** * @brief Get giant packet size limit value * * @param [in] pEnet the base address of the Ethernet instance * @return Giant packet size limit value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetGiantPacketSizeLimit(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_EXT_CONFIGURATION & ENET_MAC_EXT_CONFIGURATION_GPSL_MASK) >> ENET_MAC_EXT_CONFIGURATION_GPSL_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set giant packet size limit value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u16SizeLimit Giant packet size limit value */ LOCAL_INLINE void ENET_HWA_MAC_SetGiantPacketSizeLimit(ENET_Type *const pEnet, uint16_t u16SizeLimit) { pEnet->MAC_EXT_CONFIGURATION = (pEnet->MAC_EXT_CONFIGURATION & ~ENET_MAC_EXT_CONFIGURATION_GPSL_MASK) | ENET_MAC_EXT_CONFIGURATION_GPSL(u16SizeLimit); } /** * @brief Get the MAC packet filter register value * * @param [in] pEnet the base address of the Ethernet instance * @return The register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPacketFilter(const ENET_Type *const pEnet) { return pEnet->MAC_PACKET_FILTER; } /** * @brief Set the MAC packet filter register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32FilterCtrl The filter control value */ LOCAL_INLINE void ENET_HWA_MAC_SetPacketFilter(ENET_Type *const pEnet, uint32_t u32FilterCtrl) { pEnet->MAC_PACKET_FILTER = u32FilterCtrl; } /** * @brief Get receive all packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Receive all packets enabled * @return false Receive all packets is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetReceiveAllEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_RA_MASK) >> ENET_MAC_PACKET_FILTER_RA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive all packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetReceiveAllEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_RA_MASK) | ENET_MAC_PACKET_FILTER_RA(bEnable ? 1u : 0u); } /** * @brief Get drop non-TCP/UDP over IP packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Drop non-TCP/UDP over IP packets * @return false Forward non-TCP/UDP over IP packets */ LOCAL_INLINE bool ENET_HWA_MAC_GetDropNonTCPUDPOverIPEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_DNTU_MASK) >> ENET_MAC_PACKET_FILTER_DNTU_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set drop non-TCP/UDP over IP packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Drop or forward non-TCP/UDP over IP packets */ LOCAL_INLINE void ENET_HWA_MAC_SetDropNonTCPUDPOverIPEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_DNTU_MASK) | ENET_MAC_PACKET_FILTER_DNTU(bEnable ? 1u : 0u); } /** * @brief Get layer 3 and layer 4 filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Enable layer 3 and layer 4 filter * @return false Disable layer 3 and layer 4 filter */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer3Layer4FilterEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_IPFE_MASK) >> ENET_MAC_PACKET_FILTER_IPFE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 3 and layer 4 filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Layer4FilterEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_IPFE_MASK) | ENET_MAC_PACKET_FILTER_IPFE(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Enable VLAN tag filter * @return false Disable VLAN tag filter */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANTagFilterEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_VTFE_MASK) >> ENET_MAC_PACKET_FILTER_VTFE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagFilterFilterEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_VTFE_MASK) | ENET_MAC_PACKET_FILTER_VTFE(bEnable ? 1u : 0u); } /** * @brief Get hash or perfect filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Enable hash or pPerfect filter * @return false Disable hash or pPerfect filter */ LOCAL_INLINE bool ENET_HWA_MAC_GetHashOrPerfectFilterEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_HPF_MASK) >> ENET_MAC_PACKET_FILTER_HPF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set hash or perfect filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetHashOrPerfectFilterEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_HPF_MASK) | ENET_MAC_PACKET_FILTER_HPF(bEnable ? 1u : 0u); } /** * @brief Get source address filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Enable source address filter * @return false Disable source address fFilter */ LOCAL_INLINE bool ENET_HWA_MAC_GetSourceAddressFilterEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_SAF_MASK) >> ENET_MAC_PACKET_FILTER_SAF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set source address filter enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetSourceAddressFilterEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_SAF_MASK) | ENET_MAC_PACKET_FILTER_SAF(bEnable ? 1u : 0u); } /** * @brief Get source address filter mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_AddrFilterModeType */ LOCAL_INLINE ENET_MAC_AddrFilterModeType ENET_HWA_MAC_GetSrcAddrFilterMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_SAIF_MASK) >> ENET_MAC_PACKET_FILTER_SAIF_SHIFT; return (ENET_MAC_AddrFilterModeType)u32TmpVal; } /** * @brief Set source address filter mode * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eFilterMode Source address filter mode */ LOCAL_INLINE void ENET_HWA_MAC_SetSrcAddrFilterMode(ENET_Type *const pEnet, ENET_MAC_AddrFilterModeType eFilterMode) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_SAIF_MASK) | ENET_MAC_PACKET_FILTER_SAIF(eFilterMode); } /** * @brief Get control packets filter mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_CtrlPacketFilterModeType */ LOCAL_INLINE ENET_MAC_CtrlPacketFilterModeType ENET_HWA_MAC_GetCtrlPacketFilterMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_PCF_MASK) >> ENET_MAC_PACKET_FILTER_PCF_SHIFT; return (ENET_MAC_CtrlPacketFilterModeType)u32TmpVal; } /** * @brief Set control packets filter mode * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eFilterMode Control packets filter mode */ LOCAL_INLINE void ENET_HWA_MAC_SetCtrlPacketFilterMode(ENET_Type *const pEnet, ENET_MAC_CtrlPacketFilterModeType eFilterMode) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_PCF_MASK) | ENET_MAC_PACKET_FILTER_PCF(eFilterMode); } /** * @brief Get broadcast packets disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Drop broadcast packets * @return false receive broadcast packets */ LOCAL_INLINE bool ENET_HWA_MAC_GetBroadcastPacketDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_DBF_MASK) >> ENET_MAC_PACKET_FILTER_DBF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set broadcast packets disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetBroadcastPacketDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_DBF_MASK) | ENET_MAC_PACKET_FILTER_DBF(bDisable ? 1u : 0u); } /** * @brief Get pass all the received multicast packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Pass all the received multicast packets * @return false Pass multicast packets that match the multicast filter */ LOCAL_INLINE bool ENET_HWA_MAC_GetPassAllMulticastEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_PM_MASK) >> ENET_MAC_PACKET_FILTER_PM_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set pass all the received multicast packets enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPassAllMulticastEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_PM_MASK) | ENET_MAC_PACKET_FILTER_PM(bEnable ? 1u : 0u); } /** * @brief Get destination address filter mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_AddrFilterModeType */ LOCAL_INLINE ENET_MAC_AddrFilterModeType ENET_HWA_MAC_GetDestAddrFilterMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_DAIF_MASK) >> ENET_MAC_PACKET_FILTER_DAIF_SHIFT; return (ENET_MAC_AddrFilterModeType)u32TmpVal; } /** * @brief Set destination address filter mode * * @param [in] pEnet the base address of the Ethernet instance * @param eFilterMode Destination address filter mode */ LOCAL_INLINE void ENET_HWA_MAC_SetDestAddrFilterMode(ENET_Type *const pEnet, ENET_MAC_AddrFilterModeType eFilterMode) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_DAIF_MASK) | ENET_MAC_PACKET_FILTER_DAIF(eFilterMode); } /** * @brief Get hash or perfect multicast filter mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_HashOrPerfectModeType */ LOCAL_INLINE ENET_MAC_HashOrPerfectModeType ENET_HWA_MAC_GetHashOrPerfectMulticastMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_HMC_MASK) >> ENET_MAC_PACKET_FILTER_HMC_SHIFT; return (ENET_MAC_HashOrPerfectModeType)u32TmpVal; } /** * @brief Set hash or perfect multicast filter mode * * @param [in] pEnet the base address of the Ethernet instance * @param eMode Hash or perfect multicast filter mode */ LOCAL_INLINE void ENET_HWA_MAC_SetHashOrPerfectMulticastMode(ENET_Type *const pEnet, ENET_MAC_HashOrPerfectModeType eMode) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_HMC_MASK) | ENET_MAC_PACKET_FILTER_HMC(eMode); } /** * @brief Get hash or perfect unicast filter mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_HashOrPerfectModeType */ LOCAL_INLINE ENET_MAC_HashOrPerfectModeType ENET_HWA_MAC_GetHashOrPerfectUnicastMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_HMC_MASK) >> ENET_MAC_PACKET_FILTER_HMC_SHIFT; return (ENET_MAC_HashOrPerfectModeType)u32TmpVal; } /** * @brief Set hash or perfect unicast filter mode * * @param [in] pEnet the base address of the Ethernet instance * @param eMode Hash or perfect unicast filter mode */ LOCAL_INLINE void ENET_HWA_MAC_SetHashOrPerfectUnicastMode(ENET_Type *const pEnet, ENET_MAC_HashOrPerfectModeType eMode) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_HUC_MASK) | ENET_MAC_PACKET_FILTER_HUC(eMode); } /** * @brief Get promiscuous mode enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Enable promiscuous mode * @return false Disable promiscuous mode */ LOCAL_INLINE bool ENET_HWA_MAC_GetPromiscuousModeEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_PACKET_FILTER & ENET_MAC_PACKET_FILTER_PR_MASK) >> ENET_MAC_PACKET_FILTER_PR_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set promiscuous mode enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPromiscuousModeEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_PACKET_FILTER = (pEnet->MAC_PACKET_FILTER & ~ENET_MAC_PACKET_FILTER_PR_MASK) | ENET_MAC_PACKET_FILTER_PR(bEnable ? 1u : 0u); } /** * @brief Get programmable watchdog timeout register value * * @param [in] pEnet the base address of the Ethernet instance * @return Watchdog timeout register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetWatchdogTimeout(const ENET_Type *const pEnet) { return pEnet->MAC_WATCHDOG_TIMEOUT; } /** * @brief Set programmable watchdog timeout register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Settings Watchdog timeout register value */ LOCAL_INLINE void ENET_HWA_MAC_SetWatchdogTimeout(ENET_Type *const pEnet, uint32_t u32Settings) { pEnet->MAC_WATCHDOG_TIMEOUT = u32Settings; } /** * @brief Get programmable watchdog enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Programmable watchdog enabled * @return false Programmable watchdog disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetWatchdogEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_WATCHDOG_TIMEOUT & ENET_MAC_WATCHDOG_TIMEOUT_PWE_MASK) >> ENET_MAC_WATCHDOG_TIMEOUT_PWE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set programmable watchdog enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetWatchdogEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_WATCHDOG_TIMEOUT = (pEnet->MAC_WATCHDOG_TIMEOUT & ~ENET_MAC_WATCHDOG_TIMEOUT_PWE_MASK) | ENET_MAC_WATCHDOG_TIMEOUT_PWE(bEnable ? 1u : 0u); } /** * @brief Get programmable watchdog timer size value * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_WDGTimerSizeType */ LOCAL_INLINE ENET_MAC_WDGTimerSizeType ENET_HWA_MAC_GetWatchdogTimerSize(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_WATCHDOG_TIMEOUT & ENET_MAC_WATCHDOG_TIMEOUT_WTO_MASK) >> ENET_MAC_WATCHDOG_TIMEOUT_WTO_SHIFT; return (ENET_MAC_WDGTimerSizeType)u32TmpVal; } /** * @brief Set programmable watchdog timer size * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eSize Watchdog timer size */ LOCAL_INLINE void ENET_HWA_MAC_SetWatchdogTimerSize(ENET_Type *const pEnet, ENET_MAC_WDGTimerSizeType eSize) { pEnet->MAC_WATCHDOG_TIMEOUT = (pEnet->MAC_WATCHDOG_TIMEOUT & ~ENET_MAC_WATCHDOG_TIMEOUT_WTO_MASK) | ENET_MAC_WATCHDOG_TIMEOUT_WTO(eSize); } /** * @brief Get the hash table first 32 bits value * * @param [in] pEnet the base address of the Ethernet instance * @return Hash table first 32 bits value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetHashTableFirst32Bits(const ENET_Type *const pEnet) { return pEnet->MAC_HASH_TABLE_REG0; } /** * @brief Set the hash table first 32 bits value * * @param [in] pEnet the base address of the Ethernet instance * @param u32Hash0 Hash table first 32 bits value */ LOCAL_INLINE void ENET_HWA_MAC_SetHashTableFirst32Bits(ENET_Type *const pEnet, uint32_t u32Hash0) { pEnet->MAC_HASH_TABLE_REG0 = u32Hash0; } /** * @brief Get the hash table second 32 bits value * * @param [in] pEnet the base address of the Ethernet instance * @return Hash table second 32 bits value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetHashTableSecond32Bits(const ENET_Type *const pEnet) { return pEnet->MAC_HASH_TABLE_REG1; } /** * @brief Set the hash table second 32 bits value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Hash1 Hash table second 32 bits value */ LOCAL_INLINE void ENET_HWA_MAC_SetHashTableSecond32Bits(ENET_Type *const pEnet, uint32_t u32Hash1) { pEnet->MAC_HASH_TABLE_REG1 = u32Hash1; } /** * @brief Get VLAN tag control register value * * @param [in] pEnet the base address of the Ethernet instance * @return VLAN tag control register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetVLANTagCtrl(const ENET_Type *const pEnet) { return pEnet->MAC_VLAN_TAG_CTRL; } /** * @brief Set VLAN tag control register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32VlanCtrl Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagCtrl(ENET_Type *const pEnet, uint32_t u32VlanCtrl) { pEnet->MAC_VLAN_TAG_CTRL = u32VlanCtrl; } /** * @brief Get inner VLAN tag enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Inner VLAN tag is enabled * @return false Inner VLAN tag is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxStatusInnerVLANTagEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_EIVLRXS_MASK) >> ENET_MAC_VLAN_TAG_CTRL_EIVLRXS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set inner VLAN tag enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxStatusInnerVLANTagEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_EIVLRXS_MASK) | ENET_MAC_VLAN_TAG_CTRL_EIVLRXS(bEnable ? 1u : 0u); } /** * @brief Get inner VLAN tag stripping mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANTagStripModeType */ LOCAL_INLINE ENET_MAC_VLANTagStripModeType ENET_HWA_MAC_GetInnerVLANTagStripMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_EIVLS_MASK) >> ENET_MAC_VLAN_TAG_CTRL_EIVLS_SHIFT; return (ENET_MAC_VLANTagStripModeType)u32TmpVal; } /** * @brief Set inner VLAN tag stripping mode * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eMode Inner VLAN tag stripping mode */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANTagStripMode(ENET_Type *const pEnet, ENET_MAC_VLANTagStripModeType eMode) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_EIVLS_MASK) | ENET_MAC_VLAN_TAG_CTRL_EIVLS(eMode); } /** * @brief Get inner VLAN tag comparison enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Inner VLAN tag comparison is enabled * @return false Inner VLAN tag comparison is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetInnerVLANTagCmpEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_ERIVLT_MASK) >> ENET_MAC_VLAN_TAG_CTRL_ERIVLT_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set inner VLAN tag comparison enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANTagCmpEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_ERIVLT_MASK) | ENET_MAC_VLAN_TAG_CTRL_ERIVLT(bEnable ? 1u : 0u); } /** * @brief Get double VLAN processing enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Double VLAN processing is enabled * @return false Double VLAN processing is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetDoubleVLANProcessEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_EDVLP_MASK) >> ENET_MAC_VLAN_TAG_CTRL_EDVLP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set double VLAN processing enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetDoubleVLANProcessEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_EDVLP_MASK) | ENET_MAC_VLAN_TAG_CTRL_EDVLP(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag hash table match enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN tag hash table match is enabled * @return false VLAN tag hash table match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANTagHashTableMatchEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_VTHM_MASK) >> ENET_MAC_VLAN_TAG_CTRL_VTHM_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag hash table match enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagHashTableMatchEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_VTHM_MASK) | ENET_MAC_VLAN_TAG_CTRL_VTHM(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag in rx status enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN tag in rx status is enabled * @return false VLAN tag in rx status is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxStatusVLANTagEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_EVLRXS_MASK) >> ENET_MAC_VLAN_TAG_CTRL_EVLRXS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag in rx status enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxStatusVLANTagEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_EVLRXS_MASK) | ENET_MAC_VLAN_TAG_CTRL_EVLRXS(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag stripping mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANTagStripModeType */ LOCAL_INLINE ENET_MAC_VLANTagStripModeType ENET_HWA_MAC_GetVLANTagStripMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_EVLS_MASK) >> ENET_MAC_VLAN_TAG_CTRL_EVLS_SHIFT; return (ENET_MAC_VLANTagStripModeType)u32TmpVal; } /** * @brief Set VLAN tag stripping mode * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eMode VLAN tag stripping mode */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagStripMode(ENET_Type *const pEnet, ENET_MAC_VLANTagStripModeType eMode) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_EVLS_MASK) | ENET_MAC_VLAN_TAG_CTRL_EVLS(eMode); } /** * @brief Get VLAN type check disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN type check is disabled * @return false VLAN type check is enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANTypeCheckDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_DOVLTC_MASK) >> ENET_MAC_VLAN_TAG_CTRL_DOVLTC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN type check disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTypeCheckDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_DOVLTC_MASK) | ENET_MAC_VLAN_TAG_CTRL_DOVLTC(bDisable ? 1u : 0u); } /** * @brief Get Receive S-VLAN match enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Receive S-VLAN match is enabled * @return false Receive S-VLAN match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxSVLANMatchEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_ERSVLM_MASK) >> ENET_MAC_VLAN_TAG_CTRL_ERSVLM_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set Receive S-VLAN match enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxSVLANMatchEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_ERSVLM_MASK) | ENET_MAC_VLAN_TAG_CTRL_ERSVLM(bEnable ? 1u : 0u); } /** * @brief Get S-VLAN enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true S-VLAN is enabled * @return false S-VLAN is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetSVLANEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_ESVL_MASK) >> ENET_MAC_VLAN_TAG_CTRL_ESVL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set S-VLAN enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetSVLANEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_ESVL_MASK) | ENET_MAC_VLAN_TAG_CTRL_ESVL(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag inverse match enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN tag inverse match is enabled * @return false VLAN tag inverse match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANInverseMatchEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_VTIM_MASK) >> ENET_MAC_VLAN_TAG_CTRL_VTIM_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag inverse match enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANInverseMatchEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_VTIM_MASK) | ENET_MAC_VLAN_TAG_CTRL_VTIM(bEnable ? 1u : 0u); } /** * @brief Get 12-Bit VLAN tag comparison enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true 12-Bit VLAN tag comparison is enabled * @return false 12-Bit VLAN tag comparison is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_Get12BitVLANTagEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_ETV_MASK) >> ENET_MAC_VLAN_TAG_CTRL_ETV_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set 12-Bit VLAN tag comparison enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_Set12BitVLANTagEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_ETV_MASK) | ENET_MAC_VLAN_TAG_CTRL_ETV(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag filter register address offset * * @param [in] pEnet the base address of the Ethernet instance * @return VLAN tag filter register address offset */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetVLANTagFilterRegOffset(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_OFS_MASK) >> ENET_MAC_VLAN_TAG_CTRL_OFS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set VLAN tag filter register address offset * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u8Offset VLAN tag filter register address offset */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagFilterRegOffset(ENET_Type *const pEnet, uint8_t u8Offset) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_OFS_MASK) | ENET_MAC_VLAN_TAG_CTRL_OFS(u8Offset); } /** * @brief Get VLAN tag filter register command type * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANCommandType */ LOCAL_INLINE ENET_MAC_VLANCommandType ENET_HWA_MAC_GetVLANCommandType(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_CT_MASK) >> ENET_MAC_VLAN_TAG_CTRL_CT_SHIFT; return (ENET_MAC_VLANCommandType)u32TmpVal; } /** * @brief Set VLAN tag filter register command type * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eCommand Command type */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANCommandType(ENET_Type *const pEnet, ENET_MAC_VLANCommandType eCommand) { pEnet->MAC_VLAN_TAG_CTRL = (pEnet->MAC_VLAN_TAG_CTRL & ~ENET_MAC_VLAN_TAG_CTRL_CT_MASK) | ENET_MAC_VLAN_TAG_CTRL_CT(eCommand); } /** * @brief Get VLAN tag filter register operation status * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetVLANOperationStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_TAG_CTRL & ENET_MAC_VLAN_TAG_CTRL_OB_MASK) >> ENET_MAC_VLAN_TAG_CTRL_OB_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Set VLAN tag filter register operation busy status * * @param [in] pEnet the base address of the Ethernet instance */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANOperationBusy(ENET_Type *const pEnet) { pEnet->MAC_VLAN_TAG_CTRL |= ENET_MAC_VLAN_TAG_CTRL_OB_MASK; } /** * @brief Get VLAN tag data registers value * * @param [in] pEnet the base address of the Ethernet instance * @return VLAN tag data registers value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetVLANTagData(const ENET_Type *const pEnet) { return pEnet->MAC_VLAN_TAG_DATA; } /** * @brief Set VLAN tag data registers value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32VLANData Data value */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagData(ENET_Type *const pEnet, uint32_t u32VLANData) { pEnet->MAC_VLAN_TAG_DATA = u32VLANData; } /** * @brief Get VLAN hash table registers value * * @param [in] pEnet the base address of the Ethernet instance * @return VLAN hash tTable registers value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetVLANHashTable(const ENET_Type *const pEnet) { return (uint16_t)(pEnet->MAC_VLAN_HASH_TABLE & ENET_MAC_VLAN_HASH_TABLE_VLHT_MASK); } /** * @brief Set VLAN hash table registers value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u16HashTable VLAN hash table registers value */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANHashTable(ENET_Type *const pEnet, uint16_t u16HashTable) { pEnet->MAC_VLAN_HASH_TABLE = ENET_MAC_VLAN_HASH_TABLE_VLHT(u16HashTable); } /** * @brief Get VLAN tag inclusion register value * * @param [in] pEnet the base address of the Ethernet instance * @return VLAN tag inclusion registers value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetVLANInclusion(const ENET_Type *const pEnet) { return pEnet->MAC_VLAN_INCL_DATA; } /** * @brief Set VLAN tag inclusion register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Inclusion VLAN tag inclusion register value */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANInclusion(ENET_Type *const pEnet, uint32_t u32Inclusion) { pEnet->MAC_VLAN_INCL_DATA = u32Inclusion; } /** * @brief Get VLAN inclusion operation status * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetVLANInclusionOperationStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_BUSY_MASK) >> ENET_MAC_VLAN_INCL_BUSY_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Set VLAN inclusion operation status * * @param [in] pEnet the base address of the Ethernet instance */ LOCAL_INLINE ENET_MAC_VLANInclCommandType ENET_HWA_MAC_GetVLANInclusionCommandType(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_RDWR_MASK) >> ENET_MAC_VLAN_INCL_RDWR_SHIFT; return (ENET_MAC_VLANInclCommandType)u32TmpVal; } /** * @brief Set VLAN tag inclusion command * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eCommand VLAN tag inclusion command */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANInclusionCommandType(ENET_Type *const pEnet, ENET_MAC_VLANInclCommandType eCommand) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_RDWR_MASK) | ENET_MAC_VLAN_INCL_RDWR(eCommand); } /** * @brief Get VLAN inclusion address * * @param [in] pEnet the base address of the Ethernet instance * @return VLAN inclusion address value */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetVLANInclusionAddr(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_ADDR_MASK) >> ENET_MAC_VLAN_INCL_ADDR_SHIFT; return (uint8_t) u32TmpVal; } /** * @brief Set VLAN inclusion address * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u8Addr VLAN tag inclusion address value */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANInclusionAddr(ENET_Type *const pEnet, uint8_t u8Addr) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_ADDR_MASK) | ENET_MAC_VLAN_INCL_ADDR(u8Addr); } /** * @brief Get channel based tag insertion enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Channel based tag insertion is enabled * @return false Channel based tag insertion is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetChannelBasedVLANTagInsertEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_CBTI_MASK) >> ENET_MAC_VLAN_INCL_CBTI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set channel based tag insertion enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetChannelBasedVLANTagInsertEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_CBTI_MASK) | ENET_MAC_VLAN_INCL_CBTI(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag input enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN tag input is enabled * @return false VLAN tag input is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANTagInputEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_VLTI_MASK) >> ENET_MAC_VLAN_INCL_VLTI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag input enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagInputEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_VLTI_MASK) | ENET_MAC_VLAN_INCL_VLTI(bEnable ? 1u : 0u); } /** * @brief Get VLAN type * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANType */ LOCAL_INLINE ENET_MAC_VLANType ENET_HWA_MAC_GetVLANType(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_CSVL_MASK) >> ENET_MAC_VLAN_INCL_CSVL_SHIFT; return (ENET_MAC_VLANType)u32TmpVal; } /** * @brief Set VLAN type * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eType VLAN type */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANType(ENET_Type *const pEnet, ENET_MAC_VLANType eType) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_CSVL_MASK) | ENET_MAC_VLAN_INCL_CSVL(eType); } /** * @brief Get VLAN priority control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN priority control is enabled * @return false VLAN priority control is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANPriorityCtrlEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_VLP_MASK) >> ENET_MAC_VLAN_INCL_VLP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag input enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANPriorityCtrlEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_VLP_MASK) | ENET_MAC_VLAN_INCL_VLP(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag control mode in transmit packets * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANTagCtrlType */ LOCAL_INLINE ENET_MAC_VLANTagCtrlType ENET_HWA_MAC_GetVLANTagCtrlOperation(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_VLC_MASK) >> ENET_MAC_VLAN_INCL_VLC_SHIFT; return (ENET_MAC_VLANTagCtrlType)u32TmpVal; } /** * @brief Set VLAN tag control mode in transmit packets * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eCtrl VLAN tag control mode */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagCtrlOperation(ENET_Type *const pEnet, ENET_MAC_VLANTagCtrlType eCtrl) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_VLC_MASK) | ENET_MAC_VLAN_INCL_VLC(eCtrl); } /** * @brief Get Tx VLAN tag value * * @param [in] pEnet the base address of the Ethernet instance * @return Tx VLAN tag value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetTxVLANTag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_VLAN_INCL_DATA & ENET_MAC_VLAN_INCL_VLT_MASK) >> ENET_MAC_VLAN_INCL_VLT_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set Tx VLAN tag value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u16VLANTag VLAN tag value */ LOCAL_INLINE void ENET_HWA_MAC_SetTxVLANTag(ENET_Type *const pEnet, uint16_t u16VLANTag) { pEnet->MAC_VLAN_INCL_DATA = (pEnet->MAC_VLAN_INCL_DATA & ~ENET_MAC_VLAN_INCL_VLT_MASK) | ENET_MAC_VLAN_INCL_VLT(u16VLANTag); } /** * @brief Get inner VLAN tag inclusion or replacement register value * * @param [in] pEnet the base address of the Ethernet instance * @return The register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetInnerVLANInclusion(const ENET_Type *const pEnet) { return pEnet->MAC_INNER_VLAN_INCL; } /** * @brief Set inner VLAN tag inclusion or replacement register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Inclusion Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANInclusion(ENET_Type *const pEnet, uint32_t u32Inclusion) { pEnet->MAC_INNER_VLAN_INCL = u32Inclusion; } /** * @brief Get inner VLAN tag input enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Inner VLAN tag input is enabled * @return false Inner VLAN tag input is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetInnerVLANTagInputEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INNER_VLAN_INCL & ENET_MAC_INNER_VLAN_INCL_VLTI_MASK) >> ENET_MAC_INNER_VLAN_INCL_VLTI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set inner VLAN tag input enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANTagInputEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INNER_VLAN_INCL = (pEnet->MAC_INNER_VLAN_INCL & ~ENET_MAC_INNER_VLAN_INCL_VLTI_MASK) | ENET_MAC_INNER_VLAN_INCL_VLTI(bEnable ? 1u : 0u); } /** * @brief Get inner VLAN type * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANType */ LOCAL_INLINE ENET_MAC_VLANType ENET_HWA_MAC_GetInnerVLANType(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INNER_VLAN_INCL & ENET_MAC_INNER_VLAN_INCL_CSVL_MASK) >> ENET_MAC_INNER_VLAN_INCL_CSVL_SHIFT; return (ENET_MAC_VLANType)u32TmpVal; } /** * @brief Set inner VLAN type * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eType Inner VLAN type */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANType(ENET_Type *const pEnet, ENET_MAC_VLANType eType) { pEnet->MAC_INNER_VLAN_INCL = (pEnet->MAC_INNER_VLAN_INCL & ~ENET_MAC_INNER_VLAN_INCL_CSVL_MASK) | ENET_MAC_INNER_VLAN_INCL_CSVL(eType); } /** * @brief Get inner VLAN priority control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Inner VLAN priority control is enabled * @return false Inner VLAN priority control is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetInnerVLANPriorityCtrlEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INNER_VLAN_INCL & ENET_MAC_INNER_VLAN_INCL_VLP_MASK) >> ENET_MAC_INNER_VLAN_INCL_VLP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set inner VLAN priority control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANPriorityCtrlEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INNER_VLAN_INCL = (pEnet->MAC_INNER_VLAN_INCL & ~ENET_MAC_INNER_VLAN_INCL_VLP_MASK) | ENET_MAC_INNER_VLAN_INCL_VLP(bEnable ? 1u : 0u); } /** * @brief Get inner VLAN tag control mode * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_VLANTagCtrlType */ LOCAL_INLINE ENET_MAC_VLANTagCtrlType ENET_HWA_MAC_GetInnerVLANTagCtrl(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INNER_VLAN_INCL & ENET_MAC_INNER_VLAN_INCL_VLC_MASK) >> ENET_MAC_INNER_VLAN_INCL_VLC_SHIFT; return (ENET_MAC_VLANTagCtrlType)u32TmpVal; } /** * @brief Set inner VLAN tag control mode * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eCtrl Inner VLAN tag control mode */ LOCAL_INLINE void ENET_HWA_MAC_SetInnerVLANTagCtrl(ENET_Type *const pEnet, ENET_MAC_VLANTagCtrlType eCtrl) { pEnet->MAC_INNER_VLAN_INCL = (pEnet->MAC_INNER_VLAN_INCL & ~ENET_MAC_INNER_VLAN_INCL_VLC_MASK) | ENET_MAC_INNER_VLAN_INCL_VLC(eCtrl); } /** * @brief Get inner VLAN tag value * * @param [in] pEnet the base address of the Ethernet instance * @return Inner VLAN tag value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetTxInnerVLANTag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INNER_VLAN_INCL & ENET_MAC_INNER_VLAN_INCL_VLT_MASK) >> ENET_MAC_INNER_VLAN_INCL_VLT_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set inner VLAN tag value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u16VLANTag Inner VLAN tag value */ LOCAL_INLINE void ENET_HWA_MAC_SetTxInnerVLANTag(ENET_Type *const pEnet, uint16_t u16VLANTag) { pEnet->MAC_INNER_VLAN_INCL = (pEnet->MAC_INNER_VLAN_INCL & ~ENET_MAC_INNER_VLAN_INCL_VLT_MASK) | ENET_MAC_INNER_VLAN_INCL_VLT(u16VLANTag); } /** * @brief Get Queue n tx flow control register value * * @param [in] pEnet the base address of the Ethernet instance * @return The register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetQnTxFlowCtrl(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue]; } /** * @brief Set Queue n tx flow control register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32FlowCtrl The register value */ LOCAL_INLINE void ENET_HWA_MAC_SetQnTxFlowCtrl(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32FlowCtrl) { pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] = u32FlowCtrl; } /** * @brief Get Queue n tx pause time value * * @param [in] pEnet the base address of the Ethernet instance * @return Pause time value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetQnTxPauseTime(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ENET_MAC_Qn_TX_FLOW_CTRL_PT_MASK) >> ENET_MAC_Qn_TX_FLOW_CTRL_PT_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set Queue n tx pause time value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u16PauseTime Pause time value */ LOCAL_INLINE void ENET_HWA_MAC_SetQnTxPauseTime(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint16_t u16PauseTime) { pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ~(ENET_MAC_Qn_TX_FLOW_CTRL_PT_MASK | ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_MASK)) | ENET_MAC_Qn_TX_FLOW_CTRL_PT(u16PauseTime); } /** * @brief Get Queue n tx zero quanta pause disable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true Queue0 tx zero quanta pause is disabled * @return false is Queue0 tx zero quanta pause enabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetQnTxZeroQuantaPauseDisableFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ENET_MAC_Qn_TX_FLOW_CTRL_DZPQ_MASK) >> ENET_MAC_Qn_TX_FLOW_CTRL_DZPQ_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set Queue n tx zero quanta pause disable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bDisable Disable or enable */ LOCAL_INLINE void ENET_HWA_MAC_SetQnTxZeroQuantaPauseDisableFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bDisable) { pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ~(ENET_MAC_Qn_TX_FLOW_CTRL_DZPQ_MASK | ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_MASK)) | ENET_MAC_Qn_TX_FLOW_CTRL_DZPQ(bDisable ? 1u : 0u); } /** * @brief Get Queue n tx pause low threshold * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_PauseThresholdType */ LOCAL_INLINE ENET_MAC_PauseThresholdType ENET_HWA_MAC_GetQnTxPauseLowThreshold(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ENET_MAC_Qn_TX_FLOW_CTRL_PLT_MASK) >> ENET_MAC_Qn_TX_FLOW_CTRL_PLT_SHIFT; return (ENET_MAC_PauseThresholdType)u32TmpVal; } /** * @brief Set Queue n tx pause low threshold * * @param [in] pEnet the base address of the Ethernet instance * @param [in] ePauseThreshold Threshold value */ LOCAL_INLINE void ENET_HWA_MAC_SetQnTxPauseLowThreshold(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MAC_PauseThresholdType ePauseThreshold) { pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ~(ENET_MAC_Qn_TX_FLOW_CTRL_PLT_MASK | ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_MASK)) | ENET_MAC_Qn_TX_FLOW_CTRL_PLT(ePauseThreshold); } /** * @brief Get Queue n tx flow control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @retval true Queue0 tx flow control is enabled * @retval false Queue0 tx flow control is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetQnTxFlowCtrlEnableFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ENET_MAC_Qn_TX_FLOW_CTRL_TFE_MASK) >> ENET_MAC_Qn_TX_FLOW_CTRL_TFE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set Queue n tx flow control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetQnTxFlowCtrlEnableFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ~(ENET_MAC_Qn_TX_FLOW_CTRL_TFE_MASK | ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_MASK)) | ENET_MAC_Qn_TX_FLOW_CTRL_TFE(bEnable ? 1u : 0u); } /** * @brief Get flow control busy or backpressure status of Queue n * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetFlowCtrlOrBackpressureStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] & ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_MASK) >> ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Initiate flow control busy or backpressure of Queue n * * @param [in] pEnet the base address of the Ethernet instance */ LOCAL_INLINE void ENET_HWA_MAC_InitiatePausePacketOrBackpressure(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_Qn_TX_FLOW_CTRL[(uint32_t)eQueue] |= ENET_MAC_Qn_TX_FLOW_CTRL_FCB_BPA_MASK; } /** * @brief Get receive flow control register value * * @param [in] pEnet the base address of the Ethernet instance * @return Register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxFlowCtrl(const ENET_Type *const pEnet) { return pEnet->MAC_RX_FLOW_CTRL; } /** * @brief Set receive flow control register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32FlowCtrl Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetRxFlowCtrl(ENET_Type *const pEnet, uint32_t u32FlowCtrl) { pEnet->MAC_RX_FLOW_CTRL = u32FlowCtrl; } /** * @brief Get unicast pause packet detect enable flag * * @param [in] pEnet the base address of the Ethernet instance * @retval true Unicast pause packet detect is enabled * @retval false Unicast pause packet detect is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetUnicastPausePacketDetectEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_FLOW_CTRL & ENET_MAC_RX_FLOW_CTRL_UP_MASK) >> ENET_MAC_RX_FLOW_CTRL_UP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set unicast pause packet detect enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetUnicastPausePacketDetectEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RX_FLOW_CTRL = (pEnet->MAC_RX_FLOW_CTRL & ~ENET_MAC_RX_FLOW_CTRL_UP_MASK) | ENET_MAC_RX_FLOW_CTRL_UP(bEnable ? 1u : 0u); } /** * @brief Get receive flow control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @retval true Receive flow control is enabled * @retval false Receive flow control is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxFlowCtrlEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_FLOW_CTRL & ENET_MAC_RX_FLOW_CTRL_RFE_MASK) >> ENET_MAC_RX_FLOW_CTRL_RFE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive flow control enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable Enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxFlowCtrlEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RX_FLOW_CTRL = (pEnet->MAC_RX_FLOW_CTRL & ~ENET_MAC_RX_FLOW_CTRL_RFE_MASK) | ENET_MAC_RX_FLOW_CTRL_RFE(bEnable ? 1u : 0u); } /** * @brief Get Receive queue control 0 register value * * @param [in] pEnet the base address of the Ethernet instance * @return Register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxQueueCtrl0(const ENET_Type *const pEnet) { return pEnet->MAC_RXQ_CTRL0; } /** * @brief Set Receive queue control 0 register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Ctrl Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetRxQueueCtrl0(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MAC_RXQ_CTRL0 = u32Ctrl; } /** * @brief Get Receive queue control 1 register value * * @param [in] pEnet the base address of the Ethernet instance * @return Register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxQueueCtrl1(const ENET_Type *const pEnet) { return pEnet->MAC_RXQ_CTRL1; } /** * @brief Set Receive queue control 1 register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Ctrl Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetRxQueueCtrl1(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MAC_RXQ_CTRL1 = u32Ctrl; } /** * @brief Get Receive queue control 2 register value * * @param [in] pEnet the base address of the Ethernet instance * @return Register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxQueueCtrl2(const ENET_Type *const pEnet) { return pEnet->MAC_RXQ_CTRL2; } /** * @brief Set Receive queue control 2 register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Ctrl Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetRxQueueCtrl2(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MAC_RXQ_CTRL2 = u32Ctrl; } /** * @brief Get Receive queue control 4 register value * * @param [in] pEnet the base address of the Ethernet instance * @return Register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxQueueCtrl4(const ENET_Type *const pEnet) { return pEnet->MAC_RXQ_CTRL4; } /** * @brief Set Receive queue control 4 register value * * @param [in] pEnet the base address of the Ethernet instance * @param [in] u32Ctrl Register value */ LOCAL_INLINE void ENET_HWA_MAC_SetRxQueueCtrl4(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MAC_RXQ_CTRL4 = u32Ctrl; } /** * @brief Get Receive queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue the queue number * @return ENET_MTL_QueueEnableType */ LOCAL_INLINE ENET_MTL_QueueEnableType ENET_HWA_MTL_GetRxQueueEnStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL0 & ((uint32_t)ENET_MAC_RXQ_CTRL0_RXQ0EN_MASK << (ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT + (ENET_MAC_RXQ_CTRL0_RXQ1EN_SHIFT - ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT) * (uint32_t)eQueue))) >> (ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT + (ENET_MAC_RXQ_CTRL0_RXQ1EN_SHIFT - ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT) * (uint32_t)eQueue); return (ENET_MTL_QueueEnableType)u32TmpVal; } /** * @brief Set Receive queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue the queue number * @param [in] eEnable receive queue enable mode */ LOCAL_INLINE void ENET_HWA_MTL_SetRxQueueEnStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MTL_QueueEnableType eEnable) { pEnet->MAC_RXQ_CTRL0 = (pEnet->MAC_RXQ_CTRL0 & ~((uint32_t)ENET_MAC_RXQ_CTRL0_RXQ0EN_MASK << (ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT + (ENET_MAC_RXQ_CTRL0_RXQ1EN_SHIFT - ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT) * (uint32_t)eQueue))) | (ENET_MAC_RXQ_CTRL0_RXQ0EN(eEnable) << ((ENET_MAC_RXQ_CTRL0_RXQ1EN_SHIFT - ENET_MAC_RXQ_CTRL0_RXQ0EN_SHIFT) * (uint32_t)eQueue)); } /** * @brief Get tagged PTP over ethernet packets queuing control * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MAC_PTPoEQueueCtrlType */ LOCAL_INLINE ENET_MAC_PTPoEQueueCtrlType ENET_HWA_MAC_GetTaggedPTPoEQueueCtrl(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_TPQC_MASK) >> ENET_MAC_RXQ_CTRL1_TPQC_SHIFT; return (ENET_MAC_PTPoEQueueCtrlType)u32TmpVal; } /** * @brief Set tagged PTP over ethernet packets queuing control * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eCtrl the control mode */ LOCAL_INLINE void ENET_HWA_MAC_SetTaggedPTPoEQueueCtrl(ENET_Type *const pEnet, ENET_MAC_PTPoEQueueCtrlType eCtrl) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_TPQC_MASK) | ENET_MAC_RXQ_CTRL1_TPQC(eCtrl); } /** * @brief Get tagged AV control packets queuing enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true tagged AV control packets queue is enabled * @return false tagged AV control packets queue is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetTaggedAVCtrlPacketQueueEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_TACPQE_MASK) >> ENET_MAC_RXQ_CTRL1_TACPQE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set tagged AV control packets queuing enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetTaggedAVCtrlPacketQueueEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_TACPQE_MASK) | ENET_MAC_RXQ_CTRL1_TACPQE(bEnable ? 1u : 0u); } /** * @brief Get multicast and broadcast queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true multicast and broadcast queue is enabled * @return false multicast and broadcast queue is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMulticastAndBroadcastQueueEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_MCBCQEN_MASK) >> ENET_MAC_RXQ_CTRL1_MCBCQEN_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set multicast and broadcast queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMulticastAndBroadcastQueueEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_MCBCQEN_MASK) | ENET_MAC_RXQ_CTRL1_MCBCQEN(bEnable ? 1u : 0u); } /** * @brief Get multicast and broadcast queue id * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetMulticastAndBroadcastQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_MCBCQ_MASK) >> ENET_MAC_RXQ_CTRL1_MCBCQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set multicast and broadcast queue id * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue the queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetMulticastAndBroadcastQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_MCBCQ_MASK) | ENET_MAC_RXQ_CTRL1_MCBCQ(eQueue); } /** * @brief Get untagged packet queue id * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetUntaggedPacketQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_UPQ_MASK) >> ENET_MAC_RXQ_CTRL1_UPQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set untagged packet queue id * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue the queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetUntaggedPacketQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_UPQ_MASK) | ENET_MAC_RXQ_CTRL1_UPQ(eQueue); } /** * @brief Get PTP over ethernet packet queue id * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetPTPoEQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_PTPQ_MASK) >> ENET_MAC_RXQ_CTRL1_PTPQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set PTP over ethernet packet queue id * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue the queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetPTPoEQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_PTPQ_MASK) | ENET_MAC_RXQ_CTRL1_PTPQ(eQueue); } /** * @brief Get AV untagged control packets queue id * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetAVCtrlPacketQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL1 & ENET_MAC_RXQ_CTRL1_AVCPQ_MASK) >> ENET_MAC_RXQ_CTRL1_AVCPQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set AV untagged control packets queue id * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue the queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetAVCtrlPacketQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL1 = (pEnet->MAC_RXQ_CTRL1 & ~ENET_MAC_RXQ_CTRL1_AVCPQ_MASK) | ENET_MAC_RXQ_CTRL1_AVCPQ(eQueue); } /** * @brief Get receive queue priorities * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue queue id * @return eQueue priorities value */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetRxQueueSelectedPriorities(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL2 & ((uint32_t)ENET_MAC_RXQ_CTRL2_PSRQ0_MASK << (ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT + (ENET_MAC_RXQ_CTRL2_PSRQ1_SHIFT - ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT) * (uint32_t)eQueue))) >> (ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT + (ENET_MAC_RXQ_CTRL2_PSRQ1_SHIFT - ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT) * (uint32_t)eQueue); return (uint8_t)u32TmpVal; } /** * @brief Set receive queue priorities * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue queue id * @param [in] u8SelPrio priorities value */ LOCAL_INLINE void ENET_HWA_MAC_SetRxQueueSelectedPriorities(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint8_t u8SelPrio) { pEnet->MAC_RXQ_CTRL2 = (pEnet->MAC_RXQ_CTRL2 & ~(ENET_MAC_RXQ_CTRL2_PSRQ0_MASK << (ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT + (ENET_MAC_RXQ_CTRL2_PSRQ1_SHIFT - ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT) * (uint32_t)eQueue))) | (ENET_MAC_RXQ_CTRL2_PSRQ0(u8SelPrio) << ((ENET_MAC_RXQ_CTRL2_PSRQ1_SHIFT - ENET_MAC_RXQ_CTRL2_PSRQ0_SHIFT) * (uint32_t)eQueue)) ; } /** * @brief Get VLAN tag filter fail packets queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true VLAN tag filter fail packets queue is enabled * @return false VLAN tag filter fail packets queue is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetVLANTagFilterFailPacketQueueEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL4 & ENET_MAC_RXQ_CTRL4_VFFQE_MASK) >> ENET_MAC_RXQ_CTRL4_VFFQE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set VLAN tag filter fail packets queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagFilterFailPacketQueueEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RXQ_CTRL4 = (pEnet->MAC_RXQ_CTRL4 & ~ENET_MAC_RXQ_CTRL4_VFFQE_MASK) | ENET_MAC_RXQ_CTRL4_VFFQE(bEnable ? 1u : 0u); } /** * @brief Get VLAN tag filter fail packets queue * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetVLANTagFilterFailPacketQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL4 & ENET_MAC_RXQ_CTRL4_VFFQ_MASK) >> ENET_MAC_RXQ_CTRL4_VFFQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set VLAN tag filter fail packets queue * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetVLANTagFilterFailPacketQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL4 = (pEnet->MAC_RXQ_CTRL4 & ~ENET_MAC_RXQ_CTRL4_VFFQ_MASK) | ENET_MAC_RXQ_CTRL4_VFFQ(eQueue); } /** * @brief Get multicast address filter fail packets queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true multicast address filter fail packets queue is enabled * @return false multicast address filter fail packets queue is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMulticastAddrFilterFailPacketQueueEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL4 & ENET_MAC_RXQ_CTRL4_MFFQE_MASK) >> ENET_MAC_RXQ_CTRL4_MFFQE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set multicast address filter fail packets queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMulticastAddrFilterFailPacketQueueEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RXQ_CTRL4 = (pEnet->MAC_RXQ_CTRL4 & ~ENET_MAC_RXQ_CTRL4_MFFQE_MASK) | ENET_MAC_RXQ_CTRL4_MFFQE(bEnable ? 1u : 0u); } /** * @brief Get multicast address filter fail packets queue * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetMulticastAddrFilterFailPacketQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL4 & ENET_MAC_RXQ_CTRL4_MFFQ_MASK) >> ENET_MAC_RXQ_CTRL4_MFFQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set multicast address filter fail packets queue * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetMulticastAddrFilterFailPacketQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL4 = (pEnet->MAC_RXQ_CTRL4 & ~ENET_MAC_RXQ_CTRL4_MFFQ_MASK) | ENET_MAC_RXQ_CTRL4_MFFQ(eQueue); } /** * @brief Get unicast address filter fail packets queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @return true unicast address filter fail packets queue is enabled * @return false unicast address filter fail packets queue is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetUnicastAddrFilterFailPacketQueueEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL4 & ENET_MAC_RXQ_CTRL4_UFFQE_MASK) >> ENET_MAC_RXQ_CTRL4_UFFQE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set unicast address filter fail packets queue enable flag * * @param [in] pEnet the base address of the Ethernet instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetUnicastAddrFilterFailPacketQueueEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_RXQ_CTRL4 = (pEnet->MAC_RXQ_CTRL4 & ~ENET_MAC_RXQ_CTRL4_UFFQE_MASK) | ENET_MAC_RXQ_CTRL4_UFFQE(bEnable ? 1u : 0u); } /** * @brief Get unicast address filter fail packets queue * * @param [in] pEnet the base address of the Ethernet instance * @return ENET_MTL_QueueType */ LOCAL_INLINE ENET_MTL_QueueType ENET_HWA_MAC_GetUnicastAddrFilterFailPacketQueue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RXQ_CTRL4 & ENET_MAC_RXQ_CTRL4_UFFQ_MASK) >> ENET_MAC_RXQ_CTRL4_UFFQ_SHIFT; return (ENET_MTL_QueueType)u32TmpVal; } /** * @brief Set unicast address filter fail packets queue * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eQueue queue id */ LOCAL_INLINE void ENET_HWA_MAC_SetUnicastAddrFilterFailPacketQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MAC_RXQ_CTRL4 = (pEnet->MAC_RXQ_CTRL4 & ~ENET_MAC_RXQ_CTRL4_UFFQ_MASK) | ENET_MAC_RXQ_CTRL4_UFFQ(eQueue); } /** * @brief Get the interrupt status of ENET MAC * * @param [in] pEnet the base address of the ENET instance * @return uint32_t the interrupt status */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetInterruptStatus(const ENET_Type *const pEnet) { return pEnet->MAC_INTERRUPT_STATUS; } /** * @brief Clear the interrupt flags of MAC * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Interrupt the interrupt events to be cleared */ LOCAL_INLINE void ENET_HWA_MAC_ClearInterruptStatus(ENET_Type *const pEnet, uint32_t u32Interrupt) { pEnet->MAC_INTERRUPT_STATUS = u32Interrupt; } /** * @brief Get the MDIO interrupt status * * @param [in] pEnet the base address of the ENET instance * @return true the MDIO operation is complete * @return false there is no MDIO operation completion event */ LOCAL_INLINE bool ENET_HWA_MAC_GetMDIOInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_MDIOIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_MDIOIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the MDIO interrupt status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearMDIOInterruptStatus(ENET_Type *const pEnet) { pEnet->MAC_INTERRUPT_STATUS &= ENET_MAC_INTERRUPT_STATUS_MDIOIS_MASK; } /** * @brief Get the receive interrupt status * * @param [in] pEnet the base address of the ENET instance * @return bool indicate the status of received packets */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_RXSTSIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_RXSTSIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the transmit interrupt status * * @param [in] pEnet the base address of the ENET instance * @return bool indicate the status of transmit packets */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_TXSTSIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_TXSTSIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the timestamp interrupt status * * @param [in] pEnet the base address of the ENET instance * @return bool indicate the status of timestamp interrupt */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_TSIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_TSIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the MMC transmit interrupt status * @note This field is valid only when you enable MAC Management Counters(MMC) * * @param [in] pEnet the base address of the ENET instance * @return bool indicate the status of MMC transmit */ LOCAL_INLINE bool ENET_HWA_MAC_GetMMCTxInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_MMCTXIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_MMCTXIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the MMC receive interrupt status * @note This field is valid only when you enable MAC Management Counters(MMC) * * @param [in] pEnet the base address of the ENET instance * @return bool indicate the status of MMC receive */ LOCAL_INLINE bool ENET_HWA_MAC_GetMMCRxInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_MMCRXIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_MMCRXIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the MMC interrupt status * @note This field is valid only when you enable MAC Management Counters(MMC) * * @param [in] pEnet the base address of the ENET instance * @return bool indicate the status of MMC interrupt */ LOCAL_INLINE bool ENET_HWA_MAC_GetMMCInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_MMCIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_MMCIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the PHY interrupt status * * @param [in] pEnet the base address of the ENET instance * @return bool indicate whether the PHY interrupt is detected */ LOCAL_INLINE bool ENET_HWA_MAC_GetPhyInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_STATUS & ENET_MAC_INTERRUPT_STATUS_PHYIS_MASK) >> ENET_MAC_INTERRUPT_STATUS_PHYIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the PHY interrupt status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearPhyInterruptStatus(ENET_Type *const pEnet) { pEnet->MAC_INTERRUPT_STATUS &= ENET_MAC_INTERRUPT_STATUS_MDIOIS_MASK; } /** * @brief Get the MAC interrupts enable register value * * @param [in] pEnet the base address of the ENET instance * @return MAC interrupts enable register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetInterruptEnable(const ENET_Type *const pEnet) { return pEnet->MAC_INTERRUPT_ENABLE; } /** * @brief Set the MAC interrupts enable register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32IntEnable interrupts enable value */ LOCAL_INLINE void ENET_HWA_MAC_SetInterruptEnable(ENET_Type *const pEnet, uint32_t u32IntEnable) { pEnet->MAC_INTERRUPT_ENABLE = u32IntEnable; } /** * @brief Get MDIO interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MDIO interrupt is enabled * @return false MDIO interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMDIOInterruptEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_ENABLE & ENET_MAC_INTERRUPT_ENABLE_MDIOIE_MASK) >> ENET_MAC_INTERRUPT_ENABLE_MDIOIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MDIO interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMDIOInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INTERRUPT_ENABLE = (pEnet->MAC_INTERRUPT_ENABLE & ~ENET_MAC_INTERRUPT_ENABLE_MDIOIE_MASK) | ENET_MAC_INTERRUPT_ENABLE_MDIOIE(bEnable ? 1u : 0u); } /** * @brief Get receive status interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @return true receive status interrupt is enabled * @return false receive status interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxStatusInterruptEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_ENABLE & ENET_MAC_INTERRUPT_ENABLE_RXSTSIE_MASK) >> ENET_MAC_INTERRUPT_ENABLE_RXSTSIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive status interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetRxStatusInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INTERRUPT_ENABLE = (pEnet->MAC_INTERRUPT_ENABLE & ~ENET_MAC_INTERRUPT_ENABLE_RXSTSIE_MASK) | ENET_MAC_INTERRUPT_ENABLE_RXSTSIE(bEnable ? 1u : 0u); } /** * @brief Get transmit status interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @return true transmit status interrupt is enabled * @return false transmit status interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxStatusInterruptEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_ENABLE & ENET_MAC_INTERRUPT_ENABLE_TXSTSIE_MASK) >> ENET_MAC_INTERRUPT_ENABLE_TXSTSIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmit status interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetTxStatusInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INTERRUPT_ENABLE = (pEnet->MAC_INTERRUPT_ENABLE & ~ENET_MAC_INTERRUPT_ENABLE_TXSTSIE_MASK) | ENET_MAC_INTERRUPT_ENABLE_TXSTSIE(bEnable ? 1u : 0u); } /** * @brief Get timestamp interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @return true timestamp interrupt is enabled * @return false timestamp interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampInterruptEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_ENABLE & ENET_MAC_INTERRUPT_ENABLE_TSIE_MASK) >> ENET_MAC_INTERRUPT_ENABLE_TSIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set timestamp interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INTERRUPT_ENABLE = (pEnet->MAC_INTERRUPT_ENABLE & ~ENET_MAC_INTERRUPT_ENABLE_TSIE_MASK) | ENET_MAC_INTERRUPT_ENABLE_TSIE(bEnable ? 1u : 0u); } /** * @brief Get phy interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @return true phy interrupt is enabled * @return false phy interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetPhyInterruptEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_INTERRUPT_ENABLE & ENET_MAC_INTERRUPT_ENABLE_PHYIE_MASK) >> ENET_MAC_INTERRUPT_ENABLE_PHYIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set phy interrupt enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPhyInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_INTERRUPT_ENABLE = (pEnet->MAC_INTERRUPT_ENABLE & ~ENET_MAC_INTERRUPT_ENABLE_PHYIE_MASK) | ENET_MAC_INTERRUPT_ENABLE_PHYIE(bEnable ? 1u : 0u); } /** * @brief Get the MAC receive and transmit status * * @param [in] pEnet the base address of the ENET instance * @return uint32_t the MAC receive and transmit status */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxTxStatus(const ENET_Type *const pEnet) { return pEnet->MAC_RX_TX_STATUS; } /** * @brief Clear the MAC receive and transmit status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Status the status flags to be cleared */ LOCAL_INLINE void ENET_HWA_MAC_ClearRxTxStatus(ENET_Type *const pEnet, uint32_t u32Status) { pEnet->MAC_RX_TX_STATUS = u32Status; } /** * @brief Get the receive watchdog timeout status * * @param [in] pEnet the base address of the ENET instance * @return true receive watchdog timeout * @return false no receive watchdog timeout */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxWDGTimeoutStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_RWT_MASK) >> ENET_MAC_RX_TX_STATUS_RWT_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the receive watchdog timeout status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearRxWDGTimeoutStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_RWT_MASK; } /** * @brief Get the excessive collision status * * @param [in] pEnet the base address of the ENET instance * @return true excessive collision is sensed * @return false no collision */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxExcessiveCollisionStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_EXCOL_MASK) >> ENET_MAC_RX_TX_STATUS_EXCOL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the excessive collision status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearTxExcessiveCollisionStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_EXCOL_MASK; } /** * @brief Get the late collision status * * @param [in] pEnet the base address of the ENET instance * @return true late collision is sensed * @return false no collision */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxLateCollisionStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_LCOL_MASK) >> ENET_MAC_RX_TX_STATUS_LCOL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the late collision status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearTxLateCollisionStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_LCOL_MASK; } /** * @brief Get the excessive deferral status * * @param [in] pEnet the base address of the ENET instance * @return true excessive deferral is sensed * @return false no excessive deferral */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxExcessiveDeferralStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_EXDEF_MASK) >> ENET_MAC_RX_TX_STATUS_EXDEF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the excessive deferral status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearExcessiveDeferralStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_EXDEF_MASK; } /** * @brief Indicates the status of carrier signal * * @param [in] pEnet the base address of the ENET instance * @return true loss of carrier * @return false carrier is present */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxLossOfCarrierStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_LCARR_MASK) >> ENET_MAC_RX_TX_STATUS_LCARR_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the loss of carrier status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearLossOfCarrierStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_LCARR_MASK; } /** * @brief Indicates whether the carrier signal is present from the PHY at the end of preamble transmission * * @param [in] pEnet the base address of the ENET instance * @return true carrier is absent * @return false carrier is present */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxNoCarrierStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_NCARR_MASK) >> ENET_MAC_RX_TX_STATUS_NCARR_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the no carrier status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearTxNoCarrierStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_NCARR_MASK; } /** * @brief Indicates whether a transmit jabber timer timeout occurred * * @param [in] pEnet the base address of the ENET instance * @return true transmit jabber timeout occured * @return false no transmit jabber timeout occured */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxJabberTimeoutStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_RX_TX_STATUS & ENET_MAC_RX_TX_STATUS_TJT_MASK) >> ENET_MAC_RX_TX_STATUS_TJT_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the transmit jabber timer timeout status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearTxJabberTimeoutStatus(ENET_Type *const pEnet) { pEnet->MAC_RX_TX_STATUS &= ENET_MAC_RX_TX_STATUS_TJT_MASK; } /** * @brief Get MAC version * * @param [in] pEnet the base address of the ENET instance * @return MAC version number */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMACVersion(const ENET_Type *const pEnet) { return pEnet->MAC_VERSION; } /** * @brief Get MAC debug status * * @param [in] pEnet the base address of the ENET instance * @return MAC debug status */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetDebugStatus(const ENET_Type *const pEnet) { return pEnet->MAC_DEBUG; } /** * @brief Get MAC transmit packet controller status * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_TxPacketControllerStatusType */ LOCAL_INLINE ENET_MAC_TxPacketControllerStatusType ENET_HWA_MAC_GetTxPacketControllerStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_DEBUG & ENET_MAC_DEBUG_TFCSTS_MASK) >> ENET_MAC_DEBUG_TFCSTS_SHIFT; return (ENET_MAC_TxPacketControllerStatusType)u32TmpVal; } /** * @brief Get MAC GMII or MII transmit protocol engine status * * @param [in] pEnet the base address of the ENET instance * @return true transmit protocol engine is active * @return false transmit protocol engine is inactive */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxPacketEngineStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_DEBUG & ENET_MAC_DEBUG_TPESTS_MASK) >> ENET_MAC_DEBUG_TPESTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get MAC receive packet controller FIFO status * * @param [in] pEnet the base address of the ENET instance * @return true receive packet controller FIFO is active * @return false receive packet controller FIFO is inactive */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxPacketControllerFIFOStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_DEBUG & ENET_MAC_DEBUG_RFCFCSTS_MASK) >> ENET_MAC_DEBUG_RFCFCSTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get MAC GMII or MII receive protocol engine status * * @param [in] pEnet the base address of the ENET instance * @return true receive protocol engine is active * @return false receive protocol engine is inactive */ LOCAL_INLINE bool ENET_HWA_MAC_GetRxProtocalEngineStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_DEBUG & ENET_MAC_DEBUG_RPESTS_MASK) >> ENET_MAC_DEBUG_RPESTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get MAC hardware features 0 * * @param [in] pEnet the base address of the ENET instance * @return MAC hardware features 0 */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetHwFeature0(const ENET_Type *const pEnet) { return pEnet->MAC_HW_FEATURE0; } /** * @brief Get phy interface mii mode * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_MiiModeType */ LOCAL_INLINE ENET_MAC_MiiModeType ENET_HWA_MAC_GetPhyMiiMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_HW_FEATURE0 & ENET_MAC_HW_FEATURE0_ACTPHYSEL_MASK) >> ENET_MAC_HW_FEATURE0_ACTPHYSEL_SHIFT; return (ENET_MAC_MiiModeType)u32TmpVal; } /** * @brief Get MAC hardware features 1 * * @param [in] pEnet the base address of the ENET instance * @return MAC hardware features 1 */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetHwFeature1(const ENET_Type *const pEnet) { return pEnet->MAC_HW_FEATURE1; } /** * @brief Get MAC hardware features 2 * * @param [in] pEnet the base address of the ENET instance * @return MAC hardware features 2 */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetHwFeature2(const ENET_Type *const pEnet) { return pEnet->MAC_HW_FEATURE2; } /** * @brief Get MAC hardware features 3 * * @param [in] pEnet the base address of the ENET instance * @return MAC hardware features 3 */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetHwFeature3(const ENET_Type *const pEnet) { return pEnet->MAC_HW_FEATURE3; } /** * @brief Get MAC MDIO address register value * * @param [in] pEnet the base address of the ENET instance * @return MDIO address register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMDIOAddress(const ENET_Type *const pEnet) { return pEnet->MAC_MDIO_ADDRESS; } /** * @brief Set MAC MDIO address register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32MDIOAddr MDIO address register value */ LOCAL_INLINE void ENET_HWA_MAC_SetMDIOAddress(ENET_Type *const pEnet, uint32_t u32MDIOAddr) { pEnet->MAC_MDIO_ADDRESS = u32MDIOAddr; } /** * @brief Get preamble suppression enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MDIO preamble suppression is enabled * @return false MDIO preamble suppression is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetPreambleSuppressionEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_PSE_MASK) >> ENET_MAC_MDIO_ADDRESS_PSE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MDIO preamble suppression enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPreambleSuppressionEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_PSE_MASK) | ENET_MAC_MDIO_ADDRESS_PSE(bEnable ? 1u : 0u); } /** * @brief Get MDIO back to back transactions enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MDIO back to back transactions is enabled * @return false MDIO back to back transactions is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetBackToBackTransactionEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_BTB_MASK) >> ENET_MAC_MDIO_ADDRESS_BTB_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MDIO back to back transactions enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetBackToBackTransactionEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_BTB_MASK) | ENET_MAC_MDIO_ADDRESS_BTB(bEnable ? 1u : 0u); } /** * @brief Get MDIO physical layer address * * @param [in] pEnet the base address of the ENET instance * @return phy address */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetPhysicalLayerAddr(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_PA_MASK) >> ENET_MAC_MDIO_ADDRESS_PA_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MDIO physical layer address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Addr phy address */ LOCAL_INLINE void ENET_HWA_MAC_SetPhysicalLayerAddr(ENET_Type *const pEnet, uint8_t u8Addr) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_PA_MASK) | ENET_MAC_MDIO_ADDRESS_PA(u8Addr); } /** * @brief Get MDIO phy register(clause22) or MMD device(clause 45) * * @param [in] pEnet the base address of the ENET instance * @return phy register or device address */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetPhyRegisterOrDeviceAddr(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_RDA_MASK) >> ENET_MAC_MDIO_ADDRESS_RDA_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MDIO phy register(clause22) or MMD device(clause 45) * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Addr phy register or device address */ LOCAL_INLINE void ENET_HWA_MAC_SetPhyRegisterOrDeviceAddr(ENET_Type *const pEnet, uint8_t u8Addr) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_RDA_MASK) | ENET_MAC_MDIO_ADDRESS_RDA(u8Addr); } /** * @brief Get the number of trailing clock cycles * * @param [in] pEnet the base address of the ENET instance * @return trailing clock cycles */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetTrailingClockCnt(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_NTC_MASK) >> ENET_MAC_MDIO_ADDRESS_NTC_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MDIO trailing clock cycles * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Cnt trailing clock cycles(range 0~7) */ LOCAL_INLINE void ENET_HWA_MAC_SetTrailingClockCnt(ENET_Type *const pEnet, uint8_t u8Cnt) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_NTC_MASK) | ENET_MAC_MDIO_ADDRESS_NTC(u8Cnt); } /** * @brief Get the MDC clock range * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_CSRClockRangeType */ LOCAL_INLINE ENET_MAC_CSRClockRangeType ENET_HWA_MAC_GetCSRClockRange(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_CR_MASK) >> ENET_MAC_MDIO_ADDRESS_CR_SHIFT; return (ENET_MAC_CSRClockRangeType)u32TmpVal; } /** * @brief Set the MDC clock range * * @param [in] pEnet the base address of the ENET instance * @param [in] eRange values defined in ENET_MAC_CSRClockRangeType */ LOCAL_INLINE void ENET_HWA_MAC_SetCSRClockRange(ENET_Type *const pEnet, ENET_MAC_CSRClockRangeType eRange) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_CR_MASK) | ENET_MAC_MDIO_ADDRESS_CR(eRange); } /** * @brief Get skip address packet enable flag * * @param [in] pEnet the base address of the ENET instance * @return true skip address packet is enabled * @return false skip address packet is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetSkipAddrPacketEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_SKAP_MASK) >> ENET_MAC_MDIO_ADDRESS_SKAP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set skip address packet enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetSkipAddrPacketEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_SKAP_MASK) | ENET_MAC_MDIO_ADDRESS_SKAP(bEnable ? 1u : 0u); } /** * @brief Get phy operation command * * @param [in] pEnet the base address of the ENET instance * @return Commands defined in ENET_MAC_PhyOperationCmdType */ LOCAL_INLINE ENET_MAC_PhyOperationCmdType ENET_HWA_MAC_GetPhyOperationCommand(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & (ENET_MAC_MDIO_ADDRESS_GOC_0_MASK | ENET_MAC_MDIO_ADDRESS_GOC_1_MASK)) >> ENET_MAC_MDIO_ADDRESS_GOC_0_SHIFT; return (ENET_MAC_PhyOperationCmdType)u32TmpVal; } /** * @brief Set phy operation command * * @param [in] pEnet the base address of the ENET instance * @param [in] eCmd Commands defined in ENET_MAC_PhyOperationCmdType */ LOCAL_INLINE void ENET_HWA_MAC_SetPhyOperationCommand(ENET_Type *const pEnet, ENET_MAC_PhyOperationCmdType eCmd) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~(ENET_MAC_MDIO_ADDRESS_GOC_0_MASK | ENET_MAC_MDIO_ADDRESS_GOC_1_MASK)) | ENET_MAC_MDIO_ADDRESS_GOC_0((uint32_t)eCmd & 0x01u) | ENET_MAC_MDIO_ADDRESS_GOC_1(((uint32_t)eCmd & 0x02u) >> 1u); } /** * @brief Get MDIO clause version * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_PHY_CLAUSE_22 access phy use clause 22 mode @return ENET_MAC_PHY_CLAUSE_45 access phy use clause 45 mode */ LOCAL_INLINE ENET_MAC_PhyClauseVersionType ENET_HWA_MAC_GetPhyClauseVersion(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_C45E_MASK) >> ENET_MAC_MDIO_ADDRESS_C45E_SHIFT; return (ENET_MAC_PhyClauseVersionType)u32TmpVal; } /** * @brief Set MDIO clause version * * @param [in] pEnet the base address of the ENET instance * @param [in] eVersion ENET_MAC_PHY_CLAUSE_22 or ENET_MAC_PHY_CLAUSE_45 */ LOCAL_INLINE void ENET_HWA_MAC_SetPhyClauseVersion(ENET_Type *const pEnet, ENET_MAC_PhyClauseVersionType eVersion) { pEnet->MAC_MDIO_ADDRESS = (pEnet->MAC_MDIO_ADDRESS & ~ENET_MAC_MDIO_ADDRESS_C45E_MASK) | ENET_MAC_MDIO_ADDRESS_C45E(eVersion); } /** * @brief Get MDIO busy status * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_STATUS_IDLE GMII status is idle @return ENET_MAC_STATUS_BUSY GMII status is busy, */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetGMIIStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_ADDRESS & ENET_MAC_MDIO_ADDRESS_GB_MASK) >> ENET_MAC_MDIO_ADDRESS_GB_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Set MDIO busy to initiate a read or write access * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_SetGMIIBusy(ENET_Type *const pEnet) { pEnet->MAC_MDIO_ADDRESS |= ENET_MAC_MDIO_ADDRESS_GB_MASK; } /** * @brief Get MDIO data register value * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMDIOData(const ENET_Type *const pEnet) { return pEnet->MAC_MDIO_DATA; } /** * @brief Set MDIO data register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Data data register value */ LOCAL_INLINE void ENET_HWA_MAC_SetMDIOData(ENET_Type *const pEnet, uint32_t u32Data) { pEnet->MAC_MDIO_DATA = u32Data; } /** * @brief Get phy register address * @note This field is valid only in clause 45 mode * * @param [in] pEnet the base address of the ENET instance * @return phy register address */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetPhyRegisterAddr(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_DATA & ENET_MAC_MDIO_DATA_RA_MASK) >> ENET_MAC_MDIO_DATA_RA_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set phy register address * @note This field is valid only in clause 45 mode * * @param [in] pEnet the base address of the ENET instance * @param [in] u16Addr phy register address */ LOCAL_INLINE void ENET_HWA_MAC_SetPhyRegisterAddr(ENET_Type *const pEnet, uint16_t u16Addr) { pEnet->MAC_MDIO_DATA = (pEnet->MAC_MDIO_DATA & ~ENET_MAC_MDIO_DATA_RA_MASK) | ENET_MAC_MDIO_DATA_RA(u16Addr); } /** * @brief Get MDIO data * * @param [in] pEnet the base address of the ENET instance * @return data value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetGMIIData(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_MDIO_DATA & ENET_MAC_MDIO_DATA_GD_MASK) >> ENET_MAC_MDIO_DATA_GD_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set MDIO data * * @param [in] pEnet the base address of the ENET instance * @param [in] u16Data MDIO data */ LOCAL_INLINE void ENET_HWA_MAC_SetGMIIData(ENET_Type *const pEnet, uint16_t u16Data) { pEnet->MAC_MDIO_DATA = (pEnet->MAC_MDIO_DATA & ~ENET_MAC_MDIO_DATA_GD_MASK) | ENET_MAC_MDIO_DATA_GD(u16Data); } #if ENET_SUPPORT_TIME_SENSITIVE_NETWORK /** * @brief Enable TX frame preemption * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable 1U enable or 0U disable */ LOCAL_INLINE void ENET_HWA_MAC_SetFramePreemptionEnFlag(ENET_Type *const pEnet, uint8_t bEnable) { pEnet->MAC_FPE_CTRL_STS = (pEnet->MAC_FPE_CTRL_STS & ~ENET_MAC_FPE_CTRL_STS_EFPE_MASK) | ENET_MAC_FPE_CTRL_STS_EFPE(bEnable); } #endif /* ENET_SUPPORT_TIME_SENSITIVE_NETWORK */ /** * @brief Get presentation time in ns * * @param [in] pEnet the base address of the ENET instance * @return presentation time */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPresentationTime(const ENET_Type *const pEnet) { return pEnet->MAC_PRESN_TIME_NS; } /** * @brief Get presentation time update * * @param [in] pEnet the base address of the ENET instance * @return update time value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPresentationTimeUpdata(const ENET_Type *const pEnet) { return pEnet->MAC_PRESN_TIME_UPDT; } /** * @brief Set presentation time update * * @param [in] pEnet the base address of the ENET instance * @param [in] u32NanoSeconds update time value */ LOCAL_INLINE void ENET_HWA_MAC_SetPresentationTimeUpdata(ENET_Type *const pEnet, uint32_t u32NanoSeconds) { pEnet->MAC_PRESN_TIME_UPDT = u32NanoSeconds; } /** * @brief Get MAC address0 high register value * * @param [in] pEnet the base address of the ENET instance * @return MAC address0 high register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMacAddr0High(const ENET_Type *const pEnet) { return pEnet->MAC_ADDRESS0_HIGH; } /** * @brief Set MAC address0 high register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32AddrHigh MAC address0 high register value */ LOCAL_INLINE void ENET_HWA_MAC_SetAddr0High(ENET_Type *const pEnet, uint32_t u32AddrHigh) { pEnet->MAC_ADDRESS0_HIGH = u32AddrHigh; } /** * @brief Get MAC address0 low register value * * @param [in] pEnet the base address of the ENET instance * @return MAC address0 low register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMacAddr0Low(const ENET_Type *const pEnet) { return pEnet->MAC_ADDRESS0_LOW; } /** * @brief Set MAC address0 low register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32AddrLow MAC address0 low register value */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr0Low(ENET_Type *const pEnet, uint32_t u32AddrLow) { pEnet->MAC_ADDRESS0_LOW = u32AddrLow; } /** * @brief Get MAC address0 enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MAC address0 is enabled * @return false MAC address0 is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMacAddr0EnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS0_HIGH & ENET_MAC_ADDRESS0_HIGH_AE_MASK) >> ENET_MAC_ADDRESS0_HIGH_AE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get MAC address0 DMA channel select * * @param [in] pEnet the base address of the ENET instance * @return MAC address0 DMA channel select */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetMacAddr0DMAChannelSelect(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS0_HIGH & ENET_MAC_ADDRESS0_HIGH_DCS_MASK) >> ENET_MAC_ADDRESS0_HIGH_DCS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MAC address0 DMA channel select * * @param [in] pEnet the base address of the ENET instance * @param [in] u8DMAChannelSel MAC address0 DMA channel select */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr0DMAChannelSelect(ENET_Type *const pEnet, uint8_t u8DMAChannelSel) { pEnet->MAC_ADDRESS0_HIGH = (pEnet->MAC_ADDRESS0_HIGH & ~ENET_MAC_ADDRESS0_HIGH_DCS_MASK) | ENET_MAC_ADDRESS0_HIGH_DCS(u8DMAChannelSel); } /** * @brief Get MAC address1 high register value * * @param [in] pEnet the base address of the ENET instance * @return MAC address1 high register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMacAddr1High(const ENET_Type *const pEnet) { return pEnet->MAC_ADDRESS1_HIGH; } /** * @brief Set MAC address1 high register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32AddrHigh MAC address1 high register value */ LOCAL_INLINE void ENET_HWA_MAC_SetAddr1High(ENET_Type *const pEnet, uint32_t u32AddrHigh) { pEnet->MAC_ADDRESS1_HIGH = u32AddrHigh; } /** * @brief Get MAC address1 low register value * * @param [in] pEnet the base address of the ENET instance * @return MAC address1 low register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMacAddr1Low(const ENET_Type *const pEnet) { return pEnet->MAC_ADDRESS1_LOW; } /** * @brief Set MAC address1 low register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32AddrLow MAC address1 low register value */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr1Low(ENET_Type *const pEnet, uint32_t u32AddrLow) { pEnet->MAC_ADDRESS1_LOW = u32AddrLow; } /** * @brief Get MAC address1 enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MAC address1 is enabled * @return false MAC address1 is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMacAddr1EnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS1_HIGH & ENET_MAC_ADDRESS1_HIGH_AE_MASK) >> ENET_MAC_ADDRESS1_HIGH_AE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MAC address1 enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr1EnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_ADDRESS1_HIGH = (pEnet->MAC_ADDRESS1_HIGH & ~ENET_MAC_ADDRESS1_HIGH_AE_MASK) | ENET_MAC_ADDRESS1_HIGH_AE(bEnable ? 1u : 0u); } /** * @brief Get MAC address1 compare mode * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_ADDR_TYPE_DEST MAC Address1 is used to compare with the DA fields * @return ENET_MAC_ADDR_TYPE_SRC MAC Address1 is used to compare with the SA fields */ LOCAL_INLINE ENET_MAC_AddrType ENET_HWA_MAC_GetMacAddr1Type(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS1_HIGH & ENET_MAC_ADDRESS1_HIGH_SA_MASK) >> ENET_MAC_ADDRESS1_HIGH_SA_SHIFT; return (ENET_MAC_AddrType)u32TmpVal; } /** * @brief Set MAC address1 compare mode * * @param [in] pEnet the base address of the ENET instance * @param [in] eAddrType ENET_MAC_ADDR_TYPE_DEST or ENET_MAC_ADDR_TYPE_SRC */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr1Type(ENET_Type *const pEnet, ENET_MAC_AddrType eAddrType) { pEnet->MAC_ADDRESS1_HIGH = (pEnet->MAC_ADDRESS1_HIGH & ~ENET_MAC_ADDRESS1_HIGH_SA_MASK) | ENET_MAC_ADDRESS1_HIGH_SA(eAddrType); } /** * @brief Get MAC address1 mask byte control * * @param [in] pEnet the base address of the ENET instance * @return MAC address1 mask byte value */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetMacAddr1MaskByteCtrl(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS1_HIGH & ENET_MAC_ADDRESS1_HIGH_MBC_MASK) >> ENET_MAC_ADDRESS1_HIGH_MBC_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MAC address1 mask byte control * * @param [in] pEnet the base address of the ENET instance * @param [in] u8MaskCtrl MAC address1 mask byte value */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr1MaskByteCtrl(ENET_Type *const pEnet, uint8_t u8MaskCtrl) { pEnet->MAC_ADDRESS1_HIGH = (pEnet->MAC_ADDRESS1_HIGH & ~ENET_MAC_ADDRESS1_HIGH_MBC_MASK) | ENET_MAC_ADDRESS1_HIGH_MBC(u8MaskCtrl); } /** * @brief Get MAC address1 DMA channel select * * @param [in] pEnet the base address of the ENET instance * @return MAC address1 DMA channel select */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetMacAddr1DMAChannelSelect(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS1_HIGH & ENET_MAC_ADDRESS1_HIGH_DCS_MASK) >> ENET_MAC_ADDRESS1_HIGH_DCS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MAC address1 DMA channel select * * @param [in] pEnet the base address of the ENET instance * @param [in] u8DMAChannelSel MAC address1 DMA channel select */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr1DMAChannelSelect(ENET_Type *const pEnet, uint8_t u8DMAChannelSel) { pEnet->MAC_ADDRESS1_HIGH = (pEnet->MAC_ADDRESS1_HIGH & ~ENET_MAC_ADDRESS1_HIGH_DCS_MASK) | ENET_MAC_ADDRESS1_HIGH_DCS(u8DMAChannelSel); } /** * @brief Get MAC address2 high register value * * @param [in] pEnet the base address of the ENET instance * @return MAC address2 high register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMacAddr2High(const ENET_Type *const pEnet) { return pEnet->MAC_ADDRESS2_HIGH; } /** * @brief Set MAC address2 high register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32AddrHigh MAC address2 high register value */ LOCAL_INLINE void ENET_HWA_MAC_SetAddr2High(ENET_Type *const pEnet, uint32_t u32AddrHigh) { pEnet->MAC_ADDRESS2_HIGH = u32AddrHigh; } /** * @brief Get MAC address2 low register value * * @param [in] pEnet the base address of the ENET instance * @return MAC address2 low register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMacAddr2Low(const ENET_Type *const pEnet) { return pEnet->MAC_ADDRESS2_LOW; } /** * @brief Set MAC address2 low register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32AddrLow MAC address2 low register value */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr2Low(ENET_Type *const pEnet, uint32_t u32AddrLow) { pEnet->MAC_ADDRESS2_LOW = u32AddrLow; } /** * @brief Get MAC address2 enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MAC address2 is enabled * @return false MAC address2 is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMacAddr2EnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS2_HIGH & ENET_MAC_ADDRESS2_HIGH_AE_MASK) >> ENET_MAC_ADDRESS2_HIGH_AE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MAC address2 enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr2EnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_ADDRESS2_HIGH = (pEnet->MAC_ADDRESS2_HIGH & ~ENET_MAC_ADDRESS2_HIGH_AE_MASK) | ENET_MAC_ADDRESS2_HIGH_AE(bEnable ? 1u : 0u); } /** * @brief Get MAC address2 compare mode * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_ADDR_TYPE_DEST MAC Address2 is used to compare with the DA fields * @return ENET_MAC_ADDR_TYPE_SRC MAC Address2 is used to compare with the SA fields */ LOCAL_INLINE ENET_MAC_AddrType ENET_HWA_MAC_GetMacAddr2Type(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS2_HIGH & ENET_MAC_ADDRESS2_HIGH_SA_MASK) >> ENET_MAC_ADDRESS2_HIGH_SA_SHIFT; return (ENET_MAC_AddrType)u32TmpVal; } /** * @brief Set MAC address2 compare mode * * @param [in] pEnet the base address of the ENET instance * @param [in] eAddrType ENET_MAC_ADDR_TYPE_DEST or ENET_MAC_ADDR_TYPE_SRC */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr2Type(ENET_Type *const pEnet, ENET_MAC_AddrType eAddrType) { pEnet->MAC_ADDRESS2_HIGH = (pEnet->MAC_ADDRESS2_HIGH & ~ENET_MAC_ADDRESS2_HIGH_SA_MASK) | ENET_MAC_ADDRESS2_HIGH_SA(eAddrType); } /** * @brief Get MAC address2 mask byte control * * @param [in] pEnet the base address of the ENET instance * @return MAC address2 mask byte value */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetMacAddr2MaskByteCtrl(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS2_HIGH & ENET_MAC_ADDRESS2_HIGH_MBC_MASK) >> ENET_MAC_ADDRESS2_HIGH_MBC_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MAC address2 mask byte control * * @param [in] pEnet the base address of the ENET instance * @param [in] u8MaskCtrl MAC address2 mask byte value */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr2MaskByteCtrl(ENET_Type *const pEnet, uint8_t u8MaskCtrl) { pEnet->MAC_ADDRESS2_HIGH = (pEnet->MAC_ADDRESS2_HIGH & ~ENET_MAC_ADDRESS2_HIGH_MBC_MASK) | ENET_MAC_ADDRESS2_HIGH_MBC(u8MaskCtrl); } /** * @brief Get MAC address2 DMA channel select * * @param [in] pEnet the base address of the ENET instance * @return MAC address2 DMA channel select */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetMacAddr2DMAChannelSelect(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_ADDRESS2_HIGH & ENET_MAC_ADDRESS2_HIGH_DCS_MASK) >> ENET_MAC_ADDRESS2_HIGH_DCS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MAC address2 DMA channel select * * @param [in] pEnet the base address of the ENET instance * @param [in] u8DMAChannelSel MAC address2 DMA channel select */ LOCAL_INLINE void ENET_HWA_MAC_SetMacAddr2DMAChannelSelect(ENET_Type *const pEnet, uint8_t u8DMAChannelSel) { pEnet->MAC_ADDRESS2_HIGH = (pEnet->MAC_ADDRESS2_HIGH & ~ENET_MAC_ADDRESS2_HIGH_DCS_MASK) | ENET_MAC_ADDRESS2_HIGH_DCS(u8DMAChannelSel); } /* ================================================================ * * ENET MAC Management Counters (MMC) * * ================================================================ */ /** * @brief Get MMC control register value * * @param [in] pEnet the base address of the ENET instance * @return MMC control register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMmcControl(const ENET_Type *const pEnet) { return pEnet->MMC_CONTROL; } /** * @brief Set MMC control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Ctrl MMC control register value */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcControl(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MMC_CONTROL = u32Ctrl; } /** * @brief Get update MMC counters for dropped broadcast packets enable flag * * @param [in] pEnet the base address of the ENET instance * @return true update MMC counters for dropped broadcast packets * @return false do not update MMC counters for dropped broadcast packets */ LOCAL_INLINE bool ENET_HWA_MAC_GetUpdateMmcCntForDroppedBroadcastPktEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_UCDBC_MASK) >> ENET_MMC_CONTROL_UCDBC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set update MMC counters for dropped broadcast packets enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetUpdateMmcCntForDroppedBroadcastPktEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MMC_CONTROL = (pEnet->MMC_CONTROL & ~ENET_MMC_CONTROL_UCDBC_MASK) | ENET_MMC_CONTROL_UCDBC(bEnable ? 1u : 0u); } /** * @brief Get MMC counters full-half preset level * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_MMC_COUNTER_PRESET_LEVEL_FULL MMC counter preset to almost-full value * @return ENET_MAC_MMC_COUNTER_PRESET_LEVEL_HALF MMC counter preset to almost-half value */ LOCAL_INLINE ENET_MAC_MmcCntPresetLevelType ENET_HWA_MAC_GetMmcCounterPresetLevel(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_CNTPRSTLVL_MASK) >> ENET_MMC_CONTROL_CNTPRSTLVL_SHIFT; return (ENET_MAC_MmcCntPresetLevelType)u32TmpVal; } /** * @brief Set MMC counters full-half preset level * * @param [in] pEnet the base address of the ENET instance * @param [in] eLevel ENET_MAC_MMC_COUNTER_PRESET_LEVEL_FULL or ENET_MAC_MMC_COUNTER_PRESET_LEVEL_HALF */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcCounterPresetLevel(ENET_Type *const pEnet, ENET_MAC_MmcCntPresetLevelType eLevel) { pEnet->MMC_CONTROL = (pEnet->MMC_CONTROL & ~ENET_MMC_CONTROL_CNTPRSTLVL_MASK) | ENET_MMC_CONTROL_CNTPRSTLVL(eLevel); } /** * @brief Get MMC counters preset status * * @param [in] pEnet the base address of the ENET instance * @return true MMC counter preset is enabled * @return false MMC counter preset is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMmcCounterPresetStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_CNTPRST_MASK) >> ENET_MMC_CONTROL_CNTPRST_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MMC counters preset * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_PresetMmcCounters(ENET_Type *const pEnet) { pEnet->MMC_CONTROL |= ENET_MMC_CONTROL_CNTPRST_MASK; } /** * @brief Get MMC counters freeze status * * @param [in] pEnet the base address of the ENET instance * @return true MMC counter freeze is enabled * @return false MMC counter freeze is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetMmcCounterFreezeStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_CNTFREEZ_MASK) >> ENET_MMC_CONTROL_CNTFREEZ_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MMC counters freeze * * @param [in] pEnet the base address of the ENET instance * @param [in] bFreeze enable or disable freeze */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcCounterFreezeStatus(ENET_Type *const pEnet, bool bFreeze) { pEnet->MMC_CONTROL = (pEnet->MMC_CONTROL & ~ENET_MMC_CONTROL_CNTFREEZ_MASK) | ENET_MMC_CONTROL_CNTFREEZ(bFreeze ? 1u : 0u); } /** * @brief Get MMC counters reset on read enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MMC counters are reset to zero after read * @return false MMC counters are not reset to zero after read */ LOCAL_INLINE bool ENET_HWA_MAC_GetMmcCounterResetOnReadEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_RSTONRD_MASK) >> ENET_MMC_CONTROL_RSTONRD_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MMC counters reset on read enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcCounterResetOnReadEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MMC_CONTROL = (pEnet->MMC_CONTROL & ~ENET_MMC_CONTROL_RSTONRD_MASK) | ENET_MMC_CONTROL_RSTONRD(bEnable ? 1u : 0u); } /** * @brief Get MMC counters stop rollover enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MMC counters does not roll over to zero after reaching the maximum value * @return false MMC counters roll over to zero after reaching the maximum value */ LOCAL_INLINE bool ENET_HWA_MAC_GetMmcCounterStopRolloverEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_CNTSTOPRO_MASK) >> ENET_MMC_CONTROL_CNTSTOPRO_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MMC counters stop rollover enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcCounterStopRolloverEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MMC_CONTROL = (pEnet->MMC_CONTROL & ~ENET_MMC_CONTROL_CNTSTOPRO_MASK) | ENET_MMC_CONTROL_CNTSTOPRO(bEnable ? 1u : 0u); } /** * @brief Get MMC counters reset status * * @param [in] pEnet the base address of the ENET instance * @return true All MMC counters are reset * @return false MMC counters are not reset */ LOCAL_INLINE bool ENET_HWA_MAC_GetMmcCounterResetStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MMC_CONTROL & ENET_MMC_CONTROL_CNTRST_MASK) >> ENET_MMC_CONTROL_CNTRST_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Reset all MMC counters * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ResetMmcCounters(ENET_Type *const pEnet) { pEnet->MMC_CONTROL |= ENET_MMC_CONTROL_CNTRST_MASK; } /** * @brief Get MMC interrupts of receive statistics counters * * @param [in] pEnet the base address of the ENET instance * @return MMC interrupts status */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMmcRxInterruptStatus(const ENET_Type *const pEnet) { return pEnet->MMC_RX_INTERRUPT; } /** * @brief Get MMC interrupts of transmit statistics counters * * @param [in] pEnet the base address of the ENET instance * @return MMC interrupts status */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMmcTxInterruptStatus(const ENET_Type *const pEnet) { return pEnet->MMC_TX_INTERRUPT; } /** * @brief Get MMC interrupts mask of receive statistics counters * * @param [in] pEnet the base address of the ENET instance * @return MMC interrupts mask */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMmcRxInterruptMask(const ENET_Type *const pEnet) { return pEnet->MMC_RX_INTERRUPT_MASK; } /** * @brief Set MMC interrupts mask of receive statistics counters * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Mask MMC interrupts mask value */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcRxInterruptMask(ENET_Type *const pEnet, uint32_t u32Mask) { pEnet->MMC_RX_INTERRUPT_MASK = u32Mask; } /** * @brief Get MMC interrupts mask of transmit statistics counters * * @param [in] pEnet the base address of the ENET instance * @return MMC interrupts mask */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetMmcTxInterruptMask(const ENET_Type *const pEnet) { return pEnet->MMC_TX_INTERRUPT_MASK; } /** * @brief Set MMC interrupts mask of transmit statistics counters * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Mask MMC interrupts mask value */ LOCAL_INLINE void ENET_HWA_MAC_SetMmcTxInterruptMask(ENET_Type *const pEnet, uint32_t u32Mask) { pEnet->MMC_TX_INTERRUPT_MASK = u32Mask; } /** * @brief Get transmitted bytes of good and bad packets * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxOctetCntGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_OCTET_COUNT_GOOD_BAD; } /** * @brief Get the number of good and bad packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_PACKET_COUNT_GOOD_BAD; } /** * @brief Get the number of good broadcast packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxBroadcastPacketGood(const ENET_Type *const pEnet) { return pEnet->TX_BROADCAST_PACKETS_GOOD; } /** * @brief Get the number of good multicast packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxMulticastPacketGood(const ENET_Type *const pEnet) { return pEnet->TX_MULTICAST_PACKETS_GOOD; } /** * @brief Get the number of good and bad packets transmitted with length 64 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTx64OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_64OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad packets transmitted with length between 65 and 127 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTx65To127OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_65TO127OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad packets transmitted with length between 128 and 255 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTx128To255OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_128TO255OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad packets transmitted with length between 256 and 511 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTx256To511OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_256TO511OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad packets transmitted with length between 512 and 1023 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTx512To1023OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_512TO1023OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad packets transmitted with length 1024 to maxsize bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTx1024ToMaxOctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_1024TOMAXOCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad unicast packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxUnicastPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_UNICAST_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad multicast packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxMulticastPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_MULTICAST_PACKETS_GOOD_BAD; } /** * @brief Get the number of good and bad broadcast packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxBroadcastPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->TX_BROADCAST_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets with transmit underflow error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxUnderflowErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_UNDERFLOW_ERROR_PACKETS; } /** * @brief Get the number of successfully transmitted packets after a single collision in half-duplex mode. * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxSingleCollisionGoodPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_SINGLE_COLLISION_GOOD_PACKETS; } /** * @brief Get the number of successfully transmitted packets after a multiple collision in half-duplex mode. * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxMultipleCollisionGoodPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_MULTIPLE_COLLISION_GOOD_PACKETS; } /** * @brief Get the number of successfully transmitted packets after a deferral in half-duplex mode. * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxDeferredPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_DEFERRED_PACKETS; } /** * @brief Get the number of packets with transmit late collision error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxLateCollisionPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_LATE_COLLISION_PACKETS; } /** * @brief Get the number of packets with transmit excessive collision errors * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxExcessiveCollisionPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_EXCESSIVE_COLLISION_PACKETS; } /** * @brief Get the number of packets with transmit carrier sense error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxCarrierErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_CARRIER_ERROR_PACKETS; } /** * @brief Get the number of bytes of good packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxOctetCntGood(const ENET_Type *const pEnet) { return pEnet->TX_OCTET_COUNT_GOOD; } /** * @brief Get the number of good packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxPacketCntGood(const ENET_Type *const pEnet) { return pEnet->TX_PACKET_COUNT_GOOD; } /** * @brief Get the number of packets with transmit excessive deferral error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxExcessiveDeferralErrorCnt(const ENET_Type *const pEnet) { return pEnet->TX_EXCESSIVE_DEFERRAL_ERROR; } /** * @brief Get the number of good pause packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxPausePacketCnt(const ENET_Type *const pEnet) { return pEnet->TX_PAUSE_PACKETS; } /** * @brief Get the number of good VLAN packets transmitted * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxVLANPacketGood(const ENET_Type *const pEnet) { return pEnet->TX_VLAN_PACKETS_GOOD; } /** * @brief Get the number of transmitted packets without errors and with length greater than the maxsize * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxOverSizePacketGood(const ENET_Type *const pEnet) { return pEnet->TX_OSIZE_PACKETS_GOOD; } /** * @brief Get the number of good and bad packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxPacketCntGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_PACKETS_COUNT_GOOD_BAD; } /** * @brief Get the number of bytes received in good and bad packets * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxOctetCntGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_OCTET_COUNT_GOOD_BAD; } /** * @brief Get the number of bytes received in good packets * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxOctetCntGood(const ENET_Type *const pEnet) { return pEnet->RX_OCTET_COUNT_GOOD; } /** * @brief Get the number of good broadcast packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxBroadcastPacketGood(const ENET_Type *const pEnet) { return pEnet->RX_BROADCAST_PACKETS_GOOD; } /** * @brief Get the number of good multicast packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxMulticastPacketGood(const ENET_Type *const pEnet) { return pEnet->RX_MULTICAST_PACKETS_GOOD; } /** * @brief Get the number of packets received with CRC error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxCRCErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_CRC_ERROR_PACKETS; } /** * @brief Get the number of packets received with alignment error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxAlignmentErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_ALIGNMENT_ERROR_PACKETS; } /** * @brief Get the number of packets received with runt error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxRuntErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_RUNT_ERROR_PACKETS; } /** * @brief Get the number of packets received with jabber error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxJabberErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_JABBER_ERROR_PACKETS; } /** * @brief Get the number of packets received with length less than 64 bytes, without any errors * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxUndersizePacketGood(const ENET_Type *const pEnet) { return pEnet->RX_UNDERSIZE_PACKETS_GOOD; } /** * @brief Get the number of packets received withouterrors and with length greater than maxsize * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxOverSizeGood(const ENET_Type *const pEnet) { return pEnet->RX_OVERSIZE_PACKETS_GOOD; } /** * @brief Get the number of packets received with length 64 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRx64OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_64OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets received with length 65 to 127 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRx65To127OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_65TO127OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets received with length 128 to 255 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRx128To255OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_128TO255OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets received with length 256 to 511 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRx256To511OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_256TO511OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets received with length 512 to 1023 bytes * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRx512To1023OctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_512TO1023OCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets received with length 1024 to maxsize * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRx1024ToMaxOctetPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_1024TOMAXOCTETS_PACKETS_GOOD_BAD; } /** * @brief Get the number of good unicast packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetUnicastPacketGood(const ENET_Type *const pEnet) { return pEnet->RX_UNICAST_PACKETS_GOOD; } /** * @brief Get the number of packets received with length error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxLengthErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_LENGTH_ERROR_PACKETS; } /** * @brief Get the number of packets received with length greater than 1500 but less than 1536 * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxOutOfRangeTypePacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_OUT_OF_RANGE_TYPE_PACKETS; } /** * @brief Get the number of good and valid pause packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxPausePacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_PAUSE_PACKETS; } /** * @brief Get the number of missed received packets because of FIFO overflow * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxFIFOOverflowPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_FIFO_OVERFLOW_PACKETS; } /** * @brief Get the number of good and bad VLAN packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxVLANPacketGoodBad(const ENET_Type *const pEnet) { return pEnet->RX_VLAN_PACKETS_GOOD_BAD; } /** * @brief Get the number of packets received with error because of watchdog timeout error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxWatchdogErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_WATCHDOG_ERROR_PACKETS; } /** * @brief Get the number of packets received with receive error or Packet Extension error * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxReceiveErrorPacketCnt(const ENET_Type *const pEnet) { return pEnet->RX_RECEIVE_ERROR_PACKETS; } /** * @brief Get the number of good control packets received * * @param [in] pEnet the base address of the ENET instance * @return MMC counter value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetRxControlPacketGood(const ENET_Type *const pEnet) { return pEnet->RX_CONTROL_PACKETS_GOOD; } /* ================================================================ * * ENET MAC Layer 3 and Layer 4 Filter * * ================================================================ */ /** * @brief Get the layer 3 and layer 4 control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 and layer 4 control register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3Layer4Ctrl(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL; } /** * @brief Set the layer 3 and layer 4 control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32Ctrl control value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Layer4Ctrl(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32Ctrl) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = u32Ctrl; } /** * @brief Get layer 3 and layer 4 control DMA channel select enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true DMA channel select is enabled * @return false DMA channel select is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer3Layer4DMASelectEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_DMCHEN0_MASK) >> ENET_MAC_L3_L4_CONTROL_DMCHEN0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 3 and layer 4 control DMA channel select enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Layer4DMASelectEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ~ENET_MAC_L3_L4_CONTROL_DMCHEN0_MASK) | ENET_MAC_L3_L4_CONTROL_DMCHEN0(bEnable ? 1u : 0u); } /** * @brief Get layer 3 and layer 4 control DMA channel number * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return ENET_DMA_ChannelType */ LOCAL_INLINE ENET_DMA_ChannelType ENET_HWA_MAC_GetLayer3Layer4DMAChannel(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_DMCHN0_MASK) >> ENET_MAC_L3_L4_CONTROL_DMCHN0_SHIFT; return (ENET_DMA_ChannelType)u32TmpVal; } /** * @brief Set layer 3 and layer 4 control DMA channel number * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] eChannel DMA channel */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Layer4DMAChannel(ENET_Type *const pEnet, uint8_t u8Index, ENET_DMA_ChannelType eChannel) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ~ENET_MAC_L3_L4_CONTROL_DMCHN0_MASK) | ENET_MAC_L3_L4_CONTROL_DMCHN0(eChannel); } /** * @brief Get layer 4 destination port inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 4 destination port inverse match is enabled * @return false layer 4 destination port inverse match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer4DestPortInvMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L4DPIM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L4DPIM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 4 destination port inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4DestPortInvMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L4DPIM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L4DPIM0(bEnable ? 1u : 0u); } /** * @brief Get layer 4 destination port match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 4 destination port match is enabled * @return false layer 4 destination port match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer4DestPortMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L4DPM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L4DPM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 4 destination port match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4DestPortMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L4DPM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L4DPM0(bEnable ? 1u : 0u); } /** * @brief Get layer 4 source port inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 4 source port inverse match is enabled * @return false layer 4 source port inverse match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer4SrcPortInvMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L4SPIM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L4SPIM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 4 source port inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4SrcPortInvMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L4SPIM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L4SPIM0(bEnable ? 1u : 0u); } /** * @brief Get layer 4 source port match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 4 source port match is enabled * @return false layer 4 source port match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer4SrcPortMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L4SPM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L4SPM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 4 source port match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4SrcPortMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L4SPM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L4SPM0(bEnable ? 1u : 0u); } /** * @brief Get layer 4 protocol type (UDP or TCP) * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return ENET_MAC_Layer4ProtocolType */ LOCAL_INLINE ENET_MAC_Layer4ProtocolType ENET_HWA_MAC_GetLayer4ProtocalType(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L4PEN0_MASK) >> ENET_MAC_L3_L4_CONTROL_L4PEN0_SHIFT; return (ENET_MAC_Layer4ProtocolType)u32TmpVal; } /** * @brief Set layer 4 protocol type (UDP or TCP) * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] eProtocol protocol type (UDP or TCP) */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4ProtocalType(ENET_Type *const pEnet, uint8_t u8Index, ENET_MAC_Layer4ProtocolType eProtocol) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L4PEN0_MASK)) | ENET_MAC_L3_L4_CONTROL_L4PEN0(eProtocol); } /** * @brief Get layer3 IPv4 destination address bits match * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return lower retval bits are masked */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetLayer3IPv4DestAddrBitsMatch(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3HDBM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3HDBM0_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set layer3 IPv4 destination address bits match * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u8MaskBits lower u8MaskBits bits are masked */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3IPv4DestAddrBitsMatch(ENET_Type *const pEnet, uint8_t u8Index, uint8_t u8MaskBits) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3HDBM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3HDBM0(u8MaskBits); } /** * @brief Get layer3 IPv4 source address bits match * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return lower retval bits are masked */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetLayer3IPv4SrcAddrBitsMatch(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3HSBM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3HSBM0_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set layer3 IPv4 source address bits match * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u8MaskBits lower u8MaskBits bits are masked */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3IPv4SrcAddrBitsMatch(ENET_Type *const pEnet, uint8_t u8Index, uint8_t u8MaskBits) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3HSBM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3HSBM0(u8MaskBits); } /** * @brief Get layer3 IPv6 address bits match * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return lower retval bits are masked */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetLayer3IPv6AddrBitsMatch(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (ENET_MAC_L3_L4_CONTROL_L3HDBM0_MASK | ENET_MAC_L3_L4_CONTROL_L3HSBM0_MASK)) >> ENET_MAC_L3_L4_CONTROL_L3HSBM0_SHIFT; return (uint8_t)(u32TmpVal & 0x7Fu); } /** * @brief Set layer3 IPv6 address bits match * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u8MaskBits lower u8MaskBits bits are masked */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3IPv6AddrBitsMatch(ENET_Type *const pEnet, uint8_t u8Index, uint8_t u8MaskBits) { uint8_t u8HighBits = (u8MaskBits & 0x60u) >> 5u; uint8_t u8LowBits = u8MaskBits & 0x1Fu; pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~(ENET_MAC_L3_L4_CONTROL_L3HDBM0_MASK | ENET_MAC_L3_L4_CONTROL_L3HSBM0_MASK))) | (ENET_MAC_L3_L4_CONTROL_L3HDBM0(u8HighBits) | ENET_MAC_L3_L4_CONTROL_L3HSBM0(u8LowBits)); } /** * @brief Get layer 3 destination address inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 3 destination address inverse match is enabled * @return false layer 3 destination address inverse match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer3DestAddrInvMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3DAIM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3DAIM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 3 destination address inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3DestAddrInvMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3DAIM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3DAIM0(bEnable ? 1u : 0u); } /** * @brief Get layer 3 destination address match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 3 destination address match is enabled * @return false layer 3 destination address match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer3DestAddrMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3DAM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3DAM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 3 destination address match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3DestAddrMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3DAM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3DAM0(bEnable ? 1u : 0u); } /** * @brief Get layer 3 source address inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 3 source address inverse match is enabled * @return false layer 3 source address inverse match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer3SrcAddrInvMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3SAIM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3SAIM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 3 source address inverse match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3SrcAddrInvMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3SAIM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3SAIM0(bEnable ? 1u : 0u); } /** * @brief Get layer 3 source address match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return true layer 3 source address match is enabled * @return false layer 3 source address match is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetLayer3SrcAddrMatchEnFlag(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3SAM0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3SAM0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set layer 3 source address match enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] bEnable enabled or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3SrcAddrMatchEnFlag(ENET_Type *const pEnet, uint8_t u8Index, bool bEnable) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3SAM0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3SAM0(bEnable ? 1u : 0u); } /** * @brief Get layer 3 protocol type (IPV4 or IPV6) * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return ENET_MAC_Layer3ProtocolType (IPV4 or IPV6) */ LOCAL_INLINE ENET_MAC_Layer3ProtocolType ENET_HWA_MAC_GetLayer3ProtocolType(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & ENET_MAC_L3_L4_CONTROL_L3PEN0_MASK) >> ENET_MAC_L3_L4_CONTROL_L3PEN0_SHIFT; return (ENET_MAC_Layer3ProtocolType)u32TmpVal; } /** * @brief Set layer 3 protocol type (IPV4 or IPV6) * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] eProtocol IPV4 or IPV6 */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3ProtocolType(ENET_Type *const pEnet, uint8_t u8Index, ENET_MAC_Layer3ProtocolType eProtocol) { pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL = (pEnet->L3_L4_FILTER[u8Index].MAC_L3_L4_CONTROL & (~ENET_MAC_L3_L4_CONTROL_L3PEN0_MASK)) | ENET_MAC_L3_L4_CONTROL_L3PEN0(eProtocol); } /** * @brief Get layer 4 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 4 address value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer4Addr(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS; } /** * @brief Set layer 4 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32Addr layer 4 address value */ LOCAL_INLINE void ENET_MAC_SetLayer4Addr(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32Addr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS = u32Addr; } /** * @brief Get layer 4 destination port number * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 4 destination port number */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetLayer4DestPort(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS & ENET_MAC_LAYER4_ADDRESS_L4DP0_MASK) >> ENET_MAC_LAYER4_ADDRESS_L4DP0_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set layer 4 destination port number * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u16DestPort port number */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4DestPort(ENET_Type *const pEnet, uint8_t u8Index, uint16_t u16DestPort) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS = (pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS & (~ENET_MAC_LAYER4_ADDRESS_L4DP0_MASK)) | ENET_MAC_LAYER4_ADDRESS_L4DP0(u16DestPort); } /** * @brief Get layer 4 source port number * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 4 source port number */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetLayer4SrcPort(const ENET_Type *const pEnet, uint8_t u8Index) { uint32_t u32TmpVal = (pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS & ENET_MAC_LAYER4_ADDRESS_L4SP0_MASK) >> ENET_MAC_LAYER4_ADDRESS_L4SP0_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set layer 4 source port number * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u16SrcPort port number */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer4SrcPort(ENET_Type *const pEnet, uint8_t u8Index, uint16_t u16SrcPort) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS = (pEnet->L3_L4_FILTER[u8Index].MAC_LAYER4_ADDRESS & (~ENET_MAC_LAYER4_ADDRESS_L4SP0_MASK)) | ENET_MAC_LAYER4_ADDRESS_L4SP0(u16SrcPort); } /** * @brief Get layer 3 address0 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 address0 value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3Addr0(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR0_REG; } /** * @brief Set layer 3 address0 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32Addr layer 3 address0 value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Addr0(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32Addr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR0_REG = u32Addr; } /** * @brief Get layer 3 address1 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 address1 value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3Addr1(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR1_REG; } /** * @brief Set layer 3 address1 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32Addr layer 3 address1 value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Addr1(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32Addr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR1_REG = u32Addr; } /** * @brief Get layer 3 address2 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 address2 value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3Addr2(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR2_REG; } /** * @brief Set layer 3 address2 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32Addr layer 3 address2 value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Addr2(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32Addr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR2_REG = u32Addr; } /** * @brief Get layer 3 address3 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 address3 value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3Addr3(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR3_REG; } /** * @brief Set layer 3 address3 * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32Addr layer 3 address3 value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3Addr3(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32Addr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR3_REG = u32Addr; } /** * @brief Get layer 3 source IPv4 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 source IPv4 address value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3SrcIPv4Addr(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR0_REG; } /** * @brief Set layer 3 source IPv4 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32SrcAddr layer 3 source IPv4 address value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3SrcIPv4Addr(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32SrcAddr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR0_REG = u32SrcAddr; } /** * @brief Get layer 3 destination IPv4 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @return layer 3 destination IPv4 address value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetLayer3DestIPv4Addr(const ENET_Type *const pEnet, uint8_t u8Index) { return pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR1_REG; } /** * @brief Set layer 3 destination IPv4 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] u32DestAddr layer 3 destination IPv4 address value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3DestIPv4Addr(ENET_Type *const pEnet, uint8_t u8Index, uint32_t u32DestAddr) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR1_REG = u32DestAddr; } /** * @brief Get layer 3 IPv6 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [out] aIPv6Addr layer 3 IPv6 address value */ LOCAL_INLINE void ENET_HWA_MAC_GetLayer3IPv6Addr(const ENET_Type *const pEnet, uint8_t u8Index, uint8_t aIPv6Addr[16u]) { uint32_t u32AddrHH = pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR3_REG; uint32_t u32AddrHL = pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR2_REG; uint32_t u32AddrLH = pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR1_REG; uint32_t u32AddrLL = pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR0_REG; aIPv6Addr[0u] = (uint8_t)((u32AddrHH & 0xFF000000u) >> 24u); aIPv6Addr[1u] = (uint8_t)((u32AddrHH & 0x00FF0000u) >> 16u); aIPv6Addr[2u] = (uint8_t)((u32AddrHH & 0x0000FF00u) >> 8u); aIPv6Addr[3u] = (uint8_t)(u32AddrHH & 0x000000FFu); aIPv6Addr[4u] = (uint8_t)((u32AddrHL & 0xFF000000u) >> 24u); aIPv6Addr[5u] = (uint8_t)((u32AddrHL & 0x00FF0000u) >> 16u); aIPv6Addr[6u] = (uint8_t)((u32AddrHL & 0x0000FF00u) >> 8u); aIPv6Addr[7u] = (uint8_t)(u32AddrHL & 0x000000FFu); aIPv6Addr[8u] = (uint8_t)((u32AddrLH & 0xFF000000u) >> 24u); aIPv6Addr[9u] = (uint8_t)((u32AddrLH & 0x00FF0000u) >> 16u); aIPv6Addr[10u] = (uint8_t)((u32AddrLH & 0x0000FF00u) >> 8u); aIPv6Addr[11u] = (uint8_t)(u32AddrLH & 0x000000FFu); aIPv6Addr[12u] = (uint8_t)((u32AddrLL & 0xFF000000u) >> 24u); aIPv6Addr[13u] = (uint8_t)((u32AddrLL & 0x00FF0000u) >> 16u); aIPv6Addr[14u] = (uint8_t)((u32AddrLL & 0x0000FF00u) >> 8u); aIPv6Addr[15u] = (uint8_t)(u32AddrLL & 0x000000FFu); } /** * @brief Set layer 3 IPv6 address * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Index layer 3 and layer 4 filter group index * @param [in] aIPv6Addr layer 3 IPv6 address value */ LOCAL_INLINE void ENET_HWA_MAC_SetLayer3IPv6Addr(ENET_Type *const pEnet, uint8_t u8Index, const uint8_t aIPv6Addr[16]) { pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR3_REG = ((uint32_t)aIPv6Addr[0u] << 24u) | ((uint32_t)aIPv6Addr[1u] << 16u) | ((uint32_t)aIPv6Addr[2u] << 8u) | ((uint32_t)aIPv6Addr[3u]); pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR2_REG = ((uint32_t)aIPv6Addr[4u] << 24u) | ((uint32_t)aIPv6Addr[5u] << 16u) | ((uint32_t)aIPv6Addr[6u] << 8u) | ((uint32_t)aIPv6Addr[7u]); pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR1_REG = ((uint32_t)aIPv6Addr[8u] << 24u) | ((uint32_t)aIPv6Addr[9u] << 16u) | ((uint32_t)aIPv6Addr[10u] << 8u) | ((uint32_t)aIPv6Addr[11u]); pEnet->L3_L4_FILTER[u8Index].MAC_LAYER3_ADDR0_REG = ((uint32_t)aIPv6Addr[12u] << 24u) | ((uint32_t)aIPv6Addr[13u] << 16u) | ((uint32_t)aIPv6Addr[14u] << 8u) | ((uint32_t)aIPv6Addr[15u]); } /* ================================================================ * * ENET MAC Timestamp Control * * ================================================================ */ /** * @brief Get time stamp control register value * * @param [in] pEnet the base address of the ENET instance * @return time stamp control value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTimestampControl(const ENET_Type *const pEnet) { return pEnet->MAC_TIMESTAMP_CONTROL; } /** * @brief Set time stamp control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Ctrl time stamp control value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampControl(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MAC_TIMESTAMP_CONTROL = u32Ctrl; } /** * @brief Get time stamp AV802_1AS mode enable flag * * @param [in] pEnet the base address of the ENET instance * @return true time stamp AV802_1AS mode is enabled * @return false time stamp AV802_1AS mode is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetAV802_1ASModeEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_AV8021ASMEN_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_AV8021ASMEN_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set time stamp AV802_1AS mode enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetAV802_1ASModeEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_AV8021ASMEN_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_AV8021ASMEN(bEnable ? 1u : 0u); } /** * @brief Get transmit timestamp status mode * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_TxTimestampStatusModeType */ LOCAL_INLINE ENET_MAC_TxTimestampStatusModeType ENET_HWA_MAC_GetTxTimestampStatusMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TXTSSTSM_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TXTSSTSM_SHIFT; return (ENET_MAC_TxTimestampStatusModeType)u32TmpVal; } /** * @brief Set transmit timestamp status mode * * @param [in] pEnet the base address of the ENET instance * @param [in] eMode transmit timestamp status mode */ LOCAL_INLINE void ENET_HWA_MAC_SetTxTimestampStatusMode(ENET_Type *const pEnet, ENET_MAC_TxTimestampStatusModeType eMode) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TXTSSTSM_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TXTSSTSM(eMode); } /** * @brief Get MAC address for PTP packet filter enable flag * * @param [in] pEnet the base address of the ENET instance * @return true MAC address for PTP packet filter is enabled * @return false MAC address for PTP packet filter is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetUseMACAddrForPTPPacketFilterEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSENMACADDR_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSENMACADDR_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set MAC address for PTP packet filter enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetUseMACAddrForPTPPacketFilterEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSENMACADDR_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSENMACADDR(bEnable ? 1u : 0u); } /** * @brief Get PTP packets type for taking snapshots * * @param [in] pEnet the base address of the ENET instance * @return PTP packets type */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetSnapshotPTPPacketType(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_SNAPTYPSEL_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_SNAPTYPSEL_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set PTP packets type for taking snapshots * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Type PTP packets type */ LOCAL_INLINE void ENET_HWA_MAC_SetSnapshotPTPPacketType(ENET_Type *const pEnet, uint8_t u8Type) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_SNAPTYPSEL_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_SNAPTYPSEL(u8Type); } /** * @brief Get snapshot for messages relevant to master enable flag * * @param [in] pEnet the base address of the ENET instance * @return true snapshot for messages relevant to master * @return false snapshot for messages relevant to slave */ LOCAL_INLINE bool ENET_HWA_MAC_GetMasterMsgSanpshotEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSMSTRENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSMSTRENA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set snapshot for messages relevant to master enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetMasterMsgSanpshotEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSMSTRENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSMSTRENA(bEnable ? 1u : 0u); } /** * @brief Get snapshot for event messages enable flag * * @param [in] pEnet the base address of the ENET instance * @return true snapshot for event messages is enabled * @return false snapshot for event messages is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetEventMsgSnapshotEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSEVNTENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSEVNTENA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set snapshot for event messages enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetEventMsgSanpshotEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSEVNTENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSEVNTENA(bEnable ? 1u : 0u); } /** * @brief Get processing of PTP packets over IPv4-UDP enable flag * * @param [in] pEnet the base address of the ENET instance * @return true processing of PTP packets over IPv4-UDP is enabled * @return false processing of PTP packets over IPv4-UDP is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetIPv4UDPPTPPacketProcessEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSIPV4ENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSIPV4ENA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set processing of PTP packets over IPv4-UDP enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetIPv4UDPPTPPacketProcessEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSIPV4ENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSIPV4ENA(bEnable ? 1u : 0u); } /** * @brief Get processing of PTP packets over IPv6-UDP enable flag * * @param [in] pEnet the base address of the ENET instance * @return true processing of PTP packets over IPv6-UDP is enabled * @return false processing of PTP packets over IPv6-UDP is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetIPv6UDPPTPPacketProcessEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSIPV6ENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSIPV6ENA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set processing of PTP packets over IPv6-UDP enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetIPv6UDPPTPPacketProcessEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSIPV6ENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSIPV6ENA(bEnable ? 1u : 0u); } /** * @brief Get processing of PTP packets over ethernet enable flag * * @param [in] pEnet the base address of the ENET instance * @return true processing of PTP packets over ethernet is enabled * @return false processing of PTP packets over ethernet is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetEthernetPTPPacketProcessEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSIPENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSIPENA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set processing of PTP packets over ethernet enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetEthernetPTPPacketProcessEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSIPENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSIPENA(bEnable ? 1u : 0u); } /** * @brief Get PTP packets processing format version * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_PTPVersionType */ LOCAL_INLINE ENET_MAC_PTPVersionType ENET_HWA_MAC_GetPTPPacketVersion(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSVER2ENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSVER2ENA_SHIFT; return (ENET_MAC_PTPVersionType)u32TmpVal; } /** * @brief Set PTP packets processing format version * * @param [in] pEnet the base address of the ENET instance * @param [in] eVersion PTP version */ LOCAL_INLINE void ENET_HWA_MAC_SetPTPPacketVersion(ENET_Type *const pEnet, ENET_MAC_PTPVersionType eVersion) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSVER2ENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSVER2ENA(eVersion); } /** * @brief Get PTP timestamp rollover mode * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_TimestampRolloverType */ LOCAL_INLINE ENET_MAC_TimestampRolloverType ENET_HWA_MAC_GetTimestampRolloverCtrl(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSCTRLSSR_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSCTRLSSR_SHIFT; return (ENET_MAC_TimestampRolloverType)u32TmpVal; } /** * @brief Set PTP timestamp rollover mode * * @param [in] pEnet the base address of the ENET instance * @param [in] eCtrl timestamp rollover mode */ LOCAL_INLINE void ENET_HWA_MAC_SetIimestampRolloverCtrl(ENET_Type *const pEnet, ENET_MAC_TimestampRolloverType eCtrl) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSCTRLSSR_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSCTRLSSR(eCtrl); } /** * @brief Get timestamp for all packets enable flag * * @param [in] pEnet the base address of the ENET instance * @return true timestamp for all packets is enabled * @return false timestamp for all packets is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampForAllPacketEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSENALL_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSENALL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set timestamp for all packets enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampForAllPacketEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSENALL_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSENALL(bEnable ? 1u : 0u); } /** * @brief Get presentation time generation enable flag * * @param [in] pEnet the base address of the ENET instance * @return true presentation time generation is enabled * @return false presentation time generation is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetPresentationTimeGenerationEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_PTGE_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_PTGE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set presentation time generation enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPresentationTimeGenerationEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_PTGE_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_PTGE(bEnable ? 1u : 0u); } /** * @brief Get PTP addend register update status * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetAddendRegisterUpdateStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Initiate the addend register update operation * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_UpdateAddendRegister(ENET_Type *const pEnet) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK; } /** * @brief Get timestamp update status * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetTimestampUpdateStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Initiate the timestamp update operation * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_UpdateTimestamp(ENET_Type *const pEnet) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK; } /** * @brief Get timestamp initialize status * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetTimestampInitStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSINIT_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Initialize PTP timestamp * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_InitTimestamp(ENET_Type *const pEnet) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK; } /** * @brief Get timestamp update method (fine or coarse) * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_TimestampUpdateMethodType */ LOCAL_INLINE ENET_MAC_TimestampUpdateMethodType ENET_HWA_MAC_GetTimestampUpdateMethod(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSCFUPDT_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSCFUPDT_SHIFT; return (ENET_MAC_TimestampUpdateMethodType)u32TmpVal; } /** * @brief Set timestamp update method (fine or coarse) * * @param [in] pEnet the base address of the ENET instance * @param [in] eMethod (fine update or coarse update) */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampUpdateMethod(ENET_Type *const pEnet, ENET_MAC_TimestampUpdateMethodType eMethod) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSCFUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSCFUPDT(eMethod); } /** * @brief Get timestamp enable flag * * @param [in] pEnet the base address of the ENET instance * @return true timestamp processing is enabled * @return false timestamp processing is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_CONTROL & ENET_MAC_TIMESTAMP_CONTROL_TSENA_MASK) >> ENET_MAC_TIMESTAMP_CONTROL_TSENA_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set timestamp processing enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable timestamp processing */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MAC_TIMESTAMP_CONTROL = (pEnet->MAC_TIMESTAMP_CONTROL & ~(ENET_MAC_TIMESTAMP_CONTROL_TSENA_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSADDREG_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSUPDT_MASK | ENET_MAC_TIMESTAMP_CONTROL_TSINIT_MASK)) | ENET_MAC_TIMESTAMP_CONTROL_TSENA(bEnable ? 1u : 0u); } /** * @brief Get PTP sub-second increment register value * * @param [in] pEnet the base address of the ENET instance * @return sub-second increment register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetSubSecondIncrementReg(const ENET_Type *const pEnet) { return pEnet->MAC_SUB_SECOND_INCREMENT; } /** * @brief Set PTP sub-second increment register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Increment increment value */ LOCAL_INLINE void ENET_HWA_MAC_SetSubSecondIncrementReg(ENET_Type *const pEnet, uint32_t u32Increment) { pEnet->MAC_SUB_SECOND_INCREMENT = u32Increment; } /** * @brief Get PTP sub-second increment value * * @param [in] pEnet the base address of the ENET instance * @return sub-second increment value */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetSubSecondIncrementValue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_SUB_SECOND_INCREMENT & ENET_MAC_SUB_SECOND_INCREMENT_SSINC_MASK) >> ENET_MAC_SUB_SECOND_INCREMENT_SSINC_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set PTP sub-second increment value * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Increment sub-second increment value */ LOCAL_INLINE void ENET_HWA_MAC_SetSubSecondIncrementValue(ENET_Type *const pEnet, uint8_t u8Increment) { pEnet->MAC_SUB_SECOND_INCREMENT = (pEnet->MAC_SUB_SECOND_INCREMENT & ~ENET_MAC_SUB_SECOND_INCREMENT_SSINC_MASK) | ENET_MAC_SUB_SECOND_INCREMENT_SSINC(u8Increment); } /** * @brief Get PTP sub-nanosecond increment value * * @param [in] pEnet the base address of the ENET instance * @return sub-nanosecond increment value */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetSubNanoSecondIncrementValue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_SUB_SECOND_INCREMENT & ENET_MAC_SUB_SECOND_INCREMENT_SNSINC_MASK) >> ENET_MAC_SUB_SECOND_INCREMENT_SNSINC_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set PTP sub-nanosecond increment value * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Increment sub-nanosecond increment value */ LOCAL_INLINE void ENET_HWA_MAC_SetSubNanoSecondIncrementValue(ENET_Type *const pEnet, uint8_t u8Increment) { pEnet->MAC_SUB_SECOND_INCREMENT = (pEnet->MAC_SUB_SECOND_INCREMENT & ~ENET_MAC_SUB_SECOND_INCREMENT_SNSINC_MASK) | ENET_MAC_SUB_SECOND_INCREMENT_SNSINC(u8Increment); } /** * @brief Get PTP system time seconds * * @param [in] pEnet the base address of the ENET instance * @return seconds value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetSystemTimeSeconds(const ENET_Type *const pEnet) { return pEnet->MAC_SYSTEM_TIME_SECONDS; } /** * @brief Get PTP system time nanoseconds * * @param [in] pEnet the base address of the ENET instance * @return nanoseconds value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetSystemTimeNanoSeconds(const ENET_Type *const pEnet) { return pEnet->MAC_SYSTEM_TIME_NANOSECONDS; } /** * @brief Get PTP system time seconds update register value * * @param [in] pEnet the base address of the ENET instance * @return seconds update register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetSystemTimeSecondsUpdateValue(const ENET_Type *const pEnet) { return pEnet->MAC_SYSTEM_TIME_SECONDS_UPDATE; } /** * @brief Set PTP system time seconds update register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Seconds seconds update register value */ LOCAL_INLINE void ENET_HWA_MAC_SetSystemTimeSecondsUpdateValue(ENET_Type *const pEnet, uint32_t u32Seconds) { pEnet->MAC_SYSTEM_TIME_SECONDS_UPDATE = u32Seconds; } /** * @brief Get PTP system time nanoseconds update register value * * @param [in] pEnet the base address of the ENET instance * @return nanoseconds update register value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetSystemTimeNanoSecondsUpdateReg(const ENET_Type *const pEnet) { return pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE; } /** * @brief Set PTP system time nanoseconds update register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Reg nanoseconds update register value */ LOCAL_INLINE void ENET_HWA_MAC_SetSystemTimeNanoSecondsUpdateReg(ENET_Type *const pEnet, uint32_t u32Reg) { pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE = u32Reg; } /** * @brief Get PTP system time update operation,add or subtract time * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_SystemTimeOperationType */ LOCAL_INLINE ENET_MAC_SystemTimeOperationType ENET_HWA_MAC_GetTimeUpdateOperation(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE & ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_ADDSUB_MASK) >> ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_ADDSUB_SHIFT; return (ENET_MAC_SystemTimeOperationType)u32TmpVal; } /** * @brief Set PTP system time update operation,add or subtract time * * @param [in] pEnet the base address of the ENET instance * @param [in] eOperation add or subtract time */ LOCAL_INLINE void ENET_HWA_MAC_SetTimeUpdateOperation(ENET_Type *const pEnet, ENET_MAC_SystemTimeOperationType eOperation) { pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE = (pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE & ~ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_ADDSUB_MASK) | ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_ADDSUB(eOperation); } /** * @brief Get PTP system time nanoseconds update value * * @param [in] pEnet the base address of the ENET instance * @return nanoseconds update value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetSystemTimeNanoSecondsUpdateValue(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE & ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_TSSS_MASK) >> ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_TSSS_SHIFT; return u32TmpVal; } /** * @brief Set PTP system time nanoseconds update value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32NanoSeconds nanoseconds update value */ LOCAL_INLINE void ENET_HWA_MAC_SetSystemTimeNanoSecondsUpdateValue(ENET_Type *const pEnet, uint32_t u32NanoSeconds) { pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE = (pEnet->MAC_SYSTEM_TIME_NANOSECONDS_UPDATE & ~ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_TSSS_MASK) | ENET_MAC_SYSTEM_TIME_NANOSECONDS_UPDATE_TSSS(u32NanoSeconds); } /** * @brief Get PTP timestamp addend register value * * @param [in] pEnet the base address of the ENET instance * @return timestamp addend value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTimestampAddend(const ENET_Type *const pEnet) { return pEnet->MAC_TIMESTAMP_ADDEND; } /** * @brief Set PTP timestamp addend register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Time timestamp addend value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampAddend(ENET_Type *const pEnet, uint32_t u32Time) { pEnet->MAC_TIMESTAMP_ADDEND = u32Time; } /** * @brief Get PTP system time seconds bits[47:32] value * * @param [in] pEnet the base address of the ENET instance * @return seconds bits[47:32] value */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetSystemTimeHigherWordSeconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_SYSTEM_TIME_HIGHER_WORD_SECONDS & ENET_MAC_SYSTEM_TIME_HIGHER_WORD_SECONDS_TSHWR_MASK) >> ENET_MAC_SYSTEM_TIME_HIGHER_WORD_SECONDS_TSHWR_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set PTP system time seconds bits[47:32] value * * @param [in] pEnet the base address of the ENET instance * @param [in] u16Seconds seconds bits[47:32] value */ LOCAL_INLINE void ENET_HWA_MAC_SetSystemTimeHigherWordSeconds(ENET_Type *const pEnet, uint16_t u16Seconds) { pEnet->MAC_SYSTEM_TIME_HIGHER_WORD_SECONDS = ENET_MAC_SYSTEM_TIME_HIGHER_WORD_SECONDS_TSHWR(u16Seconds); } /** * @brief Get the timestamp status * * @param [in] pEnet the base address of the ENET instance * @return uint32_t the timestamp status */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTimestampStatus(const ENET_Type *const pEnet) { return pEnet->MAC_TIMESTAMP_STATUS; } /** * @brief Indicates whether the transmit timestamp interrupt status is detected * * @param [in] pEnet the base address of the ENET instance * @return true transmit timestamp interrupt is detected * @return false transmit timestamp interrupt is not detected */ LOCAL_INLINE bool ENET_HWA_MAC_GetTxTimestampInterruptStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_STATUS & ENET_MAC_TIMESTAMP_STATUS_TXTSSIS_MASK) >> ENET_MAC_TIMESTAMP_STATUS_TXTSSIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the transmit timestamp interrupt status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearTxTimestampInterruptStatus(ENET_Type *const pEnet) { pEnet->MAC_TX_TIMESTAMP_STATUS_SECONDS = ENET_MAC_TX_TIMESTAMP_STATUS_SECONDS_MASK; } /** * @brief Indicates whether the timestamp target time error status of the PPS channel is detected * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann the channel number of PPS * @return true timestamp target time error is detected * @return false timestamp target time error is not detected */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampTargetTimeError(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_STATUS & ((uint32_t)ENET_MAC_TIMESTAMP_STATUS_TSTRGTERR0_MASK << (2u * (uint32_t)ePPSChann))) >> ((uint32_t)ENET_MAC_TIMESTAMP_STATUS_TSTRGTERR0_SHIFT + 2u * (uint32_t)ePPSChann); return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the timestamp target time error status of the PPS channel * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann the channel number of PPS */ LOCAL_INLINE void ENET_HWA_MAC_ClearTimestampTargetTimeError(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { pEnet->MAC_TIMESTAMP_STATUS &= (uint32_t)ENET_MAC_TIMESTAMP_STATUS_TSTRGTERR0_MASK << (2u * (uint32_t)ePPSChann); } /** * @brief Indicates whether the timestamp target time reached for target time of the PPS channel * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann the channel number of PPS * @return true timestamp target time is reached * @return false timestamp target time is not reached */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampTargetTimeReachedStatus(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_STATUS & ((uint32_t)ENET_MAC_TIMESTAMP_STATUS_TSTARGT0_MASK << (2u * (uint32_t)ePPSChann))) >> ((uint32_t)ENET_MAC_TIMESTAMP_STATUS_TSTARGT0_SHIFT + 2u * (uint32_t)ePPSChann); return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the status of the timestamp target time reached for target time of the PPS channel * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann the channel number of PPS */ LOCAL_INLINE void ENET_HWA_MAC_ClearTimestampTargetTimeReachedStatus(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { pEnet->MAC_TIMESTAMP_STATUS &= (uint32_t)ENET_MAC_TIMESTAMP_STATUS_TSTARGT0_MASK << (2u * (uint32_t)ePPSChann); } /** * @brief Indicates whether the timestamp seconds overflow status is detected * * @param [in] pEnet the base address of the ENET instance * @return true timestamp seconds overflow status is detected * @return false timestamp seconds overflow status is not detected */ LOCAL_INLINE bool ENET_HWA_MAC_GetTimestampSecondsOverflowStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_STATUS & ENET_MAC_TIMESTAMP_STATUS_TSSOVF_MASK) >> ENET_MAC_TIMESTAMP_STATUS_TSSOVF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear the timestamp seconds overflow status * @note This function shall only be called when MAC_CSR_SW_CTRL[RCWE] = 1 * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MAC_ClearTimestampSecondsOverflowStatus(ENET_Type *const pEnet) { pEnet->MAC_TIMESTAMP_STATUS &= ENET_MAC_TIMESTAMP_STATUS_TSSOVF_MASK; } /** * @brief Contains the nanosecond part of timestamp captured for transmit packets when tx status is disabled * * @param [in] pEnet the base address of the ENET instance * @return uint32_t transmit timestamp status in nanoseconds */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxTimestampStatusInNanoseconds(const ENET_Type *const pEnet) { return pEnet->MAC_TX_TIMESTAMP_STATUS_NANOSECONDS; } /** * @brief Contains the second part of timestamp captured for transmit packets when tx status is disabled * * @param [in] pEnet the base address of the ENET instance * @return uint32_t transmit timestamp status in seconds */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTxTimestampStatusInSeconds(const ENET_Type *const pEnet) { return pEnet->MAC_TX_TIMESTAMP_STATUS_SECONDS; } /** * @brief Get timestamp ingress asymmetry correction, used for PDelay_Resp PTP messages * * @param [in] pEnet the base address of the ENET instance * @return uint32_t correction value */ LOCAL_INLINE int32_t ENET_HWA_MAC_GetTimestampIngressAsymmetryCorrection(const ENET_Type *const pEnet) { return (int32_t)pEnet->MAC_TIMESTAMP_INGRESS_ASYM_CORR; } /** * @brief Set timestamp ingress asymmetry correction, used for PDelay_Resp PTP messages * * @param [in] pEnet the base address of the ENET instance * @param [in] s32Correction correction value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampIngressAsymmetryCorrection(ENET_Type *const pEnet, int32_t s32Correction) { pEnet->MAC_TIMESTAMP_INGRESS_ASYM_CORR = (uint32_t)s32Correction; } /** * @brief Get timestamp egress asymmetry correction, used for PDelay_Req PTP messages * * @param [in] pEnet the base address of the ENET instance * @return uint32_t correction value */ LOCAL_INLINE int32_t ENET_HWA_MAC_GetTimestampEgressAsymmetryCorrection(const ENET_Type *const pEnet) { return (int32_t)pEnet->MAC_TIMESTAMP_EGRESS_ASYM_CORR; } /** * @brief Set timestamp egress asymmetry correction, used for PDelay_Req PTP messages * * @param [in] pEnet the base address of the ENET instance * @param [in] s32Correction correction value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampEgressAsymmetryCorrection(ENET_Type *const pEnet, int32_t s32Correction) { pEnet->MAC_TIMESTAMP_EGRESS_ASYM_CORR = (uint32_t)s32Correction; } /** * @brief Get timestamp ingress correction in nanoseconds, used for timestamp in ingress path * * @param [in] pEnet the base address of the ENET instance * @return uint32_t correction value */ LOCAL_INLINE int32_t ENET_HWA_MAC_GetTimestampIngressCorrectionInNanoseconds(const ENET_Type *const pEnet) { return (int32_t)pEnet->MAC_TIMESTAMP_INGRESS_CORR_NANOSECOND; } /** * @brief Set timestamp ingress correction in nanoseconds, used for timestamp in ingress path * * @param [in] pEnet the base address of the ENET instance * @param [in] s32NanoSec correction value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampIngressCorrectionInNanoseconds(ENET_Type *const pEnet, int32_t s32NanoSec) { pEnet->MAC_TIMESTAMP_INGRESS_CORR_NANOSECOND = (uint32_t)s32NanoSec; } /** * @brief Get timestamp egress correction in nanoseconds, used for timestamp in egress path * * @param [in] pEnet the base address of the ENET instance * @return uint32_t correction value */ LOCAL_INLINE int32_t ENET_HWA_MAC_GetTimestampEgressCorrectionInNanoseconds(const ENET_Type *const pEnet) { return (int32_t)pEnet->MAC_TIMESTAMP_EGRESS_CORR_NANOSECOND; } /** * @brief Set timestamp egress correction in nanoseconds, used for timestamp in egress path * * @param [in] pEnet the base address of the ENET instance * @param [in] s32NanoSec correction value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampEgressCorrectionInNanoseconds(ENET_Type *const pEnet, int32_t s32NanoSec) { pEnet->MAC_TIMESTAMP_EGRESS_CORR_NANOSECOND = (uint32_t)s32NanoSec; } /** * @brief Get timestamp ingress correction in sub-nanoseconds, used for timestamp in ingress path * * @param [in] pEnet the base address of the ENET instance * @return uint32_t correction value */ LOCAL_INLINE int8_t ENET_HWA_MAC_GetTimestampIngressCorrectionInSubNanoseconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_INGRESS_CORR_SUBNANOSEC & ENET_MAC_TIMESTAMP_INGRESS_CORR_SUBNANOSEC_TSICSNS_MASK) >> ENET_MAC_TIMESTAMP_INGRESS_CORR_SUBNANOSEC_TSICSNS_SHIFT; return (int8_t)u32TmpVal; } /** * @brief Set timestamp ingress correction in sub-nanoseconds, used for timestamp in ingress path * * @param [in] pEnet the base address of the ENET instance * @param [in] s8SubNanoSec correction value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampIngressCorrectionInSubNanoseconds(ENET_Type *const pEnet, int8_t s8SubNanoSec) { pEnet->MAC_TIMESTAMP_INGRESS_CORR_SUBNANOSEC = ENET_MAC_TIMESTAMP_INGRESS_CORR_SUBNANOSEC_TSICSNS(s8SubNanoSec); } /** * @brief Get timestamp egress correction in sub-nanoseconds, used for timestamp in egress path * * @param [in] pEnet the base address of the ENET instance * @return uint32_t correction value */ LOCAL_INLINE int8_t ENET_HWA_MAC_GetTimestampEgressCorrectionInSubNanoseconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_EGRESS_CORR_SUBNANOSEC & ENET_MAC_TIMESTAMP_EGRESS_CORR_SUBNANOSEC_TSECSNS_MASK) >> ENET_MAC_TIMESTAMP_EGRESS_CORR_SUBNANOSEC_TSECSNS_SHIFT; return (int8_t)u32TmpVal; } /** * @brief Set timestamp egress correction in sub-nanoseconds, used for timestamp in egress path * * @param [in] pEnet the base address of the ENET instance * @param [in] s8SubNanoSec correction value */ LOCAL_INLINE void ENET_HWA_MAC_SetTimestampEgressCorrectionInSubNanoseconds(ENET_Type *const pEnet, int8_t s8SubNanoSec) { pEnet->MAC_TIMESTAMP_EGRESS_CORR_SUBNANOSEC = ENET_MAC_TIMESTAMP_EGRESS_CORR_SUBNANOSEC_TSECSNS(s8SubNanoSec); } /** * @brief Get the ingress MAC latency * * @param [in] pEnet the base address of the ENET instance * @return uint32_t ingress latency */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTimestampIngressLatency(const ENET_Type *const pEnet) { return pEnet->MAC_TIMESTAMP_INGRESS_LATENCY; } /** * @brief Get the ingress MAC latency in nanoseconds * * @param [in] pEnet the base address of the ENET instance * @return uint32_t ingress latency in nanoseconds */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetTimestampIngressLatencyInNanoseconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_INGRESS_LATENCY & ENET_MAC_TIMESTAMP_INGRESS_LATENCY_ITLNS_MASK) >> ENET_MAC_TIMESTAMP_INGRESS_LATENCY_ITLNS_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Get the ingress MAC latency in sub-nanoseconds * * @param [in] pEnet the base address of the ENET instance * @return uint32_t ingress latency in sub-nanoseconds */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetTimestampIngressLatencyInSubNanoseconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_INGRESS_LATENCY & ENET_MAC_TIMESTAMP_INGRESS_LATENCY_ITLSNS_MASK) >> ENET_MAC_TIMESTAMP_INGRESS_LATENCY_ITLSNS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get the egress MAC latency * * @param [in] pEnet the base address of the ENET instance * @return uint32_t egress latency */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetTimestampEgressLatency(const ENET_Type *const pEnet) { return pEnet->MAC_TIMESTAMP_EGRESS_LATENCY; } /** * @brief Get the egress MAC latency in nanoseconds * * @param [in] pEnet the base address of the ENET instance * @return uint32_t egress latency in nanoseconds */ LOCAL_INLINE uint16_t ENET_HWA_MAC_GetTimestampEgressLatencyInNanoseconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_EGRESS_LATENCY & ENET_MAC_TIMESTAMP_EGRESS_LATENCY_ETLNS_MASK) >> ENET_MAC_TIMESTAMP_EGRESS_LATENCY_ETLNS_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Get the egress MAC latency in sub-nanoseconds * * @param [in] pEnet the base address of the ENET instance * @return uint32_t egress latency in sub-nanoseconds */ LOCAL_INLINE uint8_t ENET_HWA_MAC_GetTimestampEgressLatencyInSubNanoseconds(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MAC_TIMESTAMP_EGRESS_LATENCY & ENET_MAC_TIMESTAMP_EGRESS_LATENCY_ETLSNS_MASK) >> ENET_MAC_TIMESTAMP_EGRESS_LATENCY_ETLSNS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get PPS control register value * * @param [in] pEnet the base address of the ENET instance * @return uint32_t PPS control value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPPSControl(const ENET_Type *const pEnet) { return pEnet->PPS.CONTROL; } /** * @brief Set PPS control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Ctrl PPS control value */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSControl(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->PPS.CONTROL = u32Ctrl; } /** * @brief Get PPS MCGR Mode enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return true PPS MCGR Mode is enabled * @return false PPS MCGR Mode is disabled */ LOCAL_INLINE bool ENET_HWA_MAC_GetPPSMCGRModeEnFlag(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = pEnet->PPS.CONTROL & ((uint32_t)ENET_MAC_PPS_CONTROL_MCGREN0_MASK << (8u * (uint32_t)ePPSChann)); return (u32TmpVal != 0u) ? true : false; } /** * @brief Set PPS MCGR Mode enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSMCGRModeEnFlag(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, bool bEnable) { pEnet->PPS.CONTROL = (pEnet->PPS.CONTROL & (~(ENET_MAC_PPS_CONTROL_MCGREN0_MASK << (8u * (uint32_t)ePPSChann)))) | ((uint32_t)ENET_MAC_PPS_CONTROL_MCGREN0(bEnable ? 1u : 0u) << (8u * (uint32_t)ePPSChann)); } /** * @brief Get PPS channel target time register operating mode * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return ENET_MAC_PPSTargetTimeModeType */ LOCAL_INLINE ENET_MAC_PPSTargetTimeModeType ENET_HWA_MAC_GetChannelPPSTargetTimeModeSelect(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->PPS.CONTROL & (ENET_MAC_PPS_CONTROL_TRGTMODSEL0_MASK << (8u * (uint32_t)ePPSChann))) >> (ENET_MAC_PPS_CONTROL_TRGTMODSEL0_SHIFT + (8u * (uint32_t)ePPSChann)); return (ENET_MAC_PPSTargetTimeModeType)u32TmpVal; } /** * @brief Set PPS channel target time register operating mode * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] eTrgtMode target time operating mode */ LOCAL_INLINE void ENET_HWA_MAC_SetChannelPPSTargetTimeModeSelect(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, ENET_MAC_PPSTargetTimeModeType eTrgtMode) { pEnet->PPS.CONTROL = (pEnet->PPS.CONTROL & (~(ENET_MAC_PPS_CONTROL_TRGTMODSEL0_MASK << (8u * (uint32_t)ePPSChann)))) | (ENET_MAC_PPS_CONTROL_TRGTMODSEL0(eTrgtMode) << (8u * (uint32_t)ePPSChann)); } /** * @brief Get PPS flexible mode enable flag * * @param [in] pEnet the base address of the ENET instance * @return true PPS work in flexible mode * @return false PPS work in fixed mode */ LOCAL_INLINE bool ENET_HWA_MAC_GetChannelFlexiblePPSOutputEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->PPS.CONTROL & ENET_MAC_PPS_CONTROL_PPSEN0_MASK) >> ENET_MAC_PPS_CONTROL_PPSEN0_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set PPS flexible mode enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable PPS flexible or fixed mode */ LOCAL_INLINE void ENET_HWA_MAC_SetChannelFlexiblePPSOutputEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->PPS.CONTROL = (pEnet->PPS.CONTROL & (~ENET_MAC_PPS_CONTROL_PPSEN0_MASK)) | ENET_MAC_PPS_CONTROL_PPSEN0(bEnable ? 1u : 0u); } /** * @brief Get PPS MCGR command * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return ENET_MAC_MCGRCmdType */ LOCAL_INLINE ENET_MAC_MCGRCmdType ENET_HWA_MAC_GetPPSMCGRCommand(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->PPS.CONTROL & ((uint32_t)ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_MASK << (8u * (uint32_t)ePPSChann))) >> ((uint32_t)ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_SHIFT + (8u * (uint32_t)ePPSChann)); return (ENET_MAC_MCGRCmdType)u32TmpVal; } /** * @brief Set PPS MCGR command * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] eCmd MCGR command */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSMCGRCommand(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, ENET_MAC_MCGRCmdType eCmd) { pEnet->PPS.CONTROL = (pEnet->PPS.CONTROL & (~(ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_MASK << (8u * (uint32_t)ePPSChann)))) | (ENET_MAC_PPS_CONTROL_MCGREN0(1u) << (8u * (uint32_t)ePPSChann)) | (ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD(eCmd) << (8u * (uint32_t)ePPSChann)); } /** * @brief Get flexible PPS command * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return ENET_MAC_PPSCmdType */ LOCAL_INLINE ENET_MAC_PPSCmdType ENET_HWA_MAC_GetFlexiblePPSCommand(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->PPS.CONTROL & ((uint32_t)ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_MASK << (8u * (uint32_t)ePPSChann))) >> ((uint32_t)ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_SHIFT + (8u * (uint32_t)ePPSChann)); return (ENET_MAC_PPSCmdType)u32TmpVal; } /** * @brief Set flexible PPS command * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] eCmd flexible PPS command */ LOCAL_INLINE void ENET_HWA_MAC_SetFlexiblePPSCommand(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, ENET_MAC_PPSCmdType eCmd) { pEnet->PPS.CONTROL = (pEnet->PPS.CONTROL & (~(ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_MASK << (8u * (uint32_t)ePPSChann)))) | (ENET_MAC_PPS_CONTROL_PPSEN0(1u)) | (ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD(eCmd) << (8u * (uint32_t)ePPSChann)); } /** * @brief Get fixed PPS output frequency * * @param [in] pEnet the base address of the ENET instance * @return ENET_MAC_PPSFreqCtrlType */ LOCAL_INLINE ENET_MAC_PPSFreqCtrlType ENET_HWA_MAC_GetFixedPPSOutputFrequency(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->PPS.CONTROL & ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_MASK) >> ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD_SHIFT; return (ENET_MAC_PPSFreqCtrlType)u32TmpVal; } /** * @brief Set fixed PPS output frequency * * @param [in] pEnet the base address of the ENET instance * @param [in] eFreq frequency value defined in ENET_MAC_PPSFreqCtrlType */ LOCAL_INLINE void ENET_HWA_MAC_SetFixedPPSOutputFrequency(ENET_Type *const pEnet, ENET_MAC_PPSFreqCtrlType eFreq) { pEnet->PPS.CONTROL = ENET_MAC_PPS_CONTROL_PPSCTRL_PPSCMD(eFreq); } /** * @brief Get PPS target time seconds * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return uint32_t target time seconds */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPPSTargetTimeInSeconds(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { return pEnet->PPS.CH[ePPSChann].TARGET_TIME_SECONDS; } /** * @brief Set PPS target time seconds * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] u32Seconds target time seconds */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSTargetTimeInSeconds(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, uint32_t u32Seconds) { pEnet->PPS.CH[ePPSChann].TARGET_TIME_SECONDS = u32Seconds; } /** * @brief Get PPS target time busy status * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return ENET_MAC_StatusType */ LOCAL_INLINE ENET_MAC_StatusType ENET_HWA_MAC_GetPPSTargetTimeBusyStatus(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->PPS.CH[ePPSChann].TARGET_TIME_NANOSECONDS & ENET_MAC_PPSn_TARGET_TIME_NANOSECONDS_TRGTBUSY0_MASK) >> ENET_MAC_PPSn_TARGET_TIME_NANOSECONDS_TRGTBUSY0_SHIFT; return (ENET_MAC_StatusType)u32TmpVal; } /** * @brief Get PPS target time nanoseconds * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return uint32_t target time nanoseconds */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPPSTargetTimeInNanoseconds(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { uint32_t u32TmpVal = (pEnet->PPS.CH[ePPSChann].TARGET_TIME_NANOSECONDS & ENET_MAC_PPSn_TARGET_TIME_NANOSECONDS_TTSL0_MASK) >> ENET_MAC_PPSn_TARGET_TIME_NANOSECONDS_TTSL0_SHIFT; return u32TmpVal; } /** * @brief Set PPS target time nanoseconds * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] u32NanoSeconds target time nanoseconds */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSTargetTimeInNanoseconds(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, uint32_t u32NanoSeconds) { pEnet->PPS.CH[ePPSChann].TARGET_TIME_NANOSECONDS = ENET_MAC_PPSn_TARGET_TIME_NANOSECONDS_TTSL0(u32NanoSeconds); } /** * @brief Get PPS pulse interval * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return uint32_t PPS interval value */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPPSInterval(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { return pEnet->PPS.CH[ePPSChann].INTERVAL; } /** * @brief Set PPS pulse interval * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] u32Interval PPS pulse interval */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSInterval(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, uint32_t u32Interval) { pEnet->PPS.CH[ePPSChann].INTERVAL = u32Interval; } /** * @brief Get PPS pulse width * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @return uint32_t PPS pulse width */ LOCAL_INLINE uint32_t ENET_HWA_MAC_GetPPSWidth(const ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann) { return pEnet->PPS.CH[ePPSChann].WIDTH; } /** * @brief Set PPS pulse width * * @param [in] pEnet the base address of the ENET instance * @param [in] ePPSChann PPS channel * @param [in] u32Width PPS pulse width */ LOCAL_INLINE void ENET_HWA_MAC_SetPPSWidth(ENET_Type *const pEnet, ENET_MAC_PPSChannelType ePPSChann, uint32_t u32Width) { pEnet->PPS.CH[ePPSChann].WIDTH = u32Width; } /* ================================================================ * * ENET MTL Configuration and Status * * ================================================================ */ /** * @brief Get MTL operation mode register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t MTL operation mode */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetOperationMode(const ENET_Type *const pEnet) { return pEnet->MTL.OPERATION_MODE; } /** * @brief Set MTL operation mode register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32OpMode MTL operation mode */ LOCAL_INLINE void ENET_HWA_MTL_SetOperationMode(ENET_Type *const pEnet, uint32_t u32OpMode) { pEnet->MTL.OPERATION_MODE = u32OpMode; } /** * @brief Get MTL counter reset status * @param [in] pEnet the base address of the ENET instance * @return uint32_t counter reset status */ LOCAL_INLINE bool ENET_HWA_MTL_GetCounterResetStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.OPERATION_MODE & ENET_MTL_OPERATION_MODE_CNTCLR_MASK) >> ENET_MTL_OPERATION_MODE_CNTCLR_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Reset MTL counters * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ResetCounters(ENET_Type *const pEnet) { pEnet->MTL.OPERATION_MODE |= ENET_MTL_OPERATION_MODE_CNTCLR_MASK; } /** * @brief Get MTL counter preset status * @param [in] pEnet the base address of the ENET instance * @return uint32_t counter preset status */ LOCAL_INLINE bool ENET_HWA_MTL_GetPresetCounterStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.OPERATION_MODE & ENET_MTL_OPERATION_MODE_CNTPRST_MASK) >> ENET_MTL_OPERATION_MODE_CNTPRST_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Preset MTL counters * * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_InitPresetCounters(ENET_Type *const pEnet) { pEnet->MTL.OPERATION_MODE |= ENET_MTL_OPERATION_MODE_CNTPRST_MASK; } /** * @brief Get MTL algorithm for transmit scheduling * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_TxScheduleAlgorithmType */ LOCAL_INLINE ENET_MTL_TxScheduleAlgorithmType ENET_HWA_MTL_GetTxSchedulingAlgorithm(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.OPERATION_MODE & ENET_MTL_OPERATION_MODE_SCHALG_MASK) >> ENET_MTL_OPERATION_MODE_SCHALG_SHIFT; return (ENET_MTL_TxScheduleAlgorithmType)u32TmpVal; } /** * @brief Set MTL algorithm for transmit scheduling * * @param [in] pEnet the base address of the ENET instance * @param [in] eScheduleAlgorithm algorithm mode */ LOCAL_INLINE void ENET_HWA_MTL_SetTxSchedulingAlgorithm(ENET_Type *const pEnet, ENET_MTL_TxScheduleAlgorithmType eScheduleAlgorithm) { pEnet->MTL.OPERATION_MODE = (pEnet->MTL.OPERATION_MODE & ~ENET_MTL_OPERATION_MODE_SCHALG_MASK) | ENET_MTL_OPERATION_MODE_SCHALG(eScheduleAlgorithm); } /** * @brief Get MTL algorithm for receive arbitration * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_RxArbitrationAlgorithmType */ LOCAL_INLINE ENET_MTL_RxArbitrationAlgorithmType ENET_HWA_MTL_GetRxArbitrationAlgorithm(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.OPERATION_MODE & ENET_MTL_OPERATION_MODE_RAA_MASK) >> ENET_MTL_OPERATION_MODE_RAA_SHIFT; return (ENET_MTL_RxArbitrationAlgorithmType)u32TmpVal; } /** * @brief Set MTL algorithm for receive arbitration * * @param [in] pEnet the base address of the ENET instance * @param [in] eArbitrationAlgorithm arbitration algorithm mode */ LOCAL_INLINE void ENET_HWA_MTL_SetRxArbitrationAlgorithm(ENET_Type *const pEnet, ENET_MTL_RxArbitrationAlgorithmType eArbitrationAlgorithm) { pEnet->MTL.OPERATION_MODE = (pEnet->MTL.OPERATION_MODE & ~ENET_MTL_OPERATION_MODE_RAA_MASK) | ENET_MTL_OPERATION_MODE_RAA(eArbitrationAlgorithm); } /** * @brief Get whether tx packet status received from the MAC is droped or not * @param [in] pEnet the base address of the ENET instance * @return true tx packet status is droped * @return false tx packet status is forwarded to application */ LOCAL_INLINE bool ENET_HWA_MTL_GetDropTxPacketStatusEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.OPERATION_MODE & ENET_MTL_OPERATION_MODE_DTXSTS_MASK) >> ENET_MTL_OPERATION_MODE_DTXSTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set drop tx packet status enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable drop or forward tx packet status */ LOCAL_INLINE void ENET_HWA_MTL_SetDropTxPacketStatusEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.OPERATION_MODE = (pEnet->MTL.OPERATION_MODE & ~ENET_MTL_OPERATION_MODE_DTXSTS_MASK) | ENET_MTL_OPERATION_MODE_DTXSTS(bEnable ? 1u : 0u); } /** * @brief Get MTL debug control register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t MTL debug control value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetDebugCtrl(const ENET_Type *const pEnet) { return pEnet->MTL.DBG_CTL; } /** * @brief Set MTL debug control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32DebugCtrl control value */ LOCAL_INLINE void ENET_HWA_MTL_SetDebugCtrl(ENET_Type *const pEnet, uint32_t u32DebugCtrl) { pEnet->MTL.DBG_CTL = u32DebugCtrl; } /** * @brief Get transmit status available interrupt status enable flag * @param [in] pEnet the base address of the ENET instance * @return true transmit status available interrupt status is enabled * @return false transmit status available interrupt status is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxStatusAvailableIntEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_STSIE_MASK) >> ENET_MTL_DBG_CTL_STSIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmit status available interrupt status enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetTxStatusAvailableIntEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_STSIE_MASK) | ENET_MTL_DBG_CTL_STSIE(bEnable ? 1u : 0u); } /** * @brief Get receive packet available interrupt status enable flag * @param [in] pEnet the base address of the ENET instance * @return true receive packet available interrupt status is enabled * @return false receive packet available interrupt status is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxPacketAvailableIntEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_PKTIE_MASK) >> ENET_MTL_DBG_CTL_PKTIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive packet available interrupt status enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetRxPacketAvailableIntEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_PKTIE_MASK) | ENET_MTL_DBG_CTL_PKTIE(bEnable ? 1u : 0u); } /** * @brief Get the FIFO selected for debug access * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_DebugAccessFIFOType */ LOCAL_INLINE ENET_MTL_DebugAccessFIFOType ENET_HWA_MTL_GetDebugAccessFIFO(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_FIFOSEL_MASK) >> ENET_MTL_DBG_CTL_FIFOSEL_SHIFT; return (ENET_MTL_DebugAccessFIFOType)u32TmpVal; } /** * @brief Set the FIFO selected for debug access * * @param [in] pEnet the base address of the ENET instance * @param [in] eFIFOType debug FIFO defined in ENET_MTL_DebugAccessFIFOType */ LOCAL_INLINE void ENET_HWA_MTL_SetDebugAccessFIFO(ENET_Type *const pEnet, ENET_MTL_DebugAccessFIFOType eFIFOType) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_FIFOSEL_MASK) | ENET_MTL_DBG_CTL_FIFOSEL(eFIFOType); } /** * @brief Get write operation on selected FIFO enable flag * @param [in] pEnet the base address of the ENET instance * @return true write operation on selected FIFO is enabled * @return false write operation on selected FIFO is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetFIFOWriteEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_FIFOWREN_MASK) >> ENET_MTL_DBG_CTL_FIFOWREN_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set write operation on selected FIFO enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetFIFOWriteEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_FIFOWREN_MASK) | ENET_MTL_DBG_CTL_FIFOWREN(bEnable ? 1u : 0u); } /** * @brief Get pointers of selected FIFO reset status * @param [in] pEnet the base address of the ENET instance * @return true FIFO reset is enabled * @return false FIFO reset is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetSelectedFIFOPointerResetStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_RSTSEL_MASK) >> ENET_MTL_DBG_CTL_RSTSEL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Reset pointers of selected FIFO * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetSelectedFIFOPointerResetFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_RSTSEL_MASK) | ENET_MTL_DBG_CTL_RSTSEL(bEnable ? 1u : 0u); } /** * @brief Get pointers of all FIFOs reset status * @param [in] pEnet the base address of the ENET instance * @return true all FIFOs reset is enabled * @return false all FIFOs reset is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetAllFIFOPointersResetStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_RSTALL_MASK) >> ENET_MTL_DBG_CTL_RSTALL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Reset pointers of all FIFOs * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetAllFIFOPointerResetFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_RSTALL_MASK) | ENET_MTL_DBG_CTL_RSTALL(bEnable ? 1u : 0u); } /** * @brief Encoded packet state,the control information to the Tx FIFO or Rx FIFO * * @param [in] pEnet the base address of the ENET instance * @param [in] eState */ LOCAL_INLINE void ENET_HWA_MTL_SetFIFOPacketState(ENET_Type *const pEnet, ENET_MTL_FIFOPacketStatusType eState) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_PKTSTATE_MASK) | ENET_MTL_DBG_CTL_PKTSTATE(eState); } /** * @brief Indicates the number of data bytes valid in the data register during Write operation * * @param [in] pEnet the base address of the ENET instance * @param [in] eByteValid the number of data bytes valid */ LOCAL_INLINE void ENET_HWA_MTL_SetByteEnable(ENET_Type *const pEnet, ENET_MTL_ByteEnableType eByteValid) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_BYTEEN_MASK) | ENET_MTL_DBG_CTL_BYTEEN(eByteValid); } /** * @brief Get pointers of all FIFOs reset status * @param [in] pEnet the base address of the ENET instance * @return true all FIFOs reset is enabled * @return false all FIFOs reset is disabled */ LOCAL_INLINE ENET_MTL_FIFODebugAccessType ENET_HWA_MTL_GetFIFODebugModeAccessType(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_DBGMOD_MASK) >> ENET_MTL_DBG_CTL_DBGMOD_SHIFT; return (ENET_MTL_FIFODebugAccessType)u32TmpVal; } /** * @brief Set the debug mode of accessing to fifo * * @param [in] pEnet the base address of the ENET instance * @param [in] eAccessType accessing to fifo is restricted or not */ LOCAL_INLINE void ENET_HWA_MTL_SetFIFODebugModeAccessType(ENET_Type *const pEnet, ENET_MTL_FIFODebugAccessType eAccessType) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_DBGMOD_MASK) | ENET_MTL_DBG_CTL_DBGMOD(eAccessType); } /** * @brief Get FIFO debug access enable flag * @param [in] pEnet the base address of the ENET instance * @return true the debug mode access to the FIFO is enabled * @return false the debug mode access to the FIFO is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetFIFODebugAccessEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_CTL & ENET_MTL_DBG_CTL_FDBGEN_MASK) >> ENET_MTL_DBG_CTL_FDBGEN_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set FIFO debug access enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetFIFODebugAccessEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.DBG_CTL = (pEnet->MTL.DBG_CTL & ~ENET_MTL_DBG_CTL_FDBGEN_MASK) | ENET_MTL_DBG_CTL_FDBGEN(bEnable ? 1u : 0u); } /** * @brief Get MTL debug status register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t debug status */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetDebugStatus(const ENET_Type *const pEnet) { return pEnet->MTL.DBG_STS; } /** * @brief Get MTL remaining locations in the FIFO * @param [in] pEnet the base address of the ENET instance * @return uint32_t */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetFIFORemainingLocation(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_STS & ENET_MTL_DBG_STS_LOCR_MASK) >> ENET_MTL_DBG_STS_LOCR_SHIFT; return u32TmpVal; } /** * @brief Get MTL transmit status available interrupt status * @param [in] pEnet the base address of the ENET instance * @return true transmit status available interrupt not detected * @return false transmit status available interrupt detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxStatusAvailableIntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_STS & ENET_MTL_DBG_STS_STSI_MASK) >> ENET_MTL_DBG_STS_STSI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear MTL transmit status available interrupt status * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearTxStatusAvailableIntStatus(ENET_Type *const pEnet) { pEnet->MTL.DBG_STS = ENET_MTL_DBG_STS_STSI_MASK; } /** * @brief Get MTL receive packet available interrupt status * @param [in] pEnet the base address of the ENET instance * @return true receive packet available interrupt not detected * @return false receive packet available interrupt detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxPacketAvailableIntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_STS & ENET_MTL_DBG_STS_PKTI_MASK) >> ENET_MTL_DBG_STS_PKTI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear MTL receive packet available interrupt status * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearRxPacketAvailableIntStatus(ENET_Type *const pEnet) { pEnet->MTL.DBG_STS = ENET_MTL_DBG_STS_PKTI_MASK; } /** * @brief Get the number of data bytes valid in the data register during Read operation * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_ByteEnableType */ LOCAL_INLINE ENET_MTL_ByteEnableType ENET_HWA_MTL_GetByteEnable(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_STS & ENET_MTL_DBG_STS_BYTEEN_MASK) >> ENET_MTL_DBG_STS_BYTEEN_SHIFT; return (ENET_MTL_ByteEnableType)u32TmpVal; } /** * @brief Get the control or status information of the selected FIFO. * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_FIFOPacketStatusType */ LOCAL_INLINE ENET_MTL_FIFOPacketStatusType ENET_HWA_MTL_GetFIFOPacketState(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_STS & ENET_MTL_DBG_STS_PKTSTATE_MASK) >> ENET_MTL_DBG_STS_PKTSTATE_SHIFT; return (ENET_MTL_FIFOPacketStatusType)u32TmpVal; } /** * @brief Get MTL FIFO busy status * @param [in] pEnet the base address of the ENET instance * @return true FIFO is busy * @return false FIFO is not busy */ LOCAL_INLINE bool ENET_HWA_MTL_GetFIFOBusy(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.DBG_STS & ENET_MTL_DBG_STS_FIFOBUSY_MASK) >> ENET_MTL_DBG_STS_FIFOBUSY_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get MTL FIFO debug data * @param [in] pEnet the base address of the ENET instance * @return uint32_t FIFO debug data */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetFIFODebugData(const ENET_Type *const pEnet) { return pEnet->MTL.FIFO_DEBUG_DATA; } /** * @brief Set MTL FIFO debug data * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Data debug data to set */ LOCAL_INLINE void ENET_HWA_MTL_SetFIFODebugData(ENET_Type *const pEnet, uint32_t u32Data) { pEnet->MTL.FIFO_DEBUG_DATA = u32Data; } /** * @brief Get MTL interrupt status * @param [in] pEnet the base address of the ENET instance * @return uint32_t MTL interrupt status */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetIntStatus(const ENET_Type *const pEnet) { return pEnet->MTL.INTERRUPT_STATUS; } /** * @brief Get debug interrupt status * @param [in] pEnet the base address of the ENET instance * @return true Debug interrupt status detected * @return false Debug interrupt status not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetDebugIntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.INTERRUPT_STATUS & ENET_MTL_INTERRUPT_STATUS_DBGIS_MASK) >> ENET_MTL_INTERRUPT_STATUS_DBGIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get Queue 1 interrupt status * @param [in] pEnet the base address of the ENET instance * @return true Queue 1 interrupt status detected * @return false Queue 1 interrupt status not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetQueue1IntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.INTERRUPT_STATUS & ENET_MTL_INTERRUPT_STATUS_Q1IS_MASK) >> ENET_MTL_INTERRUPT_STATUS_Q1IS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get Queue 0 interrupt status * @param [in] pEnet the base address of the ENET instance * @return true Queue 0 interrupt status detected * @return false Queue 0 interrupt status not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetQueue0IntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.INTERRUPT_STATUS & ENET_MTL_INTERRUPT_STATUS_Q0IS_MASK) >> ENET_MTL_INTERRUPT_STATUS_Q0IS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get DA-based DMA channel selection enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true eQueue is enabled for DA-based DMA channel selection * @return false eQueue is disabled for DA-based DMA channel selection */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxDABasedDMAChannelSelectionEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.RXQ_DMA_MAP0 & ((uint32_t)ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_MASK << ((uint32_t)ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_SHIFT + ((uint32_t)ENET_MTL_RXQ_DMA_MAP0_Q1DDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_SHIFT) * (uint32_t)eQueue))); return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DA-based DMA channel selection enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetRxDABasedDMAChannelSelectionEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.RXQ_DMA_MAP0 = (pEnet->MTL.RXQ_DMA_MAP0 & ~(ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_MASK << (ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_SHIFT + (ENET_MTL_RXQ_DMA_MAP0_Q1DDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_SHIFT) * (uint32_t)eQueue))) | (ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH(bEnable ? 1u : 0u) << ((ENET_MTL_RXQ_DMA_MAP0_Q1DDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0DDMACH_SHIFT) * (uint32_t)eQueue)); } /** * @brief Get DMA channel mapped to eQueue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_DMA_ChannelType */ LOCAL_INLINE ENET_DMA_ChannelType ENET_HWA_MTL_GetRxDMAChannelMap(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.RXQ_DMA_MAP0 & ((uint32_t)ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_MASK << ((uint32_t)ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT + (uint32_t)(ENET_MTL_RXQ_DMA_MAP0_Q1MDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT) * (uint32_t)eQueue))) >> ((uint32_t)ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT + (uint32_t)(ENET_MTL_RXQ_DMA_MAP0_Q1MDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT) * (uint32_t)eQueue); return (ENET_DMA_ChannelType)u32TmpVal; } /** * @brief Set DMA channel mapped to eQueue * * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_MTL_SetRxDMAChannelMap(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_DMA_ChannelType eDMAChannel) { pEnet->MTL.RXQ_DMA_MAP0 = (pEnet->MTL.RXQ_DMA_MAP0 & ~(ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_MASK << (ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT + (ENET_MTL_RXQ_DMA_MAP0_Q1MDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT) * (uint32_t)eQueue))) | (ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH(eDMAChannel) << ((ENET_MTL_RXQ_DMA_MAP0_Q1MDMACH_SHIFT - ENET_MTL_RXQ_DMA_MAP0_Q0MDMACH_SHIFT) * (uint32_t)eQueue)); } #if ENET_SUPPORT_TIME_SENSITIVE_NETWORK /** * @brief Get Time Based Scheduling control register * @param [in] pEnet the base address of the ENET instance * @return uint32_t Time Based Scheduling control */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetTBSCtrl(const ENET_Type *const pEnet) { return pEnet->MTL.TBS_CTRL; } /** * @brief Set Time Based Scheduling control register * * @param [in] pEnet the base address of the ENET instance * @param [in] u32Ctrl control value */ LOCAL_INLINE void ENET_HWA_MTL_SetTBSCtrl(ENET_Type *const pEnet, uint32_t u32Ctrl) { pEnet->MTL.TBS_CTRL = u32Ctrl; } /** * @brief Get launch expiry offset * @param [in] pEnet the base address of the ENET instance * @return uint32_t launch expiry offset */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetLaunchExpiryOffset(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.TBS_CTRL & ENET_MTL_TBS_CTRL_LEOS_MASK) >> ENET_MTL_TBS_CTRL_LEOS_SHIFT; return u32TmpVal; } /** * @brief Set launch expiry offset * * @param [in] pEnet the base address of the ENET instance * @param [in] u32ExpiryOffset launch expiry offset value */ LOCAL_INLINE void ENET_HWA_MTL_SetLaunchExpiryOffset(ENET_Type *const pEnet, uint32_t u32ExpiryOffset) { pEnet->MTL.TBS_CTRL = (pEnet->MTL.TBS_CTRL & ~ENET_MTL_TBS_CTRL_LEOS_MASK) | ENET_MTL_TBS_CTRL_LEOS(u32ExpiryOffset); } /** * @brief Get launch expiry offset enable flag * @param [in] pEnet the base address of the ENET instance * @return true launch expiry offset is valid * @return false launch expiry offset is invalid */ LOCAL_INLINE bool ENET_HWA_MTL_GetLaunchExpiryOffsetEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.TBS_CTRL & ENET_MTL_TBS_CTRL_LEOV_MASK) >> ENET_MTL_TBS_CTRL_LEOV_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set launch expiry offset enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable launch expiry offset */ LOCAL_INLINE void ENET_HWA_MTL_SetLaunchExpiryOffsetEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.TBS_CTRL = (pEnet->MTL.TBS_CTRL & ~ENET_MTL_TBS_CTRL_LEOV_MASK) | ENET_MTL_TBS_CTRL_LEOV(bEnable ? 1u : 0u); } /** * @brief Get enhancements to scheduled transmission control register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t EST control value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetEstControl(const ENET_Type *const pEnet) { return pEnet->MTL.EST_CONTROL; } /** * @brief Set enhancements to scheduled transmission control register value * * @param [in] pEnet the base address of the ENET instance * @param [in] u32EstControl EST control value */ LOCAL_INLINE void ENET_HWA_MTL_SetEstControl(ENET_Type *const pEnet, uint32_t u32EstControl) { pEnet->MTL.EST_CONTROL = u32EstControl; } /** * @brief Get enhancements to scheduled transmission PTP time offset * @param [in] pEnet the base address of the ENET instance * @return uint8_t PTP time offset */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetEstPtpTimeOffset(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_PTOV_MASK) >> ENET_MTL_EST_CONTROL_PTOV_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set enhancements to scheduled transmission PTP time offset * * @param [in] pEnet the base address of the ENET instance * @param [in] u8Value PTP time offset */ LOCAL_INLINE void ENET_HWA_MTL_SetEstPtpTimeOffset(ENET_Type *const pEnet, uint8_t u8Value) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_PTOV_MASK) | ENET_MTL_EST_CONTROL_PTOV(u8Value); } /** * @brief Get enhancements to scheduled transmission current time offset * @param [in] pEnet the base address of the ENET instance * @return uint16_t current time offset */ LOCAL_INLINE uint16_t ENET_HWA_MTL_GetEstCurrentTimeOffset(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_CTOV_MASK) >> ENET_MTL_EST_CONTROL_CTOV_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set enhancements to scheduled transmission current time offset * * @param [in] pEnet the base address of the ENET instance * @param [in] u16Value current time offset */ LOCAL_INLINE void ENET_HWA_MTL_SetEstCurrentTimeOffset(ENET_Type *const pEnet, uint16_t u16Value) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_CTOV_MASK) | ENET_MTL_EST_CONTROL_CTOV(u16Value); } /** * @brief Get EST time interval left shift amount * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_GCLIntervalMultipleType */ LOCAL_INLINE ENET_MTL_GCLIntervalMultipleType ENET_HWA_MTL_GetEstTimeIntervalLeftShift(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_TILS_MASK) >> ENET_MTL_EST_CONTROL_TILS_SHIFT; return (ENET_MTL_GCLIntervalMultipleType)u32TmpVal; } /** * @brief Set EST time interval left shift amount * * @param [in] pEnet the base address of the ENET instance * @param [in] eValue left shift amount */ LOCAL_INLINE void ENET_HWA_MTL_SetEstTimeIntervalLeftShift(ENET_Type *const pEnet, ENET_MTL_GCLIntervalMultipleType eValue) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_TILS_MASK) | ENET_MTL_EST_CONTROL_TILS(eValue); } /** * @brief Get the loop count to report scheduling error * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_ScheduleErrorLoopCountType */ LOCAL_INLINE ENET_MTL_ScheduleErrorLoopCountType ENET_HWA_MTL_GetEstScheduleErrorLoopCount(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_LCSE_MASK) >> ENET_MTL_EST_CONTROL_LCSE_SHIFT; return (ENET_MTL_ScheduleErrorLoopCountType)u32TmpVal; } /** * @brief Set the loop count to report scheduling error * * @param [in] pEnet the base address of the ENET instance * @param [in] eValue loop count */ LOCAL_INLINE void ENET_HWA_MTL_SetEstScheduleErrorLoopCount(ENET_Type *const pEnet, ENET_MTL_ScheduleErrorLoopCountType eValue) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_LCSE_MASK) | ENET_MTL_EST_CONTROL_LCSE(eValue); } /** * @brief Drop frames causing scheduling error * @param [in] pEnet the base address of the ENET instance * @return true Drop frames causing scheduling error * @return false Do not drop frames causing scheduling error */ LOCAL_INLINE bool ENET_HWA_MTL_GetDropSchedulingErrorFramesEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_DFBS_MASK) >> ENET_MTL_EST_CONTROL_DFBS_SHIFT; return (bool)u32TmpVal; } /** * @brief Enable dropping frames causing scheduling error * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetDropSchedulingErrorFramesEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_DFBS_MASK) | ENET_MTL_EST_CONTROL_DFBS(bEnable ? 1u : 0u); } /** * @brief Drop frames during frame size error * @param [in] pEnet the base address of the ENET instance * @return true Do not drop frames during frame size error * @return false Drop frames during frame size error */ LOCAL_INLINE bool ENET_HWA_MTL_GetDropFrameSizeErrorFramesDisableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_DDBF_MASK) >> ENET_MTL_EST_CONTROL_DDBF_SHIFT; return (bool)u32TmpVal; } /** * @brief Enable dropping frames causing scheduling error * * @param [in] pEnet the base address of the ENET instance * @param [in] bDisable disable or enable */ LOCAL_INLINE void ENET_HWA_MTL_SetDropFrameSizeErrorFramesDisableFlag(ENET_Type *const pEnet, bool bDisable) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_DDBF_MASK) | ENET_MTL_EST_CONTROL_DDBF(bDisable ? 1u : 0u); } /** * @brief Get switch gate control list enable flag * @param [in] pEnet the base address of the ENET instance * @return true switch gate control list is enabled * @return false switch gate control list is diabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetSwitchGateControlListEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_SSWL_MASK) >> ENET_MTL_EST_CONTROL_SSWL_SHIFT; return (bool)u32TmpVal; } /** * @brief Switch gate control list * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetSwitchGateControlListEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_SSWL_MASK) | ENET_MTL_EST_CONTROL_SSWL(bEnable ? 1u : 0u); } /** * @brief Get EST enable flag * @param [in] pEnet the base address of the ENET instance * @return true EST is enabled * @return false EST is diabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetEstEnableFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_CONTROL & ENET_MTL_EST_CONTROL_EEST_MASK) >> ENET_MTL_EST_CONTROL_EEST_SHIFT; return (bool)u32TmpVal; } /** * @brief Enable EST * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetEstEnableFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_CONTROL & ~ENET_MTL_EST_CONTROL_EEST_MASK) | ENET_MTL_EST_CONTROL_EEST(bEnable ? 1u : 0u); } /** * @brief Get EST overhead bytes value * @param [in] pEnet the base address of the ENET instance * @return uint8_t EST overhead bytes value */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetEstOverheadBytes(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_EXT_CONTROL & ENET_MTL_EST_EXT_CONTROL_OVHD_MASK) >> ENET_MTL_EST_EXT_CONTROL_OVHD_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set EST overhead bytes value * * @param[in] pEnet the base address of the ENET instance * @param[in] u8Value EST overhead bytes value */ LOCAL_INLINE void ENET_HWA_MTL_SetEstOverheadBytes(ENET_Type *const pEnet, uint8_t u8Value) { pEnet->MTL.EST_CONTROL = (pEnet->MTL.EST_EXT_CONTROL & ~ENET_MTL_EST_EXT_CONTROL_OVHD_MASK) | ENET_MTL_EST_EXT_CONTROL_OVHD(u8Value); } /** * @brief Get EST status register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t EST status register value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetEstStatus(const ENET_Type *const pEnet) { return pEnet->MTL.EST_STATUS; } /** * @brief Get current GCL slot number * @param [in] pEnet the base address of the ENET instance * @return uint8_t current GCL slot number */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetCurrentGCLSlotNumber(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_CGSN_MASK) >> ENET_MTL_EST_STATUS_CGSN_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get BTR error loop count * @param [in] pEnet the base address of the ENET instance * @return uint8_t BTR error loop count */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetBTRErrorLoopCount(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_BTRL_MASK) >> ENET_MTL_EST_STATUS_BTRL_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get the gate control list owned by software * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_GateControlListType */ LOCAL_INLINE ENET_MTL_GateControlListType ENET_HWA_MTL_GetSoftwareOwnedList(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_SWOL_MASK) >> ENET_MTL_EST_STATUS_SWOL_SHIFT; return (ENET_MTL_GateControlListType)u32TmpVal; } /** * @brief Get constant gate control error * @param [in] pEnet the base address of the ENET instance * @return true constant gate control error detected * @return false constant gate control error not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetConstantGateControlErrorFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_CGCE_MASK) >> ENET_MTL_EST_STATUS_CGCE_SHIFT; return (bool)u32TmpVal; } /** * @brief Clear constant gate control error flag * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearConstantGateControlErrorFlag(ENET_Type *const pEnet) { pEnet->MTL.EST_STATUS = pEnet->MTL.EST_STATUS | ENET_MTL_EST_STATUS_CGCE_MASK; } /** * @brief Get Head-Of-Line blocking due to scheduling * @param [in] pEnet the base address of the ENET instance * @return true Head-Of-Line blocking due to scheduling detected * @return false Head-Of-Line blocking due to scheduling not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetHeadOfLineBlockingDueToSchedulingFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_HLBS_MASK) >> ENET_MTL_EST_STATUS_HLBS_SHIFT; return (bool)u32TmpVal; } /** * @brief Get Head-Of-Line blocking due to frame size * @param [in] pEnet the base address of the ENET instance * @return true Head-Of-Line blocking due to frame size detected * @return false Head-Of-Line blocking due to frame size not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetHeadOfLineBlockingDueToFrameSizeFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_HLBF_MASK) >> ENET_MTL_EST_STATUS_HLBF_SHIFT; return (bool)u32TmpVal; } /** * @brief Get BTR error flag * @param [in] pEnet the base address of the ENET instance * @return true BTR error detected * @return false BTR error not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetBTRErrorFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_BTRE_MASK) >> ENET_MTL_EST_STATUS_BTRE_SHIFT; return (bool)u32TmpVal; } /** * @brief Clear BTR error flag * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearBTRErrorFlag(ENET_Type *const pEnet) { pEnet->MTL.EST_STATUS = pEnet->MTL.EST_STATUS | ENET_MTL_EST_STATUS_BTRE_MASK; } /** * @brief Get switch gate control list complete status * @param [in] pEnet the base address of the ENET instance * @return true Switching to S/W owned list completed * @return false Switching to S/W owned list not completed */ LOCAL_INLINE bool ENET_HWA_MTL_GetSwitchGateControlListCompleteFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_SWLC_MASK) >> ENET_MTL_EST_STATUS_SWLC_SHIFT; return (bool)u32TmpVal; } /** * @brief Clear switch gate control list complete status * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearSwitchGateControlListCompleteFlag(ENET_Type *const pEnet) { pEnet->MTL.EST_STATUS = pEnet->MTL.EST_STATUS | ENET_MTL_EST_STATUS_SWLC_MASK; } /** * @brief Get the One Hot encoded queue numbers that are having the scheduling related error * @param [in] pEnet the base address of the ENET instance * @return true queue 1 caused scheduling error * @return false queue 0 caused scheduling error */ LOCAL_INLINE bool ENET_HWA_MTL_GetScheduleErrorQueueNumber(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_SCH_ERROR & ENET_MTL_EST_SCH_ERROR_SEQN_MASK) >> ENET_MTL_EST_SCH_ERROR_SEQN_SHIFT; return (bool)u32TmpVal; } /** * @brief Clear the value of schedule error queue number register * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearScheduleErrorQueueNumber(ENET_Type *const pEnet) { pEnet->MTL.EST_SCH_ERROR = pEnet->MTL.EST_SCH_ERROR | ENET_MTL_EST_SCH_ERROR_SEQN_MASK; } /** * @brief Get the One Hot encoded queue numbers that are having the frame size error * @param [in] pEnet the base address of the ENET instance * @return true queue 1 caused frame size error * @return false queue 0 caused frame size error */ LOCAL_INLINE bool ENET_HWA_MTL_GetFrameSizeErrorQueueNumber(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_FRM_SIZE_ERROR & ENET_MTL_EST_FRM_SIZE_ERROR_FEQN_MASK) >> ENET_MTL_EST_FRM_SIZE_ERROR_FEQN_SHIFT; return (bool)u32TmpVal; } /** * @brief Clear the value of frame size error queue number register * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_MTL_ClearFrameSizeErrorQueueNumber(ENET_Type *const pEnet) { pEnet->MTL.EST_FRM_SIZE_ERROR = pEnet->MTL.EST_FRM_SIZE_ERROR | ENET_MTL_EST_FRM_SIZE_ERROR_FEQN_MASK; } /** * @brief Get the queue numbers that are having the first frame size error * @param [in] pEnet the base address of the ENET instance * @return true queue 1 caused the first frame size error * @return false queue 0 caused the first frame size error */ LOCAL_INLINE bool ENET_HWA_MTL_GetFrameSizeErrorFirstQueueNumber(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_FRM_SIZE_CAPTURE & ENET_MTL_EST_FRM_SIZE_CAPTURE_HBFQ_MASK) >> ENET_MTL_EST_FRM_SIZE_CAPTURE_HBFQ_SHIFT; return (bool)u32TmpVal; } /** * @brief Get the frame size of the first frame size error * @param [in] pEnet the base address of the ENET instance * @return uint16_t frame size of the first frame size error */ LOCAL_INLINE uint16_t ENET_HWA_MTL_GetFrameSizeErrorFirstFrameSize(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_FRM_SIZE_CAPTURE & ENET_MTL_EST_FRM_SIZE_CAPTURE_HBFS_MASK) >> ENET_MTL_EST_FRM_SIZE_CAPTURE_HBFS_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Get enable flag of constant gate control error interrupt * @param [in] pEnet the base address of the ENET instance * @return true CGCE interrupt is enabled * @return false CGCE interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetConstantGateControlErrorInterruptEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_INTR_ENABLE & ENET_MTL_EST_INTR_ENABLE_CGCE_MASK) >> ENET_MTL_EST_INTR_ENABLE_CGCE_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of constant gate control error interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetConstantGateControlErrorInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_INTR_ENABLE = (pEnet->MTL.EST_INTR_ENABLE & ~ENET_MTL_EST_INTR_ENABLE_CGCE_MASK) | ENET_MTL_EST_INTR_ENABLE_CGCE(bEnable ? 1u : 0u); } /** * @brief Get enable flag of head of line blocking due to scheduling interrupt * @param [in] pEnet the base address of the ENET instance * @return true HLBS interrupt is enabled * @return false HLBS interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetHeadofLineBlockingDueToSchedulingInterruptEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_INTR_ENABLE & ENET_MTL_EST_INTR_ENABLE_IEHS_MASK) >> ENET_MTL_EST_INTR_ENABLE_IEHS_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of head of line blocking due to scheduling interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetHeadofLineBlockingDueToSchedulingInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_INTR_ENABLE = (pEnet->MTL.EST_INTR_ENABLE & ~ENET_MTL_EST_INTR_ENABLE_IEHS_MASK) | ENET_MTL_EST_INTR_ENABLE_IEHS(bEnable ? 1u : 0u); } /** * @brief Get enable flag of head of line blocking due to frame size interrupt * @param [in] pEnet the base address of the ENET instance * @return true HLBF interrupt is enabled * @return false HLBF interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetHeadofLineBlockingDueToFrameSizeInterruptEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_INTR_ENABLE & ENET_MTL_EST_INTR_ENABLE_IEHF_MASK) >> ENET_MTL_EST_INTR_ENABLE_IEHF_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of head of line blocking due to frame size interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetHeadofLineBlockingDueToFrameSizeInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_INTR_ENABLE = (pEnet->MTL.EST_INTR_ENABLE & ~ENET_MTL_EST_INTR_ENABLE_IEHF_MASK) | ENET_MTL_EST_INTR_ENABLE_IEHF(bEnable ? 1u : 0u); } /** * @brief Get enable flag of base time register error interrupt * @param [in] pEnet the base address of the ENET instance * @return true BTR Error interrupt is enabled * @return false BTR Error interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetBaseTimeRegisterErrorInterruptEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_INTR_ENABLE & ENET_MTL_EST_INTR_ENABLE_IEBE_MASK) >> ENET_MTL_EST_INTR_ENABLE_IEBE_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of base time register error interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetBaseTimeRegisterErrorInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_INTR_ENABLE = (pEnet->MTL.EST_INTR_ENABLE & ~ENET_MTL_EST_INTR_ENABLE_IEBE_MASK) | ENET_MTL_EST_INTR_ENABLE_IEBE(bEnable ? 1u : 0u); } /** * @brief Get enable flag of switch GCL completion interrupt * @param [in] pEnet the base address of the ENET instance * @return true BTR Error interrupt is enabled * @return false BTR Error interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetSwitchListInterruptEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_INTR_ENABLE & ENET_MTL_EST_INTR_ENABLE_IECC_MASK) >> ENET_MTL_EST_INTR_ENABLE_IECC_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of base time switch GCL completion interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetSwitchListInterruptEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_INTR_ENABLE = (pEnet->MTL.EST_INTR_ENABLE & ~ENET_MTL_EST_INTR_ENABLE_IECC_MASK) | ENET_MTL_EST_INTR_ENABLE_IECC(bEnable ? 1u : 0u); } /** * @brief Get the mode of EST ECC inject error control for EST memory * @param [in] pEnet the base address of the ENET instance * @return true inject 2 bit errors * @return false inject 1 bit error */ LOCAL_INLINE bool ENET_HWA_MTL_GetEstEccInjectErrorControl(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_ESTEIEC_MASK) >> ENET_MTL_EST_GCL_CONTROL_ESTEIEC_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set the mode of EST ECC inject error control for EST memory * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable true inject 2 bit errors,false inject 1 bit error */ LOCAL_INLINE void ENET_HWA_MTL_SetEstEccInjectErrorControl(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_ESTEIEC_MASK) | ENET_MTL_EST_GCL_CONTROL_ESTEIEC(bEnable ? 1u : 0u); } /** * @brief Get enable flag of EST ECC address error injection * @param [in] pEnet the base address of the ENET instance * @return true inject 2 bit errors * @return false inject 1 bit error */ LOCAL_INLINE bool ENET_HWA_MTL_GetEstEccInjectAddressErrorEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_ESTEIAEE_MASK) >> ENET_MTL_EST_GCL_CONTROL_ESTEIAEE_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of EST ECC address error injection * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetEstEccInjectAddressErrorEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_ESTEIAEE_MASK) | ENET_MTL_EST_GCL_CONTROL_ESTEIAEE(bEnable ? 1u : 0u); } /** * @brief Get enable flag of EST ECC error injection * @param [in] pEnet the base address of the ENET instance * @return true EST ECC inject error is enabled * @return false EST ECC inject error is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetEstEccInjectErrorEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_ESTEIEE_MASK) >> ENET_MTL_EST_GCL_CONTROL_ESTEIEE_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set enable flag of EST ECC error injection * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetEstEccInjectErrorEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_ESTEIEE_MASK) | ENET_MTL_EST_GCL_CONTROL_ESTEIEE(bEnable ? 1u : 0u); } /** * @brief Get GCL address or GCL related registers address depend on GCRR bit * @param [in] pEnet the base address of the ENET instance * @return uint8_t GCL address or GCL related registers address */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetEstGateControlListAddress(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_ADDR_MASK) >> ENET_MTL_EST_GCL_CONTROL_ADDR_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set GCL address or GCL related registers address depend on GCRR bit * @param [in] pEnet the base address of the ENET instance * @param [in] eAddress GCL address or GCL related registers address */ LOCAL_INLINE void ENET_HWA_MTL_SetEstGateControlListAddress(ENET_Type *const pEnet, uint8_t eAddress) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_ADDR_MASK) | ENET_MTL_EST_GCL_CONTROL_ADDR(eAddress); } /** * @brief Get GCL debug mode bank selected * @param [in] pEnet the base address of the ENET instance * @return uint8_t debug mode bank */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetGclDebugModeBankSelect(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_DBGB_MASK) >> ENET_MTL_EST_GCL_CONTROL_DBGB_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set GCL debug mode bank * @param [in] pEnet the base address of the ENET instance * @param [in] eBank debug mode bank */ LOCAL_INLINE void ENET_HWA_MTL_SetGclDebugModeBankSelect(ENET_Type *const pEnet, uint8_t eBank) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_DBGB_MASK) | ENET_MTL_EST_GCL_CONTROL_DBGB(eBank); } /** * @brief Get GCL debug mode enable flag * @param [in] pEnet the base address of the ENET instance * @return true debug mode is enabled * @return false debug mode is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetGclDebugModeEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_DBGM_MASK) >> ENET_MTL_EST_GCL_CONTROL_DBGM_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set GCL debug mode enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetGclDebugModeEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_DBGM_MASK) | ENET_MTL_EST_GCL_CONTROL_DBGM(bEnable ? 1u : 0u); } /** * @brief Get gate control releated registers enable flag * @param [in] pEnet the base address of the ENET instance * @return true ADDR fields is used for gate control releated registers * @return false ADDR fields is used for gate control list address */ LOCAL_INLINE bool ENET_HWA_MTL_GetGateControlReleatedRegistersEnFlag(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_GCRR_MASK) >> ENET_MTL_EST_GCL_CONTROL_GCRR_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Set gate control releated registers enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetGateControlReleatedRegistersEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_GCRR_MASK) | ENET_MTL_EST_GCL_CONTROL_GCRR(bEnable ? 1u : 0u); } /** * @brief Get GCL operation mode (read or write) * @param [in] pEnet the base address of the ENET instance * @return ENET_MTL_GclOperationType (read or write) */ LOCAL_INLINE ENET_MTL_GclOperationType ENET_HWA_MTL_GetGclOperation(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_R1W0_MASK) >> ENET_MTL_EST_GCL_CONTROL_R1W0_SHIFT; return (ENET_MTL_GclOperationType)u32TmpVal; } /** * @brief Set GCL operation mode (read or write) * @param [in] pEnet the base address of the ENET instance * @param [in] eOperation (read or write) */ LOCAL_INLINE void ENET_HWA_MTL_SetGclOperation(ENET_Type *const pEnet, ENET_MTL_GclOperationType eOperation) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_R1W0_MASK) | ENET_MTL_EST_GCL_CONTROL_R1W0(eOperation); } /** * @brief Get GCL operation busy status * @param [in] pEnet the base address of the ENET instance * @return true Start Read/Write operation is enabled,status is busy * @return false Start Read/Write operation is disabled,status is idle */ LOCAL_INLINE bool ENET_HWA_MTL_GetGclOperationBusyState(ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.EST_GCL_CONTROL & ENET_MTL_EST_GCL_CONTROL_SRWO_MASK) >> ENET_MTL_EST_GCL_CONTROL_SRWO_SHIFT; return u32TmpVal != 0u ? true : false; } /** * @brief Start GCL Read/Write operation * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_MTL_SetGclOperationStartFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.EST_GCL_CONTROL = (pEnet->MTL.EST_GCL_CONTROL & ~ENET_MTL_EST_GCL_CONTROL_SRWO_MASK) | ENET_MTL_EST_GCL_CONTROL_SRWO(bEnable ? 1u : 0u); } /** * @brief Get GCL data * @param [in] pEnet the base address of the ENET instance * @return uint32_t GCL data value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetGclData(ENET_Type *const pEnet) { return pEnet->MTL.EST_GCL_DATA; } /** * @brief Set GCL data register value * @param [in] pEnet the base address of the ENET instance * @param [in] eData data to set */ LOCAL_INLINE void ENET_HWA_MTL_SetGclData(ENET_Type *const pEnet, uint32_t eData) { pEnet->MTL.EST_GCL_DATA = eData; } /** * @brief Set the corresponding Queue classified as express or preemptable. * @details Set the Classification of Queues.A bit indicates a queue, when '1' indicates the * corresponding Queue must be classified as preemptable, when '0' Queue is classified * as express. * * @param [in] pEnet the base address of the ENET instance * @param [in] u8value Preemption classification value */ LOCAL_INLINE void ENET_HWA_MTL_SetPreemptionClassification(ENET_Type *const pEnet, uint8_t u8value) { pEnet->MTL.FPE_CTRL_STS = (pEnet->MTL.FPE_CTRL_STS & ~ENET_MTL_FPE_CTRL_STS_PEC_MASK) | ENET_MTL_FPE_CTRL_STS_PEC(u8value); } /** * @brief Set the maximum time in nanoseconds that can elapse between issuing a RELEASE to the MAC * and the MAC being ready to resume transmission of preemptable frames. * * @param [in] pEnet the base address of the ENET instance * @param [in] u16value Release Advance time value */ LOCAL_INLINE void ENET_HWA_MTL_SetPreemptionReleaseAdvance(ENET_Type *const pEnet, uint16_t u16value) { pEnet->MTL.FPE_ADVANCE = (pEnet->MTL.FPE_ADVANCE & ~ENET_MTL_FPE_ADVANCE_RADV_MASK) | ENET_MTL_FPE_ADVANCE_RADV(u16value); } /** * @brief Set the maximum time in nanoseconds that can elapse between issuing a HOLD to the MAC * and the MAC ceasing to transmit any preemptable frame. * * @param [in] pEnet the base address of the ENET instance * @param [in] u16value Hold Advance time value */ LOCAL_INLINE void ENET_HWA_MTL_SetPreemptionHoldAdvance(ENET_Type *const pEnet, uint16_t u16value) { pEnet->MTL.FPE_ADVANCE = (pEnet->MTL.FPE_ADVANCE & ~ENET_MTL_FPE_ADVANCE_HADV_MASK) | ENET_MTL_FPE_ADVANCE_HADV(u16value); } #endif /* ENET_SUPPORT_TIME_SENSITIVE_NETWORK */ /** * @brief Get MTL queue Tx operation mode register value * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t MTL queue Tx operation mode */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetTxOperationMode(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE; } /** * @brief Set MTL queue Tx operation mode register value * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32OpMode MTL queue Tx operation mode */ LOCAL_INLINE void ENET_HWA_MTL_SetTxOperationMode(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32OpMode) { pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE = u32OpMode; } /** * @brief Get MTL transmit queue size * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint8_t queue size in blocks of 256 bytes */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetTxQueueSize(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & ENET_MTL_TXQn_OPERATION_MODE_TQS_MASK) >> ENET_MTL_TXQn_OPERATION_MODE_TQS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set MTL transmit queue size * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u8QueueSize queue size in blocks of 256 bytes,range(0~15) */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueSize(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint8_t u8QueueSize) { pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & (~ENET_MTL_TXQn_OPERATION_MODE_TQS_MASK)) | ENET_MTL_TXQn_OPERATION_MODE_TQS(u8QueueSize); } /** * @brief Get the threshold level of the MTL Tx Queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_TxThresholdType_t threshold level */ LOCAL_INLINE ENET_MTL_TxThresholdType ENET_HWA_MTL_GetTxThreshold(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE; uint32_t u32Threshold = (u32TmpVal & ENET_MTL_TXQn_OPERATION_MODE_TTC_MASK) >> ENET_MTL_TXQn_OPERATION_MODE_TTC_SHIFT; return ((u32TmpVal & ENET_MTL_TXQn_OPERATION_MODE_TSF_MASK) == ENET_MTL_TXQn_OPERATION_MODE_TSF_MASK) ? ENET_MTL_TX_STORE_FORWARD : (ENET_MTL_TxThresholdType)u32Threshold; } /** * @brief Set the threshold level of the MTL Tx Queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] eThreshold threshold level */ LOCAL_INLINE void ENET_HWA_MTL_SetTxThreshold(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MTL_TxThresholdType eThreshold) { pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & (~(ENET_MTL_TXQn_OPERATION_MODE_TTC_MASK | ENET_MTL_TXQn_OPERATION_MODE_TSF_MASK))) | (ENET_MTL_TXQn_OPERATION_MODE_TTC(eThreshold) | ENET_MTL_TXQn_OPERATION_MODE_TSF((uint32_t)eThreshold >> ENET_MTL_TXQn_OPERATION_MODE_TTC_WIDTH)); } /** * @brief Get the transmit queue enable mode * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_QueueEnableType queue enable mode */ LOCAL_INLINE ENET_MTL_QueueEnableType ENET_HWA_MTL_GetTxQueueEnStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & ENET_MTL_TXQn_OPERATION_MODE_TXQEN_MASK) >> ENET_MTL_TXQn_OPERATION_MODE_TXQEN_SHIFT; return (ENET_MTL_QueueEnableType)u32TmpVal; } /** * @brief Set the transmit queue enable mode * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] eEnable queue enable mode */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueEnStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MTL_QueueEnableType eEnable) { pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & (~ENET_MTL_TXQn_OPERATION_MODE_TXQEN_MASK)) | ENET_MTL_TXQn_OPERATION_MODE_TXQEN(eEnable); } /** * @brief Get transmit queue store and forward enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true store and forward is enabled * @return false store and forward is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxStoreForwardModeEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & ENET_MTL_TXQn_OPERATION_MODE_TSF_MASK) >> ENET_MTL_TXQn_OPERATION_MODE_TSF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmit queue store and forward enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_MTL_SetTxStoreForwardModeEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & (~ENET_MTL_TXQn_OPERATION_MODE_TSF_MASK)) | ENET_MTL_TXQn_OPERATION_MODE_TSF(bEnable ? 1u : 0u); } /** * @brief Get transmit queue flush state * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true flush transmit queue is enabled * @return false flush transmit queue is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxFlushState(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE & ENET_MTL_TXQn_OPERATION_MODE_FTQ_MASK) >> ENET_MTL_TXQn_OPERATION_MODE_FTQ_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Flush transmit queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id */ LOCAL_INLINE void ENET_HWA_MTL_FlushTxQueue(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MTL.QUEUE[eQueue].TX_OPERATION_MODE |= ENET_MTL_TXQn_OPERATION_MODE_FTQ_MASK; } /** * @brief Get the underflow counter register of transmit queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [out] pPacketCnt packet counter value * @retval true Underflow packet counter overflow and rollover happened * @retval false Underflow packet counter is not overflowed */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxUnderflowPacketCount(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint16_t *pPacketCnt) { bool bRet; uint32_t u32TmpVal = pEnet->MTL.QUEUE[eQueue].TX_UNDERFLOW; *pPacketCnt = (uint16_t)(u32TmpVal & ENET_MTL_TXQn_UNDERFLOW_UFFRMCNT_MASK) >> ENET_MTL_TXQn_UNDERFLOW_UFFRMCNT_SHIFT; bRet = (((u32TmpVal & ENET_MTL_TXQn_UNDERFLOW_UFCNTOVF_MASK) >> ENET_MTL_TXQn_UNDERFLOW_UFCNTOVF_SHIFT) != 0u) ? true : false; return bRet; } /** * @brief Get transmit queue debug status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t transmit queue debug status register value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetTxDebugStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MTL.QUEUE[eQueue].TX_DEBUG; } /** * @brief Get the current number of status in the transmit Status FIFO of this queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint8_t number of status */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetTxStatusWordCount(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_STXSTSF_MASK) >> ENET_MTL_TXQn_DEBUG_STXSTSF_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get the current number of packets in the transmit queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint8_t number of packets */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetTxPacketCount(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_PTXQ_MASK) >> ENET_MTL_TXQn_DEBUG_PTXQ_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get the full flag of transmit Status FIFO * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true transmit Status FIFO is full * @return false transmit Status FIFO is not full */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxStatusFIFOFullStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_TXSTSFSTS_MASK) >> ENET_MTL_TXQn_DEBUG_TXSTSFSTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the not empty flag of transmit queue data * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true transmit queue data is empty * @return false transmit queue data is not empty */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxQueueNotEmptyStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_TXQSTS_MASK) >> ENET_MTL_TXQn_DEBUG_TXQSTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get the transmit queue write controller status,indicates that the MTL Tx Queue Write controller is active, and it is transferring the data to the transmit queue. * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_WriteControllerStatusType */ LOCAL_INLINE ENET_MTL_WriteControllerStatusType ENET_HWA_MTL_GetTxQueueWriteControllerStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_TWCSTS_MASK) >> ENET_MTL_TXQn_DEBUG_TWCSTS_SHIFT; return (ENET_MTL_WriteControllerStatusType)u32TmpVal; } /** * @brief Get the transmit queue read controller status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_ReadControllerStatusType */ LOCAL_INLINE ENET_MTL_ReadControllerStatusType ENET_HWA_MTL_GetTxQueueReadControllerStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_TRCSTS_MASK) >> ENET_MTL_TXQn_DEBUG_TRCSTS_SHIFT; return (ENET_MTL_ReadControllerStatusType)u32TmpVal; } /** * @brief Get the transmit queue paused status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true transmit queue is paused * @return false transmit queue is not paused */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxQueuePausedStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_DEBUG & ENET_MTL_TXQn_DEBUG_TXQPAUSED_MASK) >> ENET_MTL_TXQn_DEBUG_TXQPAUSED_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Enable or disable credit control. * If credit control is enabled, the credit accumulates even when there is * no packet waiting in Tx Queue and another Tx Queue is transmitting. * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable 1U enable credit control, 0U disable credit control. */ LOCAL_INLINE void ENET_HWA_MTL_SetCreditControlEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint8_t bEnable) { pEnet->MTL.QUEUE[eQueue].TX_ETS_CONTROL = (pEnet->MTL.QUEUE[eQueue].TX_ETS_CONTROL & (~ENET_MTL_TXQn_ETS_CONTROL_CC_MASK)) | ENET_MTL_TXQn_ETS_CONTROL_CC(bEnable); } /** * @brief Set AV algorithm for strict priority or credit based shaper. * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable 1U use credit based shaper or 0U use strict priority. */ LOCAL_INLINE void ENET_HWA_MTL_SetAVAlgorithmCBSEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint8_t bEnable) { pEnet->MTL.QUEUE[eQueue].TX_ETS_CONTROL = (pEnet->MTL.QUEUE[eQueue].TX_ETS_CONTROL & (~ENET_MTL_TXQn_ETS_CONTROL_AVALG_MASK)) | ENET_MTL_TXQn_ETS_CONTROL_AVALG(bEnable); } /** * @brief Get the average bits per slot,when the DCB operation is enabled for the queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t average bits per slot */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetSlotAverageBits(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_ETS_STATUS & ENET_MTL_TXQn_ETS_STATUS_ABS_MASK) >> ENET_MTL_TXQn_ETS_STATUS_ABS_SHIFT; return u32TmpVal; } /** * @brief Get the quantum or weights for transmit algorithm (DWRR WRR WFQ) * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t quantum or weights */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetTxQueueQuantumOrWeight(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].TX_QUANTUM_WEIGHT & ENET_MTL_TXQn_QUANTUM_WEIGHT_ISCQW_MASK) >> ENET_MTL_TXQn_QUANTUM_WEIGHT_ISCQW_SHIFT; return u32TmpVal; } /** * @brief Set the quantum or weights for transmit algorithm (DWRR WRR WFQ) * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32QuantumWeight quantum or weights */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueQuantumOrWeight(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32QuantumWeight) { pEnet->MTL.QUEUE[eQueue].TX_QUANTUM_WEIGHT = ENET_MTL_TXQn_QUANTUM_WEIGHT_ISCQW(u32QuantumWeight); } /** * @brief Set the sendSlope credit value required for the credit-based shaper algorithm for the * Queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32SendSlopeCredit sendSlope credit credit based shaper. */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueSendSlopeCredit(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32SendSlopeCredit) { pEnet->MTL.QUEUE[eQueue].TX_SENDSLOPECREDIT = ENET_MTL_TXQn_SENDSLOPECREDIT_SSC(u32SendSlopeCredit); } /** * @brief Set hiCredit value required for the credit-based shaper algorithm for the Queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32hiCredit hiCredit credit based shaper. */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueHiCredit(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32hiCredit) { pEnet->MTL.QUEUE[eQueue].TX_HICREDIT = ENET_MTL_TXQn_HICREDIT_HC(u32hiCredit); } /** * @brief Set the loCredit value required for the credit-based shaper algorithm for the Queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32LoCredit loCredit credit based shaper. */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueLoCredit(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32LoCredit) { pEnet->MTL.QUEUE[eQueue].TX_LOCREDIT = ENET_MTL_TXQn_LOCREDIT_LC(u32LoCredit); } /** * @brief Get the interrupt enable and status for the queue interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t interrupt enable and status */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetInterruptCtrlStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS; } /** * @brief Set the interrupt enable and status for the queue interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32CtrlStatus interrupt enable and status */ LOCAL_INLINE void ENET_HWA_MTL_SetInterruptCtrlStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32CtrlStatus) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = u32CtrlStatus; } /** * @brief Clear all the interrupts of the MTL queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id */ LOCAL_INLINE void ENET_HWA_MTL_ClearAllIntStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS; } /** * @brief Get receive queue overflow interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true receive queue overflow interrupt is enabled * @return false receive queue overflow interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxQueueOverflowIntEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOIE_MASK) >> ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive queue overflow interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable enable receive queue overflow interrupt */ LOCAL_INLINE void ENET_HWA_MTL_SetRxQueueOverflowIntEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ~(ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOIE_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK)) | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOIE(bEnable ? 1u : 0u); } /** * @brief Get receive queue overflow interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true receive queue overflow interrupt detected * @return false receive queue overflow interrupt not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxQueueOverflowIntStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK) >> ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear receive queue overflow interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id */ LOCAL_INLINE void ENET_HWA_MTL_ClearRxQueueOverflowIntStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ~(ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK)) | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK; } /** * @brief Get average bits per slot interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true average bits per slot interrupt is enabled * @return false average bits per slot interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetSlotAverageBitsIntEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIE_MASK) >> ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set average bits per slot interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable enable average bits per slot interrupt */ LOCAL_INLINE void ENET_HWA_MTL_SetSlotAverageBitsIntEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ~(ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIE_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK)) | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIE(bEnable ? 1u : 0u); } /** * @brief Get transmit queue underflow interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @retval true transmit queue underflow interrupt is enabled * @retval false transmit queue underflow interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxQueueUnderflowIntEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUIE_MASK) >> ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUIE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set transmit queue underflow interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable enable transmit queue underflow interrupt */ LOCAL_INLINE void ENET_HWA_MTL_SetTxQueueUnderflowIntEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ~(ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUIE_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK)) | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUIE(bEnable ? 1u : 0u); } /** * @brief Get average bits per slot interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true average bits per slot interrupt detected * @return false average bits per slot interrupt not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetSlotAverageBitsIntStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK) >> ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear average bits per slot interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id */ LOCAL_INLINE void ENET_HWA_MTL_ClearSlotAverageBitsIntStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ~(ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK)) | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK; } /** * @brief Get transmit queue underflow interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true transmit queue underflow interrupt detected * @return false transmit queue underflow interrupt not detected */ LOCAL_INLINE bool ENET_HWA_MTL_GetTxQueueUnderflowIntStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK) >> ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear transmit queue underflow interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id */ LOCAL_INLINE void ENET_HWA_MTL_ClearTxQueueUnderflowIntStatus(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS = (pEnet->MTL.QUEUE[eQueue].INTERRUPT_CONTROL_STATUS & ~(ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_RXOVFIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_ABPSIS_MASK | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK)) | ENET_MTL_Qn_INTERRUPT_CONTROL_STATUS_TXUNFIS_MASK; } /** * @brief Get receive operation mode of the queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t receive operation mode */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetRxOperationMode(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE; } /** * @brief Set receive operation mode of the queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32OpMode receive operation mode */ LOCAL_INLINE void ENET_HWA_MTL_SetRxOperationMode(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32OpMode) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = u32OpMode; } /** * @brief Get receive queue size * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint8_t receive queues size in blocks of 256 bytes */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetRxQueueSize(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_RQS_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_RQS_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set receive queue size * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u8QueueSize receive queues size in blocks of 256 bytes, range(0~15) */ LOCAL_INLINE void ENET_HWA_MTL_SetRxQueueSize(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint8_t u8QueueSize) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_RQS_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_RQS(u8QueueSize); } /** * @brief Get the threshold of receive queue at which the flow control is deactivated * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_RxFlowCtrlThresholdType flow control deactivating threshold */ LOCAL_INLINE ENET_MTL_RxFlowCtrlThresholdType ENET_HWA_MTL_GetRxDeactivateFlowCtrlThres(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_RFD_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_RFD_SHIFT; return (ENET_MTL_RxFlowCtrlThresholdType)u32TmpVal; } /** * @brief Set the threshold of receive queue at which the flow control is deactivated * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] eThreshold flow control deactivating threshold */ LOCAL_INLINE void ENET_HWA_MTL_SetRxDeactivateFlowCtrlThres(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MTL_RxFlowCtrlThresholdType eThreshold) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_RFD_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_RFD(eThreshold); } /** * @brief Get the threshold of receive queue at which the flow control is activated * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_RxFlowCtrlThresholdType flow control activating threshold */ LOCAL_INLINE ENET_MTL_RxFlowCtrlThresholdType ENET_HWA_MTL_GetRxActivateFlowCtrlThres(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_RFA_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_RFA_SHIFT; return (ENET_MTL_RxFlowCtrlThresholdType)u32TmpVal; } /** * @brief Set the threshold of receive queue at which the flow control is activated * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] eThreshold flow control activating threshold */ LOCAL_INLINE void ENET_HWA_MTL_SetRxActivateFlowCtrlThres(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MTL_RxFlowCtrlThresholdType eThreshold) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_RFA_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_RFA(eThreshold); } /** * @brief Get receive queue hardware flow control enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true receive queue hardware flow control is enabled * @return false receive queue hardware flow control is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxHwFlowCtrlEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_EHFC_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_EHFC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive queue hardware flow control enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable enable hardware flow control */ LOCAL_INLINE void ENET_HWA_MTL_SetRxHwFlowCtrlEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_EHFC_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_EHFC(bEnable ? 1u : 0u); } /** * @brief Get forwarding of TCP/IP checksum error packets enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true forward TCP/IP checksum error packets to application * @return false drop TCP/IP checksum error packets */ LOCAL_INLINE bool ENET_HWA_MTL_GetForwardTCPChecksumErrorPacketEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_DIS_TCP_EF_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_DIS_TCP_EF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set forwarding of TCP/IP checksum error packets enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable forward TCP/IP checksum error packets */ LOCAL_INLINE void ENET_HWA_MTL_SetForwardTCPChecksumErrorPacketEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (uint32_t)(pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_DIS_TCP_EF_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_DIS_TCP_EF(bEnable ? 1u : 0u); } /** * @brief Get receive queue store and forward enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true store and forward is enabled * @return false store and forward is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxStoreForwardModeEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_RSF_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_RSF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive queue store and forward enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_MTL_SetRxStoreForwardModeEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_RSF_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_RSF(bEnable ? 1u : 0u); } /** * @brief Get forward error packets enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true forward error packets to application * @return false drop error packets */ LOCAL_INLINE bool ENET_HWA_MTL_GetForwardErrorPacketEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_FEP_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_FEP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set forward error packets enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_MTL_SetForwardErrorPacketEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_FEP_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_FEP(bEnable ? 1u : 0u); } /** * @brief Get forward undersized good packets enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true forward undersized good packets to application * @return false drop undersized good packets */ LOCAL_INLINE bool ENET_HWA_MTL_GetForwardUndersizedPacketEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ENET_MTL_RXQn_OPERATION_MODE_FUP_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_FUP_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set forward undersized good packets enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_MTL_SetForwardUndersizedPacketEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & (~ENET_MTL_RXQn_OPERATION_MODE_FUP_MASK)) | ENET_MTL_RXQn_OPERATION_MODE_FUP(bEnable ? 1u : 0u); } /** * @brief Get the receive queue threshold control * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_RxThresholdType */ LOCAL_INLINE ENET_MTL_RxThresholdType ENET_HWA_MTL_GetRxThreshold(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE; uint32_t u32Thrshold = (u32TmpVal & ENET_MTL_RXQn_OPERATION_MODE_RTC_MASK) >> ENET_MTL_RXQn_OPERATION_MODE_RTC_SHIFT; return ((u32TmpVal & ENET_MTL_RXQn_OPERATION_MODE_RSF_MASK) == ENET_MTL_RXQn_OPERATION_MODE_RSF_MASK) ? ENET_MTL_RX_STORE_FORWARD : (ENET_MTL_RxThresholdType)u32Thrshold; } /** * @brief Set the receive queue threshold * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] eThreshold receive queue threshold */ LOCAL_INLINE void ENET_HWA_MTL_SetRxThreshold(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, ENET_MTL_RxThresholdType eThreshold) { pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE = (pEnet->MTL.QUEUE[eQueue].RX_OPERATION_MODE & ~(ENET_MTL_RXQn_OPERATION_MODE_RTC_MASK | ENET_MTL_RXQn_OPERATION_MODE_RSF_MASK)) | (ENET_MTL_RXQn_OPERATION_MODE_RTC(eThreshold) | ENET_MTL_RXQn_OPERATION_MODE_RSF((uint32_t)eThreshold >> ENET_MTL_RXQn_OPERATION_MODE_RTC_WIDTH)); } /** * @brief Get the missed packet and overflow counters of the queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [out] pMissedPacketCntOverflowFlag missed packet counter overflow detected * @param [out] pMissedPacketCnt missed pPacket counter * @param [out] pOverflowPacketCntOverflowFlag overflow packet counter overflow detected * @param [out] pOverflowPacketCnt overflow packet counter */ LOCAL_INLINE void ENET_HWA_MTL_GetRxMissedPacketOverflowCount(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool *pMissedPacketCntOverflowFlag, uint16_t *pMissedPacketCnt, bool *pOverflowPacketCntOverflowFlag, uint16_t *pOverflowPacketCnt) { uint32_t u32TmpVal = pEnet->MTL.QUEUE[eQueue].RX_MISSED_PACKET_OVERFLOW_CNT; *pMissedPacketCntOverflowFlag = ((u32TmpVal & ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_MISCNTOVF_MASK) == ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_MISCNTOVF_MASK) ? true : false; *pMissedPacketCnt = (uint16_t)((u32TmpVal & ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_MISPKTCNT_MASK) >> ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_MISPKTCNT_SHIFT); *pOverflowPacketCntOverflowFlag = ((u32TmpVal & ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_OVFCNTOVF_MASK) == ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_OVFCNTOVF_MASK) ? true : false; *pOverflowPacketCnt = (uint16_t)((u32TmpVal & ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_OVFPKTCNT_MASK) >> ENET_MTL_RXQn_MISSED_PACKET_OVERFLOW_CNT_OVFPKTCNT_SHIFT); } /** * @brief Get the receive queue debug status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t receive queue debug status */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetRxDebugStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MTL.QUEUE[eQueue].RX_DEBUG; } /** * @brief Get the number of packets in receive queue * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint8_t packets number */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetRxPacketCount(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_DEBUG & ENET_MTL_RXQn_DEBUG_PRXQ_MASK) >> ENET_MTL_RXQn_DEBUG_PRXQ_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Get receive queue Fill-Level status * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_RxQueueStatusType (empty,below flow-control deactivate threshold,above flow-control activate threshold,full) */ LOCAL_INLINE ENET_MTL_RxQueueStatusType ENET_HWA_MTL_GetRxFillLevelStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_DEBUG & ENET_MTL_RXQn_DEBUG_RXQSTS_MASK) >> ENET_MTL_RXQn_DEBUG_RXQSTS_SHIFT; return (ENET_MTL_RxQueueStatusType)u32TmpVal; } /** * @brief Get receive queue read controller state * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_ReadControllerStatusType */ LOCAL_INLINE ENET_MTL_ReadControllerStatusType ENET_HWA_MTL_GetRxQueueReadControllerStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_DEBUG & ENET_MTL_RXQn_DEBUG_RRCSTS_MASK) >> ENET_MTL_RXQn_DEBUG_RRCSTS_SHIFT; return (ENET_MTL_ReadControllerStatusType)u32TmpVal; } /** * @brief Get receive queue write controller state * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return ENET_MTL_WriteControllerStatusType */ LOCAL_INLINE ENET_MTL_WriteControllerStatusType ENET_HWA_MTL_GetRxQueueWriteControllerStatus(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_DEBUG & ENET_MTL_RXQn_DEBUG_RWCSTS_MASK) >> ENET_MTL_RXQn_DEBUG_RWCSTS_SHIFT; return (ENET_MTL_WriteControllerStatusType)u32TmpVal; } /** * @brief Get MTL queue receive control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint32_t receive control value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetRxControl(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { return pEnet->MTL.QUEUE[eQueue].RX_CONTROL; } /** * @brief Set MTL queue receive control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u32Ctrl receive control value */ LOCAL_INLINE void ENET_HWA_MTL_SetRxControl(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint32_t u32Ctrl) { pEnet->MTL.QUEUE[eQueue].RX_CONTROL = u32Ctrl; } /** * @brief Get receive queue packet arbitration enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return true receive queue packet arbitration is enabled * @return false receive queue packet arbitration is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetRxQueuePacketArbitrationEnFlag(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_CONTROL & ENET_MTL_RXQn_CONTROL_RXQ_FRM_ARBIT_MASK) >> ENET_MTL_RXQn_CONTROL_RXQ_FRM_ARBIT_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set receive queue packet arbitration enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] bEnable enable or disable */ LOCAL_INLINE void ENET_HWA_MTL_SetRxQueuePacketArbitrationEnFlag(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, bool bEnable) { pEnet->MTL.QUEUE[eQueue].RX_CONTROL = (pEnet->MTL.QUEUE[eQueue].RX_CONTROL & ~ENET_MTL_RXQn_CONTROL_RXQ_FRM_ARBIT_MASK) | ENET_MTL_RXQn_CONTROL_RXQ_FRM_ARBIT(bEnable ? 1u : 0u); } /** * @brief Get receive queue weight * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @return uint8_t receive queue weight */ LOCAL_INLINE uint8_t ENET_HWA_MTL_GetRxQueueWeight(const ENET_Type *const pEnet, ENET_MTL_QueueType eQueue) { uint32_t u32TmpVal = (pEnet->MTL.QUEUE[eQueue].RX_CONTROL & ENET_MTL_RXQn_CONTROL_RXQ_WEGT_MASK) >> ENET_MTL_RXQn_CONTROL_RXQ_WEGT_SHIFT; return (uint8_t)(u32TmpVal + 1u); } /** * @brief Set receive queue weight * @param [in] pEnet the base address of the ENET instance * @param [in] eQueue MTL queue id * @param [in] u8Weight receive queue weight */ LOCAL_INLINE void ENET_HWA_MTL_SetRxQueueWeight(ENET_Type *const pEnet, ENET_MTL_QueueType eQueue, uint8_t u8Weight) { pEnet->MTL.QUEUE[eQueue].RX_CONTROL = (pEnet->MTL.QUEUE[eQueue].RX_CONTROL & ~ENET_MTL_RXQn_CONTROL_RXQ_WEGT_MASK) | ENET_MTL_RXQn_CONTROL_RXQ_WEGT((uint32_t)u8Weight - 1u); } /* ================================================================ * * ENET DMA Configuration and Status * * ================================================================ */ /** * @brief Get DMA bus mode register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t DMA bus mode register value */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetMode(const ENET_Type *const pEnet) { return pEnet->ENET_DMA.MODE; } /** * @brief Set DMA bus mode register value * @param [in] pEnet the base address of the ENET instance * @param [in] u32Mode DMA bus mode value */ LOCAL_INLINE void ENET_HWA_DMA_SetMode(ENET_Type *const pEnet, uint32_t u32Mode) { pEnet->ENET_DMA.MODE = u32Mode; } /** * @brief Get DMA software reset status * @param [in] pEnet the base address of the ENET instance * @return ENET_DMA_StatusType */ LOCAL_INLINE ENET_DMA_StatusType ENET_HWA_DMA_GetSwResetStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.MODE & ENET_DMA_MODE_SWR_MASK) >> ENET_DMA_MODE_SWR_SHIFT; return (ENET_DMA_StatusType)u32TmpVal; } /** * @brief Initiate DMA software reset * @param [in] pEnet the base address of the ENET instance */ LOCAL_INLINE void ENET_HWA_DMA_SwReset(ENET_Type *const pEnet) { pEnet->ENET_DMA.MODE |= ENET_DMA_MODE_SWR_MASK; } /** * @brief Get DMA interrupt mode * @param [in] pEnet the base address of the ENET instance * @return ENET_DMA_IntModeType */ LOCAL_INLINE ENET_DMA_IntModeType ENET_HWA_DMA_GetInterruptMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.MODE & ENET_DMA_MODE_INTM_MASK) >> ENET_DMA_MODE_INTM_SHIFT; return (ENET_DMA_IntModeType)u32TmpVal; } /** * @brief Set DMA interrupt mode * @param [in] pEnet the base address of the ENET instance * @param [in] eIntMode DMA interrupt mode */ LOCAL_INLINE void ENET_HWA_DMA_SetInterruptMode(ENET_Type *const pEnet, ENET_DMA_IntModeType eIntMode) { pEnet->ENET_DMA.MODE = (pEnet->ENET_DMA.MODE & ~ENET_DMA_MODE_INTM_MASK) | ENET_DMA_MODE_INTM(eIntMode); } /** * @brief Get DMA Rx:Tx or Tx:Rx priority ratio * @param [in] pEnet the base address of the ENET instance * @return ENET_DMA_PriorityRatioType */ LOCAL_INLINE ENET_DMA_PriorityRatioType ENET_HWA_DMA_GetPriorityRatio(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.MODE & ENET_DMA_MODE_PR_MASK) >> ENET_DMA_MODE_PR_SHIFT; return (ENET_DMA_PriorityRatioType)u32TmpVal; } /** * @brief Set DMA Rx:Tx or Tx:Rx priority ratio * @param [in] pEnet the base address of the ENET instance * @param [in] ePriorityRatio priority ratio */ LOCAL_INLINE void ENET_HWA_DMA_SetPriorityRatio(ENET_Type *const pEnet, ENET_DMA_PriorityRatioType ePriorityRatio) { pEnet->ENET_DMA.MODE = (pEnet->ENET_DMA.MODE & ~ENET_DMA_MODE_PR_MASK) | ENET_DMA_MODE_PR(ePriorityRatio); } /** * @brief Get DMA priority mode * @param [in] pEnet the base address of the ENET instance * @return ENET_DMA_PRIORITY_MODE_RX_TX the priority ratio is RX:TX * @return ENET_DMA_PRIORITY_MODE_TX_RX the priority ratio is TX:RX */ LOCAL_INLINE ENET_DMA_PriorityModeType ENET_HWA_DMA_GetPriorityMode(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.MODE & ENET_DMA_MODE_TXPR_MASK) >> ENET_DMA_MODE_TXPR_SHIFT; return (ENET_DMA_PriorityModeType)u32TmpVal; } /** * @brief Set DMA priority mode,Rx:Tx or Tx:Rx * @param [in] pEnet the base address of the ENET instance * @param [in] ePriorityMode priority mode */ LOCAL_INLINE void ENET_HWA_DMA_SetPriorityMode(ENET_Type *const pEnet, ENET_DMA_PriorityModeType ePriorityMode) { pEnet->ENET_DMA.MODE = (pEnet->ENET_DMA.MODE & ~ENET_DMA_MODE_TXPR_MASK) | ENET_DMA_MODE_TXPR(ePriorityMode); } /** * @brief Get DMA arbitration algorithm between transmit channels * @param [in] pEnet the base address of the ENET instance * @return ENET_DMA_TxArbitrationAlgorithmType */ LOCAL_INLINE ENET_DMA_TxArbitrationAlgorithmType ENET_HWA_DMA_GetTxArbitrationAlgorithm(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.MODE & ENET_DMA_MODE_TAA_MASK) >> ENET_DMA_MODE_TAA_SHIFT; return (ENET_DMA_TxArbitrationAlgorithmType)u32TmpVal; } /** * @brief Set DMA arbitration algorithm between transmit channels * @param [in] pEnet the base address of the ENET instance * @param [in] eArbitrationAlgorithm DMA arbitration algorithm */ LOCAL_INLINE void ENET_HWA_DMA_SetTxArbitrationAlgorithm(ENET_Type *const pEnet, ENET_DMA_TxArbitrationAlgorithmType eArbitrationAlgorithm) { pEnet->ENET_DMA.MODE = (pEnet->ENET_DMA.MODE & ~ENET_DMA_MODE_TAA_MASK) | ENET_DMA_MODE_TAA(eArbitrationAlgorithm); } /** * @brief Get DMA arbitration scheme between the transmit and receive paths * @param [in] pEnet the base address of the ENET instance * @return ENET_DMA_ArbitrationSchemeType */ LOCAL_INLINE ENET_DMA_ArbitrationSchemeType ENET_HWA_DMA_GetTxRxArbitrationScheme(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.MODE & ENET_DMA_MODE_DA_MASK) >> ENET_DMA_MODE_DA_SHIFT; return (ENET_DMA_ArbitrationSchemeType)u32TmpVal; } /** * @brief Set DMA arbitration scheme between the transmit and receive paths * @param [in] pEnet the base address of the ENET instance * @param [in] eArbitrationScheme DMA arbitration algorithm */ LOCAL_INLINE void ENET_HWA_DMA_SetTxRxArbitrationScheme(ENET_Type *const pEnet, ENET_DMA_ArbitrationSchemeType eArbitrationScheme) { pEnet->ENET_DMA.MODE = (pEnet->ENET_DMA.MODE & ~ENET_DMA_MODE_DA_MASK) | ENET_DMA_MODE_DA(eArbitrationScheme); } /** * @brief Get DMA rebuild INCRx burst enable flag * @param [in] pEnet the base address of the ENET instance * @return true rebuild INCRx burst is enabled * @return false rebuild INCRx burst is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetRebuildINCRxBurstEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.SYSBUS_MODE & ENET_DMA_SYSBUS_MODE_RB_MASK) >> ENET_DMA_SYSBUS_MODE_RB_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA rebuild INCRx burst enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetRebuildINCRxBurstEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->ENET_DMA.SYSBUS_MODE = (pEnet->ENET_DMA.SYSBUS_MODE & ~ENET_DMA_SYSBUS_MODE_RB_MASK) | ENET_DMA_SYSBUS_MODE_RB(bEnable ? 1u : 0u); } /** * @brief Get DMA mixed burst length enable flag * @param [in] pEnet the base address of the ENET instance * @return true mixed burst is enabled * @return false mixed burst is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetMixedBurstEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.SYSBUS_MODE & ENET_DMA_SYSBUS_MODE_MB_MASK) >> ENET_DMA_SYSBUS_MODE_MB_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA mixed burst length enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetMixedBurstEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->ENET_DMA.SYSBUS_MODE = (pEnet->ENET_DMA.SYSBUS_MODE & ~ENET_DMA_SYSBUS_MODE_MB_MASK) | ENET_DMA_SYSBUS_MODE_MB(bEnable ? 1u : 0u); } /** * @brief Get DMA Address-Aligned Beats enable flag * @param [in] pEnet the base address of the ENET instance * @return true Address-Aligned Beats is enabled * @return false Address-Aligned Beats is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetAddressAlignedBeatsEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.SYSBUS_MODE & ENET_DMA_SYSBUS_MODE_AAL_MASK) >> ENET_DMA_SYSBUS_MODE_AAL_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA Address-Aligned Beats enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetAddressAlignedBeatsEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->ENET_DMA.SYSBUS_MODE = (pEnet->ENET_DMA.SYSBUS_MODE & ~ENET_DMA_SYSBUS_MODE_AAL_MASK) | ENET_DMA_SYSBUS_MODE_AAL(bEnable ? 1u : 0u); } /** * @brief Get DMA fixed burst length enable flag * @param [in] pEnet the base address of the ENET instance * @return true fixed burst length is enabled * @return false fixed burst length is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetFixedBurstLengthEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.SYSBUS_MODE & ENET_DMA_SYSBUS_MODE_FB_MASK) >> ENET_DMA_SYSBUS_MODE_FB_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA fixed burst length enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetFixedBurstLengthEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->ENET_DMA.SYSBUS_MODE = (pEnet->ENET_DMA.SYSBUS_MODE & ~ENET_DMA_SYSBUS_MODE_FB_MASK) | ENET_DMA_SYSBUS_MODE_FB(bEnable ? 1u : 0u); } /** * @brief Get DMA interrupt status * @param [in] pEnet the base address of the ENET instance * @return uint32_t DMA interrupt status value */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetDMAIntStatus(const ENET_Type *const pEnet) { return pEnet->ENET_DMA.INTERRUPT_STATUS; } /** * @brief Get MAC interrupt event in DMA interrupt status * @param [in] pEnet the base address of the ENET instance * @return true MAC interrupt event detected * @return false MAC interrupt event not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetMACIntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.INTERRUPT_STATUS & ENET_DMA_INTERRUPT_STATUS_MACIS_MASK) >> ENET_DMA_INTERRUPT_STATUS_MACIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get MTL interrupt event in DMA interrupt status * @param [in] pEnet the base address of the ENET instance * @return true MTL interrupt event detected * @return false MTL interrupt event not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetMTLIntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.INTERRUPT_STATUS & ENET_DMA_INTERRUPT_STATUS_MTLIS_MASK) >> ENET_DMA_INTERRUPT_STATUS_MTLIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get DMA channel0 interrupt event in DMA interrupt status * @param [in] pEnet the base address of the ENET instance * @return true DMA channel0 interrupt event detected * @return false DMA channel0 interrupt event not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetDMAChannel0IntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.INTERRUPT_STATUS & ENET_DMA_INTERRUPT_STATUS_DC0IS_MASK) >> ENET_DMA_INTERRUPT_STATUS_DC0IS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get DMA channel1 interrupt event in DMA interrupt status * @param [in] pEnet the base address of the ENET instance * @return true DMA channel1 interrupt event detected * @return false DMA channel1 interrupt event not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetDMAChannel1IntStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.INTERRUPT_STATUS & ENET_DMA_INTERRUPT_STATUS_DC1IS_MASK) >> ENET_DMA_INTERRUPT_STATUS_DC1IS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Get DMA channel interrupt event in DMA interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eChannel DMA channel * @return true eChannel interrupt event detected * @return false eChannel interrupt event not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetDMAChannelIntStatus(const ENET_Type *const pEnet, ENET_DMA_ChannelType eChannel) { uint32_t u32TmpVal = pEnet->ENET_DMA.INTERRUPT_STATUS & ((uint32_t)1u << (uint32_t)eChannel); return (u32TmpVal != 0u) ? true : false; } /** * @brief Get AXI Master Read Channel Status * @param [in] pEnet the base address of the ENET instance * @return true AXI Master Read Channel detected * @return false AXI Master Read Channel not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetAHBMasterBusyStatus(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->ENET_DMA.DEBUG_STATUS0 & ENET_DMA_DEBUG_STATUS0_AXWHSTS_MASK) >> ENET_DMA_DEBUG_STATUS0_AXWHSTS_SHIFT; return (u32TmpVal != 0u) ? true : false; } #if ENET_SUPPORT_TIME_SENSITIVE_NETWORK /** * @brief Get DMA TBS fetch time offset * @param [in] pEnet the base address of the ENET instance * @param [in] eCtrlIndex DMA TBS control index * @return uint32_t DMA TBS fetch time offset */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetFetchTimeOffset(const ENET_Type *const pEnet, uint8_t eCtrlIndex) { uint32_t u32TmpVal = (pEnet->ENET_DMA.TBS_CTRL[eCtrlIndex] & ENET_DMA_TBS_CTRL_FTOS_MASK) >> ENET_DMA_TBS_CTRL_FTOS_SHIFT; return u32TmpVal; } /** * @brief Set DMA TBS fetch time offset * @param [in] pEnet the base address of the ENET instance * @param [in] eCtrlIndex DMA TBS control index * @param [in] u32FetchTimeOffset DMA TBS fetch time offset */ LOCAL_INLINE void ENET_HWA_DMA_SetFetchTimeOffset(ENET_Type *const pEnet, uint8_t eCtrlIndex, uint32_t u32FetchTimeOffset) { pEnet->ENET_DMA.TBS_CTRL[eCtrlIndex] = (pEnet->ENET_DMA.TBS_CTRL[eCtrlIndex] & ~ENET_DMA_TBS_CTRL_FTOS_MASK) | ENET_DMA_TBS_CTRL_FTOS(u32FetchTimeOffset); } /** * @brief Get DMA TBS fetch time offset valid * @param [in] pEnet the base address of the ENET instance * @param [in] eCtrlIndex DMA TBS control index * @return true TBS fetch time offset is valid * @return false TBS fetch time offset is invalid */ LOCAL_INLINE bool ENET_HWA_DMA_GetFetchTimeOffsetValid(const ENET_Type *const pEnet, uint8_t eCtrlIndex) { uint32_t u32TmpVal = (pEnet->ENET_DMA.TBS_CTRL[eCtrlIndex] & ENET_DMA_TBS_CTRL_FTOV_MASK) >> ENET_DMA_TBS_CTRL_FTOV_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA TBS fetch time offset valid * @param [in] pEnet the base address of the ENET instance * @param [in] eCtrlIndex DMA TBS control index * @param [in] bEnable set valid */ LOCAL_INLINE void ENET_HWA_DMA_SetFetchTimeOffsetValid(ENET_Type *const pEnet, uint8_t eCtrlIndex, bool bEnable) { pEnet->ENET_DMA.TBS_CTRL[eCtrlIndex] = (pEnet->ENET_DMA.TBS_CTRL[eCtrlIndex] & ~ENET_DMA_TBS_CTRL_FTOV_MASK) | ENET_DMA_TBS_CTRL_FTOV(bEnable ? 1u : 0u); } #endif /* ENET_SUPPORT_TIME_SENSITIVE_NETWORK */ /** * @brief Get DMA channel control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t register value */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetChannelCtrl(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].CONTROL; } /** * @brief Set DMA channel control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32ChannelCtrl control value */ LOCAL_INLINE void ENET_HWA_DMA_SetChannelCtrl(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32ChannelCtrl) { pEnet->ENET_DMA.CH[eDMAChannel].CONTROL = u32ChannelCtrl; } /** * @brief Get DMA descriptor skip length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint8_t descriptor skip length */ LOCAL_INLINE uint8_t ENET_HWA_DMA_GetDescriptorSkipLength(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].CONTROL & ENET_DMA_CHn_CONTROL_DSL_MASK) >> ENET_DMA_CHn_CONTROL_DSL_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set DMA descriptor skip length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u8Length descriptor skip length */ LOCAL_INLINE void ENET_HWA_DMA_SetDescriptorSkipLength(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint8_t u8Length) { pEnet->ENET_DMA.CH[eDMAChannel].CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].CONTROL & ~ENET_DMA_CHn_CONTROL_DSL_MASK) | ENET_DMA_CHn_CONTROL_DSL(u8Length); } /** * @brief Get DMA burst length multiply by 8 mode * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true DMA Tx and Rx burst length is multipled by 8 * @return false use DMA Tx and Rx burst length */ LOCAL_INLINE bool ENET_HWA_DMA_Get8xPBLModeEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].CONTROL & ENET_DMA_CHn_CONTROL_PBLX8_MASK) >> ENET_DMA_CHn_CONTROL_PBLX8_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA burst length multiply by 8 mode * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable enable x8 mode */ LOCAL_INLINE void ENET_HWA_DMA_Set8xPBLModeEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].CONTROL & ~ENET_DMA_CHn_CONTROL_PBLX8_MASK) | ENET_DMA_CHn_CONTROL_PBLX8(bEnable ? 1u : 0u); } /** * @brief Get DMA transmit channel control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t register value */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetChannelTxCtrl(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL; } /** * @brief Set DMA transmit channel control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32TxCtrl control value */ LOCAL_INLINE void ENET_HWA_DMA_SetChannelTxCtrl(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32TxCtrl) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL = u32TxCtrl; } /** * @brief Get DMA enhanced descriptor enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true enhanced descriptor is enabled * @return false enhanced descriptor is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetEnhancedDescriptorEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & ENET_DMA_CHn_TX_CONTROL_EDSE_MASK) >> ENET_DMA_CHn_TX_CONTROL_EDSE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA enhanced descriptor enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetEnhancedDescriptorEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & (~ENET_DMA_CHn_TX_CONTROL_EDSE_MASK)) | ENET_DMA_CHn_TX_CONTROL_EDSE(bEnable ? 1u : 0u); } /** * @brief Get DMA early transmit interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true early transmit interrupt is enabled * @return false early transmit interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetEarlyTxIntEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & ENET_DMA_CHn_TX_CONTROL_ETIC_MASK) >> ENET_DMA_CHn_TX_CONTROL_ETIC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA early transmit interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetEarlyTxIntEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & (~ENET_DMA_CHn_TX_CONTROL_ETIC_MASK)) | ENET_DMA_CHn_TX_CONTROL_ETIC(bEnable ? 1u : 0u); } /** * @brief Get DMA transmit programmable burst length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint8_t transmit burst length */ LOCAL_INLINE uint8_t ENET_HWA_DMA_GetTxBurstLength(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & ENET_DMA_CHn_TX_CONTROL_TXPBL_MASK) >> ENET_DMA_CHn_TX_CONTROL_TXPBL_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set DMA transmit programmable burst length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u8Length transmit burst length */ LOCAL_INLINE void ENET_HWA_DMA_SetTxBurstLength(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint8_t u8Length) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & (~ENET_DMA_CHn_TX_CONTROL_TXPBL_MASK)) | ENET_DMA_CHn_TX_CONTROL_TXPBL(u8Length); } /** * @brief Get DMA operate on second packet enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true operate on second packet is enabled * @return false operate on second packet is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetOperateOnSecondPacketEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & ENET_DMA_CHn_TX_CONTROL_OSF_MASK) >> ENET_DMA_CHn_TX_CONTROL_OSF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA operate on second packet enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetOperateOnSecondPacketEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & (~ENET_DMA_CHn_TX_CONTROL_OSF_MASK)) | ENET_DMA_CHn_TX_CONTROL_OSF(bEnable ? 1u : 0u); } /** * @brief Get DMA transmit channel weight * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint8_t transmit channel weight */ LOCAL_INLINE uint8_t ENET_HWA_DMA_GetTxChannelWeight(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & ENET_DMA_CHn_TX_CONTROL_TCW_MASK) >> ENET_DMA_CHn_TX_CONTROL_TCW_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set DMA transmit channel weight * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u8Weight transmit channel weight */ LOCAL_INLINE void ENET_HWA_DMA_SetTxChannelWeight(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint8_t u8Weight) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & (~ENET_DMA_CHn_TX_CONTROL_TCW_MASK)) | ENET_DMA_CHn_TX_CONTROL_TCW(u8Weight); } /** * @brief Get DMA transmit channel active status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return ENET_DMA_STATUS_IDLE DMA transmission is stopped * @return ENET_DMA_STATUS_ACTIVE DMA transmission is running */ LOCAL_INLINE ENET_DMA_StatusType ENET_HWA_DMA_GetTxActiveStatus(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL & ENET_DMA_CHn_TX_CONTROL_ST_MASK) >> ENET_DMA_CHn_TX_CONTROL_ST_SHIFT; return (ENET_DMA_StatusType)u32TmpVal; } /** * @brief Start DMA transmission * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_StartTx(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL |= ENET_DMA_CHn_TX_CONTROL_ST_MASK; } /** * @brief Stop DMA transmission * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_StopTx(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].TX_CONTROL &= ~ENET_DMA_CHn_TX_CONTROL_ST_MASK; } /** * @brief Get DMA receive channel control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t register value */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetChannelRxCtrl(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL; } /** * @brief Set DMA receive channel control register value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32RxCtrl control value */ LOCAL_INLINE void ENET_HWA_DMA_SetChannelRxCtrl(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32RxCtrl) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL = u32RxCtrl; } /** * @brief Get DMA receive packet flush enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true Rx packet flush is enabled * @return false Rx packet flush is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetRxPacketFlushEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & ENET_DMA_CHn_RX_CONTROL_RPF_MASK) >> ENET_DMA_CHn_RX_CONTROL_RPF_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA receive packet flush enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetRxPacketFlushEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & (~ENET_DMA_CHn_RX_CONTROL_RPF_MASK)) | ENET_DMA_CHn_RX_CONTROL_RPF(bEnable ? 1u : 0u); } /** * @brief Get DMA early receive interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true early receive interrupt is enabled * @return false early receive interrupt is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetEarlyRxIntEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & ENET_DMA_CHn_RX_CONTROL_ERIC_MASK) >> ENET_DMA_CHn_RX_CONTROL_ERIC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set DMA early receive interrupt enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetEarlyRxIntEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & (~ENET_DMA_CHn_RX_CONTROL_ERIC_MASK)) | ENET_DMA_CHn_RX_CONTROL_ERIC(bEnable ? 1u : 0u); } /** * @brief Get DMA receive programmable burst length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint8_t receive burst length */ LOCAL_INLINE uint8_t ENET_HWA_DMA_GetRxBurstLength(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & ENET_DMA_CHn_RX_CONTROL_RXPBL_MASK) >> ENET_DMA_CHn_RX_CONTROL_RXPBL_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set DMA receive programmable burst length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u8Length receive burst length */ LOCAL_INLINE void ENET_HWA_DMA_SetRxBurstLength(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint8_t u8Length) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & (~ENET_DMA_CHn_RX_CONTROL_RXPBL_MASK)) | ENET_DMA_CHn_RX_CONTROL_RXPBL(u8Length); } /** * @brief Get DMA receive buffer size * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint16_t receive buffer size */ LOCAL_INLINE uint16_t ENET_HWA_DMA_GetRxBufferSize(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & (ENET_DMA_CHn_RX_CONTROL_RBSZ_13_Y_MASK | ENET_DMA_CHn_RX_CONTROL_RBSZ_X_0_MASK)) >> ENET_DMA_CHn_RX_CONTROL_RBSZ_X_0_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set DMA receive buffer size * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u16BufferSize receive buffer size */ LOCAL_INLINE void ENET_HWA_DMA_SetRxBufferSize(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint16_t u16BufferSize) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & (~ENET_DMA_CHn_RX_CONTROL_RBSZ_13_Y_MASK)) | ENET_DMA_CHn_RX_CONTROL_RBSZ_13_Y(((uint32_t)u16BufferSize >> (ENET_DMA_CHn_RX_CONTROL_RBSZ_13_Y_SHIFT - ENET_DMA_CHn_RX_CONTROL_RBSZ_X_0_SHIFT))); } /** * @brief Get DMA receive channel active status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return ENET_DMA_STATUS_IDLE DMA reception is stopped * @return ENET_DMA_STATUS_ACTIVE DMA reception is running */ LOCAL_INLINE ENET_DMA_StatusType ENET_HWA_DMA_GetRxActiveStatus(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL & ENET_DMA_CHn_RX_CONTROL_SR_MASK) >> ENET_DMA_CHn_RX_CONTROL_SR_SHIFT; return (ENET_DMA_StatusType)u32TmpVal; } /** * @brief Start DMA reception * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_StartRx(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL |= ENET_DMA_CHn_RX_CONTROL_SR_MASK; } /** * @brief Stop DMA reception * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_StopRx(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL &= ~ENET_DMA_CHn_RX_CONTROL_SR_MASK; } /** * @brief Get DMA channel Tx descriptor list header address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t Tx descriptor list header address */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetTxDescListHeadAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].TXDESC_LIST_ADDRESS; } /** * @brief Set DMA channel Tx descriptor list header address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32TxAddr Tx descriptor list header address */ LOCAL_INLINE void ENET_HWA_DMA_SetTxDescListHeadAddr(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32TxAddr) { pEnet->ENET_DMA.CH[eDMAChannel].TXDESC_LIST_ADDRESS = ENET_DMA_CHn_TXDESC_LIST_ADDRESS_TDESLA(u32TxAddr >> ENET_DMA_CHn_TXDESC_LIST_ADDRESS_TDESLA_SHIFT); } /** * @brief Get DMA channel Rx descriptor list header address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t Rx descriptor list header address */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetRxDescListHeadAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].RXDESC_LIST_ADDRESS; } /** * @brief Set DMA channel Rx descriptor list header address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32RxAddr Rx descriptor list header address */ LOCAL_INLINE void ENET_HWA_DMA_SetRxDescListHeadAddr(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32RxAddr) { pEnet->ENET_DMA.CH[eDMAChannel].RXDESC_LIST_ADDRESS = ENET_DMA_CHn_RXDESC_LIST_ADDRESS_RDESLA(u32RxAddr >> ENET_DMA_CHn_RXDESC_LIST_ADDRESS_RDESLA_SHIFT); } /** * @brief Get DMA channel Tx descriptor list tail address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t Tx descriptor list tail address */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetTxDescListTailAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].TXDESC_TAIL_POINTER; } /** * @brief Set DMA channel Tx descriptor list tail address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32TxAddr Tx descriptor list tail address */ LOCAL_INLINE void ENET_HWA_DMA_SetTxDescListTailAddr(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32TxAddr) { pEnet->ENET_DMA.CH[eDMAChannel].TXDESC_TAIL_POINTER = ENET_DMA_CHn_TXDESC_TAIL_POINTER_TDTP(u32TxAddr >> ENET_DMA_CHn_TXDESC_TAIL_POINTER_TDTP_SHIFT); } /** * @brief Get DMA channel Rx descriptor list tail address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t Rx descriptor list tail address */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetRxDescListTailAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].RXDESC_TAIL_POINTER; } /** * @brief Set DMA channel Rx descriptor list tail address * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32RxAddr Rx descriptor list tail address */ LOCAL_INLINE void ENET_HWA_DMA_SetRxDescListTailAddr(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32RxAddr) { pEnet->ENET_DMA.CH[eDMAChannel].RXDESC_TAIL_POINTER = ENET_DMA_CHn_RXDESC_TAIL_POINTER_RDTP(u32RxAddr >> ENET_DMA_CHn_RXDESC_TAIL_POINTER_RDTP_SHIFT); } /** * @brief Get DMA channel Tx descriptor ring length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint16_t Tx descriptor ring length */ LOCAL_INLINE uint16_t ENET_HWA_DMA_GetTxDescRingLength(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].TXDESC_RING_LENGTH & ENET_DMA_CHn_TXDESC_RING_LENGTH_TDRL_MASK) >> ENET_DMA_CHn_TXDESC_RING_LENGTH_TDRL_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set DMA channel Tx descriptor ring length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u16Length Tx descriptor ring length */ LOCAL_INLINE void ENET_HWA_DMA_SetTxDescRingLength(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint16_t u16Length) { pEnet->ENET_DMA.CH[eDMAChannel].TXDESC_RING_LENGTH = ENET_DMA_CHn_TXDESC_RING_LENGTH_TDRL(u16Length); } /** * @brief Get DMA channel Rx descriptor ring length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t Rx descriptor ring length */ LOCAL_INLINE uint16_t ENET_HWA_DMA_GetRxDescRingLength(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL2 & ENET_DMA_CHn_RX_CONTROL2_RDRL_MASK) >> ENET_DMA_CHn_RX_CONTROL2_RDRL_SHIFT; return (uint16_t)u32TmpVal; } /** * @brief Set DMA channel Rx descriptor ring length * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u16Length Rx descriptor ring length */ LOCAL_INLINE void ENET_HWA_DMA_SetRxDescRingLength(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint16_t u16Length) { pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL2 = (pEnet->ENET_DMA.CH[eDMAChannel].RX_CONTROL2 & (~ENET_DMA_CHn_RX_CONTROL2_RDRL_MASK)) | ENET_DMA_CHn_RX_CONTROL2_RDRL(u16Length); } /** * @brief Get DMA channel enabled interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t enabled interrupts */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetEnabledInterrupts(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].INTERRUPT_ENABLE; } /** * @brief Set DMA channel interrupts enable state * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32IntEnable interrupts to be enabled */ LOCAL_INLINE void ENET_HWA_DMA_SetEnabledInterrupts(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32IntEnable) { pEnet->ENET_DMA.CH[eDMAChannel].INTERRUPT_ENABLE = u32IntEnable; } /** * @brief Enable one of the DMA channel interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] eIntFlag interrupt to be enabled */ LOCAL_INLINE void ENET_HWA_DMA_EnableInterrupt(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, ENET_DMA_InterruptFlagType eIntFlag) { pEnet->ENET_DMA.CH[eDMAChannel].INTERRUPT_ENABLE |= (uint32_t)eIntFlag; } /** * @brief Disable one of the DMA channel interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] eIntFlag interrupt to be disbled */ LOCAL_INLINE void ENET_HWA_DMA_DisableInterrupt(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, ENET_DMA_InterruptFlagType eIntFlag) { pEnet->ENET_DMA.CH[eDMAChannel].INTERRUPT_ENABLE &= ~(uint32_t)eIntFlag; } /** * @brief Get receive interrupt watchdog timer count unit * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return ENET_DMA_WDGCounterUnitType */ LOCAL_INLINE ENET_DMA_WDGCounterUnitType ENET_HWA_DMA_GetRxWDGCounterUnit(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_INTERRUPT_WATCHDOG_TIMER & ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWTU_MASK) >> ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWTU_SHIFT; return (ENET_DMA_WDGCounterUnitType)u32TmpVal; } /** * @brief Set receive interrupt watchdog timer count unit * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] eCounterUnit watchdog timer count unit */ LOCAL_INLINE void ENET_HWA_DMA_SetRxWDGCounterUnit(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, ENET_DMA_WDGCounterUnitType eCounterUnit) { pEnet->ENET_DMA.CH[eDMAChannel].RX_INTERRUPT_WATCHDOG_TIMER = (pEnet->ENET_DMA.CH[eDMAChannel].RX_INTERRUPT_WATCHDOG_TIMER & (~ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWTU_MASK)) | ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWTU(eCounterUnit); } /** * @brief Get receive interrupt watchdog timer count * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint8_t watchdog timer count value */ LOCAL_INLINE uint8_t ENET_HWA_DMA_GetRxWDGCount(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_INTERRUPT_WATCHDOG_TIMER & ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWT_MASK) >> ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWT_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set receive interrupt watchdog timer count * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u8WDGCnt watchdog timer count */ LOCAL_INLINE void ENET_HWA_DMA_SetRxWDGCount(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint8_t u8WDGCnt) { pEnet->ENET_DMA.CH[eDMAChannel].RX_INTERRUPT_WATCHDOG_TIMER = (pEnet->ENET_DMA.CH[eDMAChannel].RX_INTERRUPT_WATCHDOG_TIMER & (~ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWT_MASK)) | ENET_DMA_CHn_RX_INTERRUPT_WATCHDOG_TIMER_RWT(u8WDGCnt); } /** * @brief Get reference slot number in the DMA * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint8_t reference slot number */ LOCAL_INLINE uint8_t ENET_HWA_DMA_GetRefSlotNumber(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_RSN_MASK) >> ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_RSN_SHIFT; return (uint8_t)u32TmpVal; } /** * @brief Set reference slot number in the DMA * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u8SlotNumber reference slot number */ LOCAL_INLINE void ENET_HWA_DMA_SetRefSlotNumber(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint8_t u8SlotNumber) { pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & (~ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_RSN_MASK)) | ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_RSN(u8SlotNumber); } /** * @brief Get slot interval value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint16_t slot interval */ LOCAL_INLINE uint16_t ENET_HWA_DMA_GetSlotInterval(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_SIV_MASK) >> ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_SIV_SHIFT; return (uint16_t)(u32TmpVal + 1u); } /** * @brief Set slot interval value * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u16SlotInterval slot interval */ LOCAL_INLINE void ENET_HWA_DMA_SetSlotInterval(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint16_t u16SlotInterval) { pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & (~ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_SIV_MASK)) | ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_SIV((uint32_t)(u16SlotInterval - (uint32_t)1u)); } /** * @brief Get advance slot check enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true advance slot check is enabled * @return false advance slot check is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetAdvanceSlotCheckEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ASC_MASK) >> ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ASC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set advance slot check enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetAdvanceSlotCheckEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & (~ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ASC_MASK)) | ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ASC(bEnable ? 1u : 0u); } /** * @brief Get slot comparison enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true slot comparison is enabled * @return false slot comparison is disabled */ LOCAL_INLINE bool ENET_HWA_DMA_GetSlotComparisonEnFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ESC_MASK) >> ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ESC_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set slot comparison enable flag * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] bEnable */ LOCAL_INLINE void ENET_HWA_DMA_SetSlotComparisonEnFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, bool bEnable) { pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].SLOT_FUNCTION_CONTROL_STATUS & (~ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ESC_MASK)) | ENET_DMA_CHn_SLOT_FUNCTION_CONTROL_STATUS_ESC(bEnable ? 1u : 0u); } /** * @brief Get DMA current Tx descriptor address pointer * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t current Tx descriptor */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetCurrentTxDescAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].CURRENT_APP_TXDESC; } /** * @brief Get DMA current Rx descriptor address pointer * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t current Rx descriptor */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetCurrentRxDescAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].CURRENT_APP_RXDESC; } /** * @brief Get DMA current Tx buffer address pointer * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t current Tx buffer */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetCurrentTxBufAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].CURRENT_APP_TXBUFFER; } /** * @brief Get DMA current Rx buffer address pointer * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t current Rx buffer */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetCurrentRxBufAddr(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].CURRENT_APP_RXBUFFER; } /** * @brief Get DMA current status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return uint32_t DMA status */ LOCAL_INLINE uint32_t ENET_HWA_DMA_GetCurrentStatus(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { return pEnet->ENET_DMA.CH[eDMAChannel].STATUS; } /** * @brief Set DMA current status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @param [in] u32Status DMA status */ LOCAL_INLINE void ENET_HWA_DMA_SetCurrentStatus(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint32_t u32Status) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = u32Status; } /** * @brief Clear all DMA abnormal interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearAllAbnormalInterruptFlags(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_AIS_MASK | ENET_DMA_CHn_STATUS_CDE_MASK | ENET_DMA_CHn_STATUS_FBE_MASK | ENET_DMA_CHn_STATUS_ETI_MASK | ENET_DMA_CHn_STATUS_RPS_MASK | ENET_DMA_CHn_STATUS_RBU_MASK | ENET_DMA_CHn_STATUS_TPS_MASK; } /** * @brief Clear all DMA normal interrupts * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearAllNormalInterruptFlags(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_NIS_MASK | ENET_DMA_CHn_STATUS_ERI_MASK | ENET_DMA_CHn_STATUS_RI_MASK | ENET_DMA_CHn_STATUS_TBU_MASK | ENET_DMA_CHn_STATUS_TI_MASK; } /** * @brief Get DMA Rx error status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return ENET_DMA_RxErrorType */ LOCAL_INLINE ENET_DMA_RxErrorType ENET_HWA_DMA_GetRxError(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_REB_MASK) >> ENET_DMA_CHn_STATUS_REB_SHIFT; return (ENET_DMA_RxErrorType)u32TmpVal; } /** * @brief Clear DMA Rx error status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearRxError(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_TEB_MASK) & (~ENET_DMA_CHn_STATUS_REB_MASK); } /** * @brief Get DMA Tx error status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return ENET_DMA_TxErrorType */ LOCAL_INLINE ENET_DMA_TxErrorType ENET_HWA_DMA_GetTxError(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_TEB_MASK) >> ENET_DMA_CHn_STATUS_TEB_SHIFT; return (ENET_DMA_TxErrorType)u32TmpVal; } /** * @brief Clear DMA Tx error status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearTxError(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_REB_MASK) & (~ENET_DMA_CHn_STATUS_TEB_MASK); } /** * @brief Get DMA normal interrupt summary * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true normal interrupt detected * @return false normal interrupt not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetNormalInterruptFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_NIS_MASK) >> ENET_DMA_CHn_STATUS_NIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA normal interrupt summary * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearNormalInterruptFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_NIS_MASK; } /** * @brief Get DMA abnormal interrupt summary * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true abnormal interrupt detected * @return false abnormal interrupt not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetAbnormalInterruptFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_AIS_MASK) >> ENET_DMA_CHn_STATUS_AIS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA abnormal interrupt summary * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearAbnormalInterruptFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_AIS_MASK; } /** * @brief Get DMA context descriptor error * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true context descriptor error detected * @return false context descriptor error not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetContextDescriptorErrorFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_CDE_MASK) >> ENET_DMA_CHn_STATUS_CDE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA context descriptor error * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearContextDescriptorErrorFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_CDE_MASK; } /** * @brief Get DMA fatal bus error * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true fatal bus error detected * @return false fatal bus error not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetFatalBusErrorFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_FBE_MASK) >> ENET_DMA_CHn_STATUS_FBE_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA fatal bus error * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearFatalBusErrorFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { /* When FBE cleared, REB and TEB becomes invalid and shall also be cleared */ pEnet->ENET_DMA.CH[eDMAChannel].STATUS = ENET_DMA_CHn_STATUS_FBE_MASK; } /** * @brief Get DMA early receive interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true early receive interrupt detected * @return false early receive interrupt not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetEarlyRxInterruptFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_ERI_MASK) >> ENET_DMA_CHn_STATUS_ERI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA early receive interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearEarlyRxInterruptFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_ERI_MASK; } /** * @brief Get DMA early transmit interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true early transmit interrupt detected * @return false early transmit interrupt not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetEarlyTxInterruptFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_ETI_MASK) >> ENET_DMA_CHn_STATUS_ETI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA early transmit interrupt * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearEarlyTxInterruptFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_ETI_MASK; } /** * @brief Get DMA receive watchdog timeout status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true receive watchdog timeout status detected * @return false receive watchdog timeout status not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetRxWDGTimeoutFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_RWT_MASK) >> ENET_DMA_CHn_STATUS_RWT_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA receive watchdog timeout status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearRxWDGTimeoutFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_RWT_MASK; } /** * @brief Get DMA receive process stopped status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true receive process stopped status detected * @return false receive process stopped status not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetRxProcessStoppedFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_RPS_MASK) >> ENET_DMA_CHn_STATUS_RPS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA receive process stopped status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearRxProcessStoppedFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_RPS_MASK; } /** * @brief Get DMA receive buffer unavailable status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true receive buffer unavailable status detected * @return false receive buffer unavailable status not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetRxBufferUnavailableFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_RBU_MASK) >> ENET_DMA_CHn_STATUS_RBU_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA receive buffer unavailable status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearRxBufferUnavailableFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_RBU_MASK; } /** * @brief Get DMA receive interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true receive interrupt detected * @return false receive interrupt not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetRxInterruptFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_RI_MASK) >> ENET_DMA_CHn_STATUS_RI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA receive interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearRxInterruptFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_RI_MASK; } /** * @brief Get DMA transmit buffer unavailable status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true transmit buffer unavailable status detected * @return false transmit buffer unavailable status not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetTxBufferUnavailableFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_TBU_MASK) >> ENET_DMA_CHn_STATUS_TBU_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA transmit buffer unavailable status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearTxBufferUnavailableFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_TBU_MASK; } /** * @brief Get DMA transmit process stopped status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true transmit process stopped status detected * @return false transmit process stopped status not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetTxProcessStoppedFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_TPS_MASK) >> ENET_DMA_CHn_STATUS_TPS_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA transmit process stopped status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearTxProcessStoppedFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_TPS_MASK; } /** * @brief Get DMA transmit interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel * @return true transmit interrupt detected * @return false transmit interrupt not detected */ LOCAL_INLINE bool ENET_HWA_DMA_GetTxInterruptFlag(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & ENET_DMA_CHn_STATUS_TI_MASK) >> ENET_DMA_CHn_STATUS_TI_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Clear DMA transmit interrupt status * @param [in] pEnet the base address of the ENET instance * @param [in] eDMAChannel DMA channel */ LOCAL_INLINE void ENET_HWA_DMA_ClearTxInterruptFlag(ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { pEnet->ENET_DMA.CH[eDMAChannel].STATUS = (pEnet->ENET_DMA.CH[eDMAChannel].STATUS & (ENET_DMA_CHn_STATUS_REB_MASK | ENET_DMA_CHn_STATUS_TEB_MASK)) | ENET_DMA_CHn_STATUS_TI_MASK; } /** * @brief Get the miss frame count and overflow status of the Ethernet DMA channel * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eDMAChannel the DMA channel of the Ethernet instance * @param [out] pMissPacketCnt the miss frame count of the channel * @return true The miss frame count is overflow * @return false the miss frame count is not overflow */ LOCAL_INLINE bool ENET_HWA_DMA_GetMissFrameCount(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel, uint16_t *pMissPacketCnt) { bool bRet; uint32_t u32TmpVal = pEnet->ENET_DMA.CH[eDMAChannel].MISS_FRAME_CNT; *pMissPacketCnt = (uint16_t)((u32TmpVal & ENET_DMA_CHn_MISS_FRAME_CNT_MFC_MASK) >> ENET_DMA_CHn_MISS_FRAME_CNT_MFC_SHIFT); bRet = (((u32TmpVal & ENET_DMA_CHn_MISS_FRAME_CNT_MFCO_MASK) >> ENET_DMA_CHn_MISS_FRAME_CNT_MFCO_SHIFT) != 0u) ? true : false; return bRet; } /** * @brief Get the count of the number of times Early Receive Interrupt was asserted. * * @param [in] pEnet the base address of the Ethernet instance * @param [in] eDMAChannel the DMA channel of the Ethernet instance * @return The count value */ LOCAL_INLINE uint16_t ENET_HWA_DMA_GetEarlyRxInterruptCount(const ENET_Type *const pEnet, ENET_DMA_ChannelType eDMAChannel) { uint32_t u32TmpVal = (pEnet->ENET_DMA.CH[eDMAChannel].RX_ERI_CNT & ENET_DMA_CHn_RX_ERI_CNT_ECNT_MASK) >> ENET_DMA_CHn_RX_ERI_CNT_ECNT_SHIFT; return (uint16_t)u32TmpVal; } #if ENET_SUPPORT_TIME_SENSITIVE_NETWORK /** * @brief Get EST offset Mode enable flag * * @param [in] pEnet the base address of the ENET instance * @return true EST offset Mode is enabled * @return false EST offset Mode is disabled */ LOCAL_INLINE bool ENET_HWA_MTL_GetEstOffsetModeEnFlag(const ENET_Type *const pEnet) { uint32_t u32TmpVal = (pEnet->MTL.TBS_CTRL & ENET_MTL_TBS_CTRL_ESTM_MASK) >> ENET_MTL_TBS_CTRL_ESTM_SHIFT; return (u32TmpVal != 0u) ? true : false; } /** * @brief Set EST offset Mode enable flag * * @param [in] pEnet the base address of the ENET instance * @param [in] bEnable Enable or disable EST offset Mode */ LOCAL_INLINE void ENET_HWA_MTL_SetEstOffsetModeEnFlag(ENET_Type *const pEnet, bool bEnable) { pEnet->MTL.TBS_CTRL = (pEnet->MTL.TBS_CTRL & ~ENET_MTL_TBS_CTRL_ESTM_MASK) | ENET_MTL_TBS_CTRL_ESTM(bEnable ? 1u : 0u); } /** * @brief Get enhancements to scheduled transmission Status register value * @param [in] pEnet the base address of the ENET instance * @return uint32_t EST Status value */ LOCAL_INLINE uint32_t ENET_HWA_MTL_GetEstCGSN(const ENET_Type *const pEnet) { return (pEnet->MTL.EST_STATUS & ENET_MTL_EST_STATUS_CGSN_MASK) >> ENET_MTL_EST_STATUS_CGSN_SHIFT; } #endif /** @}*/ #endif /* ENET_INSTANCE_COUNT > 0u */ #endif /* _HWA_ENET_H_ */