SAME54P20A Test Project
Data Structures | Macros
gmac.h File Reference

Component description for GMAC. More...

Go to the source code of this file.

Data Structures

union  GMAC_NCR_Type
 
union  GMAC_NCFGR_Type
 
union  GMAC_NSR_Type
 
union  GMAC_UR_Type
 
union  GMAC_DCFGR_Type
 
union  GMAC_TSR_Type
 
union  GMAC_RBQB_Type
 
union  GMAC_TBQB_Type
 
union  GMAC_RSR_Type
 
union  GMAC_ISR_Type
 
union  GMAC_IER_Type
 
union  GMAC_IDR_Type
 
union  GMAC_IMR_Type
 
union  GMAC_MAN_Type
 
union  GMAC_RPQ_Type
 
union  GMAC_TPQ_Type
 
union  GMAC_TPSF_Type
 
union  GMAC_RPSF_Type
 
union  GMAC_RJFML_Type
 
union  GMAC_HRB_Type
 
union  GMAC_HRT_Type
 
union  GMAC_SAB_Type
 
union  GMAC_SAT_Type
 
union  GMAC_TIDM_Type
 
union  GMAC_WOL_Type
 
union  GMAC_IPGS_Type
 
union  GMAC_SVLAN_Type
 
union  GMAC_TPFCP_Type
 
union  GMAC_SAMB1_Type
 
union  GMAC_SAMT1_Type
 
union  GMAC_NSC_Type
 
union  GMAC_SCL_Type
 
union  GMAC_SCH_Type
 
union  GMAC_EFTSH_Type
 
union  GMAC_EFRSH_Type
 
union  GMAC_PEFTSH_Type
 
union  GMAC_PEFRSH_Type
 
union  GMAC_OTLO_Type
 
union  GMAC_OTHI_Type
 
union  GMAC_FT_Type
 
union  GMAC_BCFT_Type
 
union  GMAC_MFT_Type
 
union  GMAC_PFT_Type
 
union  GMAC_BFT64_Type
 
union  GMAC_TBFT127_Type
 
union  GMAC_TBFT255_Type
 
union  GMAC_TBFT511_Type
 
union  GMAC_TBFT1023_Type
 
union  GMAC_TBFT1518_Type
 
union  GMAC_GTBFT1518_Type
 
union  GMAC_TUR_Type
 
union  GMAC_SCF_Type
 
union  GMAC_MCF_Type
 
union  GMAC_EC_Type
 
union  GMAC_LC_Type
 
union  GMAC_DTF_Type
 
union  GMAC_CSE_Type
 
union  GMAC_ORLO_Type
 
union  GMAC_ORHI_Type
 
union  GMAC_FR_Type
 
union  GMAC_BCFR_Type
 
union  GMAC_MFR_Type
 
union  GMAC_PFR_Type
 
union  GMAC_BFR64_Type
 
union  GMAC_TBFR127_Type
 
union  GMAC_TBFR255_Type
 
union  GMAC_TBFR511_Type
 
union  GMAC_TBFR1023_Type
 
union  GMAC_TBFR1518_Type
 
union  GMAC_TMXBFR_Type
 
union  GMAC_UFR_Type
 
union  GMAC_OFR_Type
 
union  GMAC_JR_Type
 
union  GMAC_FCSE_Type
 
union  GMAC_LFFE_Type
 
union  GMAC_RSE_Type
 
union  GMAC_AE_Type
 
union  GMAC_RRE_Type
 
union  GMAC_ROE_Type
 
union  GMAC_IHCE_Type
 
union  GMAC_TCE_Type
 
union  GMAC_UCE_Type
 
union  GMAC_TISUBN_Type
 
union  GMAC_TSH_Type
 
union  GMAC_TSSSL_Type
 
union  GMAC_TSSN_Type
 
union  GMAC_TSL_Type
 
union  GMAC_TN_Type
 
union  GMAC_TA_Type
 
union  GMAC_TI_Type
 
union  GMAC_EFTSL_Type
 
union  GMAC_EFTN_Type
 
union  GMAC_EFRSL_Type
 
union  GMAC_EFRN_Type
 
union  GMAC_PEFTSL_Type
 
union  GMAC_PEFTN_Type
 
union  GMAC_PEFRSL_Type
 
union  GMAC_PEFRN_Type
 
union  GMAC_RLPITR_Type
 
union  GMAC_RLPITI_Type
 
union  GMAC_TLPITR_Type
 
union  GMAC_TLPITI_Type
 
struct  GmacSa
 GmacSa hardware registers. More...
 
struct  Gmac
 GMAC hardware registers. More...
 

Macros

#define GMAC_U2005
 
#define REV_GMAC   0x100
 
#define GMAC_NCR_OFFSET   0x000
 (GMAC_NCR offset) Network Control Register
 
#define GMAC_NCR_RESETVALUE   _U_(0x00000000)
 (GMAC_NCR reset_value) Network Control Register
 
#define GMAC_NCR_LBL_Pos   1
 (GMAC_NCR) Loop Back Local
 
#define GMAC_NCR_LBL   (_U_(0x1) << GMAC_NCR_LBL_Pos)
 
#define GMAC_NCR_RXEN_Pos   2
 (GMAC_NCR) Receive Enable
 
#define GMAC_NCR_RXEN   (_U_(0x1) << GMAC_NCR_RXEN_Pos)
 
#define GMAC_NCR_TXEN_Pos   3
 (GMAC_NCR) Transmit Enable
 
#define GMAC_NCR_TXEN   (_U_(0x1) << GMAC_NCR_TXEN_Pos)
 
#define GMAC_NCR_MPE_Pos   4
 (GMAC_NCR) Management Port Enable
 
#define GMAC_NCR_MPE   (_U_(0x1) << GMAC_NCR_MPE_Pos)
 
#define GMAC_NCR_CLRSTAT_Pos   5
 (GMAC_NCR) Clear Statistics Registers
 
#define GMAC_NCR_CLRSTAT   (_U_(0x1) << GMAC_NCR_CLRSTAT_Pos)
 
#define GMAC_NCR_INCSTAT_Pos   6
 (GMAC_NCR) Increment Statistics Registers
 
#define GMAC_NCR_INCSTAT   (_U_(0x1) << GMAC_NCR_INCSTAT_Pos)
 
#define GMAC_NCR_WESTAT_Pos   7
 (GMAC_NCR) Write Enable for Statistics Registers
 
#define GMAC_NCR_WESTAT   (_U_(0x1) << GMAC_NCR_WESTAT_Pos)
 
#define GMAC_NCR_BP_Pos   8
 (GMAC_NCR) Back pressure
 
#define GMAC_NCR_BP   (_U_(0x1) << GMAC_NCR_BP_Pos)
 
#define GMAC_NCR_TSTART_Pos   9
 (GMAC_NCR) Start Transmission
 
#define GMAC_NCR_TSTART   (_U_(0x1) << GMAC_NCR_TSTART_Pos)
 
#define GMAC_NCR_THALT_Pos   10
 (GMAC_NCR) Transmit Halt
 
#define GMAC_NCR_THALT   (_U_(0x1) << GMAC_NCR_THALT_Pos)
 
#define GMAC_NCR_TXPF_Pos   11
 (GMAC_NCR) Transmit Pause Frame
 
#define GMAC_NCR_TXPF   (_U_(0x1) << GMAC_NCR_TXPF_Pos)
 
#define GMAC_NCR_TXZQPF_Pos   12
 (GMAC_NCR) Transmit Zero Quantum Pause Frame
 
#define GMAC_NCR_TXZQPF   (_U_(0x1) << GMAC_NCR_TXZQPF_Pos)
 
#define GMAC_NCR_SRTSM_Pos   15
 (GMAC_NCR) Store Receive Time Stamp to Memory
 
#define GMAC_NCR_SRTSM   (_U_(0x1) << GMAC_NCR_SRTSM_Pos)
 
#define GMAC_NCR_ENPBPR_Pos   16
 (GMAC_NCR) Enable PFC Priority-based Pause Reception
 
#define GMAC_NCR_ENPBPR   (_U_(0x1) << GMAC_NCR_ENPBPR_Pos)
 
#define GMAC_NCR_TXPBPF_Pos   17
 (GMAC_NCR) Transmit PFC Priority-based Pause Frame
 
#define GMAC_NCR_TXPBPF   (_U_(0x1) << GMAC_NCR_TXPBPF_Pos)
 
#define GMAC_NCR_FNP_Pos   18
 (GMAC_NCR) Flush Next Packet
 
#define GMAC_NCR_FNP   (_U_(0x1) << GMAC_NCR_FNP_Pos)
 
#define GMAC_NCR_LPI_Pos   19
 (GMAC_NCR) Low Power Idle Enable
 
#define GMAC_NCR_LPI   (_U_(0x1) << GMAC_NCR_LPI_Pos)
 
#define GMAC_NCR_MASK   _U_(0x000F9FFE)
 (GMAC_NCR) MASK Register
 
#define GMAC_NCFGR_OFFSET   0x004
 (GMAC_NCFGR offset) Network Configuration Register
 
#define GMAC_NCFGR_RESETVALUE   _U_(0x00080000)
 (GMAC_NCFGR reset_value) Network Configuration Register
 
#define GMAC_NCFGR_SPD_Pos   0
 (GMAC_NCFGR) Speed
 
#define GMAC_NCFGR_SPD   (_U_(0x1) << GMAC_NCFGR_SPD_Pos)
 
#define GMAC_NCFGR_FD_Pos   1
 (GMAC_NCFGR) Full Duplex
 
#define GMAC_NCFGR_FD   (_U_(0x1) << GMAC_NCFGR_FD_Pos)
 
#define GMAC_NCFGR_DNVLAN_Pos   2
 (GMAC_NCFGR) Discard Non-VLAN FRAMES
 
#define GMAC_NCFGR_DNVLAN   (_U_(0x1) << GMAC_NCFGR_DNVLAN_Pos)
 
#define GMAC_NCFGR_JFRAME_Pos   3
 (GMAC_NCFGR) Jumbo Frame Size
 
#define GMAC_NCFGR_JFRAME   (_U_(0x1) << GMAC_NCFGR_JFRAME_Pos)
 
#define GMAC_NCFGR_CAF_Pos   4
 (GMAC_NCFGR) Copy All Frames
 
#define GMAC_NCFGR_CAF   (_U_(0x1) << GMAC_NCFGR_CAF_Pos)
 
#define GMAC_NCFGR_NBC_Pos   5
 (GMAC_NCFGR) No Broadcast
 
#define GMAC_NCFGR_NBC   (_U_(0x1) << GMAC_NCFGR_NBC_Pos)
 
#define GMAC_NCFGR_MTIHEN_Pos   6
 (GMAC_NCFGR) Multicast Hash Enable
 
#define GMAC_NCFGR_MTIHEN   (_U_(0x1) << GMAC_NCFGR_MTIHEN_Pos)
 
#define GMAC_NCFGR_UNIHEN_Pos   7
 (GMAC_NCFGR) Unicast Hash Enable
 
#define GMAC_NCFGR_UNIHEN   (_U_(0x1) << GMAC_NCFGR_UNIHEN_Pos)
 
#define GMAC_NCFGR_MAXFS_Pos   8
 (GMAC_NCFGR) 1536 Maximum Frame Size
 
#define GMAC_NCFGR_MAXFS   (_U_(0x1) << GMAC_NCFGR_MAXFS_Pos)
 
#define GMAC_NCFGR_RTY_Pos   12
 (GMAC_NCFGR) Retry Test
 
#define GMAC_NCFGR_RTY   (_U_(0x1) << GMAC_NCFGR_RTY_Pos)
 
#define GMAC_NCFGR_PEN_Pos   13
 (GMAC_NCFGR) Pause Enable
 
#define GMAC_NCFGR_PEN   (_U_(0x1) << GMAC_NCFGR_PEN_Pos)
 
#define GMAC_NCFGR_RXBUFO_Pos   14
 (GMAC_NCFGR) Receive Buffer Offset
 
#define GMAC_NCFGR_RXBUFO_Msk   (_U_(0x3) << GMAC_NCFGR_RXBUFO_Pos)
 
#define GMAC_NCFGR_RXBUFO(value)   (GMAC_NCFGR_RXBUFO_Msk & ((value) << GMAC_NCFGR_RXBUFO_Pos))
 
#define GMAC_NCFGR_LFERD_Pos   16
 (GMAC_NCFGR) Length Field Error Frame Discard
 
#define GMAC_NCFGR_LFERD   (_U_(0x1) << GMAC_NCFGR_LFERD_Pos)
 
#define GMAC_NCFGR_RFCS_Pos   17
 (GMAC_NCFGR) Remove FCS
 
#define GMAC_NCFGR_RFCS   (_U_(0x1) << GMAC_NCFGR_RFCS_Pos)
 
#define GMAC_NCFGR_CLK_Pos   18
 (GMAC_NCFGR) MDC CLock Division
 
#define GMAC_NCFGR_CLK_Msk   (_U_(0x7) << GMAC_NCFGR_CLK_Pos)
 
#define GMAC_NCFGR_CLK(value)   (GMAC_NCFGR_CLK_Msk & ((value) << GMAC_NCFGR_CLK_Pos))
 
#define GMAC_NCFGR_DBW_Pos   21
 (GMAC_NCFGR) Data Bus Width
 
#define GMAC_NCFGR_DBW_Msk   (_U_(0x3) << GMAC_NCFGR_DBW_Pos)
 
#define GMAC_NCFGR_DBW(value)   (GMAC_NCFGR_DBW_Msk & ((value) << GMAC_NCFGR_DBW_Pos))
 
#define GMAC_NCFGR_DCPF_Pos   23
 (GMAC_NCFGR) Disable Copy of Pause Frames
 
#define GMAC_NCFGR_DCPF   (_U_(0x1) << GMAC_NCFGR_DCPF_Pos)
 
#define GMAC_NCFGR_RXCOEN_Pos   24
 (GMAC_NCFGR) Receive Checksum Offload Enable
 
#define GMAC_NCFGR_RXCOEN   (_U_(0x1) << GMAC_NCFGR_RXCOEN_Pos)
 
#define GMAC_NCFGR_EFRHD_Pos   25
 (GMAC_NCFGR) Enable Frames Received in Half Duplex
 
#define GMAC_NCFGR_EFRHD   (_U_(0x1) << GMAC_NCFGR_EFRHD_Pos)
 
#define GMAC_NCFGR_IRXFCS_Pos   26
 (GMAC_NCFGR) Ignore RX FCS
 
#define GMAC_NCFGR_IRXFCS   (_U_(0x1) << GMAC_NCFGR_IRXFCS_Pos)
 
#define GMAC_NCFGR_IPGSEN_Pos   28
 (GMAC_NCFGR) IP Stretch Enable
 
#define GMAC_NCFGR_IPGSEN   (_U_(0x1) << GMAC_NCFGR_IPGSEN_Pos)
 
#define GMAC_NCFGR_RXBP_Pos   29
 (GMAC_NCFGR) Receive Bad Preamble
 
#define GMAC_NCFGR_RXBP   (_U_(0x1) << GMAC_NCFGR_RXBP_Pos)
 
#define GMAC_NCFGR_IRXER_Pos   30
 (GMAC_NCFGR) Ignore IPG GRXER
 
#define GMAC_NCFGR_IRXER   (_U_(0x1) << GMAC_NCFGR_IRXER_Pos)
 
#define GMAC_NCFGR_MASK   _U_(0x77FFF1FF)
 (GMAC_NCFGR) MASK Register
 
#define GMAC_NSR_OFFSET   0x008
 (GMAC_NSR offset) Network Status Register
 
#define GMAC_NSR_RESETVALUE   _U_(0x00000004)
 (GMAC_NSR reset_value) Network Status Register
 
#define GMAC_NSR_MDIO_Pos   1
 (GMAC_NSR) MDIO Input Status
 
