MCUXpresso SDK API Reference Manual  Rev. 0
NXP Semiconductors
 All Data Structures Functions Variables Typedefs Enumerations Enumerator Groups Pages
ENET: Ethernet MAC Driver

Overview

The MCUXpresso SDK provides a peripheral driver for the 10/100 Mbps Ethernet MAC (ENET) module of MCUXpresso SDK devices.

ENET: Ethernet MAC Driver {EthernetMACDriver}

Operations of Ethernet MAC Driver

MII interface Operation

The MII interface is the interface connected with MAC and PHY. the Serial management interface - MII management interface should be set before any access to the external PHY chip register. Call ENET_SetSMI() to initialize the MII management interface. Use ENET_StartSMIRead(), ENET_StartSMIWrite(), and ENET_ReadSMIData() to read/write to PHY registers. This function group sets up the MII and serial management SMI interface, gets data from the SMI interface, and starts the SMI read and write command. Use ENET_SetMII() to configure the MII before successfully getting data from the external PHY.

MAC address filter

This group sets/gets the ENET mac address and the multicast group address filter. ENET_AddMulticastGroup() should be called to add the ENET MAC to the multicast group. The IEEE 1588 feature requires receiving the PTP message.

Other Baisc control Operations

This group has the receive active API ENET_ActiveRead() for single and multiple rings. The ENET_AVBConfigure() is provided to configure the AVB features to support the AVB frames transmission. Note that due to the AVB frames transmission scheme being a credit-based TX scheme, it is only supported with the Enhanced buffer descriptors. Because of this, the AVB configuration should only be done with the Enhanced buffer descriptor. When the AVB feature is required, make sure the the "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" is defined before using this feature.

Transactional Operation

For ENET receive, the ENET_GetRxFrameSize() function needs to be called to get the received data size. Then, call the ENET_ReadFrame() function to get the received data. If the received error occurs, call the ENET_GetRxErrBeforeReadFrame() function after ENET_GetRxFrameSize() and before ENET_ReadFrame() functions to get the detailed error information.

For ENET transmit, call the ENET_SendFrame() function to send the data out. The transmit data error information is only accessible for the IEEE 1588 enhanced buffer descriptor mode. When the ENET_ENHANCEDBUFFERDESCRIPTOR_MODE is defined, the ENET_GetTxErrAfterSendFrame() can be used to get the detail transmit error information. The transmit error information can only be updated by uDMA after the data is transmitted. The ENET_GetTxErrAfterSendFrame() function is recommended to be called on the transmit interrupt handler.

If send/read frame with zero-copy mechanism is needed, there're special APIs like ENET_GetRxBuffer(), ENET_ReleaseRxBuffer(), ENET_SendFrameZeroCopy() and ENET_SetTxBuffer(). The send frame zero-copy APIs can't be used mixed with ENET_SendFrame() for the same ENET peripheral, same as read frame zero-copy APIs.

PTP IEEE 1588 Feature Operation

This function group configures the PTP IEEE 1588 feature, starts/stops/gets/sets/adjusts the PTP IEEE 1588 timer, gets the receive/transmit frame timestamp, and PTP IEEE 1588 timer channel feature setting.

The ENET_Ptp1588Configure() function needs to be called when the ENET_ENHANCEDBUFFERDESCRIPTOR_MODE is defined and the IEEE 1588 feature is required.

Typical use case

ENET Initialization, receive, and transmit operations

For the ENET_ENHANCEDBUFFERDESCRIPTOR_MODE undefined use case, use the legacy type buffer descriptor transmit/receive the frame as follows. Refer to the driver examples codes located at <SDK_ROOT>/boards/<BOARD>/driver_examples/enet For the ENET_ENHANCEDBUFFERDESCRIPTOR_MODE defined use case, add the PTP IEEE 1588 configuration to enable the PTP IEEE 1588 feature. The initialization occurs as follows. Refer to the driver examples codes located at <SDK_ROOT>/boards/<BOARD>/driver_examples/enet

Modules

 ENET CMSIS Driver
 

Data Structures

struct  enet_rx_bd_struct_t
 Defines the receive buffer descriptor structure for the little endian system. More...
 
struct  enet_tx_bd_struct_t
 Defines the enhanced transmit buffer descriptor structure for the little endian system. More...
 
struct  enet_data_error_stats_t
 Defines the ENET data error statistics structure. More...
 
struct  enet_frame_info_t
 Defines the frame info structure. More...
 
struct  enet_tx_dirty_ring_t
 Defines the ENET transmit dirty addresses ring/queue structure. More...
 
struct  enet_buffer_config_t
 Defines the receive buffer descriptor configuration structure. More...
 
struct  enet_intcoalesce_config_t
 Defines the interrupt coalescing configure structure. More...
 
struct  enet_config_t
 Defines the basic configuration structure for the ENET device. More...
 
struct  enet_tx_bd_ring_t
 Defines the ENET transmit buffer descriptor ring/queue structure. More...
 
struct  enet_rx_bd_ring_t
 Defines the ENET receive buffer descriptor ring/queue structure. More...
 
struct  enet_handle_t
 Defines the ENET handler structure. More...
 

Macros

#define ENET_BUFFDESCRIPTOR_RX_ERR_MASK
 Defines the receive error status flag mask. More...
 

Typedefs

typedef void(* enet_callback_t )(ENET_Type *base, enet_handle_t *handle, enet_event_t event, enet_frame_info_t *frameInfo, void *userData)
 ENET callback function. More...
 
typedef void(* enet_isr_t )(ENET_Type *base, enet_handle_t *handle)
 Define interrupt IRQ handler. More...
 

Enumerations

enum  {
  kStatus_ENET_RxFrameError = MAKE_STATUS(kStatusGroup_ENET, 0U),
  kStatus_ENET_RxFrameFail = MAKE_STATUS(kStatusGroup_ENET, 1U),
  kStatus_ENET_RxFrameEmpty = MAKE_STATUS(kStatusGroup_ENET, 2U),
  kStatus_ENET_TxFrameOverLen = MAKE_STATUS(kStatusGroup_ENET, 3U),
  kStatus_ENET_TxFrameBusy = MAKE_STATUS(kStatusGroup_ENET, 4U),
  kStatus_ENET_TxFrameFail = MAKE_STATUS(kStatusGroup_ENET, 5U)
}
 Defines the status return codes for transaction. More...
 
enum  enet_mii_mode_t {
  kENET_MiiMode = 0U,
  kENET_RmiiMode = 1U
}
 Defines the MII/RMII/RGMII mode for data interface between the MAC and the PHY. More...
 
enum  enet_mii_speed_t {
  kENET_MiiSpeed10M = 0U,
  kENET_MiiSpeed100M = 1U
}
 Defines the 10/100/1000 Mbps speed for the MII data interface. More...
 
enum  enet_mii_duplex_t {
  kENET_MiiHalfDuplex = 0U,
  kENET_MiiFullDuplex
}
 Defines the half or full duplex for the MII data interface. More...
 
enum  enet_mii_write_t {
  kENET_MiiWriteNoCompliant = 0U,
  kENET_MiiWriteValidFrame
}
 Define the MII opcode for normal MDIO_CLAUSES_22 Frame. More...
 
enum  enet_mii_read_t {
  kENET_MiiReadValidFrame = 2U,
  kENET_MiiReadNoCompliant = 3U
}
 Defines the read operation for the MII management frame. More...
 
enum  enet_mii_extend_opcode {
  kENET_MiiAddrWrite_C45 = 0U,
  kENET_MiiWriteFrame_C45 = 1U,
  kENET_MiiReadFrame_C45 = 3U
}
 Define the MII opcode for extended MDIO_CLAUSES_45 Frame. More...
 
enum  enet_special_control_flag_t {
  kENET_ControlFlowControlEnable = 0x0001U,
  kENET_ControlRxPayloadCheckEnable = 0x0002U,
  kENET_ControlRxPadRemoveEnable = 0x0004U,
  kENET_ControlRxBroadCastRejectEnable = 0x0008U,
  kENET_ControlMacAddrInsert = 0x0010U,
  kENET_ControlStoreAndFwdDisable = 0x0020U,
  kENET_ControlSMIPreambleDisable = 0x0040U,
  kENET_ControlPromiscuousEnable = 0x0080U,
  kENET_ControlMIILoopEnable = 0x0100U,
  kENET_ControlVLANTagEnable = 0x0200U
}
 Defines a special configuration for ENET MAC controller. More...
 
