text: 
  /**
   * @file xmc_eth_mac.h
   * @date 2018-08-08
   *
   * @cond
   *********************************************************************************************************************
   * XMClib v2.1.24 - XMC Peripheral Driver Library 
   *
   * Copyright (c) 2015-2019, Infineon Technologies AG
   * All rights reserved.                        
   *                                             
   * Redistribution and use in source and binary forms, with or without modification,are permitted provided that the 
   * following conditions are met:   
   *                                                                              
   * Redistributions of source code must retain the above copyright notice, this list of conditions and the following 
   * disclaimer.                        
   * 
   * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following 
   * disclaimer in the documentation and/or other materials provided with the distribution.                       
   * 
   * Neither the name of the copyright holders nor the names of its contributors may be used to endorse or promote 
   * products derived from this software without specific prior written permission.                                           
   *                                                                              
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE  
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE  FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
   * WHETHER IN CONTRACT, STRICT LIABILITY,OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                                  
   *                                                                              
   * To improve the quality of the software, users are encouraged to share modifications, enhancements or bug fixes with 
   * Infineon Technologies AG dave@infineon.com).                                                          
   *********************************************************************************************************************
   *
   * Change History
   * --------------
   *
   * 2015-06-20:
   *     - Initial
   *
   * 2016-04-25:
   *     - Change XMC_ETH_MAC_BUF_SIZE to 1524 to allow for Tagged MAC frame format
   *  
   * 2016-05-19:
   *      - Added XMC_ETH_MAC_GetTxBuffer() and XMC_ETH_MAC_GetRxBuffer()
   *      - Added XMC_ETH_MAC_SetTxBufferSize()
   *
   * 2016-06-08:
   *      - Added XMC_ETH_MAC_IsRxDescriptorOwnedByDma()
   * 
   * 2017-02-25:
   *      - XMC_ETH_MAC_SetPortControl() fixed compilation warning
   *
   * 2017-04-02:
   *     - Added XMC_ETH_MAC_InitPTPEx()
   *     - Added XMC_ETH_MAC_SetPTPTime()
   *     - Added XMC_ETH_MAC_UpdateAddend()
   *
   * 2017-04-11:
   *     - Added XMC_ETH_MAC_EnablePTPAlarm() and XMC_ETH_MAC_DisablePTPAlarm
   *
   * 2017-04-17:
   *     - Fixed ordering of PTP nanoseconds and seconds in XMC_ETH_MAC_DMA_DESC_t
   *
   * 2017-08-07:
   *     - Added XMC_ETH_MAC_TIMESTAMP_STATUS_t
   *
   * 2017-09-27:
   *     - Added XMC_ETH_MAC_InitEx()
   *     - XMC_ETH_MAC_SetAddressEx(), XMC_ETH_MAC_GetAddressEx() and XMC_ETH_MAC_SetAddressPerfectFilterEx() which receives a byte array with the MAC address instead of uint64_t
   *
   * 2018-06-21:
   *     - Changed definition of XMC_ETH_MAC_DMA_DESC_t declaring its fields volatile
   *
   * 2018-08-08:
   *     - Fixed XMC_ETH_MAC_SetVLANTag() which now accepts a 32bit tag parameter that allows setting ETV bit to compare only VLAN Tag ID
   *
   * @endcond
   */
  
  /**
   * @addtogroup XMClib XMC Peripheral Library
   * @{
   */
  
  /**
   * @addtogroup ETH_MAC
   * @brief Ethernet Low level driver for XMC4000 microcontroller family.
   *
   * The Ethernet MAC (ETH) is a major communication peripheral that supports 10/100
   * MBit/s data transfer rates in compliance with the IEEE 802.3-2002 standard. The ETH
   * may be used to implement internet connected applications using IPv4 and IPv6. The
   * ETH also includes support for IEEE1588 time synchronisation to allow implementation
   * of Real Time Ethernet protocols.
   *
   * The XMC_ETH_MAC low level driver provides functions to configure and initialize
   * the ETH_MAC hardware peripheral.
   * @{
   */
  
  #ifndef XMC_ETH_MAC_H
  #define XMC_ETH_MAC_H
  
  /**********************************************************************************************************************
   * HEADER FILES
   *********************************************************************************************************************/
  
  #include "xmc_common.h"
  
  #if defined (ETH0)
  
  #include "xmc_eth_mac_map.h"
  
  /**********************************************************************************************************************
   * MACROS
   *********************************************************************************************************************/
  
  #define XMC_ETH_MAC_BUF_SIZE           (1524)     /**< ETH MAC buffer size */
  #define XMC_ETH_MAC_PHY_MAX_RETRIES    (0xffffUL) /**< Maximum retries */
  #define XMC_ETH_WAKEUP_REGISTER_LENGTH (8U)       /**< Remote wakeup frame reg length */
  
  /**
   * TDES0 Descriptor TX Packet Control/Status
   */
  #define ETH_MAC_DMA_TDES0_OWN  (0x80000000U) /**< Own bit 1=DMA, 0=CPU */
  #define ETH_MAC_DMA_TDES0_IC   (0x40000000U) /**< Interrupt on competition */
  #define ETH_MAC_DMA_TDES0_LS   (0x20000000U) /**< Last segment */
  #define ETH_MAC_DMA_TDES0_FS   (0x10000000U) /**< First segment */
  #define ETH_MAC_DMA_TDES0_DC   (0x08000000U) /**< Disable CRC */
  #define ETH_MAC_DMA_TDES0_DP   (0x04000000U) /**< Disable pad */
  #define ETH_MAC_DMA_TDES0_TTSE (0x02000000U) /**< Transmit time stamp enable */
  #define ETH_MAC_DMA_TDES0_CIC  (0x00C00000U) /**< Checksum insertion control */
  #define ETH_MAC_DMA_TDES0_TER  (0x00200000U) /**< Transmit end of ring */
  #define ETH_MAC_DMA_TDES0_TCH  (0x00100000U) /**< Second address chained */
  #define ETH_MAC_DMA_TDES0_TTSS (0x00020000U) /**< Transmit time stamp status */
  #define ETH_MAC_DMA_TDES0_IHE  (0x00010000U) /**< IP header error */
  #define ETH_MAC_DMA_TDES0_ES   (0x00008000U) /**< Error summary */
  #define ETH_MAC_DMA_TDES0_JT   (0x00004000U) /**< Jabber timeout */
  #define ETH_MAC_DMA_TDES0_FF   (0x00002000U) /**< Frame flushed */
  #define ETH_MAC_DMA_TDES0_IPE  (0x00001000U) /**< IP payload error */
  #define ETH_MAC_DMA_TDES0_LOC  (0x00000800U) /**< Loss of carrier */
  #define ETH_MAC_DMA_TDES0_NC   (0x00000400U) /**< No carrier */
  #define ETH_MAC_DMA_TDES0_LC   (0x00000200U) /**< Late collision */
  #define ETH_MAC_DMA_TDES0_EC   (0x00000100U) /**< Excessive collision */
  #define ETH_MAC_DMA_TDES0_VF   (0x00000080U) /**< VLAN frame */
  #define ETH_MAC_DMA_TDES0_CC   (0x00000078U) /**< Collision count */
  #define ETH_MAC_DMA_TDES0_ED   (0x00000004U) /**< Excessive deferral */
  #define ETH_MAC_DMA_TDES0_UF   (0x00000002U) /**< Underflow error */
  #define ETH_MAC_DMA_TDES0_DB   (0x00000001U) /**< Deferred bit */
  
  /**
   * RDES0 Descriptor RX Packet Status
   */
  #define ETH_MAC_DMA_RDES0_OWN  (0x80000000U) /**< Own bit 1=DMA, 0=CPU */
  #define ETH_MAC_DMA_RDES0_AFM  (0x40000000U) /**< Destination address filter fail */
  #define ETH_MAC_DMA_RDES0_FL   (0x3FFF0000U) /**< Frame length mask */
  #define ETH_MAC_DMA_RDES0_ES   (0x00008000U) /**< Error summary */
  #define ETH_MAC_DMA_RDES0_DE   (0x00004000U) /**< Descriptor error */
  #define ETH_MAC_DMA_RDES0_SAF  (0x00002000U) /**< Source address filter fail */
  #define ETH_MAC_DMA_RDES0_LE   (0x00001000U) /**< Length error */
  #define ETH_MAC_DMA_RDES0_OE   (0x00000800U) /**< Overflow error */
  #define ETH_MAC_DMA_RDES0_VLAN (0x00000400U) /**< VLAN tag */
  #define ETH_MAC_DMA_RDES0_FS   (0x00000200U) /**< First descriptor */
  #define ETH_MAC_DMA_RDES0_LS   (0x00000100U) /**< Last descriptor */
  #define ETH_MAC_DMA_RDES0_TSA  (0x00000080U) /**< Timestamp available */
  #define ETH_MAC_DMA_RDES0_LC   (0x00000040U) /**< Late collision */
  #define ETH_MAC_DMA_RDES0_FT   (0x00000020U) /**< Frame type */
  #define ETH_MAC_DMA_RDES0_RWT  (0x00000010U) /**< Receive watchdog timeout */
  #define ETH_MAC_DMA_RDES0_RE   (0x00000008U) /**< Receive error */
  #define ETH_MAC_DMA_RDES0_DBE  (0x00000004U) /**< Dribble bit error */
  #define ETH_MAC_DMA_RDES0_CE   (0x00000002U) /**< CRC error */
  #define ETH_MAC_DMA_RDES0_ESA  (0x00000001U) /**< Extended Status/Rx MAC address */
  
  /**********************************************************************************************************************
   * ENUMS
   *********************************************************************************************************************/
  
  /**
   * Ethernet MAC status return values
   */
  typedef enum XMC_ETH_MAC_STATUS
  {
    XMC_ETH_MAC_STATUS_OK    = 0U, /**< Driver accepted application request */
    XMC_ETH_MAC_STATUS_BUSY  = 1U, /**< Driver is busy and cannot handle request */
    XMC_ETH_MAC_STATUS_ERROR = 2U  /**< Driver could not fulfil application request */
  } XMC_ETH_MAC_STATUS_t;
  
  /**
   * Transmission frame
   */
  typedef enum XMC_ETH_MAC_TX_FRAME
  {
    XMC_ETH_MAC_TX_FRAME_FRAGMENT  = 0x1U, /**< Indicate frame fragment */
    XMC_ETH_MAC_TX_FRAME_EVENT     = 0x2U, /**< Generate event when frame is transmitted */
    XMC_ETH_MAC_TX_FRAME_TIMESTAMP = 0x4U  /**< Capture frame time stamp */
  } XMC_ETH_MAC_TX_FRAME_t;
  
  /**
   * ETH MAC event
   */
  typedef enum XMC_ETH_MAC_EVENT
  {
    XMC_ETH_MAC_EVENT_PMT = ETH_INTERRUPT_MASK_PMTIM_Msk << 16,        /**< Power management event */
    XMC_ETH_MAC_EVENT_TIMESTAMP = ETH_INTERRUPT_MASK_TSIM_Msk << 16,   /**< Time stamp event */
    XMC_ETH_MAC_EVENT_EARLY_RECEIVE = ETH_STATUS_ERI_Msk,              /**< Early receive */
    XMC_ETH_MAC_EVENT_BUS_ERROR = ETH_STATUS_FBI_Msk,                  /**< Bus error */
    XMC_ETH_MAC_EVENT_EARLY_TRANSMIT = ETH_STATUS_ETI_Msk,             /**< Early transmit */
    XMC_ETH_MAC_EVENT_RECEIVE_WATCHDOG_TIMEOUT = ETH_STATUS_RWT_Msk,   /**< Receive watchdog time-out */
    XMC_ETH_MAC_EVENT_RECEIVE_PROCESS_STOPPED = ETH_STATUS_RPS_Msk,    /**< Receive process stopped */
    XMC_ETH_MAC_EVENT_RECEIVE_BUFFER_UNAVAILABLE = ETH_STATUS_RU_Msk,  /**< Receive buffer unavailable */
    XMC_ETH_MAC_EVENT_RECEIVE = ETH_STATUS_RI_Msk,                     /**< Receive event */
    XMC_ETH_MAC_EVENT_TRANSMIT_UNDERFLOW = ETH_STATUS_UNF_Msk,         /**< Transmit underflow */
    XMC_ETH_MAC_EVENT_RECEIVE_OVERFLOW = ETH_STATUS_OVF_Msk,           /**< Receive overflow */
    XMC_ETH_MAC_EVENT_TRANSMIT_JABBER_TIMEOUT = ETH_STATUS_TJT_Msk,    /**< Transmit jabber time-out */
    XMC_ETH_MAC_EVENT_TRANSMIT_BUFFER_UNAVAILABLE = ETH_STATUS_TU_Msk, /**< Transmit buffer unavailable */
    XMC_ETH_MAC_EVENT_TRANSMIT_PROCESS_STOPPED = ETH_STATUS_TPS_Msk,   /**< Transmit process stopped */
    XMC_ETH_MAC_EVENT_TRANSMIT = ETH_STATUS_TI_Msk                     /**< Transmit event */
  } XMC_ETH_MAC_EVENT_t;
  
  /**
   * Link interface
   */
  typedef enum XMC_ETH_LINK_INTERFACE
  {
    XMC_ETH_LINK_INTERFACE_MII, /**< Link interface: Media independent interface */
    XMC_ETH_LINK_INTERFACE_RMII /**< Link interface: Reduced media independent interface */
  } XMC_ETH_LINK_INTERFACE_t;
  
  /**
   * ETH link status
   */
  typedef enum XMC_ETH_LINK_STATUS
  {
    XMC_ETH_LINK_STATUS_DOWN, /**< Link status down */
    XMC_ETH_LINK_STATUS_UP    /**< Link status up */
  } XMC_ETH_LINK_STATUS_t;
  
  /**
   * ETH link speed
   */
  typedef enum XMC_ETH_LINK_SPEED
  {
    XMC_ETH_LINK_SPEED_10M  = 0UL << ETH_MAC_CONFIGURATION_FES_Pos, /**< Link speed: 10M */
    XMC_ETH_LINK_SPEED_100M = 1UL << ETH_MAC_CONFIGURATION_FES_Pos  /**< Link speed: 100M */
  } XMC_ETH_LINK_SPEED_t;
  
  /**
   * ETH duplex settings (full/half?)
   */
  typedef enum XMC_ETH_LINK_DUPLEX
  {
    XMC_ETH_LINK_DUPLEX_HALF = 0UL << ETH_MAC_CONFIGURATION_DM_Pos, /**< Half duplex */
    XMC_ETH_LINK_DUPLEX_FULL = 1UL << ETH_MAC_CONFIGURATION_DM_Pos  /**< Full duplex */
  } XMC_ETH_LINK_DUPLEX_t;
  
  /**
   * MAC address filter
   */
  typedef enum XMC_ETH_MAC_ADDR_FILTER
  {
    XMC_ETH_MAC_ADDR_FILTER_MASK_BYTE0 = 0x01000000UL, /**< Address filter mask: byte 0 */
    XMC_ETH_MAC_ADDR_FILTER_MASK_BYTE1 = 0x02000000UL, /**< Address filter mask: byte 1 */
    XMC_ETH_MAC_ADDR_FILTER_MASK_BYTE2 = 0x04000000UL, /**< Address filter mask: byte 2 */
    XMC_ETH_MAC_ADDR_FILTER_MASK_BYTE3 = 0x08000000UL, /**< Address filter mask: byte 3 */
    XMC_ETH_MAC_ADDR_FILTER_MASK_BYTE4 = 0x10000000UL, /**< Address filter mask: byte 4 */
    XMC_ETH_MAC_ADDR_FILTER_MASK_BYTE5 = 0x20000000UL, /**< Address filter mask: byte 5 */
    XMC_ETH_MAC_ADDR_FILTER_SA         = 0x40000000UL  /**< Address filter SA */
  } XMC_ETH_MAC_ADDR_FILTER_t;
  
  /**
   * Power management events that triggers a PMT interrupt
   */
  typedef enum XMC_ETH_MAC_PMT_EVENT
  {
    XMC_ETH_MAC_PMT_EVENT_ON_WAKEUP_FRAME         = ETH_PMT_CONTROL_STATUS_RWKPKTEN_Msk,  /**< Wakeup frame */
    XMC_ETH_MAC_PMT_EVENT_ON_MAGIC_PACKET         = ETH_PMT_CONTROL_STATUS_MGKPKTEN_Msk,  /**< Magic packet */
    XMC_ETH_MAC_PMT_EVENT_ON_UNICAST_FRAME_FILTER = ETH_PMT_CONTROL_STATUS_GLBLUCAST_Msk  /**< Unicast frame filter */
  } XMC_ETH_MAC_PMT_EVENT_t;
  
  
  /**
   * ETH MAC time-stamp configuration enable
   */
  typedef enum XMC_ETH_MAC_TIMESTAMP_CONFIG
  {
    XMC_ETH_MAC_TIMESTAMP_CONFIG_FINE_UPDATE = ETH_TIMESTAMP_CONTROL_TSCFUPDT_Msk,             /**< Fine update */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_TS_INTERRUPT = ETH_TIMESTAMP_CONTROL_TSTRIG_Msk,       /**< Timestamp Interrupt Trigger Enable */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_ALL_FRAMES = ETH_TIMESTAMP_CONTROL_TSENALL_Msk,        /**< Enable all frames */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_PTPV2 = ETH_TIMESTAMP_CONTROL_TSVER2ENA_Msk,           /**< PTPV2 */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_PTP_OVER_ETHERNET = ETH_TIMESTAMP_CONTROL_TSIPENA_Msk, /**< PTP over ETH */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_PTP_OVER_IPV6 = ETH_TIMESTAMP_CONTROL_TSIPV6ENA_Msk,   /**< PTP over IPV6 */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_PTP_OVER_IPV4 = ETH_TIMESTAMP_CONTROL_TSIPV4ENA_Msk,   /**< PTP over IPV4 */
    XMC_ETH_MAC_TIMESTAMP_CONFIG_ENABLE_MAC_ADDRESS_FILTER = ETH_TIMESTAMP_CONTROL_TSENMACADDR_Msk /**< MAC address filter */
  } XMC_ETH_MAC_TIMESTAMP_CONFIG_t;
  
  /**
   * ETH MAC time-stamp status
   */
  typedef enum XMC_ETH_MAC_TIMESTAMP_STATUS
  {
    XMC_ETH_MAC_TIMESTAMP_STATUS_SECONDS_OVERFLOW = ETH_TIMESTAMP_STATUS_TSSOVF_Msk,           /**< Indicates that the seconds value of the timestamp has overflowed beyond 0xFFFFFFFF */
    XMC_ETH_MAC_TIMESTAMP_STATUS_TARGET_TIME_REACHED = ETH_TIMESTAMP_STATUS_TSTARGT_Msk,       /**< Indicates that the value of system time is greater or equal to the value specified in the Target_Time_ Seconds Register and Target Time Nanoseconds Register */
    XMC_ETH_MAC_TIMESTAMP_STATUS_TARGET_TIMER_ERROR = ETH_TIMESTAMP_STATUS_TSTRGTERR_Msk,      /**< Set when the target time, being programmed in Target Time Registers, is already elapsed */
  } XMC_ETH_MAC_TIMESTAMP_STATUS_t;
  
  
  /**********************************************************************************************************************
   * DATA STRUCTURES
   *********************************************************************************************************************/
  
  /* Anonymous structure/union guard start */
  #if defined (__CC_ARM)
  #pragma push
  #pragma anon_unions
  #elif defined (__TASKING__)
  #pragma warning 586
  #endif
  
  /**
   * ETH MAC port control
   */
  typedef union XMC_ETH_MAC_PORT_CTRL
  {
    struct
    {
      uint32_t rxd0: 2;     /**< Receive data bit 0 (::XMC_ETH_MAC_PORT_CTRL_RXD0_t) */
      uint32_t rxd1: 2;     /**< Receive data bit 1 (::XMC_ETH_MAC_PORT_CTRL_RXD1_t) */
      uint32_t rxd2: 2;     /**< Receive data bit 2 (only MII) (::XMC_ETH_MAC_PORT_CTRL_RXD2_t) */
      uint32_t rxd3: 2;     /**< Receive data bit 3 (only MII) (::XMC_ETH_MAC_PORT_CTRL_RXD3_t) */
      uint32_t clk_rmii: 2; /**< RMII: Continuous 50 MHz reference clock.
                                 MII: Receive clock, 25 MHz for 100Mbit/s, 2.5 MHz for 10Mbit/s
                                 (::XMC_ETH_MAC_PORT_CTRL_CLK_RMII_t) */
      uint32_t crs_dv: 2;   /**< RMII: carrier sense/RX_Data valid. MII: RX_Data valid (::XMC_ETH_MAC_PORT_CTRL_CRS_DV_t) */
      uint32_t crs: 2;      /**< Carrier sense for only MII (::XMC_ETH_MAC_PORT_CTRL_CRS_t) */
      uint32_t rxer: 2;     /**< Receive error (::XMC_ETH_MAC_PORT_CTRL_RXER_t) */
      uint32_t col: 2;      /**< Collision Detect for only MII (::XMC_ETH_MAC_PORT_CTRL_COL_t) */
      uint32_t clk_tx: 2;   /**< Transmit clock (only MII), 25 MHz for 100Mbit/s, 2.5 MHz for 10Mbit/s (::XMC_ETH_MAC_PORT_CTRL_CLK_TX_t) */
      uint32_t: 2;          /**< Reserved bits */
      uint32_t mdio: 2;     /**< Bidirectional, push-pull management data I/O line (::XMC_ETH_MAC_PORT_CTRL_MDIO_t) */
      uint32_t: 2;          /**< Reserved bits */
      uint32_t mode: 1;     /**< RMII or MII (::XMC_ETH_MAC_PORT_CTRL_MODE_t) */
    };
  
    uint32_t raw;
  } XMC_ETH_MAC_PORT_CTRL_t;
  
  /**
   * ETH MAC DMA descriptor
   */
  typedef struct XMC_ETH_MAC_DMA_DESC
  {
    volatile uint32_t status;                 /**< DMA descriptor status */
    volatile uint32_t length;                 /**< Descriptor length */
    volatile uint32_t buffer1;                /**< Buffer 1 */
    volatile uint32_t buffer2;                /**< Buffer 2 */
    volatile uint32_t extended_status;        /**< Extended status */
    volatile uint32_t reserved;               /**< Reserved */
    volatile uint32_t time_stamp_nanoseconds; /**< Time stamp low */
    volatile uint32_t time_stamp_seconds;     /**< Time stamp high */
  } XMC_ETH_MAC_DMA_DESC_t;
  
  /**
   * ETH MAC time
   */
  typedef struct XMC_ETH_MAC_TIME
  {
    uint32_t seconds;                 /**< Seconds */
    int32_t nanoseconds;              /**< Nanoseconds */
  } XMC_ETH_MAC_TIME_t;
  
  /**
   * ETH driver structure
   */
  typedef struct XMC_ETH_MAC
  {
    ETH_GLOBAL_TypeDef *regs;        /**< ETH module 0 (now, we have a single ETH module) */
    uint64_t address;              /**< MAC address */
    XMC_ETH_MAC_DMA_DESC_t *rx_desc; /**< DMA descriptor: RX */
    XMC_ETH_MAC_DMA_DESC_t *tx_desc; /**< DMA descriptor: TX */
    uint8_t *rx_buf;                /**< RX buffer */
    uint8_t *tx_buf;                /**< TX buffer */
    uint8_t *frame_end;              /**< End of assembled frame fragments */
    uint8_t num_rx_buf;              /**< How many RX descriptors? */
    uint8_t num_tx_buf;              /**< How many TX descriptors? */
    uint8_t tx_index;                /**< Transmit descriptor index */
    uint8_t rx_index;                /**< Receive descriptor index */
    uint8_t tx_ts_index;             /**< Transmit time-stamp descriptor index */
  } XMC_ETH_MAC_t;
  
  /* Anonymous structure/union guard end */
  #if defined (__CC_ARM)
  #pragma pop
  #elif defined (__TASKING__)
  #pragma warning restore
  #endif
  
  /**********************************************************************************************************************
   * API PROTOTYPES
   *********************************************************************************************************************/
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return XMC_ETH_MAC_STATUS_t Initialization status
   *
   * \par<b>Description: </b><br>
   * Initialize the Ethernet MAC peripheral <br>
   *
   * \par
   * The function sets the link speed, applies the duplex mode, sets auto-negotiation
   * and loop-back settings.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_Init(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Initialize the Ethernet MAC peripheral. <br>
   * Required when initializing the PHY, to deliver the clocks to the MAC, before MAC is reseted.
   * \note The module needs to be enabled before using XMC_ETH_MAC_Enable() <br>
   *
   * \par
   * The function sets the link speed, applies the duplex mode, sets auto-negotiation
   * and loop-back settings.
   */
  void XMC_ETH_MAC_InitEx(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Initialize the RX DMA descriptors <br>
   *
   * \par
   * The function initializes the RX descriptors in a chained configuration. It sets
   * up the status bit, control bit, buffer length and the buffer pointer.
   */
  void XMC_ETH_MAC_InitRxDescriptors(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Initialize the TX DMA descriptors <br>
   *
   * \par
   * The function initializes the TX descriptors in a chained configuration. It sets
   * up the status bit, control bit, buffer length and the buffer pointer.
   */
  void XMC_ETH_MAC_InitTxDescriptors(XMC_ETH_MAC_t *const eth_mac);
   
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable the Ethernet MAC peripheral <br>
   *
   * \par
   * The function de-asserts the peripheral reset.
   */
  void XMC_ETH_MAC_Enable(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable the Ethernet MAC peripheral <br>
   *
   * \par
   * The function asserts the peripheral reset.
   */
  void XMC_ETH_MAC_Disable(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return bool
   *
   * \par<b>Description: </b><br>
   * Check if the ETH MAC is enabled <br>
   *
   * \par
   * The function checks if the ETH MAC is enabled or not. It returns "true" if the
   * peripheral is enabled, "false" otherwise.
   */
  bool XMC_ETH_MAC_IsEnabled(const XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Reset the ETH MAC peripheral <br>
   *
   * \par
   * The function resets the ETH MAC peripheral. It blocks until reset.
   */
  __STATIC_INLINE void XMC_ETH_MAC_Reset(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->BUS_MODE |= (uint32_t)ETH_BUS_MODE_SWR_Msk;
    while ((eth_mac->regs->BUS_MODE & (uint32_t)ETH_BUS_MODE_SWR_Msk) != 0U)
    {
    }
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param phy_addr PHY address
   * @param reg_addr Register address
   * @param data The destination to which the read data needs to be copied to
   * @return XMC_ETH_MAC_STATUS_t ETH MAC status
   *
   * \par<b>Description: </b><br>
   * Read a PHY register <br>
   *
   * \par
   * The function reads a PHY register. It essentially polls busy bit during max
   * PHY_TIMEOUT time and reads the information into 'data' when not busy.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_ReadPhy(XMC_ETH_MAC_t *const eth_mac, uint8_t phy_addr, uint8_t reg_addr, uint16_t *data);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param phy_addr PHY address
   * @param reg_addr Register address
   * @param data The data to write
   * @return XMC_ETH_MAC_STATUS_t ETH MAC status
   *
   * \par<b>Description: </b><br>
   * Write a PHY register <br>
   *
   * \par
   * The function reads a PHY register. It essentially writes the data and polls
   * the busy bit until it is no longer busy.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_WritePhy(XMC_ETH_MAC_t *const eth_mac, uint8_t phy_addr, uint8_t reg_addr, uint16_t data);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param port_ctrl Port control configuration
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set port control configuration <br>
   *
   * \par
   * The function sets the port control by writing the configuration into the
   * CON register.
   *
   * \note
   * MII Mode is only available in:
   * - XMC4500 LQFP144 and BGA144 packages
   * - XMC4700 LQFP144 and BGA196 packages
   * - XMC4800 LQFP144 and BGA196 packages
   *
   */
  __STATIC_INLINE void XMC_ETH_MAC_SetPortControl(XMC_ETH_MAC_t *const eth_mac, const XMC_ETH_MAC_PORT_CTRL_t port_ctrl)
  {
    XMC_UNUSED_ARG(eth_mac);
    ETH0_CON->CON = (uint32_t)port_ctrl.raw;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return XMC_ETH_MAC_STATUS_t ETH MAC status
   *
   * \par<b>Description: </b><br>
   * Set management clock divider <br>
   *
   * \par
   * The function sets the management clock divider by writing to the GMII_ADDRESS
   * register.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_SetManagmentClockDivider(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param addr The MAC address to set
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set MAC address <br>
   *
   * \par
   * The function sets the MAC address by writing to the MAC_ADDRESS0_HIGH and
   * MAC_ADDRESS0_LOW registers.
   */
  __STATIC_INLINE void XMC_ETH_MAC_SetAddress(XMC_ETH_MAC_t *const eth_mac, uint64_t addr)
  {
    eth_mac->regs->MAC_ADDRESS0_HIGH = (uint32_t)(addr >> 32);
    eth_mac->regs->MAC_ADDRESS0_LOW = (uint32_t)addr;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param addr Pointer to 6 byte MAC address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set MAC address <br>
   *
   * \par
   * The function sets the MAC address by writing to the MAC_ADDRESS0_HIGH and
   * MAC_ADDRESS0_LOW registers.
   */
  void XMC_ETH_MAC_SetAddressEx(XMC_ETH_MAC_t *const eth_mac, uint8_t *const addr);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return uint64_t The MAC address which has been set
   *
   * \par<b>Description: </b><br>
   * Get MAC address <br>
   *
   * \par
   * The function returns the current ETH MAC address.
   */
  __STATIC_INLINE uint64_t XMC_ETH_MAC_GetAddress(XMC_ETH_MAC_t *const eth_mac)
  {
    return ((((uint64_t)eth_mac->regs->MAC_ADDRESS0_HIGH << 32)) | (uint64_t)eth_mac->regs->MAC_ADDRESS0_LOW);
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return uint64_t The MAC address which has been set
   *
   * \par<b>Description: </b><br>
   * Get MAC address <br>
   *
   * \par
   * The function returns the current ETH MAC address.
   */
  void XMC_ETH_MAC_GetAddressEx(XMC_ETH_MAC_t *const eth_mac, uint8_t *const addr);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param index Table entry index
   * @param addr Address value
   * @param flags Compare control. OR'ed combination of @ref XMC_ETH_MAC_ADDR_FILTER_t or zero. 
   *
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set perfect filter for address filtering <br>
   *
   * \par
   * The function can be used to set perfect filter for address filtering.
   */
  void XMC_ETH_MAC_SetAddressPerfectFilter(XMC_ETH_MAC_t *const eth_mac, uint8_t index, const uint64_t addr, uint32_t flags);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param index Table entry index
   * @param addr Pointer to 6 byte MAC address
   * @param flags Compare control. OR'ed combination of @ref XMC_ETH_MAC_ADDR_FILTER_t or zero. 
   *
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set perfect filter for address filtering <br>
   *
   * \par
   * The function can be used to set perfect filter for address filtering.
   */
  void XMC_ETH_MAC_SetAddressPerfectFilterEx(XMC_ETH_MAC_t *const eth_mac, uint8_t index, uint8_t *const addr, uint32_t flags);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param hash The hash to be used for filtering
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set hash filter for group address filtering <br>
   *
   * \par
   * The function sets up a hash filter for group address filtering. It writes the
   * given hash value into the HASH_TABLE_LOW and HASH_TABLE_HIGH registers.
   */
  void XMC_ETH_MAC_SetAddressHashFilter(XMC_ETH_MAC_t *const eth_mac, const uint64_t hash);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable frame filter <br>
   *
   * \par
   * The function resets the RA bitfield of the MAC_FRAME_FILTER register. This
   * ensures that the receiver module passes only those frames (to the application)
   * that pass the SA or DA address filter.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableFrameFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_RA_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable frame filter <br>
   *
   * \par
   * The function sets the RA bitfield of the MAC_FRAME_FILTER register. This
   * ensures that the receiver module passes all received frames, irrespective
   * of whether they pass the address filter or not.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableFrameFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_RA_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable hash perfect filter <br>
   *
   * \par
   * The function sets the HPF bitfield of the MAC_FRAME_FILTER register. The
   * function configures the address filter to pass a frame if it matches
   * either the perfect filtering or the hash filtering.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableHashPerfectFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_HPF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable perfect filter <br>
   *
   * \par
   * The function clears the HPF bitfield of the MAC_FRAME_FILTER register. When the
   * function is invoked, the frame is passed only if it matches the hash filter.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnablePerfectFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_HPF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable source address filter <br>
   *
   * \par
   * The function sets the SAF bitfield of the MAC_FRAME_FILTER register. Verbatim
   * from the reference manual - "When invoked, the MAC compares the SA field of the
   * received frames with the values programmed in the enabled SA registers. If the
   * comparison matches, then the SA Match bit of RxStatus Word is set high. When
   * this bit is set high and the SA filter fails, the MAC drops the frame.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableSourceAddressFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_SAF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable source address filter <br>
   *
   * \par
   * The function resets the SAF bitfield of the MAC_FRAME_FILTER register. Verbatim
   * from the reference manual - "When invoked, the MAC forwards the received frame to
   * the application and updates the SA Match bit of the RxStatus depending on
   * the SA address comparison".
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableSourceAddressFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_SAF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable source address inverse filtering <br>
   *
   * \par
   * The function resets the SAIF bitfield of the MAC_FRAME_FILTER register. Verbatim
   * from the reference manual - "When invoked, the address check block operates in
   * inverse filtering mode for the SA address comparison. The frames whose SA matches
   * the SA registers are marked as failing the SA Address filter".
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableSourceAddressInverseFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_SAIF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable source address inverse filtering <br>
   *
   * \par
   * The function resets the SAIF bitfield of the MAC_FRAME_FILTER register. Verbatim
   * from the reference manual - "When invoked, frames whose SA does not match the SA
   * registers are marked as failing the SA Address filter".
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableSourceAddressInverseFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_SAIF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable destination address inverse filtering <br>
   *
   * \par
   * The function sets the DAIF bitfield of the MAC_FRAME_FILTER register. Verbatim
   * from the reference manual - "When invoked, the address check block operates in
   * inverse filtering mode for the DA address comparison for both unicast and
   * multicast frames".
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableDestinationAddressInverseFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_DAIF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable destination address inverse filtering <br>
   *
   * \par
   * The function sets the DAIF bitfield of the MAC_FRAME_FILTER register. It can
   * be used to perform normal filtering of frames.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableDestinationAddressInverseFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_DAIF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable multicast hash filter <br>
   *
   * \par
   * When invoked, the MAC performs destination address filtering of received
   * multicast frames according to the hash table.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableMulticastHashFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_HMC_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable multicast hash filter <br>
   *
   * \par
   * The function disables multicast hash filtering. The MAC performs a perfect
   * destination address filtering for multicast frames post invocation.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableMulticastHashFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_HMC_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable unicast hash filter <br>
   *
   * \par
   * The function enables the MAC to perform destination address filtering of
   * unicast frames according to the hash table.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableUnicastHashFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_HUC_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable unicast hash filter <br>
   *
   * \par
   * The function disables unicast hash filtering. When invoked, the MAC performs a
   * perfect destination address filtering for unicast frames.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableUnicastHashFilter(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_HUC_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param frame A pointer to a uint8_t constant, holding the frame to be transmitted
   * @param len Length of the frame to transmit
   * @param flags Additional flags: ored combination of ::XMC_ETH_MAC_TX_FRAME_t or zero.
   * @return XMC_ETH_MAC_STATUS_t ETH MAC status (XMC_ETH_MAC_STATUS_BUSY if busy,
   *         XMC_ETH_MAC_STATUS_OK otherwise).
   *
   * \par<b>Description: </b><br>
   * Send a frame <br>
   *
   * \par
   * The function is used to send a frame. The transmission is done using
   * the ETH MAC's dedicated DMA unit.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_SendFrame(XMC_ETH_MAC_t *const eth_mac,
                                             const uint8_t *frame,
                                             uint32_t len,
                                             uint32_t flags);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param frame A constant pointer to a uint8_t constant, holding the received frame
   * @param len Frame length?
   * @return uint32_t Length of the frame
   *
   * \par<b>Description: </b><br>
   * Read a frame <br>
   *
   * \par
   * The function is used to read a frame. The function returns 'len', the length
   * as specified as the actual parameter in the function call.
   */
  uint32_t XMC_ETH_MAC_ReadFrame(XMC_ETH_MAC_t *const eth_mac, uint8_t *const frame, uint32_t len);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return uint32_t RX frame size
   *
   * \par<b>Description: </b><br>
   * Get RX frame size <br>
   *
   * \par
   * The function is used to get the effective length of the RX frame size.
   */
  uint32_t XMC_ETH_MAC_GetRxFrameSize(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable reception of broadcast frames <br>
   *
   * \par
   * This function enables the AFM module to pass all received broadcast frames.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableReceptionBroadcastFrames(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_DBF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable reception of broadcast frames <br>
   *
   * \par
   * The function sets the DBF bitfield of the MAC_FRAME_FILTER register. When set,
   * the AFM module filters all incoming broadcast frames. In addition, it overrides
   * all other filter settings.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableReceptionBroadcastFrames(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_DBF_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable reception of multicast frames <br>
   *
   * \par
   * The function sets the DBF bitfield of the MAC_FRAME_FILTER register. When set,
   * the AFM module filters all incoming broadcast frames. In addition, it overrides
   * all other filter settings.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableReceptionMulticastFrames(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_PM_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable reception of multicast frames <br>
   *
   * \par
   * The function disables the reception of multicast frames. When invoked, the AFM
   * module passes all received broadcast frames.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableReceptionMulticastFrames(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_PM_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable promiscuous mode <br>
   *
   * \par
   * The function enables the promiscuous mode. In this mode, the address filter
   * module passes all incoming frames regardless of its destination or source
   * address.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnablePromiscuousMode(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER |= (uint32_t)ETH_MAC_FRAME_FILTER_PR_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable promiscuous mode <br>
   *
   * \par
   * The function disables the promiscuous mode.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisablePromiscuousMode(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_FRAME_FILTER &= (uint32_t)~ETH_MAC_FRAME_FILTER_PR_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable RX watchdog <br>
   *
   * \par
   * The function enables the RX watchdog by clearing the WD bitfield of the
   * MAC_CONFIGURATION register. When invoked, the MAC does not allow more
   * than 2048 bytes of the frame being received.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableRxWatchdog(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_WD_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable RX watchdog <br>
   *
   * \par
   * The function disables the RX watchdog by disabling the timer on the RX.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableRxWatchdog(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_WD_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable TX jabber <br>
   *
   * \par
   * When the function is invoked, the MAC cuts off the transmitter if the application
   * sends out more than 2,048 bytes of data during transmission (10,240 bytes if
   * jumbo frames are enabled)
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableTxJabber(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_JD_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable TX jabber <br>
   *
   * \par
   * When the function is invoked, the MAC disables the jabber timer on TX.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableTxJabber(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_JD_Msk;
  } 
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Frame burst enable <br>
   *
   * \par
   * The function can be used to enable frame bursting during transmission in the
   * MII half-duplex mode.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableFrameBurst(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_BE_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Frame burst disable <br>
   *
   * \par
   * The function can be used to disable frame bursting.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableFrameBurst(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_BE_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Jumbo frame enable <br>
   *
   * \par
   * The function can be used to enable jumbo frames. When enabled, the MAC allows
   * jumbo frames of 9,018 bytes without reporting a giant frame error in the receive
   * frame status.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableJumboFrame(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_JE_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Jumbo frame disable <br>
   *
   * \par
   * The function can be used to disable jumbo frames.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableJumboFrame(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_JE_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable receive own <br>
   *
   * \par
   * The function enables the MAC to receive all packets that are given by the PHY
   * while transmitting.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableRxOwn(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_DO_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable receive own <br>
   *
   * \par
   * On invocation of the function, the MAC disables the reception of frames in the
   * half-duplex mode.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableRxOwn(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_DO_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable loopback mode <br>
   *
   * \par
   * The function enables the MAC to operate in the loopback mode using the MII.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableLoopback(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_LM_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable loopback mode <br>
   *
   * \par
   * The function can be used to disable the loopback mode.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableLoopback(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_LM_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param speed The speed at which the link is set (10M or 100M?)
   * @param duplex Duplex settings (half or full duplex?)
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set link <br>
   *
   * \par
   * The function sets the link speed and duplex settings.
   */
  __STATIC_INLINE void XMC_ETH_MAC_SetLink(XMC_ETH_MAC_t *const eth_mac,
                                           XMC_ETH_LINK_SPEED_t speed,
                                           XMC_ETH_LINK_DUPLEX_t duplex)
  {
    eth_mac->regs->MAC_CONFIGURATION = (eth_mac->regs->MAC_CONFIGURATION &
                                        (uint32_t)~(ETH_MAC_CONFIGURATION_DM_Msk | ETH_MAC_CONFIGURATION_FES_Msk)) |
                                       (uint32_t)speed | (uint32_t)duplex;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Return RX descriptor <br>
   *
   * \par
   * The function sets the specified DMA RX descriptor own bit.
   */
  void XMC_ETH_MAC_ReturnRxDescriptor(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return bool true if RX descriptor is owned by DMA, false otherwise
   *
   * \par<b>Description: </b><br>
   * Is RX descriptor owned by DMA? <br>
   *
   * \par
   * The function checks if the RX descriptor is owned by the DMA.
   */
  __STATIC_INLINE bool XMC_ETH_MAC_IsRxDescriptorOwnedByDma(XMC_ETH_MAC_t *const eth_mac)
  {
    return ((eth_mac->rx_desc[eth_mac->rx_index].status & ETH_MAC_DMA_RDES0_OWN) != 0U);
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Return TX descriptor <br>
   *
   * \par
   * The function sets the specified DMA TX descriptor own bit.
   */
  void XMC_ETH_MAC_ReturnTxDescriptor(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return bool true if TX descriptor is owned by DMA, false otherwise
   *
   * \par<b>Description: </b><br>
   * Is TX descriptor owned by DMA? <br>
   *
   * \par
   * The function checks if the TX descriptor is owned by the DMA.
   */
  __STATIC_INLINE bool XMC_ETH_MAC_IsTxDescriptorOwnedByDma(XMC_ETH_MAC_t *const eth_mac)
  {
    return ((eth_mac->tx_desc[eth_mac->tx_index].status & ETH_MAC_DMA_TDES0_OWN) != 0U);
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * ETH MAC Enable RX <br>
   *
   * \par
   * The function enables the receiver state machine of the MAC and puts the
   * receive process in running state. The DMA then acquires the descriptor
   * from the receive list and processes the received frames.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableRx(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->OPERATION_MODE |= (uint32_t)ETH_OPERATION_MODE_SR_Msk;
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_RE_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * ETH MAC Disable RX <br>
   *
   * \par
   * The function disables the receive process.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableRx(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_RE_Msk;
    eth_mac->regs->OPERATION_MODE &= (uint32_t)~ETH_OPERATION_MODE_SR_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * ETH MAC Enable TX <br>
   *
   * \par
   * The function enables the transmit state machine of the MAC and puts the
   * transmit process in running state. The DMA then checks the TX list at the
   * current position for transmitting a frame.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnableTx(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->OPERATION_MODE |= (uint32_t)ETH_OPERATION_MODE_ST_Msk;
    eth_mac->regs->MAC_CONFIGURATION |= (uint32_t)ETH_MAC_CONFIGURATION_TE_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * ETH MAC Disable TX <br>
   *
   * \par
   * The function disables the transmit process.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisableTx(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->MAC_CONFIGURATION &= (uint32_t)~ETH_MAC_CONFIGURATION_TE_Msk;
    eth_mac->regs->OPERATION_MODE &= (uint32_t)~ETH_OPERATION_MODE_ST_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Flush TX <br>
   *
   * \par
   * The function initializes the TX DMA descriptors and enables the DMA transmission.
   */
  void XMC_ETH_MAC_FlushTx(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Flush RX <br>
   *
   * \par
   * The function initializes the RX DMA descriptors and enables the DMA transmission.
   */
  void XMC_ETH_MAC_FlushRx(XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Resume TX <br>
   *
   * \par
   * Verbatim from the reference manual, the function enables the DMA to read the
   * current descriptor pointed to by the "current host transmit descriptor" reg.
   * If that descriptor is not available (owned by the CPU), the transmission
   * returns to the suspend state else the transmission resumes.
   */
  __STATIC_INLINE void XMC_ETH_MAC_ResumeTx(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->STATUS = (uint32_t)ETH_STATUS_TPS_Msk;
    eth_mac->regs->TRANSMIT_POLL_DEMAND = 0U;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Resume RX <br>
   *
   * \par
   * Verbatim from the reference manual the function enables the DMA to read the
   * current descriptor pointed to by the "current host transmit descriptor" reg.
   * If that descriptor is not available (owned by the CPU), the transmission
   * returns to the suspend state else the transmission resumes.
   */
  __STATIC_INLINE void XMC_ETH_MAC_ResumeRx(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->STATUS = (uint32_t)ETH_STATUS_RU_Msk;
    eth_mac->regs->RECEIVE_POLL_DEMAND = 0U;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return Pointer to current TX buffer
   *
   * \par<b>Description: </b><br>
   * Returns the current TX buffer.
   */
  __STATIC_INLINE uint8_t *XMC_ETH_MAC_GetTxBuffer(XMC_ETH_MAC_t *const eth_mac)
  {
    return (uint8_t *)(eth_mac->tx_desc[eth_mac->tx_index].buffer1);
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return Pointer to current RX buffer
   *
   * \par<b>Description: </b><br>
   * Returns the current RX buffer.
   */
  __STATIC_INLINE uint8_t *XMC_ETH_MAC_GetRxBuffer(XMC_ETH_MAC_t *const eth_mac)
  {
    return (uint8_t *)(eth_mac->rx_desc[eth_mac->rx_index].buffer1); 
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param size Size of buffer
   * @return None
   *
   * \par<b>Description: </b><br>
   * Sets the current TX buffer size.
   */
  __STATIC_INLINE void XMC_ETH_MAC_SetTxBufferSize(XMC_ETH_MAC_t *const eth_mac, uint32_t size)
  {
    eth_mac->tx_desc[eth_mac->tx_index].length = size;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param event A valid ETH PMT event (XMC_ETH_MAC_PMT_EVENT_t) or a valid combination
   *              of logically OR'd events
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable power management event(s) <br>
   *
   * \par
   * The function enables the event(s) that trigger(s) a PMT interrupt.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnablePowerManagmentEvent(XMC_ETH_MAC_t *const eth_mac, uint32_t event)
  {
    eth_mac->regs->PMT_CONTROL_STATUS |= (uint32_t)event;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param event A valid ETH PMT event (XMC_ETH_MAC_PMT_EVENT_t) or a valid combination
   *              of logically OR'd events
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable power management event(s) <br>
   *
   * \par
   * The function disables the event(s) that trigger(s) a PMT interrupt.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisablePowerManagmentEvent(XMC_ETH_MAC_t *const eth_mac, uint32_t event)
  {
    eth_mac->regs->PMT_CONTROL_STATUS &= ~(uint32_t)event;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param filter wake-up filter registers
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set wakeup frame filter <br>
   *
   * \par
   * The function populates the remote wakeup frame registers.
   */
  void XMC_ETH_MAC_SetWakeUpFrameFilter(XMC_ETH_MAC_t *const eth_mac,
                                        const uint32_t (*const filter)[XMC_ETH_WAKEUP_REGISTER_LENGTH]);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return bool true if the received packet is a magic packet, false otherwise
   *
   * \par<b>Description: </b><br>
   * Is magic packet received? <br>
   *
   * \par
   * The function checks if the packet received is a magic packet.
   */
  __STATIC_INLINE bool XMC_ETH_MAC_IsMagicPacketReceived(XMC_ETH_MAC_t *const eth_mac)
  {
    return (bool)(eth_mac->regs->PMT_CONTROL_STATUS & (uint32_t)ETH_PMT_CONTROL_STATUS_MGKPRCVD_Msk);
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return bool true if the received packet is a wakeup frame, false otherwise
   *
   * \par<b>Description: </b><br>
   * Is wakeup frame received? <br>
   *
   * \par
   * The function checks if the packet received is a wakeup frame.
   */
  __STATIC_INLINE bool XMC_ETH_MAC_IsWakeupFrameReceived(XMC_ETH_MAC_t *const eth_mac)
  {
    return (bool)(eth_mac->regs->PMT_CONTROL_STATUS & (uint32_t)ETH_PMT_CONTROL_STATUS_RWKPRCVD_Msk);
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable power down mode <br>
   *
   * \par
   * The function enables the power down mode of the ETH MAC.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnablePowerDownMode(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->PMT_CONTROL_STATUS |= (uint32_t)ETH_PMT_CONTROL_STATUS_PWRDWN_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable power down mode <br>
   *
   * \par
   * The function disables the power down mode of the ETH MAC.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisablePowerDownMode(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->PMT_CONTROL_STATUS &= ~(uint32_t)ETH_PMT_CONTROL_STATUS_PWRDWN_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param tag The (16 bit) VLAN tag to set
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set VLAN tag <br>
   *
   * \par
   * The function sets the VLAN tag to identify the VLAN frames.
   */
  void XMC_ETH_MAC_SetVLANTag(XMC_ETH_MAC_t *const eth_mac, uint32_t tag);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param config The configuration the PTP should be configured with
   * @return None
   *
   * \par<b>Description: </b><br>
   * Initialize PTP <br>
   *
   * \par
   * The function can be used to initialize PTP.
   */
  void XMC_ETH_MAC_InitPTP(XMC_ETH_MAC_t *const eth_mac, uint32_t config);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param config Configuration of PTP module. See ::XMC_ETH_MAC_TIMESTAMP_CONFIG_t
   * @param time Initialization time
   * @return None
   *
   * \par<b>Description: </b><br>
   * Initialize PTP <br>
   *
   * \par
   * The function can be used to initialize PTP given a time parameter in addition
   */
  void XMC_ETH_MAC_InitPTPEx(XMC_ETH_MAC_t *const eth_mac, uint32_t config, XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param time A constant pointer to XMC_ETH_MAC_TIME_t, pointing to the PTP time
   * @return None
   *
   * \par<b>Description: </b><br>
   * Get PTP time <br>
   *
   * \par
   * The function obtains the PTP time and writes the nanoseconds and seconds info
   * to the 'time' argument.
   */
  void XMC_ETH_MAC_GetPTPTime(XMC_ETH_MAC_t *const eth_mac, XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param time A constant pointer to XMC_ETH_MAC_TIME_t, pointing to the PTP time
   * @return None
   *
   * \par<b>Description: </b><br>
   * Get PTP time <br>
   *
   * \par
   * The function sets the PTP time give by the time parameter
   */
  void XMC_ETH_MAC_SetPTPTime(XMC_ETH_MAC_t *const eth_mac, XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param time A constant pointer to XMC_ETH_MAC_TIME_t, pointing to the PTP time
   * @return None
   *
   * \par<b>Description: </b><br>
   * Update PTP time <br>
   *
   * \par
   * The function updates the PTP time with the nanoseconds and seconds info contained in
   * the 'time' argument.
   */
  void XMC_ETH_MAC_UpdatePTPTime(XMC_ETH_MAC_t *const eth_mac, const XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param time A constant pointer to XMC_ETH_MAC_TIME_t, pointing to the PTP time
   * @return None
   *
   * \par<b>Description: </b><br>
   * Set PTP alarm <br>
   *
   * \par
   * The function programs the TARGET_TIME_NANOSECONDS and TARGET_TIME_SECONDS registers. It can
   * be used to schedule an interrupt event triggered when the set alarm time limit is reached.
   */
  void XMC_ETH_MAC_SetPTPAlarm(XMC_ETH_MAC_t *const eth_mac, const XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enables timestamp interrupt <br>
   *
   * \par
   * The timestamp interrupt is generated when the System Time becomes greater than the value written
   * in the Target Time register (Alarm). After the generation of the Timestamp Trigger Interrupt, the interrupt is disabled.
   */
  __STATIC_INLINE void XMC_ETH_MAC_EnablePTPAlarm(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->TIMESTAMP_CONTROL |= (uint32_t)ETH_TIMESTAMP_CONTROL_TSTRIG_Msk;
  }
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disables timestamp interrupt <br>
   *
   * \par
   * The timestamp interrupt is generated when the System Time becomes greater than the value written
   * in the Target Time register (Alarm). After the generation of the Timestamp Trigger Interrupt, the interrupt is disabled.
   */
  __STATIC_INLINE void XMC_ETH_MAC_DisablePTPAlarm(XMC_ETH_MAC_t *const eth_mac)
  {
    eth_mac->regs->TIMESTAMP_CONTROL &= (uint32_t)~ETH_TIMESTAMP_CONTROL_TSTRIG_Msk;
  }
  
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param addend Addend value
   * @return None
   *
   * \par<b>Description: </b><br>
   * Adjust PTP clock <br>
   *
   * \par
   * The function is used to adjust the PTP clock (time synchronization) to compensate a reference clock drift. 
   */
  void XMC_ETH_MAC_UpdateAddend(XMC_ETH_MAC_t *const eth_mac, uint32_t addend);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param correction Correction factor
   * @return None
   *
   * \par<b>Description: </b><br>
   * Adjust PTP clock <br>
   *
   * \par
   * The function can be used to adjust the PTP clock (time synchronization). Please see the
   * function implementation for more information.
   */
  void XMC_ETH_MAC_AdjustPTPClock(XMC_ETH_MAC_t *const eth_mac, uint32_t correction);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return uint32_t Timestamp status
   *
   * \par<b>Description: </b><br>
   * Get PTP status <br>
   *
   * \par
   * The function returns the timestamp status by reading the TIMESTAMP_STATUS register.
   * As indicated in the reference manual, all bits of the TIMESTAMP_STATUS register (except
   * bits [27:25]) are cleared after the invocation of this function.
   */
  uint32_t XMC_ETH_MAC_GetPTPStatus(const XMC_ETH_MAC_t *const eth_mac);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param time A constant pointer to XMC_ETH_MAC_TIME_t, pointing to the RX timestamp
   * @return XMC_ETH_MAC_STATUS_t ETH MAC status
   *
   * \par<b>Description: </b><br>
   * Get RX timestamp <br>
   *
   * \par
   * The function can be used to get the RX timestamp.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_GetRxTimeStamp(XMC_ETH_MAC_t *const eth_mac, XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param time A constant pointer to XMC_ETH_MAC_TIME_t, pointing to the TX timestamp
   * @return XMC_ETH_MAC_STATUS_t ETH MAC status
   *
   * \par<b>Description: </b><br>
   * Get TX timestamp <br>
   *
   * \par
   * The function can be used to get the TX timestamp.
   */
  XMC_ETH_MAC_STATUS_t XMC_ETH_MAC_GetTxTimeStamp(XMC_ETH_MAC_t *const eth_mac, XMC_ETH_MAC_TIME_t *const time);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param event Which event (or a combination of logically OR'd events) needs to be enabled?
   * @return None
   *
   * \par<b>Description: </b><br>
   * Enable ETH MAC event(s) <br>
   *
   * \par
   * The function can be used to enable ETH MAC event(s).
   */
  void XMC_ETH_MAC_EnableEvent(XMC_ETH_MAC_t *const eth_mac, uint32_t event);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param event Which event (or a combination of logically OR'd events) needs to be disabled?
   * @return None
   *
   * \par<b>Description: </b><br>
   * Disable an ETH MAC event(s) <br>
   *
   * \par
   * The function can be used to disable ETH MAC event(s).
   */
  void XMC_ETH_MAC_DisableEvent(XMC_ETH_MAC_t *const eth_mac, uint32_t event);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @param event The status of which event (or a combination of logically OR'd events) needs to be cleared
   * @return None
   *
   * \par<b>Description: </b><br>
   * Clear event status <br>
   *
   * \par
   * The function clears the status of an event passed as a parameter to the function.
   */
  void XMC_ETH_MAC_ClearEventStatus(XMC_ETH_MAC_t *const eth_mac, uint32_t event);
  
  /**
   * @param eth_mac A constant pointer to XMC_ETH_MAC_t, pointing to the ETH MAC base address
   * @return uint32_t Event status
   *
   * \par<b>Description: </b><br>
   * Get event status <br>
   *
   * \par
   * The function returns the ETH status and interrupt status as a single word. The user
   * can then check the status of the events by using an appropriate mask.
   */
  uint32_t XMC_ETH_MAC_GetEventStatus(const XMC_ETH_MAC_t *const eth_mac);
  
  #ifdef __cplusplus
  }
  #endif
   
  /**
   * @}
   */
   
  /**
   * @}
   */
   
  #endif /* defined (ETH0) */
  
  #endif /* XMC_ETH_MAC_H */
  