#define GMAC_NSR_MDIO   (_U_(0x1) << GMAC_NSR_MDIO_Pos)
 
#define GMAC_NSR_IDLE_Pos   2
 (GMAC_NSR) PHY Management Logic Idle
 
#define GMAC_NSR_IDLE   (_U_(0x1) << GMAC_NSR_IDLE_Pos)
 
#define GMAC_NSR_MASK   _U_(0x00000006)
 (GMAC_NSR) MASK Register
 
#define GMAC_UR_OFFSET   0x00C
 (GMAC_UR offset) User Register
 
#define GMAC_UR_RESETVALUE   _U_(0x00000000)
 (GMAC_UR reset_value) User Register
 
#define GMAC_UR_MII_Pos   0
 (GMAC_UR) MII Mode
 
#define GMAC_UR_MII   (_U_(0x1) << GMAC_UR_MII_Pos)
 
#define GMAC_UR_MASK   _U_(0x00000001)
 (GMAC_UR) MASK Register
 
#define GMAC_DCFGR_OFFSET   0x010
 (GMAC_DCFGR offset) DMA Configuration Register
 
#define GMAC_DCFGR_RESETVALUE   _U_(0x00020704)
 (GMAC_DCFGR reset_value) DMA Configuration Register
 
#define GMAC_DCFGR_FBLDO_Pos   0
 (GMAC_DCFGR) Fixed Burst Length for DMA Data Operations:
 
#define GMAC_DCFGR_FBLDO_Msk   (_U_(0x1F) << GMAC_DCFGR_FBLDO_Pos)
 
#define GMAC_DCFGR_FBLDO(value)   (GMAC_DCFGR_FBLDO_Msk & ((value) << GMAC_DCFGR_FBLDO_Pos))
 
#define GMAC_DCFGR_ESMA_Pos   6
 (GMAC_DCFGR) Endian Swap Mode Enable for Management Descriptor Accesses
 
#define GMAC_DCFGR_ESMA   (_U_(0x1) << GMAC_DCFGR_ESMA_Pos)
 
#define GMAC_DCFGR_ESPA_Pos   7
 (GMAC_DCFGR) Endian Swap Mode Enable for Packet Data Accesses
 
#define GMAC_DCFGR_ESPA   (_U_(0x1) << GMAC_DCFGR_ESPA_Pos)
 
#define GMAC_DCFGR_RXBMS_Pos   8
 (GMAC_DCFGR) Receiver Packet Buffer Memory Size Select
 
#define GMAC_DCFGR_RXBMS_Msk   (_U_(0x3) << GMAC_DCFGR_RXBMS_Pos)
 
#define GMAC_DCFGR_RXBMS(value)   (GMAC_DCFGR_RXBMS_Msk & ((value) << GMAC_DCFGR_RXBMS_Pos))
 
#define GMAC_DCFGR_TXPBMS_Pos   10
 (GMAC_DCFGR) Transmitter Packet Buffer Memory Size Select
 
#define GMAC_DCFGR_TXPBMS   (_U_(0x1) << GMAC_DCFGR_TXPBMS_Pos)
 
#define GMAC_DCFGR_TXCOEN_Pos   11
 (GMAC_DCFGR) Transmitter Checksum Generation Offload Enable
 
#define GMAC_DCFGR_TXCOEN   (_U_(0x1) << GMAC_DCFGR_TXCOEN_Pos)
 
#define GMAC_DCFGR_DRBS_Pos   16
 (GMAC_DCFGR) DMA Receive Buffer Size
 
#define GMAC_DCFGR_DRBS_Msk   (_U_(0xFF) << GMAC_DCFGR_DRBS_Pos)
 
#define GMAC_DCFGR_DRBS(value)   (GMAC_DCFGR_DRBS_Msk & ((value) << GMAC_DCFGR_DRBS_Pos))
 
#define GMAC_DCFGR_DDRP_Pos   24
 (GMAC_DCFGR) DMA Discard Receive Packets
 
#define GMAC_DCFGR_DDRP   (_U_(0x1) << GMAC_DCFGR_DDRP_Pos)
 
#define GMAC_DCFGR_MASK   _U_(0x01FF0FDF)
 (GMAC_DCFGR) MASK Register
 
#define GMAC_TSR_OFFSET   0x014
 (GMAC_TSR offset) Transmit Status Register
 
#define GMAC_TSR_RESETVALUE   _U_(0x00000000)
 (GMAC_TSR reset_value) Transmit Status Register
 
#define GMAC_TSR_UBR_Pos   0
 (GMAC_TSR) Used Bit Read
 
#define GMAC_TSR_UBR   (_U_(0x1) << GMAC_TSR_UBR_Pos)
 
#define GMAC_TSR_COL_Pos   1
 (GMAC_TSR) Collision Occurred
 
#define GMAC_TSR_COL   (_U_(0x1) << GMAC_TSR_COL_Pos)
 
#define GMAC_TSR_RLE_Pos   2
 (GMAC_TSR) Retry Limit Exceeded
 
#define GMAC_TSR_RLE   (_U_(0x1) << GMAC_TSR_RLE_Pos)
 
#define GMAC_TSR_TXGO_Pos   3
 (GMAC_TSR) Transmit Go
 
#define GMAC_TSR_TXGO   (_U_(0x1) << GMAC_TSR_TXGO_Pos)
 
#define GMAC_TSR_TFC_Pos   4
 (GMAC_TSR) Transmit Frame Corruption Due to AHB Error
 
#define GMAC_TSR_TFC   (_U_(0x1) << GMAC_TSR_TFC_Pos)
 
#define GMAC_TSR_TXCOMP_Pos   5
 (GMAC_TSR) Transmit Complete
 
#define GMAC_TSR_TXCOMP   (_U_(0x1) << GMAC_TSR_TXCOMP_Pos)
 
#define GMAC_TSR_UND_Pos   6
 (GMAC_TSR) Transmit Underrun
 
#define GMAC_TSR_UND   (_U_(0x1) << GMAC_TSR_UND_Pos)
 
#define GMAC_TSR_HRESP_Pos   8
 (GMAC_TSR) HRESP Not OK
 
#define GMAC_TSR_HRESP   (_U_(0x1) << GMAC_TSR_HRESP_Pos)
 
#define GMAC_TSR_MASK   _U_(0x0000017F)
 (GMAC_TSR) MASK Register
 
#define GMAC_RBQB_OFFSET   0x018
 (GMAC_RBQB offset) Receive Buffer Queue Base Address
 
#define GMAC_RBQB_RESETVALUE   _U_(0x00000000)
 (GMAC_RBQB reset_value) Receive Buffer Queue Base Address
 
#define GMAC_RBQB_ADDR_Pos   2
 (GMAC_RBQB) Receive Buffer Queue Base Address
 
#define GMAC_RBQB_ADDR_Msk   (_U_(0x3FFFFFFF) << GMAC_RBQB_ADDR_Pos)
 
#define GMAC_RBQB_ADDR(value)   (GMAC_RBQB_ADDR_Msk & ((value) << GMAC_RBQB_ADDR_Pos))
 
#define GMAC_RBQB_MASK   _U_(0xFFFFFFFC)
 (GMAC_RBQB) MASK Register
 
#define GMAC_TBQB_OFFSET   0x01C
 (GMAC_TBQB offset) Transmit Buffer Queue Base Address
 
#define GMAC_TBQB_RESETVALUE   _U_(0x00000000)
 (GMAC_TBQB reset_value) Transmit Buffer Queue Base Address
 
#define GMAC_TBQB_ADDR_Pos   2
 (GMAC_TBQB) Transmit Buffer Queue Base Address
 
#define GMAC_TBQB_ADDR_Msk   (_U_(0x3FFFFFFF) << GMAC_TBQB_ADDR_Pos)
 
#define GMAC_TBQB_ADDR(value)   (GMAC_TBQB_ADDR_Msk & ((value) << GMAC_TBQB_ADDR_Pos))
 
#define GMAC_TBQB_MASK   _U_(0xFFFFFFFC)
 (GMAC_TBQB) MASK Register
 
#define GMAC_RSR_OFFSET   0x020
 (GMAC_RSR offset) Receive Status Register
 
#define GMAC_RSR_RESETVALUE   _U_(0x00000000)
 (GMAC_RSR reset_value) Receive Status Register
 
#define GMAC_RSR_BNA_Pos   0
 (GMAC_RSR) Buffer Not Available
 
#define GMAC_RSR_BNA   (_U_(0x1) << GMAC_RSR_BNA_Pos)
 
#define GMAC_RSR_REC_Pos   1
 (GMAC_RSR) Frame Received
 
#define GMAC_RSR_REC   (_U_(0x1) << GMAC_RSR_REC_Pos)
 
#define GMAC_RSR_RXOVR_Pos   2
 (GMAC_RSR) Receive Overrun
 
#define GMAC_RSR_RXOVR   (_U_(0x1) << GMAC_RSR_RXOVR_Pos)
 
#define GMAC_RSR_HNO_Pos   3
 (GMAC_RSR) HRESP Not OK
 
#define GMAC_RSR_HNO   (_U_(0x1) << GMAC_RSR_HNO_Pos)
 
#define GMAC_RSR_MASK   _U_(0x0000000F)
 (GMAC_RSR) MASK Register
 
#define GMAC_ISR_OFFSET   0x024
 (GMAC_ISR offset) Interrupt Status Register
 
#define GMAC_ISR_RESETVALUE   _U_(0x00000000)
 (GMAC_ISR reset_value) Interrupt Status Register
 
#define GMAC_ISR_MFS_Pos   0
 (GMAC_ISR) Management Frame Sent
 
#define GMAC_ISR_MFS   (_U_(0x1) << GMAC_ISR_MFS_Pos)
 
#define GMAC_ISR_RCOMP_Pos   1
 (GMAC_ISR) Receive Complete
 
#define GMAC_ISR_RCOMP   (_U_(0x1) << GMAC_ISR_RCOMP_Pos)
 
#define GMAC_ISR_RXUBR_Pos   2
 (GMAC_ISR) RX Used Bit Read
 
#define GMAC_ISR_RXUBR   (_U_(0x1) << GMAC_ISR_RXUBR_Pos)
 
#define GMAC_ISR_TXUBR_Pos   3
 (GMAC_ISR) TX Used Bit Read
 
#define GMAC_ISR_TXUBR   (_U_(0x1) << GMAC_ISR_TXUBR_Pos)
 
#define GMAC_ISR_TUR_Pos   4
 (GMAC_ISR) Transmit Underrun
 
#define GMAC_ISR_TUR   (_U_(0x1) << GMAC_ISR_TUR_Pos)
 
#define GMAC_ISR_RLEX_Pos   5
 (GMAC_ISR) Retry Limit Exceeded
 
#define GMAC_ISR_RLEX   (_U_(0x1) << GMAC_ISR_RLEX_Pos)
 
#define GMAC_ISR_TFC_Pos   6
 (GMAC_ISR) Transmit Frame Corruption Due to AHB Error
 
#define GMAC_ISR_TFC   (_U_(0x1) << GMAC_ISR_TFC_Pos)
 
#define GMAC_ISR_TCOMP_Pos   7
 (GMAC_ISR) Transmit Complete
 
#define GMAC_ISR_TCOMP   (_U_(0x1) << GMAC_ISR_TCOMP_Pos)
 
#define GMAC_ISR_ROVR_Pos   10
 (GMAC_ISR) Receive Overrun
 
#define GMAC_ISR_ROVR   (_U_(0x1) << GMAC_ISR_ROVR_Pos)
 
#define GMAC_ISR_HRESP_Pos   11
 (GMAC_ISR) HRESP Not OK
 
#define GMAC_ISR_HRESP   (_U_(0x1) << GMAC_ISR_HRESP_Pos)
 
#define GMAC_ISR_PFNZ_Pos   12
 (GMAC_ISR) Pause Frame with Non-zero Pause Quantum Received
 
#define GMAC_ISR_PFNZ   (_U_(0x1) << GMAC_ISR_PFNZ_Pos)
 
#define GMAC_ISR_PTZ_Pos   13
 (GMAC_ISR) Pause Time Zero
 
#define GMAC_ISR_PTZ   (_U_(0x1) << GMAC_ISR_PTZ_Pos)
 
#define GMAC_ISR_PFTR_Pos   14
 (GMAC_ISR) Pause Frame Transmitted
 
#define GMAC_ISR_PFTR   (_U_(0x1) << GMAC_ISR_PFTR_Pos)
 
#define GMAC_ISR_DRQFR_Pos   18
 (GMAC_ISR) PTP Delay Request Frame Received
 
#define GMAC_ISR_DRQFR   (_U_(0x1) << GMAC_ISR_DRQFR_Pos)
 
#define GMAC_ISR_SFR_Pos   19
 (GMAC_ISR) PTP Sync Frame Received
 
#define GMAC_ISR_SFR   (_U_(0x1) << GMAC_ISR_SFR_Pos)
 
#define GMAC_ISR_DRQFT_Pos   20
 (GMAC_ISR) PTP Delay Request Frame Transmitted
 
#define GMAC_ISR_DRQFT   (_U_(0x1) << GMAC_ISR_DRQFT_Pos)
 
#define GMAC_ISR_SFT_Pos   21
 (GMAC_ISR) PTP Sync Frame Transmitted
 
#define GMAC_ISR_SFT   (_U_(0x1) << GMAC_ISR_SFT_Pos)
 
#define GMAC_ISR_PDRQFR_Pos   22
 (GMAC_ISR) PDelay Request Frame Received
 
#define GMAC_ISR_PDRQFR   (_U_(0x1) << GMAC_ISR_PDRQFR_Pos)
 
#define GMAC_ISR_PDRSFR_Pos   23
 (GMAC_ISR) PDelay Response Frame Received
 
#define GMAC_ISR_PDRSFR   (_U_(0x1) << GMAC_ISR_PDRSFR_Pos)
 
#define GMAC_ISR_PDRQFT_Pos   24
 (GMAC_ISR) PDelay Request Frame Transmitted
 
#define GMAC_ISR_PDRQFT   (_U_(0x1) << GMAC_ISR_PDRQFT_Pos)
 
#define GMAC_ISR_PDRSFT_Pos   25
 (GMAC_ISR) PDelay Response Frame Transmitted
 
#define GMAC_ISR_PDRSFT   (_U_(0x1) << GMAC_ISR_PDRSFT_Pos)
 
#define GMAC_ISR_SRI_Pos   26
 (GMAC_ISR) TSU Seconds Register Increment
 
#define GMAC_ISR_SRI   (_U_(0x1) << GMAC_ISR_SRI_Pos)
 
#define GMAC_ISR_WOL_Pos   28
 (GMAC_ISR) Wake On LAN
 
#define GMAC_ISR_WOL   (_U_(0x1) << GMAC_ISR_WOL_Pos)
 
#define GMAC_ISR_TSUCMP_Pos   29
 (GMAC_ISR) Tsu timer comparison
 
#define GMAC_ISR_TSUCMP   (_U_(0x1) << GMAC_ISR_TSUCMP_Pos)
 
#define GMAC_ISR_MASK   _U_(0x37FC7CFF)
 (GMAC_ISR) MASK Register
 
#define GMAC_IER_OFFSET   0x028
 (GMAC_IER offset) Interrupt Enable Register
 
#define GMAC_IER_MFS_Pos   0
 (GMAC_IER) Management Frame Sent
 
#define GMAC_IER_MFS   (_U_(0x1) << GMAC_IER_MFS_Pos)
 
#define GMAC_IER_RCOMP_Pos   1
 (GMAC_IER) Receive Complete
 
#define GMAC_IER_RCOMP   (_U_(0x1) << GMAC_IER_RCOMP_Pos)
 
#define GMAC_IER_RXUBR_Pos   2
 (GMAC_IER) RX Used Bit Read
 