enum  enet_interrupt_enable_t {
  kENET_BabrInterrupt = ENET_EIR_BABR_MASK,
  kENET_BabtInterrupt = ENET_EIR_BABT_MASK,
  kENET_GraceStopInterrupt = ENET_EIR_GRA_MASK,
  kENET_TxFrameInterrupt = ENET_EIR_TXF_MASK,
  kENET_TxBufferInterrupt = ENET_EIR_TXB_MASK,
  kENET_RxFrameInterrupt = ENET_EIR_RXF_MASK,
  kENET_RxBufferInterrupt = ENET_EIR_RXB_MASK,
  kENET_MiiInterrupt = ENET_EIR_MII_MASK,
  kENET_EBusERInterrupt = ENET_EIR_EBERR_MASK,
  kENET_LateCollisionInterrupt = ENET_EIR_LC_MASK,
  kENET_RetryLimitInterrupt = ENET_EIR_RL_MASK,
  kENET_UnderrunInterrupt = ENET_EIR_UN_MASK,
  kENET_PayloadRxInterrupt = ENET_EIR_PLR_MASK,
  kENET_WakeupInterrupt = ENET_EIR_WAKEUP_MASK,
  kENET_TsAvailInterrupt = ENET_EIR_TS_AVAIL_MASK,
  kENET_TsTimerInterrupt = ENET_EIR_TS_TIMER_MASK
}
 List of interrupts supported by the peripheral. More...
 
enum  enet_event_t {
  kENET_RxEvent,
  kENET_TxEvent,
  kENET_ErrEvent,
  kENET_WakeUpEvent,
  kENET_TimeStampEvent,
  kENET_TimeStampAvailEvent
}
 Defines the common interrupt event for callback use. More...
 
enum  enet_tx_accelerator_t {
  kENET_TxAccelIsShift16Enabled = ENET_TACC_SHIFT16_MASK,
  kENET_TxAccelIpCheckEnabled = ENET_TACC_IPCHK_MASK,
  kENET_TxAccelProtoCheckEnabled = ENET_TACC_PROCHK_MASK
}
 Defines the transmit accelerator configuration. More...
 
enum  enet_rx_accelerator_t {
  kENET_RxAccelPadRemoveEnabled = ENET_RACC_PADREM_MASK,
  kENET_RxAccelIpCheckEnabled = ENET_RACC_IPDIS_MASK,
  kENET_RxAccelProtoCheckEnabled = ENET_RACC_PRODIS_MASK,
  kENET_RxAccelMacCheckEnabled = ENET_RACC_LINEDIS_MASK,
  kENET_RxAccelisShift16Enabled = ENET_RACC_SHIFT16_MASK
}
 Defines the receive accelerator configuration. More...
 

Functions

uint32_t ENET_GetInstance (ENET_Type *base)
 Get the ENET instance from peripheral base address. More...
 

Driver version

#define FSL_ENET_DRIVER_VERSION   (MAKE_VERSION(2, 3, 0))
 Defines the driver version. More...
 

Control and status region bit masks of the receive buffer descriptor.

Defines the queue number.

#define ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK   0x8000U
 Empty bit mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_SOFTOWNER1_MASK   0x4000U
 Software owner one mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_WRAP_MASK   0x2000U
 Next buffer descriptor is the start address. More...
 
#define ENET_BUFFDESCRIPTOR_RX_SOFTOWNER2_Mask   0x1000U
 Software owner two mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_LAST_MASK   0x0800U
 Last BD of the frame mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_MISS_MASK   0x0100U
 Received because of the promiscuous mode. More...
 
#define ENET_BUFFDESCRIPTOR_RX_BROADCAST_MASK   0x0080U
 Broadcast packet mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_MULTICAST_MASK   0x0040U
 Multicast packet mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK   0x0020U
 Length violation mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK   0x0010U
 Non-octet aligned frame mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_CRC_MASK   0x0004U
 CRC error mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK   0x0002U
 FIFO overrun mask. More...
 
#define ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK   0x0001U
 Frame is truncated mask. More...
 

Control and status bit masks of the transmit buffer descriptor.

#define ENET_BUFFDESCRIPTOR_TX_READY_MASK   0x8000U
 Ready bit mask. More...
 
#define ENET_BUFFDESCRIPTOR_TX_SOFTOWENER1_MASK   0x4000U
 Software owner one mask. More...
 
#define ENET_BUFFDESCRIPTOR_TX_WRAP_MASK   0x2000U
 Wrap buffer descriptor mask. More...
 
#define ENET_BUFFDESCRIPTOR_TX_SOFTOWENER2_MASK   0x1000U
 Software owner two mask. More...
 
#define ENET_BUFFDESCRIPTOR_TX_LAST_MASK   0x0800U
 Last BD of the frame mask. More...
 
#define ENET_BUFFDESCRIPTOR_TX_TRANMITCRC_MASK   0x0400U
 Transmit CRC mask. More...
 

Defines some Ethernet parameters.

#define ENET_FRAME_MAX_FRAMELEN   1518U
 Default maximum Ethernet frame size. More...
 
#define ENET_FIFO_MIN_RX_FULL   5U
 ENET minimum receive FIFO full. More...
 
#define ENET_RX_MIN_BUFFERSIZE   256U
 ENET minimum buffer size. More...
 
#define ENET_PHY_MAXADDRESS   (ENET_MMFR_PA_MASK >> ENET_MMFR_PA_SHIFT)
 Maximum PHY address. More...
 
#define ENET_TX_INTERRUPT   ((uint32_t)kENET_TxFrameInterrupt | (uint32_t)kENET_TxBufferInterrupt)
 Enet Tx interrupt flag. More...
 
#define ENET_RX_INTERRUPT   ((uint32_t)kENET_RxFrameInterrupt | (uint32_t)kENET_RxBufferInterrupt)
 Enet Rx interrupt flag. More...
 
#define ENET_TS_INTERRUPT   ((uint32_t)kENET_TsTimerInterrupt | (uint32_t)kENET_TsAvailInterrupt)
 Enet timestamp interrupt flag. More...
 
#define ENET_ERR_INTERRUPT
 Enet error interrupt flag. More...
 

Defines Tx operation flags.

#define ENET_TX_LAST_BD_FLAG   0x01U
 Tx set last buffer descriptor flag. More...
 
#define ENET_TX_TIMESTAMP_FLAG   0x02U
 Tx timestamp flag. More...
 

Initialization and De-initialization

void ENET_GetDefaultConfig (enet_config_t *config)
 Gets the ENET default configuration structure. More...
 
void ENET_Up (ENET_Type *base, enet_handle_t *handle, const enet_config_t *config, const enet_buffer_config_t *bufferConfig, uint8_t *macAddr, uint32_t srcClock_Hz)
 Initializes the ENET module. More...
 
void ENET_Init (ENET_Type *base, enet_handle_t *handle, const enet_config_t *config, const enet_buffer_config_t *bufferConfig, uint8_t *macAddr, uint32_t srcClock_Hz)
 Initializes the ENET module. More...
 
void ENET_Down (ENET_Type *base)
 Stops the ENET module. More...
 
void ENET_Deinit (ENET_Type *base)
 Deinitializes the ENET module. More...
 
static void ENET_Reset (ENET_Type *base)
 Resets the ENET module. More...
 

MII interface operation

void ENET_SetMII (ENET_Type *base, enet_mii_speed_t speed, enet_mii_duplex_t duplex)
 Sets the ENET MII speed and duplex. More...
 
void ENET_SetSMI (ENET_Type *base, uint32_t srcClock_Hz, bool isPreambleDisabled)
 Sets the ENET SMI(serial management interface)- MII management interface. More...
 
static bool ENET_GetSMI (ENET_Type *base)
 Gets the ENET SMI- MII management interface configuration. More...
 
static uint32_t ENET_ReadSMIData (ENET_Type *base)
 Reads data from the PHY register through an SMI interface. More...
 
void ENET_StartSMIRead (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, enet_mii_read_t operation)
 Starts an SMI (Serial Management Interface) read command. More...
 
void ENET_StartSMIWrite (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, enet_mii_write_t operation, uint32_t data)
 Starts an SMI write command. More...
 
void ENET_StartExtC45SMIRead (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg)
 Starts the extended IEEE802.3 Clause 45 MDIO format SMI read command. More...
 
void ENET_StartExtC45SMIWrite (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t data)
 Starts the extended IEEE802.3 Clause 45 MDIO format SMI write command. More...
 
void ENET_StartExtC45SMIWriteReg (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg)
 Starts the extended IEEE802.3 Clause 45 MDIO format SMI write register command. More...
 
void ENET_StartExtC45SMIWriteData (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t data)
 Starts the extended IEEE802.3 Clause 45 MDIO format SMI write data command. More...
 
void ENET_StartExtC45SMIReadData (ENET_Type *base, uint32_t phyAddr, uint32_t phyReg)
 Starts the extended IEEE802.3 Clause 45 MDIO format SMI read data command. More...
 