#define GMAC_IER_RXUBR   (_U_(0x1) << GMAC_IER_RXUBR_Pos)
 
#define GMAC_IER_TXUBR_Pos   3
 (GMAC_IER) TX Used Bit Read
 
#define GMAC_IER_TXUBR   (_U_(0x1) << GMAC_IER_TXUBR_Pos)
 
#define GMAC_IER_TUR_Pos   4
 (GMAC_IER) Transmit Underrun
 
#define GMAC_IER_TUR   (_U_(0x1) << GMAC_IER_TUR_Pos)
 
#define GMAC_IER_RLEX_Pos   5
 (GMAC_IER) Retry Limit Exceeded or Late Collision
 
#define GMAC_IER_RLEX   (_U_(0x1) << GMAC_IER_RLEX_Pos)
 
#define GMAC_IER_TFC_Pos   6
 (GMAC_IER) Transmit Frame Corruption Due to AHB Error
 
#define GMAC_IER_TFC   (_U_(0x1) << GMAC_IER_TFC_Pos)
 
#define GMAC_IER_TCOMP_Pos   7
 (GMAC_IER) Transmit Complete
 
#define GMAC_IER_TCOMP   (_U_(0x1) << GMAC_IER_TCOMP_Pos)
 
#define GMAC_IER_ROVR_Pos   10
 (GMAC_IER) Receive Overrun
 
#define GMAC_IER_ROVR   (_U_(0x1) << GMAC_IER_ROVR_Pos)
 
#define GMAC_IER_HRESP_Pos   11
 (GMAC_IER) HRESP Not OK
 
#define GMAC_IER_HRESP   (_U_(0x1) << GMAC_IER_HRESP_Pos)
 
#define GMAC_IER_PFNZ_Pos   12
 (GMAC_IER) Pause Frame with Non-zero Pause Quantum Received
 
#define GMAC_IER_PFNZ   (_U_(0x1) << GMAC_IER_PFNZ_Pos)
 
#define GMAC_IER_PTZ_Pos   13
 (GMAC_IER) Pause Time Zero
 
#define GMAC_IER_PTZ   (_U_(0x1) << GMAC_IER_PTZ_Pos)
 
#define GMAC_IER_PFTR_Pos   14
 (GMAC_IER) Pause Frame Transmitted
 
#define GMAC_IER_PFTR   (_U_(0x1) << GMAC_IER_PFTR_Pos)
 
#define GMAC_IER_EXINT_Pos   15
 (GMAC_IER) External Interrupt
 
#define GMAC_IER_EXINT   (_U_(0x1) << GMAC_IER_EXINT_Pos)
 
#define GMAC_IER_DRQFR_Pos   18
 (GMAC_IER) PTP Delay Request Frame Received
 
#define GMAC_IER_DRQFR   (_U_(0x1) << GMAC_IER_DRQFR_Pos)
 
#define GMAC_IER_SFR_Pos   19
 (GMAC_IER) PTP Sync Frame Received
 
#define GMAC_IER_SFR   (_U_(0x1) << GMAC_IER_SFR_Pos)
 
#define GMAC_IER_DRQFT_Pos   20
 (GMAC_IER) PTP Delay Request Frame Transmitted
 
#define GMAC_IER_DRQFT   (_U_(0x1) << GMAC_IER_DRQFT_Pos)
 
#define GMAC_IER_SFT_Pos   21
 (GMAC_IER) PTP Sync Frame Transmitted
 
#define GMAC_IER_SFT   (_U_(0x1) << GMAC_IER_SFT_Pos)
 
#define GMAC_IER_PDRQFR_Pos   22
 (GMAC_IER) PDelay Request Frame Received
 
#define GMAC_IER_PDRQFR   (_U_(0x1) << GMAC_IER_PDRQFR_Pos)
 
#define GMAC_IER_PDRSFR_Pos   23
 (GMAC_IER) PDelay Response Frame Received
 
#define GMAC_IER_PDRSFR   (_U_(0x1) << GMAC_IER_PDRSFR_Pos)
 
#define GMAC_IER_PDRQFT_Pos   24
 (GMAC_IER) PDelay Request Frame Transmitted
 
#define GMAC_IER_PDRQFT   (_U_(0x1) << GMAC_IER_PDRQFT_Pos)
 
#define GMAC_IER_PDRSFT_Pos   25
 (GMAC_IER) PDelay Response Frame Transmitted
 
#define GMAC_IER_PDRSFT   (_U_(0x1) << GMAC_IER_PDRSFT_Pos)
 
#define GMAC_IER_SRI_Pos   26
 (GMAC_IER) TSU Seconds Register Increment
 
#define GMAC_IER_SRI   (_U_(0x1) << GMAC_IER_SRI_Pos)
 
#define GMAC_IER_WOL_Pos   28
 (GMAC_IER) Wake On LAN
 
#define GMAC_IER_WOL   (_U_(0x1) << GMAC_IER_WOL_Pos)
 
#define GMAC_IER_TSUCMP_Pos   29
 (GMAC_IER) Tsu timer comparison
 
#define GMAC_IER_TSUCMP   (_U_(0x1) << GMAC_IER_TSUCMP_Pos)
 
#define GMAC_IER_MASK   _U_(0x37FCFCFF)
 (GMAC_IER) MASK Register
 
#define GMAC_IDR_OFFSET   0x02C
 (GMAC_IDR offset) Interrupt Disable Register
 
#define GMAC_IDR_MFS_Pos   0
 (GMAC_IDR) Management Frame Sent
 
#define GMAC_IDR_MFS   (_U_(0x1) << GMAC_IDR_MFS_Pos)
 
#define GMAC_IDR_RCOMP_Pos   1
 (GMAC_IDR) Receive Complete
 
#define GMAC_IDR_RCOMP   (_U_(0x1) << GMAC_IDR_RCOMP_Pos)
 
#define GMAC_IDR_RXUBR_Pos   2
 (GMAC_IDR) RX Used Bit Read
 
#define GMAC_IDR_RXUBR   (_U_(0x1) << GMAC_IDR_RXUBR_Pos)
 
#define GMAC_IDR_TXUBR_Pos   3
 (GMAC_IDR) TX Used Bit Read
 
#define GMAC_IDR_TXUBR   (_U_(0x1) << GMAC_IDR_TXUBR_Pos)
 
#define GMAC_IDR_TUR_Pos   4
 (GMAC_IDR) Transmit Underrun
 
#define GMAC_IDR_TUR   (_U_(0x1) << GMAC_IDR_TUR_Pos)
 
#define GMAC_IDR_RLEX_Pos   5
 (GMAC_IDR) Retry Limit Exceeded or Late Collision
 
#define GMAC_IDR_RLEX   (_U_(0x1) << GMAC_IDR_RLEX_Pos)
 
#define GMAC_IDR_TFC_Pos   6
 (GMAC_IDR) Transmit Frame Corruption Due to AHB Error
 
#define GMAC_IDR_TFC   (_U_(0x1) << GMAC_IDR_TFC_Pos)
 
#define GMAC_IDR_TCOMP_Pos   7
 (GMAC_IDR) Transmit Complete
 
#define GMAC_IDR_TCOMP   (_U_(0x1) << GMAC_IDR_TCOMP_Pos)
 
#define GMAC_IDR_ROVR_Pos   10
 (GMAC_IDR) Receive Overrun
 
#define GMAC_IDR_ROVR   (_U_(0x1) << GMAC_IDR_ROVR_Pos)
 
#define GMAC_IDR_HRESP_Pos   11
 (GMAC_IDR) HRESP Not OK
 
#define GMAC_IDR_HRESP   (_U_(0x1) << GMAC_IDR_HRESP_Pos)
 
#define GMAC_IDR_PFNZ_Pos   12
 (GMAC_IDR) Pause Frame with Non-zero Pause Quantum Received
 
#define GMAC_IDR_PFNZ   (_U_(0x1) << GMAC_IDR_PFNZ_Pos)
 
#define GMAC_IDR_PTZ_Pos   13
 (GMAC_IDR) Pause Time Zero
 
#define GMAC_IDR_PTZ   (_U_(0x1) << GMAC_IDR_PTZ_Pos)
 
#define GMAC_IDR_PFTR_Pos   14
 (GMAC_IDR) Pause Frame Transmitted
 
#define GMAC_IDR_PFTR   (_U_(0x1) << GMAC_IDR_PFTR_Pos)
 
#define GMAC_IDR_EXINT_Pos   15
 (GMAC_IDR) External Interrupt
 
#define GMAC_IDR_EXINT   (_U_(0x1) << GMAC_IDR_EXINT_Pos)
 
#define GMAC_IDR_DRQFR_Pos   18
 (GMAC_IDR) PTP Delay Request Frame Received
 
#define GMAC_IDR_DRQFR   (_U_(0x1) << GMAC_IDR_DRQFR_Pos)
 
#define GMAC_IDR_SFR_Pos   19
 (GMAC_IDR) PTP Sync Frame Received
 
#define GMAC_IDR_SFR   (_U_(0x1) << GMAC_IDR_SFR_Pos)
 
#define GMAC_IDR_DRQFT_Pos   20
 (GMAC_IDR) PTP Delay Request Frame Transmitted
 
#define GMAC_IDR_DRQFT   (_U_(0x1) << GMAC_IDR_DRQFT_Pos)
 
#define GMAC_IDR_SFT_Pos   21
 (GMAC_IDR) PTP Sync Frame Transmitted
 
#define GMAC_IDR_SFT   (_U_(0x1) << GMAC_IDR_SFT_Pos)
 
#define GMAC_IDR_PDRQFR_Pos   22
 (GMAC_IDR) PDelay Request Frame Received
 
#define GMAC_IDR_PDRQFR   (_U_(0x1) << GMAC_IDR_PDRQFR_Pos)
 
#define GMAC_IDR_PDRSFR_Pos   23
 (GMAC_IDR) PDelay Response Frame Received
 
#define GMAC_IDR_PDRSFR   (_U_(0x1) << GMAC_IDR_PDRSFR_Pos)
 
#define GMAC_IDR_PDRQFT_Pos   24
 (GMAC_IDR) PDelay Request Frame Transmitted
 
#define GMAC_IDR_PDRQFT   (_U_(0x1) << GMAC_IDR_PDRQFT_Pos)
 
#define GMAC_IDR_PDRSFT_Pos   25
 (GMAC_IDR) PDelay Response Frame Transmitted
 
#define GMAC_IDR_PDRSFT   (_U_(0x1) << GMAC_IDR_PDRSFT_Pos)
 
#define GMAC_IDR_SRI_Pos   26
 (GMAC_IDR) TSU Seconds Register Increment
 
#define GMAC_IDR_SRI   (_U_(0x1) << GMAC_IDR_SRI_Pos)
 
#define GMAC_IDR_WOL_Pos   28
 (GMAC_IDR) Wake On LAN
 
#define GMAC_IDR_WOL   (_U_(0x1) << GMAC_IDR_WOL_Pos)
 
#define GMAC_IDR_TSUCMP_Pos   29
 (GMAC_IDR) Tsu timer comparison
 
#define GMAC_IDR_TSUCMP   (_U_(0x1) << GMAC_IDR_TSUCMP_Pos)
 
#define GMAC_IDR_MASK   _U_(0x37FCFCFF)
 (GMAC_IDR) MASK Register
 
#define GMAC_IMR_OFFSET   0x030
 (GMAC_IMR offset) Interrupt Mask Register
 
#define GMAC_IMR_RESETVALUE   _U_(0x3FFFFFFF)
 (GMAC_IMR reset_value) Interrupt Mask Register
 
#define GMAC_IMR_MFS_Pos   0
 (GMAC_IMR) Management Frame Sent
 
#define GMAC_IMR_MFS   (_U_(0x1) << GMAC_IMR_MFS_Pos)
 
#define GMAC_IMR_RCOMP_Pos   1
 (GMAC_IMR) Receive Complete
 
#define GMAC_IMR_RCOMP   (_U_(0x1) << GMAC_IMR_RCOMP_Pos)
 
#define GMAC_IMR_RXUBR_Pos   2
 (GMAC_IMR) RX Used Bit Read
 
#define GMAC_IMR_RXUBR   (_U_(0x1) << GMAC_IMR_RXUBR_Pos)
 
#define GMAC_IMR_TXUBR_Pos   3
 (GMAC_IMR) TX Used Bit Read
 
#define GMAC_IMR_TXUBR   (_U_(0x1) << GMAC_IMR_TXUBR_Pos)
 
#define GMAC_IMR_TUR_Pos   4
 (GMAC_IMR) Transmit Underrun
 
#define GMAC_IMR_TUR   (_U_(0x1) << GMAC_IMR_TUR_Pos)
 
#define GMAC_IMR_RLEX_Pos   5
 (GMAC_IMR) Retry Limit Exceeded
 
#define GMAC_IMR_RLEX   (_U_(0x1) << GMAC_IMR_RLEX_Pos)
 
#define GMAC_IMR_TFC_Pos   6
 (GMAC_IMR) Transmit Frame Corruption Due to AHB Error
 
#define GMAC_IMR_TFC   (_U_(0x1) << GMAC_IMR_TFC_Pos)
 
#define GMAC_IMR_TCOMP_Pos   7
 (GMAC_IMR) Transmit Complete
 
#define GMAC_IMR_TCOMP   (_U_(0x1) << GMAC_IMR_TCOMP_Pos)
 
#define GMAC_IMR_ROVR_Pos   10
 (GMAC_IMR) Receive Overrun
 
#define GMAC_IMR_ROVR   (_U_(0x1) << GMAC_IMR_ROVR_Pos)
 
#define GMAC_IMR_HRESP_Pos   11
 (GMAC_IMR) HRESP Not OK
 
#define GMAC_IMR_HRESP   (_U_(0x1) << GMAC_IMR_HRESP_Pos)
 
#define GMAC_IMR_PFNZ_Pos   12
 (GMAC_IMR) Pause Frame with Non-zero Pause Quantum Received
 
#define GMAC_IMR_PFNZ   (_U_(0x1) << GMAC_IMR_PFNZ_Pos)
 
#define GMAC_IMR_PTZ_Pos   13
 (GMAC_IMR) Pause Time Zero
 
#define GMAC_IMR_PTZ   (_U_(0x1) << GMAC_IMR_PTZ_Pos)
 
#define GMAC_IMR_PFTR_Pos   14
 (GMAC_IMR) Pause Frame Transmitted
 
#define GMAC_IMR_PFTR   (_U_(0x1) << GMAC_IMR_PFTR_Pos)
 
#define GMAC_IMR_EXINT_Pos   15
 (GMAC_IMR) External Interrupt
 
#define GMAC_IMR_EXINT   (_U_(0x1) << GMAC_IMR_EXINT_Pos)
 
#define GMAC_IMR_DRQFR_Pos   18
 (GMAC_IMR) PTP Delay Request Frame Received
 
#define GMAC_IMR_DRQFR   (_U_(0x1) << GMAC_IMR_DRQFR_Pos)
 
#define GMAC_IMR_SFR_Pos   19
 (GMAC_IMR) PTP Sync Frame Received
 
#define GMAC_IMR_SFR   (_U_(0x1) << GMAC_IMR_SFR_Pos)
 
#define GMAC_IMR_DRQFT_Pos   20
 (GMAC_IMR) PTP Delay Request Frame Transmitted
 
#define GMAC_IMR_DRQFT   (_U_(0x1) << GMAC_IMR_DRQFT_Pos)
 
#define GMAC_IMR_SFT_Pos   21
 (GMAC_IMR) PTP Sync Frame Transmitted
 
#define GMAC_IMR_SFT   (_U_(0x1) << GMAC_IMR_SFT_Pos)
 
#define GMAC_IMR_PDRQFR_Pos   22
 (GMAC_IMR) PDelay Request Frame Received
 
#define GMAC_IMR_PDRQFR   (_U_(0x1) << GMAC_IMR_PDRQFR_Pos)
 
#define GMAC_IMR_PDRSFR_Pos   23
 (GMAC_IMR) PDelay Response Frame Received
 
#define GMAC_IMR_PDRSFR   (_U_(0x1) << GMAC_IMR_PDRSFR_Pos)
 
#define GMAC_IMR_PDRQFT_Pos   24
 (GMAC_IMR) PDelay Request Frame Transmitted
 
#define GMAC_IMR_PDRQFT   (_U_(0x1) << GMAC_IMR_PDRQFT_Pos)
 
#define GMAC_IMR_PDRSFT_Pos   25
 (GMAC_IMR) PDelay Response Frame Transmitted
 
#define GMAC_IMR_PDRSFT   (_U_(0x1) << GMAC_IMR_PDRSFT_Pos)
 
#define GMAC_IMR_SRI_Pos   26
 (GMAC_IMR) TSU Seconds Register Increment
 
#define GMAC_IMR_SRI   (_U_(0x1) << GMAC_IMR_SRI_Pos)
 
#define GMAC_IMR_WOL_Pos   28
 (GMAC_IMR) Wake On Lan
 
#define GMAC_IMR_WOL   (_U_(0x1) << GMAC_IMR_WOL_Pos)
 
#define GMAC_IMR_TSUCMP_Pos   29
 (GMAC_IMR) Tsu timer comparison
 
#define GMAC_IMR_TSUCMP   (_U_(0x1) << GMAC_IMR_TSUCMP_Pos)
 
#define GMAC_IMR_MASK   _U_(0x37FCFCFF)
 (GMAC_IMR) MASK Register
 
#define GMAC_MAN_OFFSET   0x034
 (GMAC_MAN offset) PHY Maintenance Register
 
#define GMAC_MAN_RESETVALUE   _U_(0x00000000)
 (GMAC_MAN reset_value) PHY Maintenance Register
 
#define GMAC_MAN_DATA_Pos   0
 (GMAC_MAN) PHY Data
 
#define GMAC_MAN_DATA_Msk   (_U_(0xFFFF) << GMAC_MAN_DATA_Pos)
 
#define GMAC_MAN_DATA(value)   (GMAC_MAN_DATA_Msk & ((value) << GMAC_MAN_DATA_Pos))
 
#define GMAC_MAN_WTN_Pos   16
 (GMAC_MAN) Write Ten
 
#define GMAC_MAN_WTN_Msk   (_U_(0x3) << GMAC_MAN_WTN_Pos)
 
#define GMAC_MAN_WTN(value)   (GMAC_MAN_WTN_Msk & ((value) << GMAC_MAN_WTN_Pos))
 
#define GMAC_MAN_REGA_Pos   18
 (GMAC_MAN) Register Address
 
#define GMAC_MAN_REGA_Msk   (_U_(0x1F) << GMAC_MAN_REGA_Pos)
 
#define GMAC_MAN_REGA(value)   (GMAC_MAN_REGA_Msk & ((value) << GMAC_MAN_REGA_Pos))
 
#define GMAC_MAN_PHYA_Pos   23
 (GMAC_MAN) PHY Address
 
#define GMAC_MAN_PHYA_Msk   (_U_(0x1F) << GMAC_MAN_PHYA_Pos)
 
#define GMAC_MAN_PHYA(value)   (GMAC_MAN_PHYA_Msk & ((value) << GMAC_MAN_PHYA_Pos))
 
#define GMAC_MAN_OP_Pos   28
 (GMAC_MAN) Operation
 
#define GMAC_MAN_OP_Msk   (_U_(0x3) << GMAC_MAN_OP_Pos)
 
#define GMAC_MAN_OP(value)   (GMAC_MAN_OP_Msk & ((value) << GMAC_MAN_OP_Pos))
 
#define GMAC_MAN_CLTTO_Pos   30
 (GMAC_MAN) Clause 22 Operation
 
#define GMAC_MAN_CLTTO   (_U_(0x1) << GMAC_MAN_CLTTO_Pos)
 
#define GMAC_MAN_WZO_Pos   31
 (GMAC_MAN) Write ZERO
 
#define GMAC_MAN_WZO   (_U_(0x1) << GMAC_MAN_WZO_Pos)
 
#define GMAC_MAN_MASK   _U_(0xFFFFFFFF)
 (GMAC_MAN) MASK Register
 
#define GMAC_RPQ_OFFSET   0x038
 (GMAC_RPQ offset) Received Pause Quantum Register
 
#define GMAC_RPQ_RESETVALUE   _U_(0x00000000)
 (GMAC_RPQ reset_value) Received Pause Quantum Register
 
#define GMAC_RPQ_RPQ_Pos   0
 (GMAC_RPQ) Received Pause Quantum
 
#define GMAC_RPQ_RPQ_Msk   (_U_(0xFFFF) << GMAC_RPQ_RPQ_Pos)
 
#define GMAC_RPQ_RPQ(value)   (GMAC_RPQ_RPQ_Msk & ((value) << GMAC_RPQ_RPQ_Pos))
 
#define GMAC_RPQ_MASK   _U_(0x0000FFFF)
 (GMAC_RPQ) MASK Register
 
#define GMAC_TPQ_OFFSET   0x03C
 (GMAC_TPQ offset) Transmit Pause Quantum Register
 
#define GMAC_TPQ_RESETVALUE   _U_(0x0000FFFF)
 (GMAC_TPQ reset_value) Transmit Pause Quantum Register
 
#define GMAC_TPQ_TPQ_Pos   0
 (GMAC_TPQ) Transmit Pause Quantum
 
#define GMAC_TPQ_TPQ_Msk   (_U_(0xFFFF) << GMAC_TPQ_TPQ_Pos)
 
#define GMAC_TPQ_TPQ(value)   (GMAC_TPQ_TPQ_Msk & ((value) << GMAC_TPQ_TPQ_Pos))
 
#define GMAC_TPQ_MASK   _U_(0x0000FFFF)
 (GMAC_TPQ) MASK Register
 
#define GMAC_TPSF_OFFSET   0x040
 (GMAC_TPSF offset) TX partial store and forward Register
 
#define GMAC_TPSF_RESETVALUE   _U_(0x000003FF)
 (GMAC_TPSF reset_value) TX partial store and forward Register
 
#define GMAC_TPSF_TPB1ADR_Pos   0
 (GMAC_TPSF) TX packet buffer address
 
#define GMAC_TPSF_TPB1ADR_Msk   (_U_(0x3FF) << GMAC_TPSF_TPB1ADR_Pos)
 
#define GMAC_TPSF_TPB1ADR(value)   (GMAC_TPSF_TPB1ADR_Msk & ((value) << GMAC_TPSF_TPB1ADR_Pos))
 
#define GMAC_TPSF_ENTXP_Pos   31
 (GMAC_TPSF) Enable TX partial store and forward operation
 
#define GMAC_TPSF_ENTXP   (_U_(0x1) << GMAC_TPSF_ENTXP_Pos)
 
#define GMAC_TPSF_MASK   _U_(0x800003FF)
 (GMAC_TPSF) MASK Register
 
#define GMAC_RPSF_OFFSET   0x044
 (GMAC_RPSF offset) RX partial store and forward Register
 
#define GMAC_RPSF_RESETVALUE   _U_(0x000003FF)
 (GMAC_RPSF reset_value) RX partial store and forward Register
 
#define GMAC_RPSF_RPB1ADR_Pos   0
 (GMAC_RPSF) RX packet buffer address
 
#define GMAC_RPSF_RPB1ADR_Msk   (_U_(0x3FF) << GMAC_RPSF_RPB1ADR_Pos)
 
#define GMAC_RPSF_RPB1ADR(value)   (GMAC_RPSF_RPB1ADR_Msk & ((value) << GMAC_RPSF_RPB1ADR_Pos))
 
#define GMAC_RPSF_ENRXP_Pos   31
 (GMAC_RPSF) Enable RX partial store and forward operation
 
#define GMAC_RPSF_ENRXP   (_U_(0x1) << GMAC_RPSF_ENRXP_Pos)
 
#define GMAC_RPSF_MASK   _U_(0x800003FF)
 (GMAC_RPSF) MASK Register
 
#define GMAC_RJFML_OFFSET   0x048
 (GMAC_RJFML offset) RX Jumbo Frame Max Length Register
 
#define GMAC_RJFML_RESETVALUE   _U_(0x00003FFF)
 (GMAC_RJFML reset_value) RX Jumbo Frame Max Length Register
 
#define GMAC_RJFML_FML_Pos   0
 (GMAC_RJFML) Frame Max Length
 
#define GMAC_RJFML_FML_Msk   (_U_(0x3FFF) << GMAC_RJFML_FML_Pos)
 
#define GMAC_RJFML_FML(value)   (GMAC_RJFML_FML_Msk & ((value) << GMAC_RJFML_FML_Pos))
 
#define GMAC_RJFML_MASK   _U_(0x00003FFF)
 (GMAC_RJFML) MASK Register
 
#define GMAC_HRB_OFFSET   0x080
 (GMAC_HRB offset) Hash Register Bottom [31:0]
 
#define GMAC_HRB_RESETVALUE   _U_(0x00000000)
 (GMAC_HRB reset_value) Hash Register Bottom [31:0]
 
#define GMAC_HRB_ADDR_Pos   0
 (GMAC_HRB) Hash Address
 
#define GMAC_HRB_ADDR_Msk   (_U_(0xFFFFFFFF) << GMAC_HRB_ADDR_Pos)
 
#define GMAC_HRB_ADDR(value)   (GMAC_HRB_ADDR_Msk & ((value) << GMAC_HRB_ADDR_Pos))
 
#define GMAC_HRB_MASK   _U_(0xFFFFFFFF)
 (GMAC_HRB) MASK Register
 
#define GMAC_HRT_OFFSET   0x084
 (GMAC_HRT offset) Hash Register Top [63:32]
 
#define GMAC_HRT_RESETVALUE   _U_(0x00000000)
 (GMAC_HRT reset_value) Hash Register Top [63:32]
 
#define GMAC_HRT_ADDR_Pos   0
 (GMAC_HRT) Hash Address
 
#define GMAC_HRT_ADDR_Msk   (_U_(0xFFFFFFFF) << GMAC_HRT_ADDR_Pos)
 
#define GMAC_HRT_ADDR(value)   (GMAC_HRT_ADDR_Msk & ((value) << GMAC_HRT_ADDR_Pos))
 
#define GMAC_HRT_MASK   _U_(0xFFFFFFFF)
 (GMAC_HRT) MASK Register
 
#define GMAC_SAB_OFFSET   0x088
 (GMAC_SAB offset) Specific Address Bottom [31:0] Register
 
#define GMAC_SAB_RESETVALUE   _U_(0x00000000)
 (GMAC_SAB reset_value) Specific Address Bottom [31:0] Register
 
#define GMAC_SAB_ADDR_Pos   0
 (GMAC_SAB) Specific Address 1
 
#define GMAC_SAB_ADDR_Msk   (_U_(0xFFFFFFFF) << GMAC_SAB_ADDR_Pos)
 
#define GMAC_SAB_ADDR(value)   (GMAC_SAB_ADDR_Msk & ((value) << GMAC_SAB_ADDR_Pos))
 
#define GMAC_SAB_MASK   _U_(0xFFFFFFFF)
 (GMAC_SAB) MASK Register
 
#define GMAC_SAT_OFFSET   0x08C
 (GMAC_SAT offset) Specific Address Top [47:32] Register
 
#define GMAC_SAT_RESETVALUE   _U_(0x00000000)
 (GMAC_SAT reset_value) Specific Address Top [47:32] Register
 
#define GMAC_SAT_ADDR_Pos   0
 (GMAC_SAT) Specific Address 1
 
#define GMAC_SAT_ADDR_Msk   (_U_(0xFFFF) << GMAC_SAT_ADDR_Pos)
 
#define GMAC_SAT_ADDR(value)   (GMAC_SAT_ADDR_Msk & ((value) << GMAC_SAT_ADDR_Pos))
 
#define GMAC_SAT_MASK   _U_(0x0000FFFF)
 (GMAC_SAT) MASK Register
 
#define GMAC_TIDM_OFFSET   0x0A8
 (GMAC_TIDM offset) Type ID Match Register
 
#define GMAC_TIDM_RESETVALUE   _U_(0x00000000)
 (GMAC_TIDM reset_value) Type ID Match Register
 
#define GMAC_TIDM_TID_Pos   0
 (GMAC_TIDM) Type ID Match 1
 
#define GMAC_TIDM_TID_Msk   (_U_(0xFFFF) << GMAC_TIDM_TID_Pos)
 
#define GMAC_TIDM_TID(value)   (GMAC_TIDM_TID_Msk & ((value) << GMAC_TIDM_TID_Pos))
 
#define GMAC_TIDM_MASK   _U_(0x0000FFFF)
 (GMAC_TIDM) MASK Register
 
#define GMAC_WOL_OFFSET   0x0B8
 (GMAC_WOL offset) Wake on LAN
 
#define GMAC_WOL_RESETVALUE   _U_(0x00000000)
 (GMAC_WOL reset_value) Wake on LAN
 
#define GMAC_WOL_IP_Pos   0
 (GMAC_WOL) IP address
 
#define GMAC_WOL_IP_Msk   (_U_(0xFFFF) << GMAC_WOL_IP_Pos)
 
#define GMAC_WOL_IP(value)   (GMAC_WOL_IP_Msk & ((value) << GMAC_WOL_IP_Pos))
 
#define GMAC_WOL_MAG_Pos   16
 (GMAC_WOL) Event enable
 
#define GMAC_WOL_MAG   (_U_(0x1) << GMAC_WOL_MAG_Pos)
 
#define GMAC_WOL_ARP_Pos   17
 (GMAC_WOL) LAN ARP req
 
#define GMAC_WOL_ARP   (_U_(0x1) << GMAC_WOL_ARP_Pos)
 
#define GMAC_WOL_SA1_Pos   18
 (GMAC_WOL) WOL specific address reg 1
 
#define GMAC_WOL_SA1   (_U_(0x1) << GMAC_WOL_SA1_Pos)
 
#define GMAC_WOL_MTI_Pos   19
 (GMAC_WOL) WOL LAN multicast
 
#define GMAC_WOL_MTI   (_U_(0x1) << GMAC_WOL_MTI_Pos)
 
#define GMAC_WOL_MASK   _U_(0x000FFFFF)
 (GMAC_WOL) MASK Register
 
#define GMAC_IPGS_OFFSET   0x0BC
 (GMAC_IPGS offset) IPG Stretch Register
 
#define GMAC_IPGS_RESETVALUE   _U_(0x00000000)
 (GMAC_IPGS reset_value) IPG Stretch Register
 
#define GMAC_IPGS_FL_Pos   0
 (GMAC_IPGS) Frame Length
 
#define GMAC_IPGS_FL_Msk   (_U_(0xFFFF) << GMAC_IPGS_FL_Pos)
 
#define GMAC_IPGS_FL(value)   (GMAC_IPGS_FL_Msk & ((value) << GMAC_IPGS_FL_Pos))
 
#define GMAC_IPGS_MASK   _U_(0x0000FFFF)
 (GMAC_IPGS) MASK Register
 
#define GMAC_SVLAN_OFFSET   0x0C0
 (GMAC_SVLAN offset) Stacked VLAN Register
 
#define GMAC_SVLAN_RESETVALUE   _U_(0x00000000)
 (GMAC_SVLAN reset_value) Stacked VLAN Register
 
#define GMAC_SVLAN_VLAN_TYPE_Pos   0
 (GMAC_SVLAN) User Defined VLAN_TYPE Field
 
#define GMAC_SVLAN_VLAN_TYPE_Msk   (_U_(0xFFFF) << GMAC_SVLAN_VLAN_TYPE_Pos)
 