MAC Address Filter

void ENET_SetMacAddr (ENET_Type *base, uint8_t *macAddr)
 Sets the ENET module Mac address. More...
 
void ENET_GetMacAddr (ENET_Type *base, uint8_t *macAddr)
 Gets the ENET module Mac address. More...
 
void ENET_AddMulticastGroup (ENET_Type *base, uint8_t *address)
 Adds the ENET device to a multicast group. More...
 
void ENET_LeaveMulticastGroup (ENET_Type *base, uint8_t *address)
 Moves the ENET device from a multicast group. More...
 

Other basic operation

static void ENET_ActiveRead (ENET_Type *base)
 Activates ENET read or receive. More...
 
static void ENET_EnableSleepMode (ENET_Type *base, bool enable)
 Enables/disables the MAC to enter sleep mode. More...
 
static void ENET_GetAccelFunction (ENET_Type *base, uint32_t *txAccelOption, uint32_t *rxAccelOption)
 Gets ENET transmit and receive accelerator functions from MAC controller. More...
 

Interrupts.

static void ENET_EnableInterrupts (ENET_Type *base, uint32_t mask)
 Enables the ENET interrupt. More...
 
static void ENET_DisableInterrupts (ENET_Type *base, uint32_t mask)
 Disables the ENET interrupt. More...
 
static uint32_t ENET_GetInterruptStatus (ENET_Type *base)
 Gets the ENET interrupt status flag. More...
 
static void ENET_ClearInterruptStatus (ENET_Type *base, uint32_t mask)
 Clears the ENET interrupt events status flag. More...
 
void ENET_SetRxISRHandler (ENET_Type *base, enet_isr_t ISRHandler)
 Set the second level Rx IRQ handler. More...
 
void ENET_SetTxISRHandler (ENET_Type *base, enet_isr_t ISRHandler)
 Set the second level Tx IRQ handler. More...
 
void ENET_SetErrISRHandler (ENET_Type *base, enet_isr_t ISRHandler)
 Set the second level Err IRQ handler. More...
 

Transactional operation

void ENET_SetCallback (enet_handle_t *handle, enet_callback_t callback, void *userData)
 Sets the callback function. More...
 
void ENET_GetRxErrBeforeReadFrame (enet_handle_t *handle, enet_data_error_stats_t *eErrorStatic, uint8_t ringId)
 Gets the error statistics of a received frame for ENET specified ring. More...
 
status_t ENET_GetRxFrameSize (enet_handle_t *handle, uint32_t *length, uint8_t ringId)
 Gets the size of the read frame for specified ring. More...
 
status_t ENET_ReadFrame (ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length, uint8_t ringId, uint32_t *ts)
 Reads a frame from the ENET device. More...
 
status_t ENET_SendFrame (ENET_Type *base, enet_handle_t *handle, const uint8_t *data, uint32_t length, uint8_t ringId, bool tsFlag, void *context)
 Transmits an ENET frame for specified ring. More...
 
status_t ENET_SetTxReclaim (enet_handle_t *handle, bool isEnable, uint8_t ringId)
 Enable or disable tx descriptors reclaim mechanism. More...
 
status_t ENET_GetRxBuffer (ENET_Type *base, enet_handle_t *handle, void **buffer, uint32_t *length, uint8_t ringId, bool *isLastBuff, uint32_t *ts)
 Get a receive buffer pointer of the ENET device for specified ring. More...
 
void ENET_ReleaseRxBuffer (ENET_Type *base, enet_handle_t *handle, void *buffer, uint8_t ringId)
 Release receive buffer descriptor to DMA. More...
 
status_t ENET_SendFrameZeroCopy (ENET_Type *base, enet_handle_t *handle, const uint8_t *data, uint32_t length, uint8_t ringId, bool tsFlag, void *context)
 Transmits an ENET frame for specified ring with zero-copy. More...
 
status_t ENET_SetTxBuffer (ENET_Type *base, enet_handle_t *handle, const uint8_t *data, uint32_t length, uint8_t ringId, uint8_t txFlag, void *context)
 Set up ENET Tx buffer descriptor, preparing for one frame stores in scattered buffer. More...
 
void ENET_TransmitIRQHandler (ENET_Type *base, enet_handle_t *handle)
 The transmit IRQ handler. More...
 
void ENET_ReceiveIRQHandler (ENET_Type *base, enet_handle_t *handle)
 The receive IRQ handler. More...
 
void ENET_ErrorIRQHandler (ENET_Type *base, enet_handle_t *handle)
 Some special IRQ handler including the error, mii, wakeup irq handler. More...
 
void ENET_CommonFrame0IRQHandler (ENET_Type *base)
 the common IRQ handler for the tx/rx/error etc irq handler. More...
 

Data Structure Documentation

struct enet_rx_bd_struct_t

Data Fields

uint16_t length
 Buffer descriptor data length. More...
 
uint16_t control
 Buffer descriptor control and status. More...
 
uint8_t * buffer
 Data buffer pointer. More...
 

Field Documentation

uint16_t enet_rx_bd_struct_t::length
uint16_t enet_rx_bd_struct_t::control
uint8_t* enet_rx_bd_struct_t::buffer
struct enet_tx_bd_struct_t

Data Fields

uint16_t length
 Buffer descriptor data length. More...
 
uint16_t control
 Buffer descriptor control and status. More...
 
uint8_t * buffer
 Data buffer pointer. More...
 

Field Documentation

uint16_t enet_tx_bd_struct_t::length
uint16_t enet_tx_bd_struct_t::control
uint8_t* enet_tx_bd_struct_t::buffer
struct enet_data_error_stats_t

Data Fields

uint32_t statsRxLenGreaterErr
 Receive length greater than RCR[MAX_FL]. More...
 
uint32_t statsRxAlignErr
 Receive non-octet alignment/.
 
uint32_t statsRxFcsErr
 Receive CRC error. More...
 
uint32_t statsRxOverRunErr
 Receive over run. More...
 
uint32_t statsRxTruncateErr
 Receive truncate. More...
 

Field Documentation

uint32_t enet_data_error_stats_t::statsRxLenGreaterErr
uint32_t enet_data_error_stats_t::statsRxFcsErr
uint32_t enet_data_error_stats_t::statsRxOverRunErr
uint32_t enet_data_error_stats_t::statsRxTruncateErr
struct enet_frame_info_t

Data Fields

void * context
 User specified data.
 
struct enet_tx_dirty_ring_t

Data Fields

enet_frame_info_ttxDirtyBase
 Dirty buffer descriptor base address pointer. More...
 
uint16_t txGenIdx
 tx generate index. More...
 
uint16_t txConsumIdx
 tx consume index. More...
 
uint16_t txRingLen
 tx ring length. More...
 
bool isFull
 tx ring is full flag. More...
 

Field Documentation

enet_frame_info_t* enet_tx_dirty_ring_t::txDirtyBase
uint16_t enet_tx_dirty_ring_t::txGenIdx
uint16_t enet_tx_dirty_ring_t::txConsumIdx
uint16_t enet_tx_dirty_ring_t::txRingLen
bool enet_tx_dirty_ring_t::isFull
struct enet_buffer_config_t

Note that for the internal DMA requirements, the buffers have a corresponding alignment requirements.

  1. The aligned receive and transmit buffer size must be evenly divisible by ENET_BUFF_ALIGNMENT. when the data buffers are in cacheable region when cache is enabled, all those size should be aligned to the maximum value of "ENET_BUFF_ALIGNMENT" and the cache line size.
  2. The aligned transmit and receive buffer descriptor start address must be at least 64 bit aligned. However, it's recommended to be evenly divisible by ENET_BUFF_ALIGNMENT. buffer descriptors should be put in non-cacheable region when cache is enabled.
  3. The aligned transmit and receive data buffer start address must be evenly divisible by ENET_BUFF_ALIGNMENT. Receive buffers should be continuous with the total size equal to "rxBdNumber * rxBuffSizeAlign". Transmit buffers should be continuous with the total size equal to "txBdNumber * txBuffSizeAlign". when the data buffers are in cacheable region when cache is enabled, all those size should be aligned to the maximum value of "ENET_BUFF_ALIGNMENT" and the cache line size.

Data Fields

uint16_t rxBdNumber
 Receive buffer descriptor number. More...
 
uint16_t txBdNumber
 Transmit buffer descriptor number. More...
 
uint16_t rxBuffSizeAlign
 Aligned receive data buffer size. More...
 
uint16_t txBuffSizeAlign
 Aligned transmit data buffer size. More...
 