#define GMAC_SVLAN_VLAN_TYPE(value)   (GMAC_SVLAN_VLAN_TYPE_Msk & ((value) << GMAC_SVLAN_VLAN_TYPE_Pos))
 
#define GMAC_SVLAN_ESVLAN_Pos   31
 (GMAC_SVLAN) Enable Stacked VLAN Processing Mode
 
#define GMAC_SVLAN_ESVLAN   (_U_(0x1) << GMAC_SVLAN_ESVLAN_Pos)
 
#define GMAC_SVLAN_MASK   _U_(0x8000FFFF)
 (GMAC_SVLAN) MASK Register
 
#define GMAC_TPFCP_OFFSET   0x0C4
 (GMAC_TPFCP offset) Transmit PFC Pause Register
 
#define GMAC_TPFCP_RESETVALUE   _U_(0x00000000)
 (GMAC_TPFCP reset_value) Transmit PFC Pause Register
 
#define GMAC_TPFCP_PEV_Pos   0
 (GMAC_TPFCP) Priority Enable Vector
 
#define GMAC_TPFCP_PEV_Msk   (_U_(0xFF) << GMAC_TPFCP_PEV_Pos)
 
#define GMAC_TPFCP_PEV(value)   (GMAC_TPFCP_PEV_Msk & ((value) << GMAC_TPFCP_PEV_Pos))
 
#define GMAC_TPFCP_PQ_Pos   8
 (GMAC_TPFCP) Pause Quantum
 
#define GMAC_TPFCP_PQ_Msk   (_U_(0xFF) << GMAC_TPFCP_PQ_Pos)
 
#define GMAC_TPFCP_PQ(value)   (GMAC_TPFCP_PQ_Msk & ((value) << GMAC_TPFCP_PQ_Pos))
 
#define GMAC_TPFCP_MASK   _U_(0x0000FFFF)
 (GMAC_TPFCP) MASK Register
 
#define GMAC_SAMB1_OFFSET   0x0C8
 (GMAC_SAMB1 offset) Specific Address 1 Mask Bottom [31:0] Register
 
#define GMAC_SAMB1_RESETVALUE   _U_(0x00000000)
 (GMAC_SAMB1 reset_value) Specific Address 1 Mask Bottom [31:0] Register
 
#define GMAC_SAMB1_ADDR_Pos   0
 (GMAC_SAMB1) Specific Address 1 Mask
 
#define GMAC_SAMB1_ADDR_Msk   (_U_(0xFFFFFFFF) << GMAC_SAMB1_ADDR_Pos)
 
#define GMAC_SAMB1_ADDR(value)   (GMAC_SAMB1_ADDR_Msk & ((value) << GMAC_SAMB1_ADDR_Pos))
 
#define GMAC_SAMB1_MASK   _U_(0xFFFFFFFF)
 (GMAC_SAMB1) MASK Register
 
#define GMAC_SAMT1_OFFSET   0x0CC
 (GMAC_SAMT1 offset) Specific Address 1 Mask Top [47:32] Register
 
#define GMAC_SAMT1_RESETVALUE   _U_(0x00000000)
 (GMAC_SAMT1 reset_value) Specific Address 1 Mask Top [47:32] Register
 
#define GMAC_SAMT1_ADDR_Pos   0
 (GMAC_SAMT1) Specific Address 1 Mask
 
#define GMAC_SAMT1_ADDR_Msk   (_U_(0xFFFF) << GMAC_SAMT1_ADDR_Pos)
 
#define GMAC_SAMT1_ADDR(value)   (GMAC_SAMT1_ADDR_Msk & ((value) << GMAC_SAMT1_ADDR_Pos))
 
#define GMAC_SAMT1_MASK   _U_(0x0000FFFF)
 (GMAC_SAMT1) MASK Register
 
#define GMAC_NSC_OFFSET   0x0DC
 (GMAC_NSC offset) Tsu timer comparison nanoseconds Register
 
#define GMAC_NSC_RESETVALUE   _U_(0x00000000)
 (GMAC_NSC reset_value) Tsu timer comparison nanoseconds Register
 
#define GMAC_NSC_NANOSEC_Pos   0
 (GMAC_NSC) 1588 Timer Nanosecond comparison value
 
#define GMAC_NSC_NANOSEC_Msk   (_U_(0x1FFFFF) << GMAC_NSC_NANOSEC_Pos)
 
#define GMAC_NSC_NANOSEC(value)   (GMAC_NSC_NANOSEC_Msk & ((value) << GMAC_NSC_NANOSEC_Pos))
 
#define GMAC_NSC_MASK   _U_(0x001FFFFF)
 (GMAC_NSC) MASK Register
 
#define GMAC_SCL_OFFSET   0x0E0
 (GMAC_SCL offset) Tsu timer second comparison Register
 
#define GMAC_SCL_RESETVALUE   _U_(0x00000000)
 (GMAC_SCL reset_value) Tsu timer second comparison Register
 
#define GMAC_SCL_SEC_Pos   0
 (GMAC_SCL) 1588 Timer Second comparison value
 
#define GMAC_SCL_SEC_Msk   (_U_(0xFFFFFFFF) << GMAC_SCL_SEC_Pos)
 
#define GMAC_SCL_SEC(value)   (GMAC_SCL_SEC_Msk & ((value) << GMAC_SCL_SEC_Pos))
 
#define GMAC_SCL_MASK   _U_(0xFFFFFFFF)
 (GMAC_SCL) MASK Register
 
#define GMAC_SCH_OFFSET   0x0E4
 (GMAC_SCH offset) Tsu timer second comparison Register
 
#define GMAC_SCH_RESETVALUE   _U_(0x00000000)
 (GMAC_SCH reset_value) Tsu timer second comparison Register
 
#define GMAC_SCH_SEC_Pos   0
 (GMAC_SCH) 1588 Timer Second comparison value
 
#define GMAC_SCH_SEC_Msk   (_U_(0xFFFF) << GMAC_SCH_SEC_Pos)
 
#define GMAC_SCH_SEC(value)   (GMAC_SCH_SEC_Msk & ((value) << GMAC_SCH_SEC_Pos))
 
#define GMAC_SCH_MASK   _U_(0x0000FFFF)
 (GMAC_SCH) MASK Register
 
#define GMAC_EFTSH_OFFSET   0x0E8
 (GMAC_EFTSH offset) PTP Event Frame Transmitted Seconds High Register
 
#define GMAC_EFTSH_RESETVALUE   _U_(0x00000000)
 (GMAC_EFTSH reset_value) PTP Event Frame Transmitted Seconds High Register
 
#define GMAC_EFTSH_RUD_Pos   0
 (GMAC_EFTSH) Register Update
 
#define GMAC_EFTSH_RUD_Msk   (_U_(0xFFFF) << GMAC_EFTSH_RUD_Pos)
 
#define GMAC_EFTSH_RUD(value)   (GMAC_EFTSH_RUD_Msk & ((value) << GMAC_EFTSH_RUD_Pos))
 
#define GMAC_EFTSH_MASK   _U_(0x0000FFFF)
 (GMAC_EFTSH) MASK Register
 
#define GMAC_EFRSH_OFFSET   0x0EC
 (GMAC_EFRSH offset) PTP Event Frame Received Seconds High Register
 
#define GMAC_EFRSH_RESETVALUE   _U_(0x00000000)
 (GMAC_EFRSH reset_value) PTP Event Frame Received Seconds High Register
 
#define GMAC_EFRSH_RUD_Pos   0
 (GMAC_EFRSH) Register Update
 
#define GMAC_EFRSH_RUD_Msk   (_U_(0xFFFF) << GMAC_EFRSH_RUD_Pos)
 
#define GMAC_EFRSH_RUD(value)   (GMAC_EFRSH_RUD_Msk & ((value) << GMAC_EFRSH_RUD_Pos))
 
#define GMAC_EFRSH_MASK   _U_(0x0000FFFF)
 (GMAC_EFRSH) MASK Register
 
#define GMAC_PEFTSH_OFFSET   0x0F0
 (GMAC_PEFTSH offset) PTP Peer Event Frame Transmitted Seconds High Register
 
#define GMAC_PEFTSH_RESETVALUE   _U_(0x00000000)
 (GMAC_PEFTSH reset_value) PTP Peer Event Frame Transmitted Seconds High Register
 
#define GMAC_PEFTSH_RUD_Pos   0
 (GMAC_PEFTSH) Register Update
 
#define GMAC_PEFTSH_RUD_Msk   (_U_(0xFFFF) << GMAC_PEFTSH_RUD_Pos)
 
#define GMAC_PEFTSH_RUD(value)   (GMAC_PEFTSH_RUD_Msk & ((value) << GMAC_PEFTSH_RUD_Pos))
 
#define GMAC_PEFTSH_MASK   _U_(0x0000FFFF)
 (GMAC_PEFTSH) MASK Register
 
#define GMAC_PEFRSH_OFFSET   0x0F4
 (GMAC_PEFRSH offset) PTP Peer Event Frame Received Seconds High Register
 
#define GMAC_PEFRSH_RESETVALUE   _U_(0x00000000)
 (GMAC_PEFRSH reset_value) PTP Peer Event Frame Received Seconds High Register
 
#define GMAC_PEFRSH_RUD_Pos   0
 (GMAC_PEFRSH) Register Update
 
#define GMAC_PEFRSH_RUD_Msk   (_U_(0xFFFF) << GMAC_PEFRSH_RUD_Pos)
 
#define GMAC_PEFRSH_RUD(value)   (GMAC_PEFRSH_RUD_Msk & ((value) << GMAC_PEFRSH_RUD_Pos))
 
#define GMAC_PEFRSH_MASK   _U_(0x0000FFFF)
 (GMAC_PEFRSH) MASK Register
 
#define GMAC_OTLO_OFFSET   0x100
 (GMAC_OTLO offset) Octets Transmitted [31:0] Register
 
#define GMAC_OTLO_RESETVALUE   _U_(0x00000000)
 (GMAC_OTLO reset_value) Octets Transmitted [31:0] Register
 
#define GMAC_OTLO_TXO_Pos   0
 (GMAC_OTLO) Transmitted Octets
 
#define GMAC_OTLO_TXO_Msk   (_U_(0xFFFFFFFF) << GMAC_OTLO_TXO_Pos)
 
#define GMAC_OTLO_TXO(value)   (GMAC_OTLO_TXO_Msk & ((value) << GMAC_OTLO_TXO_Pos))
 
#define GMAC_OTLO_MASK   _U_(0xFFFFFFFF)
 (GMAC_OTLO) MASK Register
 
#define GMAC_OTHI_OFFSET   0x104
 (GMAC_OTHI offset) Octets Transmitted [47:32] Register
 
#define GMAC_OTHI_RESETVALUE   _U_(0x00000000)
 (GMAC_OTHI reset_value) Octets Transmitted [47:32] Register
 
#define GMAC_OTHI_TXO_Pos   0
 (GMAC_OTHI) Transmitted Octets
 
#define GMAC_OTHI_TXO_Msk   (_U_(0xFFFF) << GMAC_OTHI_TXO_Pos)
 
#define GMAC_OTHI_TXO(value)   (GMAC_OTHI_TXO_Msk & ((value) << GMAC_OTHI_TXO_Pos))
 
#define GMAC_OTHI_MASK   _U_(0x0000FFFF)
 (GMAC_OTHI) MASK Register
 
#define GMAC_FT_OFFSET   0x108
 (GMAC_FT offset) Frames Transmitted Register
 
#define GMAC_FT_RESETVALUE   _U_(0x00000000)
 (GMAC_FT reset_value) Frames Transmitted Register
 
#define GMAC_FT_FTX_Pos   0
 (GMAC_FT) Frames Transmitted without Error
 
#define GMAC_FT_FTX_Msk   (_U_(0xFFFFFFFF) << GMAC_FT_FTX_Pos)
 
#define GMAC_FT_FTX(value)   (GMAC_FT_FTX_Msk & ((value) << GMAC_FT_FTX_Pos))
 
#define GMAC_FT_MASK   _U_(0xFFFFFFFF)
 (GMAC_FT) MASK Register
 
#define GMAC_BCFT_OFFSET   0x10C
 (GMAC_BCFT offset) Broadcast Frames Transmitted Register
 
#define GMAC_BCFT_RESETVALUE   _U_(0x00000000)
 (GMAC_BCFT reset_value) Broadcast Frames Transmitted Register
 
#define GMAC_BCFT_BFTX_Pos   0
 (GMAC_BCFT) Broadcast Frames Transmitted without Error
 
#define GMAC_BCFT_BFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_BCFT_BFTX_Pos)
 
#define GMAC_BCFT_BFTX(value)   (GMAC_BCFT_BFTX_Msk & ((value) << GMAC_BCFT_BFTX_Pos))
 
#define GMAC_BCFT_MASK   _U_(0xFFFFFFFF)
 (GMAC_BCFT) MASK Register
 
#define GMAC_MFT_OFFSET   0x110
 (GMAC_MFT offset) Multicast Frames Transmitted Register
 
#define GMAC_MFT_RESETVALUE   _U_(0x00000000)
 (GMAC_MFT reset_value) Multicast Frames Transmitted Register
 
#define GMAC_MFT_MFTX_Pos   0
 (GMAC_MFT) Multicast Frames Transmitted without Error
 
#define GMAC_MFT_MFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_MFT_MFTX_Pos)
 
#define GMAC_MFT_MFTX(value)   (GMAC_MFT_MFTX_Msk & ((value) << GMAC_MFT_MFTX_Pos))
 
#define GMAC_MFT_MASK   _U_(0xFFFFFFFF)
 (GMAC_MFT) MASK Register
 
#define GMAC_PFT_OFFSET   0x114
 (GMAC_PFT offset) Pause Frames Transmitted Register
 
#define GMAC_PFT_RESETVALUE   _U_(0x00000000)
 (GMAC_PFT reset_value) Pause Frames Transmitted Register
 
#define GMAC_PFT_PFTX_Pos   0
 (GMAC_PFT) Pause Frames Transmitted Register
 
#define GMAC_PFT_PFTX_Msk   (_U_(0xFFFF) << GMAC_PFT_PFTX_Pos)
 
#define GMAC_PFT_PFTX(value)   (GMAC_PFT_PFTX_Msk & ((value) << GMAC_PFT_PFTX_Pos))
 
#define GMAC_PFT_MASK   _U_(0x0000FFFF)
 (GMAC_PFT) MASK Register
 
#define GMAC_BFT64_OFFSET   0x118
 (GMAC_BFT64 offset) 64 Byte Frames Transmitted Register
 
#define GMAC_BFT64_RESETVALUE   _U_(0x00000000)
 (GMAC_BFT64 reset_value) 64 Byte Frames Transmitted Register
 
#define GMAC_BFT64_NFTX_Pos   0
 (GMAC_BFT64) 64 Byte Frames Transmitted without Error
 
#define GMAC_BFT64_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_BFT64_NFTX_Pos)
 
#define GMAC_BFT64_NFTX(value)   (GMAC_BFT64_NFTX_Msk & ((value) << GMAC_BFT64_NFTX_Pos))
 
#define GMAC_BFT64_MASK   _U_(0xFFFFFFFF)
 (GMAC_BFT64) MASK Register
 
#define GMAC_TBFT127_OFFSET   0x11C
 (GMAC_TBFT127 offset) 65 to 127 Byte Frames Transmitted Register
 
#define GMAC_TBFT127_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFT127 reset_value) 65 to 127 Byte Frames Transmitted Register
 
#define GMAC_TBFT127_NFTX_Pos   0
 (GMAC_TBFT127) 65 to 127 Byte Frames Transmitted without Error
 
#define GMAC_TBFT127_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFT127_NFTX_Pos)
 
#define GMAC_TBFT127_NFTX(value)   (GMAC_TBFT127_NFTX_Msk & ((value) << GMAC_TBFT127_NFTX_Pos))
 
#define GMAC_TBFT127_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFT127) MASK Register
 
#define GMAC_TBFT255_OFFSET   0x120
 (GMAC_TBFT255 offset) 128 to 255 Byte Frames Transmitted Register
 
#define GMAC_TBFT255_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFT255 reset_value) 128 to 255 Byte Frames Transmitted Register
 
#define GMAC_TBFT255_NFTX_Pos   0
 (GMAC_TBFT255) 128 to 255 Byte Frames Transmitted without Error
 
#define GMAC_TBFT255_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFT255_NFTX_Pos)
 
#define GMAC_TBFT255_NFTX(value)   (GMAC_TBFT255_NFTX_Msk & ((value) << GMAC_TBFT255_NFTX_Pos))
 
#define GMAC_TBFT255_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFT255) MASK Register
 
#define GMAC_TBFT511_OFFSET   0x124
 (GMAC_TBFT511 offset) 256 to 511 Byte Frames Transmitted Register
 
#define GMAC_TBFT511_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFT511 reset_value) 256 to 511 Byte Frames Transmitted Register
 
#define GMAC_TBFT511_NFTX_Pos   0
 (GMAC_TBFT511) 256 to 511 Byte Frames Transmitted without Error
 
#define GMAC_TBFT511_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFT511_NFTX_Pos)
 
#define GMAC_TBFT511_NFTX(value)   (GMAC_TBFT511_NFTX_Msk & ((value) << GMAC_TBFT511_NFTX_Pos))
 
#define GMAC_TBFT511_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFT511) MASK Register
 
#define GMAC_TBFT1023_OFFSET   0x128
 (GMAC_TBFT1023 offset) 512 to 1023 Byte Frames Transmitted Register
 
#define GMAC_TBFT1023_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFT1023 reset_value) 512 to 1023 Byte Frames Transmitted Register
 
#define GMAC_TBFT1023_NFTX_Pos   0
 (GMAC_TBFT1023) 512 to 1023 Byte Frames Transmitted without Error
 
#define GMAC_TBFT1023_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFT1023_NFTX_Pos)
 
#define GMAC_TBFT1023_NFTX(value)   (GMAC_TBFT1023_NFTX_Msk & ((value) << GMAC_TBFT1023_NFTX_Pos))
 
#define GMAC_TBFT1023_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFT1023) MASK Register
 
#define GMAC_TBFT1518_OFFSET   0x12C
 (GMAC_TBFT1518 offset) 1024 to 1518 Byte Frames Transmitted Register
 
#define GMAC_TBFT1518_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFT1518 reset_value) 1024 to 1518 Byte Frames Transmitted Register
 
#define GMAC_TBFT1518_NFTX_Pos   0
 (GMAC_TBFT1518) 1024 to 1518 Byte Frames Transmitted without Error
 
#define GMAC_TBFT1518_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFT1518_NFTX_Pos)
 
#define GMAC_TBFT1518_NFTX(value)   (GMAC_TBFT1518_NFTX_Msk & ((value) << GMAC_TBFT1518_NFTX_Pos))
 
#define GMAC_TBFT1518_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFT1518) MASK Register
 
#define GMAC_GTBFT1518_OFFSET   0x130
 (GMAC_GTBFT1518 offset) Greater Than 1518 Byte Frames Transmitted Register
 
#define GMAC_GTBFT1518_RESETVALUE   _U_(0x00000000)
 (GMAC_GTBFT1518 reset_value) Greater Than 1518 Byte Frames Transmitted Register
 
#define GMAC_GTBFT1518_NFTX_Pos   0
 (GMAC_GTBFT1518) Greater than 1518 Byte Frames Transmitted without Error
 
#define GMAC_GTBFT1518_NFTX_Msk   (_U_(0xFFFFFFFF) << GMAC_GTBFT1518_NFTX_Pos)
 
#define GMAC_GTBFT1518_NFTX(value)   (GMAC_GTBFT1518_NFTX_Msk & ((value) << GMAC_GTBFT1518_NFTX_Pos))
 
#define GMAC_GTBFT1518_MASK   _U_(0xFFFFFFFF)
 (GMAC_GTBFT1518) MASK Register
 
#define GMAC_TUR_OFFSET   0x134
 (GMAC_TUR offset) Transmit Underruns Register
 
#define GMAC_TUR_RESETVALUE   _U_(0x00000000)
 (GMAC_TUR reset_value) Transmit Underruns Register
 
#define GMAC_TUR_TXUNR_Pos   0
 (GMAC_TUR) Transmit Underruns
 
#define GMAC_TUR_TXUNR_Msk   (_U_(0x3FF) << GMAC_TUR_TXUNR_Pos)
 
#define GMAC_TUR_TXUNR(value)   (GMAC_TUR_TXUNR_Msk & ((value) << GMAC_TUR_TXUNR_Pos))
 
#define GMAC_TUR_MASK   _U_(0x000003FF)
 (GMAC_TUR) MASK Register
 
#define GMAC_SCF_OFFSET   0x138
 (GMAC_SCF offset) Single Collision Frames Register
 
#define GMAC_SCF_RESETVALUE   _U_(0x00000000)
 (GMAC_SCF reset_value) Single Collision Frames Register
 
#define GMAC_SCF_SCOL_Pos   0
 (GMAC_SCF) Single Collision
 
#define GMAC_SCF_SCOL_Msk   (_U_(0x3FFFF) << GMAC_SCF_SCOL_Pos)
 
#define GMAC_SCF_SCOL(value)   (GMAC_SCF_SCOL_Msk & ((value) << GMAC_SCF_SCOL_Pos))
 
#define GMAC_SCF_MASK   _U_(0x0003FFFF)
 (GMAC_SCF) MASK Register
 
#define GMAC_MCF_OFFSET   0x13C
 (GMAC_MCF offset) Multiple Collision Frames Register
 
#define GMAC_MCF_RESETVALUE   _U_(0x00000000)
 (GMAC_MCF reset_value) Multiple Collision Frames Register
 
#define GMAC_MCF_MCOL_Pos   0
 (GMAC_MCF) Multiple Collision
 
#define GMAC_MCF_MCOL_Msk   (_U_(0x3FFFF) << GMAC_MCF_MCOL_Pos)
 
#define GMAC_MCF_MCOL(value)   (GMAC_MCF_MCOL_Msk & ((value) << GMAC_MCF_MCOL_Pos))
 
#define GMAC_MCF_MASK   _U_(0x0003FFFF)
 (GMAC_MCF) MASK Register
 
#define GMAC_EC_OFFSET   0x140
 (GMAC_EC offset) Excessive Collisions Register
 
#define GMAC_EC_RESETVALUE   _U_(0x00000000)
 (GMAC_EC reset_value) Excessive Collisions Register
 
#define GMAC_EC_XCOL_Pos   0
 (GMAC_EC) Excessive Collisions
 
#define GMAC_EC_XCOL_Msk   (_U_(0x3FF) << GMAC_EC_XCOL_Pos)
 
#define GMAC_EC_XCOL(value)   (GMAC_EC_XCOL_Msk & ((value) << GMAC_EC_XCOL_Pos))
 
#define GMAC_EC_MASK   _U_(0x000003FF)
 (GMAC_EC) MASK Register
 
#define GMAC_LC_OFFSET   0x144
 (GMAC_LC offset) Late Collisions Register
 
#define GMAC_LC_RESETVALUE   _U_(0x00000000)
 (GMAC_LC reset_value) Late Collisions Register
 
#define GMAC_LC_LCOL_Pos   0
 (GMAC_LC) Late Collisions
 
#define GMAC_LC_LCOL_Msk   (_U_(0x3FF) << GMAC_LC_LCOL_Pos)
 
#define GMAC_LC_LCOL(value)   (GMAC_LC_LCOL_Msk & ((value) << GMAC_LC_LCOL_Pos))
 
#define GMAC_LC_MASK   _U_(0x000003FF)
 (GMAC_LC) MASK Register
 
#define GMAC_DTF_OFFSET   0x148
 (GMAC_DTF offset) Deferred Transmission Frames Register
 
#define GMAC_DTF_RESETVALUE   _U_(0x00000000)
 (GMAC_DTF reset_value) Deferred Transmission Frames Register
 
#define GMAC_DTF_DEFT_Pos   0
 (GMAC_DTF) Deferred Transmission
 
#define GMAC_DTF_DEFT_Msk   (_U_(0x3FFFF) << GMAC_DTF_DEFT_Pos)
 
#define GMAC_DTF_DEFT(value)   (GMAC_DTF_DEFT_Msk & ((value) << GMAC_DTF_DEFT_Pos))
 
#define GMAC_DTF_MASK   _U_(0x0003FFFF)
 (GMAC_DTF) MASK Register
 
#define GMAC_CSE_OFFSET   0x14C
 (GMAC_CSE offset) Carrier Sense Errors Register
 
#define GMAC_CSE_RESETVALUE   _U_(0x00000000)
 (GMAC_CSE reset_value) Carrier Sense Errors Register
 
#define GMAC_CSE_CSR_Pos   0
 (GMAC_CSE) Carrier Sense Error
 
#define GMAC_CSE_CSR_Msk   (_U_(0x3FF) << GMAC_CSE_CSR_Pos)
 
#define GMAC_CSE_CSR(value)   (GMAC_CSE_CSR_Msk & ((value) << GMAC_CSE_CSR_Pos))
 
#define GMAC_CSE_MASK   _U_(0x000003FF)
 (GMAC_CSE) MASK Register
 
#define GMAC_ORLO_OFFSET   0x150
 (GMAC_ORLO offset) Octets Received [31:0] Received
 
#define GMAC_ORLO_RESETVALUE   _U_(0x00000000)
 (GMAC_ORLO reset_value) Octets Received [31:0] Received
 
#define GMAC_ORLO_RXO_Pos   0
 (GMAC_ORLO) Received Octets
 
#define GMAC_ORLO_RXO_Msk   (_U_(0xFFFFFFFF) << GMAC_ORLO_RXO_Pos)
 
#define GMAC_ORLO_RXO(value)   (GMAC_ORLO_RXO_Msk & ((value) << GMAC_ORLO_RXO_Pos))
 
#define GMAC_ORLO_MASK   _U_(0xFFFFFFFF)
 (GMAC_ORLO) MASK Register
 
#define GMAC_ORHI_OFFSET   0x154
 (GMAC_ORHI offset) Octets Received [47:32] Received
 
#define GMAC_ORHI_RESETVALUE   _U_(0x00000000)
 (GMAC_ORHI reset_value) Octets Received [47:32] Received
 
#define GMAC_ORHI_RXO_Pos   0
 (GMAC_ORHI) Received Octets
 
#define GMAC_ORHI_RXO_Msk   (_U_(0xFFFF) << GMAC_ORHI_RXO_Pos)
 
#define GMAC_ORHI_RXO(value)   (GMAC_ORHI_RXO_Msk & ((value) << GMAC_ORHI_RXO_Pos))
 
#define GMAC_ORHI_MASK   _U_(0x0000FFFF)
 (GMAC_ORHI) MASK Register
 
#define GMAC_FR_OFFSET   0x158
 (GMAC_FR offset) Frames Received Register
 
#define GMAC_FR_RESETVALUE   _U_(0x00000000)
 (GMAC_FR reset_value) Frames Received Register
 
#define GMAC_FR_FRX_Pos   0
 (GMAC_FR) Frames Received without Error
 
#define GMAC_FR_FRX_Msk   (_U_(0xFFFFFFFF) << GMAC_FR_FRX_Pos)
 
#define GMAC_FR_FRX(value)   (GMAC_FR_FRX_Msk & ((value) << GMAC_FR_FRX_Pos))
 
#define GMAC_FR_MASK   _U_(0xFFFFFFFF)
 (GMAC_FR) MASK Register
 
#define GMAC_BCFR_OFFSET   0x15C
 (GMAC_BCFR offset) Broadcast Frames Received Register
 
#define GMAC_BCFR_RESETVALUE   _U_(0x00000000)
 (GMAC_BCFR reset_value) Broadcast Frames Received Register
 
#define GMAC_BCFR_BFRX_Pos   0
 (GMAC_BCFR) Broadcast Frames Received without Error
 
#define GMAC_BCFR_BFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_BCFR_BFRX_Pos)
 
#define GMAC_BCFR_BFRX(value)   (GMAC_BCFR_BFRX_Msk & ((value) << GMAC_BCFR_BFRX_Pos))
 
#define GMAC_BCFR_MASK   _U_(0xFFFFFFFF)
 (GMAC_BCFR) MASK Register
 
#define GMAC_MFR_OFFSET   0x160
 (GMAC_MFR offset) Multicast Frames Received Register
 
#define GMAC_MFR_RESETVALUE   _U_(0x00000000)
 (GMAC_MFR reset_value) Multicast Frames Received Register
 
#define GMAC_MFR_MFRX_Pos   0
 (GMAC_MFR) Multicast Frames Received without Error
 
#define GMAC_MFR_MFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_MFR_MFRX_Pos)
 
#define GMAC_MFR_MFRX(value)   (GMAC_MFR_MFRX_Msk & ((value) << GMAC_MFR_MFRX_Pos))
 
#define GMAC_MFR_MASK   _U_(0xFFFFFFFF)
 (GMAC_MFR) MASK Register
 
#define GMAC_PFR_OFFSET   0x164
 (GMAC_PFR offset) Pause Frames Received Register
 
#define GMAC_PFR_RESETVALUE   _U_(0x00000000)
 (GMAC_PFR reset_value) Pause Frames Received Register
 
#define GMAC_PFR_PFRX_Pos   0
 (GMAC_PFR) Pause Frames Received Register
 
#define GMAC_PFR_PFRX_Msk   (_U_(0xFFFF) << GMAC_PFR_PFRX_Pos)
 
#define GMAC_PFR_PFRX(value)   (GMAC_PFR_PFRX_Msk & ((value) << GMAC_PFR_PFRX_Pos))
 
#define GMAC_PFR_MASK   _U_(0x0000FFFF)
 (GMAC_PFR) MASK Register
 
#define GMAC_BFR64_OFFSET   0x168
 (GMAC_BFR64 offset) 64 Byte Frames Received Register
 
#define GMAC_BFR64_RESETVALUE   _U_(0x00000000)
 (GMAC_BFR64 reset_value) 64 Byte Frames Received Register
 
#define GMAC_BFR64_NFRX_Pos   0
 (GMAC_BFR64) 64 Byte Frames Received without Error
 
#define GMAC_BFR64_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_BFR64_NFRX_Pos)
 
#define GMAC_BFR64_NFRX(value)   (GMAC_BFR64_NFRX_Msk & ((value) << GMAC_BFR64_NFRX_Pos))
 
#define GMAC_BFR64_MASK   _U_(0xFFFFFFFF)
 (GMAC_BFR64) MASK Register
 
#define GMAC_TBFR127_OFFSET   0x16C
 (GMAC_TBFR127 offset) 65 to 127 Byte Frames Received Register
 
#define GMAC_TBFR127_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFR127 reset_value) 65 to 127 Byte Frames Received Register
 
#define GMAC_TBFR127_NFRX_Pos   0
 (GMAC_TBFR127) 65 to 127 Byte Frames Received without Error
 
#define GMAC_TBFR127_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFR127_NFRX_Pos)
 
#define GMAC_TBFR127_NFRX(value)   (GMAC_TBFR127_NFRX_Msk & ((value) << GMAC_TBFR127_NFRX_Pos))
 
#define GMAC_TBFR127_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFR127) MASK Register
 
#define GMAC_TBFR255_OFFSET   0x170
 (GMAC_TBFR255 offset) 128 to 255 Byte Frames Received Register
 
#define GMAC_TBFR255_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFR255 reset_value) 128 to 255 Byte Frames Received Register
 