volatile enet_rx_bd_struct_trxBdStartAddrAlign
 Aligned receive buffer descriptor start address: should be non-cacheable. More...
 
volatile enet_tx_bd_struct_ttxBdStartAddrAlign
 Aligned transmit buffer descriptor start address: should be non-cacheable. More...
 
uint8_t * rxBufferAlign
 Receive data buffer start address. More...
 
uint8_t * txBufferAlign
 Transmit data buffer start address. More...
 
bool rxMaintainEnable
 Receive buffer cache maintain. More...
 
bool txMaintainEnable
 Transmit buffer cache maintain. More...
 
enet_frame_info_ttxFrameInfo
 Transmit frame information start address. More...
 

Field Documentation

uint16_t enet_buffer_config_t::rxBdNumber
uint16_t enet_buffer_config_t::txBdNumber
uint16_t enet_buffer_config_t::rxBuffSizeAlign
uint16_t enet_buffer_config_t::txBuffSizeAlign
volatile enet_rx_bd_struct_t* enet_buffer_config_t::rxBdStartAddrAlign
volatile enet_tx_bd_struct_t* enet_buffer_config_t::txBdStartAddrAlign
uint8_t* enet_buffer_config_t::rxBufferAlign
uint8_t* enet_buffer_config_t::txBufferAlign
bool enet_buffer_config_t::rxMaintainEnable
bool enet_buffer_config_t::txMaintainEnable
enet_frame_info_t* enet_buffer_config_t::txFrameInfo
struct enet_intcoalesce_config_t

Data Fields

uint8_t txCoalesceFrameCount [FSL_FEATURE_ENET_QUEUE]
 Transmit interrupt coalescing frame count threshold. More...
 
uint16_t txCoalesceTimeCount [FSL_FEATURE_ENET_QUEUE]
 Transmit interrupt coalescing timer count threshold. More...
 
uint8_t rxCoalesceFrameCount [FSL_FEATURE_ENET_QUEUE]
 Receive interrupt coalescing frame count threshold. More...
 
uint16_t rxCoalesceTimeCount [FSL_FEATURE_ENET_QUEUE]
 Receive interrupt coalescing timer count threshold. More...
 

Field Documentation

uint8_t enet_intcoalesce_config_t::txCoalesceFrameCount[FSL_FEATURE_ENET_QUEUE]
uint16_t enet_intcoalesce_config_t::txCoalesceTimeCount[FSL_FEATURE_ENET_QUEUE]
uint8_t enet_intcoalesce_config_t::rxCoalesceFrameCount[FSL_FEATURE_ENET_QUEUE]
uint16_t enet_intcoalesce_config_t::rxCoalesceTimeCount[FSL_FEATURE_ENET_QUEUE]
struct enet_config_t

Note:

  1. macSpecialConfig is used for a special control configuration, A logical OR of "enet_special_control_flag_t". For a special configuration for MAC, set this parameter to 0.
  2. txWatermark is used for a cut-through operation. It is in steps of 64 bytes: 0/1 - 64 bytes written to TX FIFO before transmission of a frame begins. 2 - 128 bytes written to TX FIFO .... 3 - 192 bytes written to TX FIFO .... The maximum of txWatermark is 0x2F - 4032 bytes written to TX FIFO .... txWatermark allows minimizing the transmit latency to set the txWatermark to 0 or 1 or for larger bus access latency 3 or larger due to contention for the system bus.
  3. rxFifoFullThreshold is similar to the txWatermark for cut-through operation in RX. It is in 64-bit words. The minimum is ENET_FIFO_MIN_RX_FULL and the maximum is 0xFF. If the end of the frame is stored in FIFO and the frame size if smaller than the txWatermark, the frame is still transmitted. The rule is the same for rxFifoFullThreshold in the receive direction.
  4. When "kENET_ControlFlowControlEnable" is set in the macSpecialConfig, ensure that the pauseDuration, rxFifoEmptyThreshold, and rxFifoStatEmptyThreshold are set for flow control enabled case.
  5. When "kENET_ControlStoreAndFwdDisabled" is set in the macSpecialConfig, ensure that the rxFifoFullThreshold and txFifoWatermark are set for store and forward disable.
  6. The rxAccelerConfig and txAccelerConfig default setting with 0 - accelerator are disabled. The "enet_tx_accelerator_t" and "enet_rx_accelerator_t" are recommended to be used to enable the transmit and receive accelerator. After the accelerators are enabled, the store and forward feature should be enabled. As a result, kENET_ControlStoreAndFwdDisabled should not be set.
  7. The intCoalesceCfg can be used in the rx or tx enabled cases to decrese the CPU loading.

Data Fields

uint32_t macSpecialConfig
 Mac special configuration. More...
 
uint32_t interrupt
 Mac interrupt source. More...
 
uint16_t rxMaxFrameLen
 Receive maximum frame length. More...
 
enet_mii_mode_t miiMode
 MII mode. More...
 
enet_mii_speed_t miiSpeed
 MII Speed. More...
 
enet_mii_duplex_t miiDuplex
 MII duplex. More...
 
uint8_t rxAccelerConfig
 Receive accelerator, A logical OR of "enet_rx_accelerator_t". More...
 
uint8_t txAccelerConfig
 Transmit accelerator, A logical OR of "enet_rx_accelerator_t". More...
 
uint16_t pauseDuration
 For flow control enabled case: Pause duration. More...
 
uint8_t rxFifoEmptyThreshold
 For flow control enabled case: when RX FIFO level reaches this value, it makes MAC generate XOFF pause frame. More...
 
uint8_t rxFifoFullThreshold
 
 For store and forward disable case, the data required in RX FIFO to notify

the MAC receive ready status. More...

 
uint8_t txFifoWatermark
 
 For store and forward disable case, the data required in TX FIFO

before a frame transmit start. More...

 
enet_intcoalesce_config_tintCoalesceCfg
 
      If the interrupt coalsecence is not required in the ring n(0,1,2),

please set to NULL. More...

 
uint8_t ringNum
 Number of used rings. More...
 

Field Documentation

uint32_t enet_config_t::macSpecialConfig

A logical OR of "enet_special_control_flag_t".

uint32_t enet_config_t::interrupt

A logical OR of "enet_interrupt_enable_t".

uint16_t enet_config_t::rxMaxFrameLen
enet_mii_mode_t enet_config_t::miiMode
enet_mii_speed_t enet_config_t::miiSpeed
enet_mii_duplex_t enet_config_t::miiDuplex
uint8_t enet_config_t::rxAccelerConfig
uint8_t enet_config_t::txAccelerConfig
uint16_t enet_config_t::pauseDuration
uint8_t enet_config_t::rxFifoEmptyThreshold
uint8_t enet_config_t::rxFifoFullThreshold
uint8_t enet_config_t::txFifoWatermark
enet_intcoalesce_config_t* enet_config_t::intCoalesceCfg
uint8_t enet_config_t::ringNum

default with 1 – single ring.

struct enet_tx_bd_ring_t

Data Fields

volatile enet_tx_bd_struct_ttxBdBase
 Buffer descriptor base address pointer. More...
 
uint16_t txGenIdx
 The current available transmit buffer descriptor pointer. More...
 
uint16_t txConsumIdx
 Transmit consume index. More...
 
volatile uint16_t txDescUsed
 Transmit descriptor used number. More...
 
uint16_t txRingLen
 Transmit ring length. More...
 

Field Documentation

volatile enet_tx_bd_struct_t* enet_tx_bd_ring_t::txBdBase
uint16_t enet_tx_bd_ring_t::txGenIdx
uint16_t enet_tx_bd_ring_t::txConsumIdx
volatile uint16_t enet_tx_bd_ring_t::txDescUsed
uint16_t enet_tx_bd_ring_t::txRingLen
struct enet_rx_bd_ring_t

Data Fields

volatile enet_rx_bd_struct_trxBdBase
 Buffer descriptor base address pointer. More...
 
uint16_t rxGenIdx
 The current available receive buffer descriptor pointer. More...
 
uint16_t rxRingLen
 Receive ring length. More...
 

Field Documentation

volatile enet_rx_bd_struct_t* enet_rx_bd_ring_t::rxBdBase
uint16_t enet_rx_bd_ring_t::rxGenIdx
uint16_t enet_rx_bd_ring_t::rxRingLen
struct _enet_handle

Data Fields

enet_rx_bd_ring_t rxBdRing [FSL_FEATURE_ENET_QUEUE]
 Receive buffer descriptor. More...
 
enet_tx_bd_ring_t txBdRing [FSL_FEATURE_ENET_QUEUE]
 Transmit buffer descriptor. More...
 
uint16_t rxBuffSizeAlign [FSL_FEATURE_ENET_QUEUE]
 Receive buffer size alignment. More...
 
uint16_t txBuffSizeAlign [FSL_FEATURE_ENET_QUEUE]
 Transmit buffer size alignment. More...
 
bool rxMaintainEnable [FSL_FEATURE_ENET_QUEUE]
 Receive buffer cache maintain. More...
 
bool txMaintainEnable [FSL_FEATURE_ENET_QUEUE]
 Transmit buffer cache maintain. More...
 
uint8_t ringNum
 Number of used rings. More...
 
enet_callback_t callback
 Callback function. More...
 
void * userData
 Callback function parameter. More...
 
enet_tx_dirty_ring_t txDirtyRing [FSL_FEATURE_ENET_QUEUE]
 Ring to store tx frame information. More...
 
bool TxReclaimEnable [FSL_FEATURE_ENET_QUEUE]
 Tx reclaim enable flag. More...
 

Field Documentation

enet_rx_bd_ring_t enet_handle_t::rxBdRing[FSL_FEATURE_ENET_QUEUE]
enet_tx_bd_ring_t enet_handle_t::txBdRing[FSL_FEATURE_ENET_QUEUE]
uint16_t enet_handle_t::rxBuffSizeAlign[FSL_FEATURE_ENET_QUEUE]
uint16_t enet_handle_t::txBuffSizeAlign[FSL_FEATURE_ENET_QUEUE]
bool enet_handle_t::rxMaintainEnable[FSL_FEATURE_ENET_QUEUE]
bool enet_handle_t::txMaintainEnable[FSL_FEATURE_ENET_QUEUE]
uint8_t enet_handle_t::ringNum
enet_callback_t enet_handle_t::callback
void* enet_handle_t::userData
enet_tx_dirty_ring_t enet_handle_t::txDirtyRing[FSL_FEATURE_ENET_QUEUE]
bool enet_handle_t::TxReclaimEnable[FSL_FEATURE_ENET_QUEUE]

Macro Definition Documentation

#define FSL_ENET_DRIVER_VERSION   (MAKE_VERSION(2, 3, 0))

Version 2.3.0.