#define GMAC_TBFR255_NFRX_Pos   0
 (GMAC_TBFR255) 128 to 255 Byte Frames Received without Error
 
#define GMAC_TBFR255_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFR255_NFRX_Pos)
 
#define GMAC_TBFR255_NFRX(value)   (GMAC_TBFR255_NFRX_Msk & ((value) << GMAC_TBFR255_NFRX_Pos))
 
#define GMAC_TBFR255_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFR255) MASK Register
 
#define GMAC_TBFR511_OFFSET   0x174
 (GMAC_TBFR511 offset) 256 to 511Byte Frames Received Register
 
#define GMAC_TBFR511_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFR511 reset_value) 256 to 511Byte Frames Received Register
 
#define GMAC_TBFR511_NFRX_Pos   0
 (GMAC_TBFR511) 256 to 511 Byte Frames Received without Error
 
#define GMAC_TBFR511_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFR511_NFRX_Pos)
 
#define GMAC_TBFR511_NFRX(value)   (GMAC_TBFR511_NFRX_Msk & ((value) << GMAC_TBFR511_NFRX_Pos))
 
#define GMAC_TBFR511_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFR511) MASK Register
 
#define GMAC_TBFR1023_OFFSET   0x178
 (GMAC_TBFR1023 offset) 512 to 1023 Byte Frames Received Register
 
#define GMAC_TBFR1023_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFR1023 reset_value) 512 to 1023 Byte Frames Received Register
 
#define GMAC_TBFR1023_NFRX_Pos   0
 (GMAC_TBFR1023) 512 to 1023 Byte Frames Received without Error
 
#define GMAC_TBFR1023_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFR1023_NFRX_Pos)
 
#define GMAC_TBFR1023_NFRX(value)   (GMAC_TBFR1023_NFRX_Msk & ((value) << GMAC_TBFR1023_NFRX_Pos))
 
#define GMAC_TBFR1023_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFR1023) MASK Register
 
#define GMAC_TBFR1518_OFFSET   0x17C
 (GMAC_TBFR1518 offset) 1024 to 1518 Byte Frames Received Register
 
#define GMAC_TBFR1518_RESETVALUE   _U_(0x00000000)
 (GMAC_TBFR1518 reset_value) 1024 to 1518 Byte Frames Received Register
 
#define GMAC_TBFR1518_NFRX_Pos   0
 (GMAC_TBFR1518) 1024 to 1518 Byte Frames Received without Error
 
#define GMAC_TBFR1518_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_TBFR1518_NFRX_Pos)
 
#define GMAC_TBFR1518_NFRX(value)   (GMAC_TBFR1518_NFRX_Msk & ((value) << GMAC_TBFR1518_NFRX_Pos))
 
#define GMAC_TBFR1518_MASK   _U_(0xFFFFFFFF)
 (GMAC_TBFR1518) MASK Register
 
#define GMAC_TMXBFR_OFFSET   0x180
 (GMAC_TMXBFR offset) 1519 to Maximum Byte Frames Received Register
 
#define GMAC_TMXBFR_RESETVALUE   _U_(0x00000000)
 (GMAC_TMXBFR reset_value) 1519 to Maximum Byte Frames Received Register
 
#define GMAC_TMXBFR_NFRX_Pos   0
 (GMAC_TMXBFR) 1519 to Maximum Byte Frames Received without Error
 
#define GMAC_TMXBFR_NFRX_Msk   (_U_(0xFFFFFFFF) << GMAC_TMXBFR_NFRX_Pos)
 
#define GMAC_TMXBFR_NFRX(value)   (GMAC_TMXBFR_NFRX_Msk & ((value) << GMAC_TMXBFR_NFRX_Pos))
 
#define GMAC_TMXBFR_MASK   _U_(0xFFFFFFFF)
 (GMAC_TMXBFR) MASK Register
 
#define GMAC_UFR_OFFSET   0x184
 (GMAC_UFR offset) Undersize Frames Received Register
 
#define GMAC_UFR_RESETVALUE   _U_(0x00000000)
 (GMAC_UFR reset_value) Undersize Frames Received Register
 
#define GMAC_UFR_UFRX_Pos   0
 (GMAC_UFR) Undersize Frames Received
 
#define GMAC_UFR_UFRX_Msk   (_U_(0x3FF) << GMAC_UFR_UFRX_Pos)
 
#define GMAC_UFR_UFRX(value)   (GMAC_UFR_UFRX_Msk & ((value) << GMAC_UFR_UFRX_Pos))
 
#define GMAC_UFR_MASK   _U_(0x000003FF)
 (GMAC_UFR) MASK Register
 
#define GMAC_OFR_OFFSET   0x188
 (GMAC_OFR offset) Oversize Frames Received Register
 
#define GMAC_OFR_RESETVALUE   _U_(0x00000000)
 (GMAC_OFR reset_value) Oversize Frames Received Register
 
#define GMAC_OFR_OFRX_Pos   0
 (GMAC_OFR) Oversized Frames Received
 
#define GMAC_OFR_OFRX_Msk   (_U_(0x3FF) << GMAC_OFR_OFRX_Pos)
 
#define GMAC_OFR_OFRX(value)   (GMAC_OFR_OFRX_Msk & ((value) << GMAC_OFR_OFRX_Pos))
 
#define GMAC_OFR_MASK   _U_(0x000003FF)
 (GMAC_OFR) MASK Register
 
#define GMAC_JR_OFFSET   0x18C
 (GMAC_JR offset) Jabbers Received Register
 
#define GMAC_JR_RESETVALUE   _U_(0x00000000)
 (GMAC_JR reset_value) Jabbers Received Register
 
#define GMAC_JR_JRX_Pos   0
 (GMAC_JR) Jabbers Received
 
#define GMAC_JR_JRX_Msk   (_U_(0x3FF) << GMAC_JR_JRX_Pos)
 
#define GMAC_JR_JRX(value)   (GMAC_JR_JRX_Msk & ((value) << GMAC_JR_JRX_Pos))
 
#define GMAC_JR_MASK   _U_(0x000003FF)
 (GMAC_JR) MASK Register
 
#define GMAC_FCSE_OFFSET   0x190
 (GMAC_FCSE offset) Frame Check Sequence Errors Register
 
#define GMAC_FCSE_RESETVALUE   _U_(0x00000000)
 (GMAC_FCSE reset_value) Frame Check Sequence Errors Register
 
#define GMAC_FCSE_FCKR_Pos   0
 (GMAC_FCSE) Frame Check Sequence Errors
 
#define GMAC_FCSE_FCKR_Msk   (_U_(0x3FF) << GMAC_FCSE_FCKR_Pos)
 
#define GMAC_FCSE_FCKR(value)   (GMAC_FCSE_FCKR_Msk & ((value) << GMAC_FCSE_FCKR_Pos))
 
#define GMAC_FCSE_MASK   _U_(0x000003FF)
 (GMAC_FCSE) MASK Register
 
#define GMAC_LFFE_OFFSET   0x194
 (GMAC_LFFE offset) Length Field Frame Errors Register
 
#define GMAC_LFFE_RESETVALUE   _U_(0x00000000)
 (GMAC_LFFE reset_value) Length Field Frame Errors Register
 
#define GMAC_LFFE_LFER_Pos   0
 (GMAC_LFFE) Length Field Frame Errors
 
#define GMAC_LFFE_LFER_Msk   (_U_(0x3FF) << GMAC_LFFE_LFER_Pos)
 
#define GMAC_LFFE_LFER(value)   (GMAC_LFFE_LFER_Msk & ((value) << GMAC_LFFE_LFER_Pos))
 
#define GMAC_LFFE_MASK   _U_(0x000003FF)
 (GMAC_LFFE) MASK Register
 
#define GMAC_RSE_OFFSET   0x198
 (GMAC_RSE offset) Receive Symbol Errors Register
 
#define GMAC_RSE_RESETVALUE   _U_(0x00000000)
 (GMAC_RSE reset_value) Receive Symbol Errors Register
 
#define GMAC_RSE_RXSE_Pos   0
 (GMAC_RSE) Receive Symbol Errors
 
#define GMAC_RSE_RXSE_Msk   (_U_(0x3FF) << GMAC_RSE_RXSE_Pos)
 
#define GMAC_RSE_RXSE(value)   (GMAC_RSE_RXSE_Msk & ((value) << GMAC_RSE_RXSE_Pos))
 
#define GMAC_RSE_MASK   _U_(0x000003FF)
 (GMAC_RSE) MASK Register
 
#define GMAC_AE_OFFSET   0x19C
 (GMAC_AE offset) Alignment Errors Register
 
#define GMAC_AE_RESETVALUE   _U_(0x00000000)
 (GMAC_AE reset_value) Alignment Errors Register
 
#define GMAC_AE_AER_Pos   0
 (GMAC_AE) Alignment Errors
 
#define GMAC_AE_AER_Msk   (_U_(0x3FF) << GMAC_AE_AER_Pos)
 
#define GMAC_AE_AER(value)   (GMAC_AE_AER_Msk & ((value) << GMAC_AE_AER_Pos))
 
#define GMAC_AE_MASK   _U_(0x000003FF)
 (GMAC_AE) MASK Register
 
#define GMAC_RRE_OFFSET   0x1A0
 (GMAC_RRE offset) Receive Resource Errors Register
 
#define GMAC_RRE_RESETVALUE   _U_(0x00000000)
 (GMAC_RRE reset_value) Receive Resource Errors Register
 
#define GMAC_RRE_RXRER_Pos   0
 (GMAC_RRE) Receive Resource Errors
 
#define GMAC_RRE_RXRER_Msk   (_U_(0x3FFFF) << GMAC_RRE_RXRER_Pos)
 
#define GMAC_RRE_RXRER(value)   (GMAC_RRE_RXRER_Msk & ((value) << GMAC_RRE_RXRER_Pos))
 
#define GMAC_RRE_MASK   _U_(0x0003FFFF)
 (GMAC_RRE) MASK Register
 
#define GMAC_ROE_OFFSET   0x1A4
 (GMAC_ROE offset) Receive Overrun Register
 
#define GMAC_ROE_RESETVALUE   _U_(0x00000000)
 (GMAC_ROE reset_value) Receive Overrun Register
 
#define GMAC_ROE_RXOVR_Pos   0
 (GMAC_ROE) Receive Overruns
 
#define GMAC_ROE_RXOVR_Msk   (_U_(0x3FF) << GMAC_ROE_RXOVR_Pos)
 
#define GMAC_ROE_RXOVR(value)   (GMAC_ROE_RXOVR_Msk & ((value) << GMAC_ROE_RXOVR_Pos))
 
#define GMAC_ROE_MASK   _U_(0x000003FF)
 (GMAC_ROE) MASK Register
 
#define GMAC_IHCE_OFFSET   0x1A8
 (GMAC_IHCE offset) IP Header Checksum Errors Register
 
#define GMAC_IHCE_RESETVALUE   _U_(0x00000000)
 (GMAC_IHCE reset_value) IP Header Checksum Errors Register
 
#define GMAC_IHCE_HCKER_Pos   0
 (GMAC_IHCE) IP Header Checksum Errors
 
#define GMAC_IHCE_HCKER_Msk   (_U_(0xFF) << GMAC_IHCE_HCKER_Pos)
 
#define GMAC_IHCE_HCKER(value)   (GMAC_IHCE_HCKER_Msk & ((value) << GMAC_IHCE_HCKER_Pos))
 
#define GMAC_IHCE_MASK   _U_(0x000000FF)
 (GMAC_IHCE) MASK Register
 
#define GMAC_TCE_OFFSET   0x1AC
 (GMAC_TCE offset) TCP Checksum Errors Register
 
#define GMAC_TCE_RESETVALUE   _U_(0x00000000)
 (GMAC_TCE reset_value) TCP Checksum Errors Register
 
#define GMAC_TCE_TCKER_Pos   0
 (GMAC_TCE) TCP Checksum Errors
 
#define GMAC_TCE_TCKER_Msk   (_U_(0xFF) << GMAC_TCE_TCKER_Pos)
 
#define GMAC_TCE_TCKER(value)   (GMAC_TCE_TCKER_Msk & ((value) << GMAC_TCE_TCKER_Pos))
 
#define GMAC_TCE_MASK   _U_(0x000000FF)
 (GMAC_TCE) MASK Register
 
#define GMAC_UCE_OFFSET   0x1B0
 (GMAC_UCE offset) UDP Checksum Errors Register
 
#define GMAC_UCE_RESETVALUE   _U_(0x00000000)
 (GMAC_UCE reset_value) UDP Checksum Errors Register
 
#define GMAC_UCE_UCKER_Pos   0
 (GMAC_UCE) UDP Checksum Errors
 
#define GMAC_UCE_UCKER_Msk   (_U_(0xFF) << GMAC_UCE_UCKER_Pos)
 
#define GMAC_UCE_UCKER(value)   (GMAC_UCE_UCKER_Msk & ((value) << GMAC_UCE_UCKER_Pos))
 
#define GMAC_UCE_MASK   _U_(0x000000FF)
 (GMAC_UCE) MASK Register
 
#define GMAC_TISUBN_OFFSET   0x1BC
 (GMAC_TISUBN offset) 1588 Timer Increment [15:0] Sub-Nanoseconds Register
 
#define GMAC_TISUBN_RESETVALUE   _U_(0x00000000)
 (GMAC_TISUBN reset_value) 1588 Timer Increment [15:0] Sub-Nanoseconds Register
 
#define GMAC_TISUBN_LSBTIR_Pos   0
 (GMAC_TISUBN) Lower Significant Bits of Timer Increment
 
#define GMAC_TISUBN_LSBTIR_Msk   (_U_(0xFFFF) << GMAC_TISUBN_LSBTIR_Pos)
 
#define GMAC_TISUBN_LSBTIR(value)   (GMAC_TISUBN_LSBTIR_Msk & ((value) << GMAC_TISUBN_LSBTIR_Pos))
 
#define GMAC_TISUBN_MASK   _U_(0x0000FFFF)
 (GMAC_TISUBN) MASK Register
 
#define GMAC_TSH_OFFSET   0x1C0
 (GMAC_TSH offset) 1588 Timer Seconds High [15:0] Register
 
#define GMAC_TSH_RESETVALUE   _U_(0x00000000)
 (GMAC_TSH reset_value) 1588 Timer Seconds High [15:0] Register
 
#define GMAC_TSH_TCS_Pos   0
 (GMAC_TSH) Timer Count in Seconds
 
#define GMAC_TSH_TCS_Msk   (_U_(0xFFFF) << GMAC_TSH_TCS_Pos)
 
#define GMAC_TSH_TCS(value)   (GMAC_TSH_TCS_Msk & ((value) << GMAC_TSH_TCS_Pos))
 
#define GMAC_TSH_MASK   _U_(0x0000FFFF)
 (GMAC_TSH) MASK Register
 
#define GMAC_TSSSL_OFFSET   0x1C8
 (GMAC_TSSSL offset) 1588 Timer Sync Strobe Seconds [31:0] Register
 
#define GMAC_TSSSL_RESETVALUE   _U_(0x00000000)
 (GMAC_TSSSL reset_value) 1588 Timer Sync Strobe Seconds [31:0] Register
 
#define GMAC_TSSSL_VTS_Pos   0
 (GMAC_TSSSL) Value of Timer Seconds Register Capture
 
#define GMAC_TSSSL_VTS_Msk   (_U_(0xFFFFFFFF) << GMAC_TSSSL_VTS_Pos)
 
#define GMAC_TSSSL_VTS(value)   (GMAC_TSSSL_VTS_Msk & ((value) << GMAC_TSSSL_VTS_Pos))
 
#define GMAC_TSSSL_MASK   _U_(0xFFFFFFFF)
 (GMAC_TSSSL) MASK Register
 
#define GMAC_TSSN_OFFSET   0x1CC
 (GMAC_TSSN offset) 1588 Timer Sync Strobe Nanoseconds Register
 
#define GMAC_TSSN_RESETVALUE   _U_(0x00000000)
 (GMAC_TSSN reset_value) 1588 Timer Sync Strobe Nanoseconds Register
 
#define GMAC_TSSN_VTN_Pos   0
 (GMAC_TSSN) Value Timer Nanoseconds Register Capture
 
#define GMAC_TSSN_VTN_Msk   (_U_(0x3FFFFFFF) << GMAC_TSSN_VTN_Pos)
 
#define GMAC_TSSN_VTN(value)   (GMAC_TSSN_VTN_Msk & ((value) << GMAC_TSSN_VTN_Pos))
 
#define GMAC_TSSN_MASK   _U_(0x3FFFFFFF)
 (GMAC_TSSN) MASK Register
 
#define GMAC_TSL_OFFSET   0x1D0
 (GMAC_TSL offset) 1588 Timer Seconds [31:0] Register
 
#define GMAC_TSL_RESETVALUE   _U_(0x00000000)
 (GMAC_TSL reset_value) 1588 Timer Seconds [31:0] Register
 
#define GMAC_TSL_TCS_Pos   0
 (GMAC_TSL) Timer Count in Seconds
 
#define GMAC_TSL_TCS_Msk   (_U_(0xFFFFFFFF) << GMAC_TSL_TCS_Pos)
 
#define GMAC_TSL_TCS(value)   (GMAC_TSL_TCS_Msk & ((value) << GMAC_TSL_TCS_Pos))
 
#define GMAC_TSL_MASK   _U_(0xFFFFFFFF)
 (GMAC_TSL) MASK Register
 
#define GMAC_TN_OFFSET   0x1D4
 (GMAC_TN offset) 1588 Timer Nanoseconds Register
 
#define GMAC_TN_RESETVALUE   _U_(0x00000000)
 (GMAC_TN reset_value) 1588 Timer Nanoseconds Register
 
#define GMAC_TN_TNS_Pos   0
 (GMAC_TN) Timer Count in Nanoseconds
 
#define GMAC_TN_TNS_Msk   (_U_(0x3FFFFFFF) << GMAC_TN_TNS_Pos)
 
#define GMAC_TN_TNS(value)   (GMAC_TN_TNS_Msk & ((value) << GMAC_TN_TNS_Pos))
 
#define GMAC_TN_MASK   _U_(0x3FFFFFFF)
 (GMAC_TN) MASK Register
 
#define GMAC_TA_OFFSET   0x1D8
 (GMAC_TA offset) 1588 Timer Adjust Register
 
#define GMAC_TA_RESETVALUE   _U_(0x00000000)
 (GMAC_TA reset_value) 1588 Timer Adjust Register
 
#define GMAC_TA_ITDT_Pos   0
 (GMAC_TA) Increment/Decrement
 
#define GMAC_TA_ITDT_Msk   (_U_(0x3FFFFFFF) << GMAC_TA_ITDT_Pos)
 
#define GMAC_TA_ITDT(value)   (GMAC_TA_ITDT_Msk & ((value) << GMAC_TA_ITDT_Pos))
 
#define GMAC_TA_ADJ_Pos   31
 (GMAC_TA) Adjust 1588 Timer
 
#define GMAC_TA_ADJ   (_U_(0x1) << GMAC_TA_ADJ_Pos)
 
#define GMAC_TA_MASK   _U_(0xBFFFFFFF)
 (GMAC_TA) MASK Register
 
#define GMAC_TI_OFFSET   0x1DC
 (GMAC_TI offset) 1588 Timer Increment Register
 
#define GMAC_TI_RESETVALUE   _U_(0x00000000)
 (GMAC_TI reset_value) 1588 Timer Increment Register
 
#define GMAC_TI_CNS_Pos   0
 (GMAC_TI) Count Nanoseconds
 
#define GMAC_TI_CNS_Msk   (_U_(0xFF) << GMAC_TI_CNS_Pos)
 
#define GMAC_TI_CNS(value)   (GMAC_TI_CNS_Msk & ((value) << GMAC_TI_CNS_Pos))
 
#define GMAC_TI_ACNS_Pos   8
 (GMAC_TI) Alternative Count Nanoseconds
 
#define GMAC_TI_ACNS_Msk   (_U_(0xFF) << GMAC_TI_ACNS_Pos)
 
#define GMAC_TI_ACNS(value)   (GMAC_TI_ACNS_Msk & ((value) << GMAC_TI_ACNS_Pos))
 
#define GMAC_TI_NIT_Pos   16
 (GMAC_TI) Number of Increments
 
#define GMAC_TI_NIT_Msk   (_U_(0xFF) << GMAC_TI_NIT_Pos)
 
#define GMAC_TI_NIT(value)   (GMAC_TI_NIT_Msk & ((value) << GMAC_TI_NIT_Pos))
 
#define GMAC_TI_MASK   _U_(0x00FFFFFF)
 (GMAC_TI) MASK Register
 
#define GMAC_EFTSL_OFFSET   0x1E0
 (GMAC_EFTSL offset) PTP Event Frame Transmitted Seconds Low Register
 
#define GMAC_EFTSL_RESETVALUE   _U_(0x00000000)
 (GMAC_EFTSL reset_value) PTP Event Frame Transmitted Seconds Low Register
 
#define GMAC_EFTSL_RUD_Pos   0
 (GMAC_EFTSL) Register Update
 
#define GMAC_EFTSL_RUD_Msk   (_U_(0xFFFFFFFF) << GMAC_EFTSL_RUD_Pos)
 
#define GMAC_EFTSL_RUD(value)   (GMAC_EFTSL_RUD_Msk & ((value) << GMAC_EFTSL_RUD_Pos))
 
#define GMAC_EFTSL_MASK   _U_(0xFFFFFFFF)
 (GMAC_EFTSL) MASK Register
 
#define GMAC_EFTN_OFFSET   0x1E4
 (GMAC_EFTN offset) PTP Event Frame Transmitted Nanoseconds
 
#define GMAC_EFTN_RESETVALUE   _U_(0x00000000)
 (GMAC_EFTN reset_value) PTP Event Frame Transmitted Nanoseconds
 
#define GMAC_EFTN_RUD_Pos   0
 (GMAC_EFTN) Register Update
 
#define GMAC_EFTN_RUD_Msk   (_U_(0x3FFFFFFF) << GMAC_EFTN_RUD_Pos)
 
#define GMAC_EFTN_RUD(value)   (GMAC_EFTN_RUD_Msk & ((value) << GMAC_EFTN_RUD_Pos))
 
#define GMAC_EFTN_MASK   _U_(0x3FFFFFFF)
 (GMAC_EFTN) MASK Register
 
#define GMAC_EFRSL_OFFSET   0x1E8
 (GMAC_EFRSL offset) PTP Event Frame Received Seconds Low Register
 
#define GMAC_EFRSL_RESETVALUE   _U_(0x00000000)
 (GMAC_EFRSL reset_value) PTP Event Frame Received Seconds Low Register
 
#define GMAC_EFRSL_RUD_Pos   0
 (GMAC_EFRSL) Register Update
 
#define GMAC_EFRSL_RUD_Msk   (_U_(0xFFFFFFFF) << GMAC_EFRSL_RUD_Pos)
 
#define GMAC_EFRSL_RUD(value)   (GMAC_EFRSL_RUD_Msk & ((value) << GMAC_EFRSL_RUD_Pos))
 
#define GMAC_EFRSL_MASK   _U_(0xFFFFFFFF)
 (GMAC_EFRSL) MASK Register
 
#define GMAC_EFRN_OFFSET   0x1EC
 (GMAC_EFRN offset) PTP Event Frame Received Nanoseconds
 
#define GMAC_EFRN_RESETVALUE   _U_(0x00000000)
 (GMAC_EFRN reset_value) PTP Event Frame Received Nanoseconds
 
#define GMAC_EFRN_RUD_Pos   0
 (GMAC_EFRN) Register Update
 
#define GMAC_EFRN_RUD_Msk   (_U_(0x3FFFFFFF) << GMAC_EFRN_RUD_Pos)
 
#define GMAC_EFRN_RUD(value)   (GMAC_EFRN_RUD_Msk & ((value) << GMAC_EFRN_RUD_Pos))
 
#define GMAC_EFRN_MASK   _U_(0x3FFFFFFF)
 (GMAC_EFRN) MASK Register
 
#define GMAC_PEFTSL_OFFSET   0x1F0
 (GMAC_PEFTSL offset) PTP Peer Event Frame Transmitted Seconds Low Register
 
#define GMAC_PEFTSL_RESETVALUE   _U_(0x00000000)
 (GMAC_PEFTSL reset_value) PTP Peer Event Frame Transmitted Seconds Low Register
 
#define GMAC_PEFTSL_RUD_Pos   0
 (GMAC_PEFTSL) Register Update
 
#define GMAC_PEFTSL_RUD_Msk   (_U_(0xFFFFFFFF) << GMAC_PEFTSL_RUD_Pos)
 
#define GMAC_PEFTSL_RUD(value)   (GMAC_PEFTSL_RUD_Msk & ((value) << GMAC_PEFTSL_RUD_Pos))
 
#define GMAC_PEFTSL_MASK   _U_(0xFFFFFFFF)
 (GMAC_PEFTSL) MASK Register
 
#define GMAC_PEFTN_OFFSET   0x1F4
 (GMAC_PEFTN offset) PTP Peer Event Frame Transmitted Nanoseconds
 
#define GMAC_PEFTN_RESETVALUE   _U_(0x00000000)
 (GMAC_PEFTN reset_value) PTP Peer Event Frame Transmitted Nanoseconds
 
#define GMAC_PEFTN_RUD_Pos   0
 (GMAC_PEFTN) Register Update
 
#define GMAC_PEFTN_RUD_Msk   (_U_(0x3FFFFFFF) << GMAC_PEFTN_RUD_Pos)
 
#define GMAC_PEFTN_RUD(value)   (GMAC_PEFTN_RUD_Msk & ((value) << GMAC_PEFTN_RUD_Pos))
 
#define GMAC_PEFTN_MASK   _U_(0x3FFFFFFF)
 (GMAC_PEFTN) MASK Register
 
#define GMAC_PEFRSL_OFFSET   0x1F8
 (GMAC_PEFRSL offset) PTP Peer Event Frame Received Seconds Low Register
 
#define GMAC_PEFRSL_RESETVALUE   _U_(0x00000000)
 (GMAC_PEFRSL reset_value) PTP Peer Event Frame Received Seconds Low Register
 
#define GMAC_PEFRSL_RUD_Pos   0
 (GMAC_PEFRSL) Register Update
 
#define GMAC_PEFRSL_RUD_Msk   (_U_(0xFFFFFFFF) << GMAC_PEFRSL_RUD_Pos)
 
#define GMAC_PEFRSL_RUD(value)   (GMAC_PEFRSL_RUD_Msk & ((value) << GMAC_PEFRSL_RUD_Pos))
 
#define GMAC_PEFRSL_MASK   _U_(0xFFFFFFFF)
 (GMAC_PEFRSL) MASK Register
 
#define GMAC_PEFRN_OFFSET   0x1FC
 (GMAC_PEFRN offset) PTP Peer Event Frame Received Nanoseconds
 
#define GMAC_PEFRN_RESETVALUE   _U_(0x00000000)
 (GMAC_PEFRN reset_value) PTP Peer Event Frame Received Nanoseconds
 
#define GMAC_PEFRN_RUD_Pos   0
 (GMAC_PEFRN) Register Update
 
#define GMAC_PEFRN_RUD_Msk   (_U_(0x3FFFFFFF) << GMAC_PEFRN_RUD_Pos)
 
#define GMAC_PEFRN_RUD(value)   (GMAC_PEFRN_RUD_Msk & ((value) << GMAC_PEFRN_RUD_Pos))
 
#define GMAC_PEFRN_MASK   _U_(0x3FFFFFFF)
 (GMAC_PEFRN) MASK Register
 
#define GMAC_RLPITR_OFFSET   0x270
 (GMAC_RLPITR offset) Receive LPI transition Register
 
#define GMAC_RLPITR_RESETVALUE   _U_(0x00000000)
 (GMAC_RLPITR reset_value) Receive LPI transition Register
 
#define GMAC_RLPITR_RLPITR_Pos   0
 (GMAC_RLPITR) Count number of times transition from rx normal idle to low power idle
 
#define GMAC_RLPITR_RLPITR_Msk   (_U_(0xFFFF) << GMAC_RLPITR_RLPITR_Pos)
 
#define GMAC_RLPITR_RLPITR(value)   (GMAC_RLPITR_RLPITR_Msk & ((value) << GMAC_RLPITR_RLPITR_Pos))
 
#define GMAC_RLPITR_MASK   _U_(0x0000FFFF)
 (GMAC_RLPITR) MASK Register
 
#define GMAC_RLPITI_OFFSET   0x274
 (GMAC_RLPITI offset) Receive LPI Time Register
 
#define GMAC_RLPITI_RESETVALUE   _U_(0x00000000)
 (GMAC_RLPITI reset_value) Receive LPI Time Register
 
#define GMAC_RLPITI_RLPITI_Pos   0
 (GMAC_RLPITI) Increment once over 16 ahb clock when LPI indication bit 20 is set in rx mode
 
#define GMAC_RLPITI_RLPITI_Msk   (_U_(0xFFFFFF) << GMAC_RLPITI_RLPITI_Pos)
 
#define GMAC_RLPITI_RLPITI(value)   (GMAC_RLPITI_RLPITI_Msk & ((value) << GMAC_RLPITI_RLPITI_Pos))
 
#define GMAC_RLPITI_MASK   _U_(0x00FFFFFF)
 (GMAC_RLPITI) MASK Register
 
#define GMAC_TLPITR_OFFSET   0x278
 (GMAC_TLPITR offset) Receive LPI transition Register
 
#define GMAC_TLPITR_RESETVALUE   _U_(0x00000000)
 (GMAC_TLPITR reset_value) Receive LPI transition Register
 
#define GMAC_TLPITR_TLPITR_Pos   0
 (GMAC_TLPITR) Count number of times enable LPI tx bit 20 goes from low to high
 
#define GMAC_TLPITR_TLPITR_Msk   (_U_(0xFFFF) << GMAC_TLPITR_TLPITR_Pos)
 
#define GMAC_TLPITR_TLPITR(value)   (GMAC_TLPITR_TLPITR_Msk & ((value) << GMAC_TLPITR_TLPITR_Pos))
 
#define GMAC_TLPITR_MASK   _U_(0x0000FFFF)
 (GMAC_TLPITR) MASK Register
 
#define GMAC_TLPITI_OFFSET   0x27C
 (GMAC_TLPITI offset) Receive LPI Time Register
 
#define GMAC_TLPITI_RESETVALUE   _U_(0x00000000)
 (GMAC_TLPITI reset_value) Receive LPI Time Register
 
#define GMAC_TLPITI_TLPITI_Pos   0
 (GMAC_TLPITI) Increment once over 16 ahb clock when LPI indication bit 20 is set in tx mode
 
#define GMAC_TLPITI_TLPITI_Msk   (_U_(0xFFFFFF) << GMAC_TLPITI_TLPITI_Pos)
 
#define GMAC_TLPITI_TLPITI(value)   (GMAC_TLPITI_TLPITI_Msk & ((value) << GMAC_TLPITI_TLPITI_Pos))
 
#define GMAC_TLPITI_MASK   _U_(0x00FFFFFF)
 (GMAC_TLPITI) MASK Register
 

Detailed Description

Component description for GMAC.

Copyright (c) 2019 Microchip Technology Inc.

\asf_license_start

Definition in file gmac.h.

Generated by doxygen 1.8.20