#define ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK   0x8000U
#define ENET_BUFFDESCRIPTOR_RX_SOFTOWNER1_MASK   0x4000U
#define ENET_BUFFDESCRIPTOR_RX_WRAP_MASK   0x2000U
#define ENET_BUFFDESCRIPTOR_RX_SOFTOWNER2_Mask   0x1000U
#define ENET_BUFFDESCRIPTOR_RX_LAST_MASK   0x0800U
#define ENET_BUFFDESCRIPTOR_RX_MISS_MASK   0x0100U
#define ENET_BUFFDESCRIPTOR_RX_BROADCAST_MASK   0x0080U
#define ENET_BUFFDESCRIPTOR_RX_MULTICAST_MASK   0x0040U
#define ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK   0x0020U
#define ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK   0x0010U
#define ENET_BUFFDESCRIPTOR_RX_CRC_MASK   0x0004U
#define ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK   0x0002U
#define ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK   0x0001U
#define ENET_BUFFDESCRIPTOR_TX_READY_MASK   0x8000U
#define ENET_BUFFDESCRIPTOR_TX_SOFTOWENER1_MASK   0x4000U
#define ENET_BUFFDESCRIPTOR_TX_WRAP_MASK   0x2000U
#define ENET_BUFFDESCRIPTOR_TX_SOFTOWENER2_MASK   0x1000U
#define ENET_BUFFDESCRIPTOR_TX_LAST_MASK   0x0800U
#define ENET_BUFFDESCRIPTOR_TX_TRANMITCRC_MASK   0x0400U
#define ENET_BUFFDESCRIPTOR_RX_ERR_MASK
Value:
#define ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK
FIFO overrun mask.
Definition: fsl_enet.h:51
#define ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK
Frame is truncated mask.
Definition: fsl_enet.h:52
#define ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK
Non-octet aligned frame mask.
Definition: fsl_enet.h:49
#define ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK
Length violation mask.
Definition: fsl_enet.h:48
#define ENET_BUFFDESCRIPTOR_RX_CRC_MASK
CRC error mask.
Definition: fsl_enet.h:50
#define ENET_FRAME_MAX_FRAMELEN   1518U
#define ENET_FIFO_MIN_RX_FULL   5U
#define ENET_RX_MIN_BUFFERSIZE   256U
#define ENET_PHY_MAXADDRESS   (ENET_MMFR_PA_MASK >> ENET_MMFR_PA_SHIFT)
#define ENET_TX_INTERRUPT   ((uint32_t)kENET_TxFrameInterrupt | (uint32_t)kENET_TxBufferInterrupt)
#define ENET_RX_INTERRUPT   ((uint32_t)kENET_RxFrameInterrupt | (uint32_t)kENET_RxBufferInterrupt)
#define ENET_TS_INTERRUPT   ((uint32_t)kENET_TsTimerInterrupt | (uint32_t)kENET_TsAvailInterrupt)
#define ENET_ERR_INTERRUPT
Value:
((uint32_t)kENET_BabrInterrupt | (uint32_t)kENET_BabtInterrupt | (uint32_t)kENET_EBusERInterrupt | \
Babbling receive error interrupt source.
Definition: fsl_enet.h:257
Ethernet bus error interrupt source.
Definition: fsl_enet.h:265
Babbling transmit error interrupt source.
Definition: fsl_enet.h:258
Transmit FIFO underrun interrupt source.
Definition: fsl_enet.h:268
Collision Retry Limit interrupt source.
Definition: fsl_enet.h:267
Late collision interrupt source.
Definition: fsl_enet.h:266
Payload Receive error interrupt source.
Definition: fsl_enet.h:269
#define ENET_TX_LAST_BD_FLAG   0x01U
#define ENET_TX_TIMESTAMP_FLAG   0x02U

Typedef Documentation

typedef void(* enet_callback_t)(ENET_Type *base, enet_handle_t *handle,enet_event_t event, enet_frame_info_t *frameInfo, void *userData)
typedef void(* enet_isr_t)(ENET_Type *base, enet_handle_t *handle)

Enumeration Type Documentation

anonymous enum
Enumerator
kStatus_ENET_RxFrameError 

A frame received but data error happen.

kStatus_ENET_RxFrameFail 

Failed to receive a frame.

kStatus_ENET_RxFrameEmpty 

No frame arrive.

kStatus_ENET_TxFrameOverLen 

Tx frame over length.

kStatus_ENET_TxFrameBusy 

Tx buffer descriptors are under process.

kStatus_ENET_TxFrameFail 

Transmit frame fail.

Enumerator
kENET_MiiMode 

MII mode for data interface.

kENET_RmiiMode 

RMII mode for data interface.

Notice: "kENET_MiiSpeed1000M" only supported when mii mode is "kENET_RgmiiMode".

Enumerator
kENET_MiiSpeed10M 

Speed 10 Mbps.

kENET_MiiSpeed100M 

Speed 100 Mbps.

Enumerator
kENET_MiiHalfDuplex 

Half duplex mode.

kENET_MiiFullDuplex 

Full duplex mode.

Enumerator
kENET_MiiWriteNoCompliant 

Write frame operation, but not MII-compliant.

kENET_MiiWriteValidFrame 

Write frame operation for a valid MII management frame.

Enumerator
kENET_MiiReadValidFrame 

Read frame operation for a valid MII management frame.

kENET_MiiReadNoCompliant 

Read frame operation, but not MII-compliant.

Enumerator
kENET_MiiAddrWrite_C45 

Address Write operation.

kENET_MiiWriteFrame_C45 

Write frame operation for a valid MII management frame.

kENET_MiiReadFrame_C45 

Read frame operation for a valid MII management frame.

These control flags are provided for special user requirements. Normally, these control flags are unused for ENET initialization. For special requirements, set the flags to macSpecialConfig in the enet_config_t. The kENET_ControlStoreAndFwdDisable is used to disable the FIFO store and forward. FIFO store and forward means that the FIFO read/send is started when a complete frame is stored in TX/RX FIFO. If this flag is set, configure rxFifoFullThreshold and txFifoWatermark in the enet_config_t.

Enumerator
kENET_ControlFlowControlEnable 

Enable ENET flow control: pause frame.

kENET_ControlRxPayloadCheckEnable 

Enable ENET receive payload length check.

kENET_ControlRxPadRemoveEnable 

Padding is removed from received frames.

kENET_ControlRxBroadCastRejectEnable 

Enable broadcast frame reject.

kENET_ControlMacAddrInsert 

Enable MAC address insert.

kENET_ControlStoreAndFwdDisable 

Enable FIFO store and forward.

kENET_ControlSMIPreambleDisable 

Enable SMI preamble.

kENET_ControlPromiscuousEnable 

Enable promiscuous mode.

kENET_ControlMIILoopEnable 

Enable ENET MII loop back.

kENET_ControlVLANTagEnable 

Enable normal VLAN (single vlan tag).

This enumeration uses one-bot encoding to allow a logical OR of multiple members. Members usually map to interrupt enable bits in one or more peripheral registers.

Enumerator
kENET_BabrInterrupt 

Babbling receive error interrupt source.

kENET_BabtInterrupt 

Babbling transmit error interrupt source.

kENET_GraceStopInterrupt 

Graceful stop complete interrupt source.

kENET_TxFrameInterrupt 

TX FRAME interrupt source.

kENET_TxBufferInterrupt 

TX BUFFER interrupt source.

kENET_RxFrameInterrupt 

RX FRAME interrupt source.

kENET_RxBufferInterrupt 

RX BUFFER interrupt source.

kENET_MiiInterrupt 

MII interrupt source.

kENET_EBusERInterrupt 

Ethernet bus error interrupt source.

kENET_LateCollisionInterrupt 

Late collision interrupt source.

kENET_RetryLimitInterrupt 

Collision Retry Limit interrupt source.

kENET_UnderrunInterrupt 

Transmit FIFO underrun interrupt source.

kENET_PayloadRxInterrupt 

Payload Receive error interrupt source.

kENET_WakeupInterrupt 

WAKEUP interrupt source.

kENET_TsAvailInterrupt 

TS AVAIL interrupt source for PTP.

kENET_TsTimerInterrupt 

TS WRAP interrupt source for PTP.

Enumerator
kENET_RxEvent 

Receive event.

kENET_TxEvent 

Transmit event.

kENET_ErrEvent 

Error event: BABR/BABT/EBERR/LC/RL/UN/PLR .

kENET_WakeUpEvent 

Wake up from sleep mode event.

kENET_TimeStampEvent 

Time stamp event.

kENET_TimeStampAvailEvent 

Time stamp available event.

Enumerator
kENET_TxAccelIsShift16Enabled 

Transmit FIFO shift-16.

kENET_TxAccelIpCheckEnabled 

Insert IP header checksum.

kENET_TxAccelProtoCheckEnabled 

Insert protocol checksum.

Enumerator
kENET_RxAccelPadRemoveEnabled 

Padding removal for short IP frames.

kENET_RxAccelIpCheckEnabled 

Discard with wrong IP header checksum.

kENET_RxAccelProtoCheckEnabled 

Discard with wrong protocol checksum.

kENET_RxAccelMacCheckEnabled 

Discard with Mac layer errors.

kENET_RxAccelisShift16Enabled 

Receive FIFO shift-16.

Function Documentation

uint32_t ENET_GetInstance ( ENET_Type *  base)
Parameters
baseENET peripheral base address.
Returns
ENET instance.
void ENET_GetDefaultConfig ( enet_config_t config)

The purpose of this API is to get the default ENET MAC controller configure structure for ENET_Init(). User may use the initialized structure unchanged in ENET_Init(), or modify some fields of the structure before calling ENET_Init(). Example:

Parameters
configThe ENET mac controller configuration structure pointer.
void ENET_Up ( ENET_Type *  base,
enet_handle_t *  handle,
const enet_config_t config,
const enet_buffer_config_t bufferConfig,
uint8_t *  macAddr,
uint32_t  srcClock_Hz 
)

This function initializes the module with the ENET configuration.

Note
ENET has two buffer descriptors legacy buffer descriptors and enhanced IEEE 1588 buffer descriptors. The legacy descriptor is used by default. To use the IEEE 1588 feature, use the enhanced IEEE 1588 buffer descriptor by defining "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" and calling ENET_Ptp1588Configure() to configure the 1588 feature and related buffers after calling ENET_Up().
Parameters
baseENET peripheral base address.
handleENET handler pointer.
configENET mac configuration structure pointer. The "enet_config_t" type mac configuration return from ENET_GetDefaultConfig can be used directly. It is also possible to verify the Mac configuration using other methods.
bufferConfigENET buffer configuration structure pointer. The buffer configuration should be prepared for ENET Initialization. It is the start address of "ringNum" enet_buffer_config structures. To support added multi-ring features in some soc and compatible with the previous enet driver version. For single ring supported, this bufferConfig is a buffer configure structure pointer, for multi-ring supported and used case, this bufferConfig pointer should be a buffer configure structure array pointer.
macAddrENET mac address of Ethernet device. This MAC address should be provided.
srcClock_HzThe internal module clock source for MII clock.
void ENET_Init ( ENET_Type *  base,
enet_handle_t *  handle,
const enet_config_t config,
const enet_buffer_config_t bufferConfig,
uint8_t *  macAddr,
uint32_t  srcClock_Hz 
)

This function ungates the module clock and initializes it with the ENET configuration.

Note
ENET has two buffer descriptors legacy buffer descriptors and enhanced IEEE 1588 buffer descriptors. The legacy descriptor is used by default. To use the IEEE 1588 feature, use the enhanced IEEE 1588 buffer descriptor by defining "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" and calling ENET_Ptp1588Configure() to configure the 1588 feature and related buffers after calling ENET_Init().
Parameters
baseENET peripheral base address.
handleENET handler pointer.
configENET mac configuration structure pointer. The "enet_config_t" type mac configuration return from ENET_GetDefaultConfig can be used directly. It is also possible to verify the Mac configuration using other methods.
bufferConfigENET buffer configuration structure pointer. The buffer configuration should be prepared for ENET Initialization. It is the start address of "ringNum" enet_buffer_config structures. To support added multi-ring features in some soc and compatible with the previous enet driver version. For single ring supported, this bufferConfig is a buffer configure structure pointer, for multi-ring supported and used case, this bufferConfig pointer should be a buffer configure structure array pointer.
macAddrENET mac address of Ethernet device. This MAC address should be provided.
srcClock_HzThe internal module clock source for MII clock.
void ENET_Down ( ENET_Type *  base)

This function disables the ENET module.

Parameters
baseENET peripheral base address.
void ENET_Deinit ( ENET_Type *  base)

This function gates the module clock, clears ENET interrupts, and disables the ENET module.

Parameters
baseENET peripheral base address.
static void ENET_Reset ( ENET_Type *  base)
inlinestatic

This function restores the ENET module to reset state. Note that this function sets all registers to reset state. As a result, the ENET module can't work after calling this function.

Parameters
baseENET peripheral base address.
void ENET_SetMII ( ENET_Type *  base,
enet_mii_speed_t  speed,
enet_mii_duplex_t  duplex 
)

This API is provided to dynamically change the speed and dulpex for MAC.

Parameters
baseENET peripheral base address.
speedThe speed of the RMII mode.
duplexThe duplex of the RMII mode.
void ENET_SetSMI ( ENET_Type *  base,
uint32_t  srcClock_Hz,
bool  isPreambleDisabled 
)
Parameters
baseENET peripheral base address.
srcClock_HzThis is the ENET module clock frequency. Normally it's the system clock. See clock distribution.
isPreambleDisabledThe preamble disable flag.
  • true Enables the preamble.
  • false Disables the preamble.
static bool ENET_GetSMI ( ENET_Type *  base)
inlinestatic

This API is used to get the SMI configuration to check whether the MII management interface has been set.

Parameters
baseENET peripheral base address.
Returns
The SMI setup status true or false.
static uint32_t ENET_ReadSMIData ( ENET_Type *  base)
inlinestatic
Parameters
baseENET peripheral base address.
Returns
The data read from PHY
void ENET_StartSMIRead ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg,
enet_mii_read_t  operation 
)

Used for standard IEEE802.3 MDIO Clause 22 format.

Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. Range from 0 ~ 31.
operationThe read operation.
void ENET_StartSMIWrite ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg,
enet_mii_write_t  operation,
uint32_t  data 
)

Used for standard IEEE802.3 MDIO Clause 22 format.

Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. Range from 0 ~ 31.
operationThe write operation.
dataThe data written to PHY.
void ENET_StartExtC45SMIRead ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg 
)
Deprecated:
Do not use this function. It has been superceded by ENET_StartExtC45SMIWriteReg and ENET_StartExtC45SMIReadData.
Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. For MDIO IEEE802.3 Clause 45, the phyReg is a 21-bits combination of the devaddr (5 bits device address) and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr.
void ENET_StartExtC45SMIWrite ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg,
uint32_t  data 
)
Deprecated:
Do not use this function. It has been superceded by ENET_StartExtC45SMIWriteReg and ENET_StartExtC45SMIWriteData.
Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. For MDIO IEEE802.3 Clause 45, the phyReg is a 21-bits combination of the devaddr (5 bits device address) and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr.
dataThe data written to PHY.
void ENET_StartExtC45SMIWriteReg ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg 
)
Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. For MDIO IEEE802.3 Clause 45, the phyReg is a 21-bits combination of the devaddr (5 bits device address) and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr.
void ENET_StartExtC45SMIWriteData ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg,
uint32_t  data 
)

After writing MMFR register, we need to check whether the transmission is over. This is an example for whole precedure of clause 45 MDIO write.

* ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK);
* ENET_StartExtC45SMIWriteReg(base, phyAddr, phyReg);
* while ((ENET_GetInterruptStatus(base) & ENET_EIR_MII_MASK) == 0U)
* {
* }
* ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK);
* ENET_StartExtC45SMIWriteData(base, phyAddr, phyReg, data);
* while ((ENET_GetInterruptStatus(base) & ENET_EIR_MII_MASK) == 0U)
* {
* }
* ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK);
*
Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. For MDIO IEEE802.3 Clause 45, the phyReg is a 21-bits combination of the devaddr (5 bits device address) and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr.
dataThe data written to PHY.
void ENET_StartExtC45SMIReadData ( ENET_Type *  base,
uint32_t  phyAddr,
uint32_t  phyReg 
)

After writing MMFR register, we need to check whether the transmission is over. This is an example for whole precedure of clause 45 MDIO read.

* uint32_t data;
* ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK);
* ENET_StartExtC45SMIWriteReg(base, phyAddr, phyReg);
* while ((ENET_GetInterruptStatus(base) & ENET_EIR_MII_MASK) == 0U)
* {
* }
* ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK);
* ENET_StartExtC45SMIReadData(base, phyAddr, phyReg);
* while ((ENET_GetInterruptStatus(base) & ENET_EIR_MII_MASK) == 0U)
* {
* }
* ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK);
* data = ENET_ReadSMIData(base);
*
Parameters
baseENET peripheral base address.
phyAddrThe PHY address.
phyRegThe PHY register. For MDIO IEEE802.3 Clause 45, the phyReg is a 21-bits combination of the devaddr (5 bits device address) and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr.
void ENET_SetMacAddr ( ENET_Type *  base,
uint8_t *  macAddr 
)
Parameters
baseENET peripheral base address.
macAddrThe six-byte Mac address pointer. The pointer is allocated by application and input into the API.
void ENET_GetMacAddr ( ENET_Type *  base,
uint8_t *  macAddr 
)
Parameters
baseENET peripheral base address.
macAddrThe six-byte Mac address pointer. The pointer is allocated by application and input into the API.
void ENET_AddMulticastGroup ( ENET_Type *  base,
uint8_t *  address 
)
Parameters
baseENET peripheral base address.
addressThe six-byte multicast group address which is provided by application.
void ENET_LeaveMulticastGroup ( ENET_Type *  base,
uint8_t *  address 
)
Parameters
baseENET peripheral base address.
addressThe six-byte multicast group address which is provided by application.
static void ENET_ActiveRead ( ENET_Type *  base)
inlinestatic

This function is to active the enet read process.

Note
This must be called after the MAC configuration and state are ready. It must be called after the ENET_Init() and ENET_Ptp1588Configure(). This should be called when the ENET receive required.
Parameters
baseENET peripheral base address.
static void ENET_EnableSleepMode ( ENET_Type *  base,
bool  enable 
)
inlinestatic

This function is used to set the MAC enter sleep mode. When entering sleep mode, the magic frame wakeup interrupt should be enabled to wake up MAC from the sleep mode and reset it to normal mode.

Parameters
baseENET peripheral base address.
enableTrue enable sleep mode, false disable sleep mode.
static void ENET_GetAccelFunction ( ENET_Type *  base,
uint32_t *  txAccelOption,
uint32_t *  rxAccelOption 
)
inlinestatic
Parameters
baseENET peripheral base address.
txAccelOptionThe transmit accelerator option. The "enet_tx_accelerator_t" is recommended to be used to as the mask to get the exact the accelerator option.
rxAccelOptionThe receive accelerator option. The "enet_rx_accelerator_t" is recommended to be used to as the mask to get the exact the accelerator option.
static void ENET_EnableInterrupts ( ENET_Type *  base,
uint32_t  mask 
)
inlinestatic

This function enables the ENET interrupt according to the provided mask. The mask is a logical OR of enumeration members. See enet_interrupt_enable_t. For example, to enable the TX frame interrupt and RX frame interrupt, do the following.

Parameters
baseENET peripheral base address.
maskENET interrupts to enable. This is a logical OR of the enumeration enet_interrupt_enable_t.
static void ENET_DisableInterrupts ( ENET_Type *  base,
uint32_t  mask 
)
inlinestatic

This function disables the ENET interrupts according to the provided mask. The mask is a logical OR of enumeration members. See :enet_interrupt_enable_t. For example, to disable the TX frame interrupt and RX frame interrupt, do the following.

Parameters
baseENET peripheral base address.
maskENET interrupts to disable. This is a logical OR of the enumeration enet_interrupt_enable_t.
static uint32_t ENET_GetInterruptStatus ( ENET_Type *  base)
inlinestatic
Parameters
baseENET peripheral base address.
Returns
The event status of the interrupt source. This is the logical OR of members of the enumeration enet_interrupt_enable_t.
static void ENET_ClearInterruptStatus ( ENET_Type *  base,
uint32_t  mask 
)
inlinestatic

This function clears enabled ENET interrupts according to the provided mask. The mask is a logical OR of enumeration members. See the enet_interrupt_enable_t. For example, to clear the TX frame interrupt and RX frame interrupt, do the following.

Parameters
baseENET peripheral base address.
maskENET interrupt source to be cleared. This is the logical OR of members of the enumeration enet_interrupt_enable_t.
void ENET_SetRxISRHandler ( ENET_Type *  base,
enet_isr_t  ISRHandler 
)
Parameters
baseENET peripheral base address.
ISRHandlerThe handler to install.
void ENET_SetTxISRHandler ( ENET_Type *  base,
enet_isr_t  ISRHandler 
)
Parameters
baseENET peripheral base address.
ISRHandlerThe handler to install.
void ENET_SetErrISRHandler ( ENET_Type *  base,
enet_isr_t  ISRHandler 
)
Parameters
baseENET peripheral base address.
ISRHandlerThe handler to install.
void ENET_SetCallback ( enet_handle_t *  handle,
enet_callback_t  callback,
void *  userData 
)

This API is provided for the application callback required case when ENET interrupt is enabled. This API should be called after calling ENET_Init.

Parameters
handleENET handler pointer. Should be provided by application.
callbackThe ENET callback function.
userDataThe callback function parameter.
void ENET_GetRxErrBeforeReadFrame ( enet_handle_t *  handle,
enet_data_error_stats_t eErrorStatic,
uint8_t  ringId 
)

This API must be called after the ENET_GetRxFrameSize and before the ENET_ReadFrame(). If the ENET_GetRxFrameSize returns kStatus_ENET_RxFrameError, the ENET_GetRxErrBeforeReadFrame can be used to get the exact error statistics. This is an example.

* status = ENET_GetRxFrameSize(&g_handle, &length, 0);
* if (status == kStatus_ENET_RxFrameError)
* {
* Comments: Get the error information of the received frame.
* ENET_GetRxErrBeforeReadFrame(&g_handle, &eErrStatic, 0);
* Comments: update the receive buffer.
* ENET_ReadFrame(EXAMPLE_ENET, &g_handle, NULL, 0);
* }
*
Parameters
handleThe ENET handler structure pointer. This is the same handler pointer used in the ENET_Init.
eErrorStaticThe error statistics structure pointer.
ringIdThe ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1.
status_t ENET_GetRxFrameSize ( enet_handle_t *  handle,
uint32_t *  length,
uint8_t  ringId 
)

This function gets a received frame size from the ENET buffer descriptors.

Note
The FCS of the frame is automatically removed by MAC and the size is the length without the FCS. After calling ENET_GetRxFrameSize, ENET_ReadFrame() should be called to update the receive buffers if the result is not "kStatus_ENET_RxFrameEmpty".
Parameters
handleThe ENET handler structure. This is the same handler pointer used in the ENET_Init.
lengthThe length of the valid frame received.
ringIdThe ring index or ring number.
Return values
kStatus_ENET_RxFrameEmptyNo frame received. Should not call ENET_ReadFrame to read frame.
kStatus_ENET_RxFrameErrorData error happens. ENET_ReadFrame should be called with NULL data and NULL length to update the receive buffers.
kStatus_SuccessReceive a frame Successfully then the ENET_ReadFrame should be called with the right data buffer and the captured data length input.
status_t ENET_ReadFrame ( ENET_Type *  base,
enet_handle_t *  handle,
uint8_t *  data,
uint32_t  length,
uint8_t  ringId,
uint32_t *  ts 
)

This function reads a frame (both the data and the length) from the ENET buffer descriptors. User can get timestamp through ts pointer if the ts is not NULL. Note that it doesn't store the timestamp in the receive timestamp queue. The ENET_GetRxFrameSize should be used to get the size of the prepared data buffer. This is an example:

* uint32_t length;
* enet_handle_t g_handle;
* Comments: Get the received frame size firstly.
* status = ENET_GetRxFrameSize(&g_handle, &length, 0);
* if (length != 0)
* {
* Comments: Allocate memory here with the size of "length"
* uint8_t *data = memory allocate interface;
* if (!data)
* {
* ENET_ReadFrame(ENET, &g_handle, NULL, 0, 0, NULL);
* Comments: Add the console warning log.
* }
* else
* {
* status = ENET_ReadFrame(ENET, &g_handle, data, length, 0, NULL);
* Comments: Call stack input API to deliver the data to stack
* }
* }
* else if (status == kStatus_ENET_RxFrameError)
* {
* Comments: Update the received buffer when a error frame is received.
* ENET_ReadFrame(ENET, &g_handle, NULL, 0, 0, NULL);
* }
*
Parameters
baseENET peripheral base address.
handleThe ENET handler structure. This is the same handler pointer used in the ENET_Init.
dataThe data buffer provided by user to store the frame which memory size should be at least "length".
lengthThe size of the data buffer which is still the length of the received frame.
ringIdThe ring index or ring number.
tsThe timestamp address to store received timestamp.
Returns
The execute status, successful or failure.
status_t ENET_SendFrame ( ENET_Type *  base,
enet_handle_t *  handle,
const uint8_t *  data,
uint32_t  length,
uint8_t  ringId,
bool  tsFlag,
void *  context 
)
Note
The CRC is automatically appended to the data. Input the data to send without the CRC.
Parameters
baseENET peripheral base address.
handleThe ENET handler pointer. This is the same handler pointer used in the ENET_Init.
dataThe data buffer provided by user to send.
lengthThe length of the data to send.
ringIdThe ring index or ring number.
tsFlagTimestamp enable flag.
contextUsed by user to handle some events after transmit over.
Return values
kStatus_SuccessSend frame succeed.
kStatus_ENET_TxFrameBusyTransmit buffer descriptor is busy under transmission. The transmit busy happens when the data send rate is over the MAC capacity. The waiting mechanism is recommended to be added after each call return with kStatus_ENET_TxFrameBusy.
status_t ENET_SetTxReclaim ( enet_handle_t *  handle,
bool  isEnable,
uint8_t  ringId 
)
Note
This function must be called when no pending send frame action. Set enable if you want to reclaim context or timestamp in interrupt.
Parameters
handleThe ENET handler pointer. This is the same handler pointer used in the ENET_Init.
isEnableEnable or disable flag.
ringIdThe ring index or ring number.
Return values
kStatus_SuccessSucceed to enable/disable Tx reclaim.
kStatus_FailFail to enable/disable Tx reclaim.
status_t ENET_GetRxBuffer ( ENET_Type *  base,
enet_handle_t *  handle,
void **  buffer,
uint32_t *  length,
uint8_t  ringId,
bool *  isLastBuff,
uint32_t *  ts 
)

This function can get the data address which stores frame. Then can analyze these data directly without doing any memory copy. When the frame locates in multiple BD buffer, need to repeat calling this function until isLastBuff=true (need to store the temp buf pointer everytime call this function). After finishing the analysis of this frame, call ENET_ReleaseRxBuffer to release rxbuff memory to DMA. This is an example:

* uint32_t length;
* uint8_t *buf = NULL;
* uint32_t data_len = 0;
* bool isLastBuff = false;
* enet_handle_t g_handle;
* status_t status;
* status = ENET_GetRxFrameSize(&g_handle, &length, 0);
* if (length != 0)
* {
* ENET_GetRxBuffer(EXAMPLE_ENET, &g_handle, &buf, &data_len, 0, &isLastBuff, NULL);
* ENET_ReleaseRxBuffer(EXAMPLE_ENET, &g_handle, buf, 0);
* }
*
Parameters
baseENET peripheral base address.
handleThe ENET handler structure. This is the same handler pointer used in the ENET_Init.
bufferThe data buffer pointer to store the frame.
lengthThe size of the data buffer. If isLastBuff=false, it represents data length of this buffer. If isLastBuff=true, it represents data length of total frame.
ringIdThe ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1.
isLastBuffThe flag represents whether this buffer is the last buffer to store frame.
tsThe 1588 timestamp value, vaild in last buffer.
Return values
kStatus_SuccessGet receive buffer succeed.
kStatus_ENET_RxFrameFailGet receive buffer fails, it's owned by application, should wait app to release this buffer.
void ENET_ReleaseRxBuffer ( ENET_Type *  base,
enet_handle_t *  handle,
void *  buffer,
uint8_t  ringId 
)

This function can release specified BD owned by application, meanwhile it may rearrange the BD to let the no-owned BDs always in back of the index of DMA transfer. So for the situation that releasing order is not same as the getting order, the rearrangement makes all ready BDs can be used by DMA.

Note
This function can't be interrupted by ENET_GetRxBuffer, so in application must make sure ENET_GetRxBuffer is called before or after this function. And this function itself isn't thread safe due to BD content exchanging.
Parameters
baseENET peripheral base address.
handleThe ENET handler structure. This is the same handler pointer used in the ENET_Init.
bufferThe buffer address to store frame, using it to find the correspond BD and release it.
ringIdThe ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1.
status_t ENET_SendFrameZeroCopy ( ENET_Type *  base,
enet_handle_t *  handle,
const uint8_t *  data,
uint32_t  length,
uint8_t  ringId,
bool  tsFlag,
void *  context 
)
Note
The CRC is automatically appended to the data. Input the data to send without the CRC. The frame must store in continuous memeory and need to check the buffer start address alignment based on your device, otherwise it has issue or can't get highest DMA transmit speed.
Parameters
baseENET peripheral base address.
handleThe ENET handler pointer. This is the same handler pointer used in the ENET_Init.
dataThe data buffer provided by user to send.
lengthThe length of the data to send.
ringIdThe ring index or ring number.
tsFlagTimestamp enable flag.
contextUsed by user to handle some events after transmit over.
Return values
kStatus_SuccessSend frame succeed.
kStatus_ENET_TxFrameBusyTransmit buffer descriptor is busy under transmission. The transmit busy happens when the data send rate is over the MAC capacity. The waiting mechanism is recommended to be added after each call return with kStatus_ENET_TxFrameBusy.
status_t ENET_SetTxBuffer ( ENET_Type *  base,
enet_handle_t *  handle,
const uint8_t *  data,
uint32_t  length,
uint8_t  ringId,
uint8_t  txFlag,
void *  context 
)

This function only set one Tx BD everytime calls, all ready data will be sent out with last flag sets or gets error. Send frame succeeds with last flag sets, then you can get context from frameInfo in callback.

Note
The CRC is automatically appended to the data. Input the data to send without the CRC. And if doesn't succeed to call this function, user can't get context in frameInfo of callback.
Parameters
baseENET peripheral base address.
handleThe ENET handler pointer. This is the same handler pointer used in the ENET_Init.
dataThe data buffer provided by user to send.
lengthThe length of the data to send.
ringIdThe ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1.
txFlagThis function uses timestamp enable flag, last BD flag.
contextUsed by user to handle some events after transmit over.
Return values
kStatus_SuccessSend frame succeed.
kStatus_ENET_TxFrameOverLenBuffer length isn't enough to store data.
kStatus_ENET_TxFrameBusyTransmit buffer descriptor is busy under transmission. The transmit busy happens when the data send rate is over the MAC capacity.
void ENET_TransmitIRQHandler ( ENET_Type *  base,
enet_handle_t *  handle 
)
Parameters
baseENET peripheral base address.
handleThe ENET handler pointer.
void ENET_ReceiveIRQHandler ( ENET_Type *  base,
enet_handle_t *  handle 
)
Parameters
baseENET peripheral base address.
handleThe ENET handler pointer.
void ENET_ErrorIRQHandler ( ENET_Type *  base,
enet_handle_t *  handle 
)
Parameters
baseENET peripheral base address.
handleThe ENET handler pointer.
void ENET_CommonFrame0IRQHandler ( ENET_Type *  base)

This is used for the combined tx/rx/error interrupt for single/mutli-ring (frame 0).

Parameters
baseENET peripheral base address.