10G Ethernet MAC Explained: Framing, PCS/PMA on FPGA

10G Ethernet MAC Explained: Framing, PCS/PMA on FPGA

Industry news — On 24 April 2026 the IEEE published IEEE Std 802.3dk-2026, Amendment 11 to IEEE Std 802.3-2022, adding Physical Layer specifications for bidirectional 100 Gb/s Ethernet over a single strand of single-mode fibre at reaches of at least 10 km, 20 km and 40 km — a reminder that the PHY beneath your MAC keeps changing while the MAC-to-PCS boundary stays where it is (IEEE Standards Association, 24 April 2026).

In short: A 10G Ethernet MAC owns framing, addressing, the frame check sequence and flow control, while the PCS and PMA beneath it own 64b/66b coding and the serial line — and on an FPGA that PMA is the device’s own transceiver, which is why knowing where the boundary falls is what makes a 10 Gb/s port integrate cleanly.

That amendment shows how IEEE 802.3 actually evolves: a new optical PHY arrives, the reach and the signalling change, and the media access control layer above it does not move at all. Ethernet is engineered around a small number of stable seams, and the one that matters most to an FPGA engineer is the boundary between the MAC and the physical coding sublayer. Get it right and a 10 Gb/s port becomes a partitioning exercise — framing logic on one side, line coding and serialisation on the other. Get it wrong and you spend weeks on clock domains, dropped frames and a link that will not come up. What follows walks the stack the way it is built in fabric: the frame first, then the coding and fault signalling underneath, then why the two live in different IP blocks.

The short answer

A 10G Ethernet MAC is the block that turns your payload into legal IEEE 802.3 frames and back: it prepends the preamble and start-of-frame delimiter, writes the destination and source addresses and the Length/Type field, pads short frames to the 64-byte minimum, computes the 4-byte frame check sequence, enforces the inter-frame gap, filters received addresses and handles pause frames. It never touches the wire. Everything below it — 64b/66b coding, scrambling, serialisation and clock recovery — belongs to the PCS and the PMA, and on an FPGA the PMA is the device’s own serial transceiver. XGMII is the seam between the two, and it is why the same MAC survives several generations of optics underneath it.

The 802.3 stack mapped onto an FPGA

IEEE 802.3 splits a 10 Gb/s port into a short stack of sublayers, and an FPGA design maps onto it almost one for one. Above, the MAC talks to your logic in whole frames; below, a transceiver drives differential pairs into an optical module. Between them sit three named things that exist so the MAC never has to know what is on the far end of the fibre.

The Reconciliation Sublayer is the adapter: the MAC is specified in abstract service primitives, and the sublayer maps those onto the concrete XGMII signals and interprets link-fault state. In an FPGA flow it is rarely a separate deliverable, so an integrator meets it mainly through its side effects — the local-fault and remote-fault status bits, and the “wrong code received from the Reconciliation Sublayer” error a receive path reports when handed something that is not a legal frame.

XGMII itself is 32 data bits plus 4 control bits per direction at 156.25 MHz on both clock edges. Almost nobody builds that in fabric, because double-data-rate buses are painful to close timing on; implementations present the identical stream as 64 data bits on a single 156.25 MHz edge. The arithmetic is the same either way: 64 bits per clock at 156.25 MHz is exactly 10 Gb/s of MAC-layer bandwidth.

The 10 Gb/s Ethernet stack and where each piece is implemented in an FPGA
Sublayer Job Typical FPGA implementation
MAC Framing, addressing, padding, FCS, inter-frame gap, address filtering, PAUSE flow control, statistics Soft IP in fabric, delivered as VHDL or Verilog source
Reconciliation Sublayer Maps MAC service primitives onto XGMII; interprets link fault ordered sets Soft logic, normally bundled inside the MAC core
XGMII 32 data + 4 control bits per direction at 156.25 MHz DDR An internal bus, widened to 64 bits single-edge; never brought to pins
PCS 64b/66b coding, scrambling, block synchronisation, BER monitoring Soft IP, or a hard block where the family provides one
PMA Serialisation and deserialisation, clock and data recovery, equalisation The FPGA’s own multi-gigabit transceiver, configured rather than written
PMD and MDI Optical or electrical signalling on the medium Outside the FPGA: an SFP+ module, a direct-attach cable, a backplane

Read the table upward and 802.3dk-2026 stops being a MAC problem: a new PMD changes how bits reach the glass, but the frame arriving at the MAC is byte-for-byte the frame it was ten years ago.

Anatomy of a 10G Ethernet frame

An Ethernet frame is a fixed sequence of fields, and the MAC exists to build that sequence on transmit and take it apart on receive. The field list has not changed since the original standard; what changed at 10 Gb/s is that half-duplex and collision detection went away, so the MAC no longer arbitrates for the medium — it only frames.

Fields of an IEEE 802.3 frame, in transmission order
Field Size What it carries What the MAC does with it
Preamble 7 bytes A repeating alternating pattern Generated on transmit, consumed on receive; never visible to your logic
Start-of-frame delimiter 1 byte The pattern that breaks the alternation and marks byte alignment Frames with a malformed delimiter are flushed and counted separately
Destination address 6 bytes Unicast, multicast or broadcast MAC address Compared against the configured device address, the multicast filter and the broadcast address
Source address 6 bytes The transmitting station’s address Inserted from the transmit configuration interface; passed up unchanged on receive
Length/Type 2 bytes Either a payload length or an EtherType A length when the value is 1500 or below, a protocol type from 1536 upward
MAC client data 46 to 1500 bytes Your payload Handed to and from the data FIFO interface
Pad 0 to 46 bytes Filler Added on transmit when the payload is short; optionally stripped on receive
Frame check sequence 4 bytes CRC-32 over the frame from the destination address onward Computed and appended on transmit; recomputed and compared on receive

The preamble and delimiter are a legacy of a shared medium. At 10 Gb/s the PCS holds block synchronisation long before a frame arrives, so the eight bytes are mostly a boundary marker — but a corrupted delimiter still means the receive path cannot trust where the frame starts, so it discards the frame rather than passing up a plausible but wrong address. A core that counts “frames flushed because of a bad start of frame” separately is telling you framing failed, not payload, which points at the PCS or the optics rather than the sender.

A MAC address is 48 bits, and the lowest-order bit of the first byte is the individual/group flag: clear for a single station, set for a group, all ones for broadcast. That one bit is the whole basis of receive filtering, and it is why a well-instrumented core keeps separate unicast, multicast and broadcast counters in both directions — the cheapest diagnostic available when a link is up but traffic is not arriving.

The two bytes after the source address are ambiguous by design, and 802.3 resolves it by value range: 1500 or less is a length in bytes, 1536 or more is an EtherType, the values between undefined. A “payload length check disable” configuration bit, which the ETH_MAC_10G_SFP core exposes, is the escape hatch for a frame declaring a length that does not match what arrived. Normally the receive status interface reports that as a payload length error; in a capture application you may want the frame regardless.

FCS, forward CRC and the inter-frame gap

The frame check sequence is a 32-bit cyclic redundancy check computed over every byte from the start of the destination address to the end of the pad. The MAC computes and appends it on transmit, recomputes and compares it on receive. Nothing else in the stack does that job, which is why a CRC error counter belongs to the MAC and not to the PCS.

Two options around the FCS are routinely misread. On the transmit side, a per-frame status interface decides whether the MAC appends a CRC at all: if your logic already holds a complete frame with a valid FCS — replaying a capture, forwarding a frame from another port — you want it transmitted verbatim. The same interface is where you ask for an Error control character instead, deliberately invalidating the frame so the far end discards it: link-level error injection without touching the transceiver.

On the receive side, forward CRC delivers the four FCS bytes with the frame instead of stripping them after checking. Enable it whenever the frame is stored or forwarded rather than consumed: a recorder writing raw frames to disk, a bridge re-transmitting on another interface, a test system that must prove bit-for-bit what arrived. It is not the same as disabling the check — the MAC still verifies the CRC and still reports an error, it simply keeps the bytes.

The inter-frame gap is the enforced idle between frames, a minimum of 96 bit times, which at any speed is 12 byte times. On a 10 Gb/s port it interacts with the 66-bit block structure, because frames do not necessarily start on a block boundary, so the transmit path rounds the gap and accounts for the difference to hold the average. That is invisible to your logic, but it explains why the gap is a configuration value rather than a constant: a link feeding a device with limited buffering may need more than the minimum.

Jumbo frames and storage over Ethernet

Jumbo frames are frames whose payload exceeds the 1500-byte maximum, and they are the most common non-standard feature in Ethernet. IEEE 802.3 does not define them: the maximum untagged frame is 1518 bytes from destination address through FCS. What the standard does provide is the mechanism a MAC uses to accept more — a configurable maximum frame length on the receive side, above which a frame is reported as a “frame too long” error.

Whether that matters depends on the traffic. For general networking it rarely does. For storage it does, because per-frame overhead is fixed — 18 bytes of framing plus preamble, delimiter and gap — while the payload is not. Carrying a disk block in one frame instead of several means fewer frames per second for the same bytes per second, fewer chances for a receive FIFO to fall behind, and block boundaries that line up with frame boundaries.

That is why the SATA recorder line accepts jumbo frames up to 9216 bytes, alongside ATA-over-Ethernet support, when fed from a 1 Gbit GMII or a 10 Gbit XGMII/XAUI interface. The same reasoning drives continuous high-rate SATA recorders and NVMe storage-area-network IP, where whole storage commands ride inside Ethernet frames.

Two cautions. Jumbo frames work only if every device on the path agrees, switches included: an oversized frame is dropped, not fragmented, so the failure mode is a link that passes small frames perfectly and loses large ones. And the FCS is still a 32-bit CRC characterised for standard-length frames; stretching a frame to six times that length does not improve it. Storage payloads usually carry their own integrity checking, but it is a trade rather than a free win.

VLAN and stacked VLAN tagging

A VLAN tag is four extra bytes inserted immediately after the source address, defined not in 802.3 but in IEEE 802.1Q. The first two bytes hold a tag protocol identifier — a reserved EtherType value announcing that what follows is a tag, not a Length/Type field. The other two hold a three-bit priority code point, a one-bit drop-eligible indicator and a twelve-bit VLAN identifier, hence the familiar ceiling of 4094 usable VLANs.

The consequence for a MAC is structural. The tag pushes the real Length/Type field four bytes deeper into the frame, so anything parsing past the addresses must know whether a tag is present and skip it, and it raises the maximum frame length to 1522 bytes. A MAC that does not understand tags reports a correctly formed tagged frame as too long — a confusing symptom to debug from outside.

Stacked VLAN tagging, or provider bridging, adds a second tag in front of the first with its own tag protocol identifier, so a carrier can transport a customer’s VLAN structure transparently inside its own. That takes the maximum to 1526 bytes and forces a parser to handle two levels rather than one. A core that counts VLAN frames and stacked VLAN frames as separate statistics in both directions is not being decorative: those counters confirm that the tagging you configured is the tagging on the wire, without attaching a capture device.

Pause frames and the nearly-full trigger

Ethernet flow control works by asking the far end to stop transmitting for a stated interval. The mechanism is a MAC Control frame: an ordinary Ethernet frame sent to a reserved multicast address, carrying the MAC Control EtherType and a PAUSE opcode with one parameter, the pause time. That parameter is not in seconds or bytes but in pause quanta of 512 bits each — at 10 Gb/s, 51.2 ns apiece, so the 16-bit field spans up to roughly 3.4 ms. Zero is the explicit cancel: resume now.

The engineering question is not how to format the frame but when to send it. A pause request is useful only if it arrives before the buffer overflows, and it takes time to work — the frame in flight must finish, the request must propagate, the sender must react. A MAC offering only a software-driven “transmit a pause frame now” interface pushes that timing problem onto you. A MAC that also provides a dedicated receive-FIFO nearly-full input, as the ETH_MAC_10G_SFP core does with separate transmit-pause and FIFO-RX-pause interfaces, lets you wire the trigger straight to the buffer watermark and choose the threshold in hardware.

The receive side needs its own decisions, and they are configuration bits rather than logic:

  • Forward pause frames. Normally the MAC consumes a pause frame and acts on it; a monitoring or bridging design may need to see it instead.
  • Ignore pause frame quanta. Treat arrival as an event but disregard the requested duration, where your own logic decides how long to hold off.
  • Ignore control frames. Drop MAC Control frames entirely, on a link where flow control is handled elsewhere or deliberately disabled.
  • Accept only specific frame classes. A configuration admitting only ATA-over-Ethernet and pause frames turns the MAC into a narrow filter for a dedicated storage link, so unrelated traffic never reaches the FIFO.

Flow control also fails in a way that looks like a performance problem: if pause frames are emitted continuously because a downstream consumer is too slow, throughput collapses without a single error counter moving. A transmit statistics interface counting pause frames separately from data frames turns that into a five-second diagnosis.

Address filtering and the hash table

Address filtering is the receive path’s per-frame decision about whether a frame is addressed to this station. A unicast frame is accepted when the destination matches the configured device address, a broadcast frame is accepted by definition, and everything else is a multicast group address — where it gets interesting, because a station may legitimately belong to many groups.

Storing a full list of accepted multicast addresses in fabric is expensive and unbounded. The standard technique is a hash table: run the destination address through a hash function, index a small table of bits with the result, accept the frame if the bit is set. The filter is imprecise by construction, since different addresses can collide onto the same bit, but it is cheap and constant-time and the client above discards the false accepts. A MAC exposing a hash table interface is exposing exactly that: a way to program which groups the hardware lets through.

Promiscuous mode short-circuits all of it, accepting every frame with valid framing regardless of destination address. That is the permanent mode of a capture appliance or protocol analyser. It is also the first thing to switch on when a link is up and nothing is arriving, because one register write separates “nothing is reaching me” from “something is reaching me and my filter is rejecting it” — two conclusions leading to entirely different debugging sessions.

64b/66b, block lock and fault signalling

The PCS beneath the MAC is where the parallel XGMII stream becomes something a serial link can carry. For 10GBASE-R — the variant behind an SFP+ cage — that means 64b/66b encoding: the PCS takes 64 bits at a time and prepends a two-bit synchronisation header to make a 66-bit block. The header is the trick. It has only two legal values, one meaning the block is data and the other meaning it is control, and because both patterns contain a transition, every block carries a transition regardless of payload. The payload is scrambled so long runs of identical bits cannot reach the line, keeping clock recovery fed. The cost is 66 bits per 64 bits of data, so a 10 Gb/s stream becomes a 10.3125 Gbaud line rate — the number you configure in the transceiver, and the reason a 10G link does not run at a round 10 Gbaud.

Block lock is not comma detection

Receivers must find the block boundary before anything else works, and the terminology trips people up. In 8b/10b line codes — used by XAUI and the 10GBASE-X variants, and by SATA and earlier PCIe generations — alignment uses a comma, a character whose bit pattern cannot occur elsewhere, which the receiver searches for. 64b/66b has no comma. Instead the PCS uses block lock: it assumes a boundary, tests whether the sync headers at that offset are consistently legal, slips by one bit and retries if they are not, and declares lock after enough consecutive valid headers. A monitor then watches the rate of invalid headers and raises a high-bit-error-rate condition when they accumulate too fast — how a marginal link announces itself before it starts corrupting frames.

Local fault and remote fault

When the PCS cannot achieve or hold lock it signals a fault upward as an ordered set on XGMII, and the Reconciliation Sublayer interprets it. A local fault means the station’s own receive path is broken. On seeing it, the sublayer stops passing data up and starts transmitting a remote fault indication back down the link, so the far end learns, with no higher-layer protocol involved, that the direction it is transmitting into is not working. A link dark in one direction only is the classic case: one end reports local fault, the other remote fault, and the pair localises the break to a specific fibre or transceiver.

That is why a MAC surfaces both as receive status even though the fault is detected below it. A local fault points at your own optics, cabling or PMA configuration; a remote fault points at the far end’s receive path or the fibre carrying your transmission. The same interface reports the related case where the sublayer delivers a code the MAC cannot interpret — the signature of a PCS and MAC that disagree about the interface, usually a width or endianness mismatch introduced during integration.

Why the MAC and the PCS/PMA are separate IP

The MAC and the PCS/PMA are delivered as separate IP blocks in every FPGA flow because they are not the same kind of thing. The MAC is pure synchronous logic with no analogue content: portable RTL that closes timing like any other fabric design and moves between vendors with a recompile. The PMA is not logic at all but a hardened analogue macro — the multi-gigabit transceiver the silicon vendor built into the device, with its own reference clock, equalisation and reset sequence. The PCS sits between and can go either way, soft in fabric or hard where the family provides one. Anything touching the transceiver is device-specific by nature, which is the practical form of the distinction drawn in soft IP versus hard IP.

That split defines what portability means. AMD’s UltraScale and UltraScale+ transceivers, Altera’s transceiver tiles in the Agilex and Stratix families, and Microchip’s PolarFire transceivers all reach 10 Gb/s, and all three are configured through entirely different vendor tooling. A MAC written as portable VHDL or Verilog crosses that boundary; a transceiver configuration does not. That is why the ETH_MAC_10G_SFP core is documented as connecting to a PCS/PMA IP rather than embedding one, and why its published validation list names a board per family — KC705, KCU105, VC707, ZC706, ZCU102 and ZCU106 across Kintex 7, Kintex UltraScale, Virtex 7, Zynq 7 and Zynq UltraScale+, plus Microchip’s PolarFire evaluation kit.

The other constraint is clocking, and it is the one most likely to bite. That core is specified as connecting to a PCS/PMA IP with only one clock domain — a deliberate decision with a real consequence. Because the transmit and receive paths and the MAC-to-PCS interface share a clock, there is no clock-domain crossing inside the datapath: no asynchronous FIFO between MAC and PCS, no elastic buffer to size, no metastability analysis on the interface, one clean set of constraints. The cost is that the crossing between your application clock and the Ethernet clock is handled outside the core, at the data FIFO interfaces, so those FIFOs must be sized deliberately rather than assumed away. For the product-level view — interfaces, statistics, validated targets — see the companion article on 10G Ethernet MAC IP for FPGA.

Which returns to where this started. XGMII below the MAC and the frame format above it are what make an amendment like 802.3dk-2026 a PHY procurement question rather than a redesign. The Ethernet Alliance’s OFC 2026 interoperability demonstration, with fourteen named member companies showing optics scaling from 200G, 400G and 800G toward 1.6T, is the same story at a larger scale: enormous churn below the coding sublayer, a stable frame above it.

Tell us the protocol, the target device family and the framing behaviour your design needs, and we will tell you where the MAC ends and the transceiver work begins.

Talk to an FPGA engineer

Where this stops applying

This is a protocol explanation, not an implementation guarantee. Five boundaries are worth stating plainly:

  • It describes 10GBASE-R over a serial PMA — the SFP+ and direct-attach case. 10GBASE-T, backplane variants and the older multi-lane XAUI and 10GBASE-X path use different coding, and the block-lock reasoning does not transfer.
  • Higher speeds are not a scaled-up version of this. 25G, 40G, 100G and above add multiple PCS lanes, alignment markers and, from 25G upward, forward error correction between PCS and PMA. The framing is the same; the layer beneath is not.
  • Nothing here is a performance figure. No latency, resource utilisation or achievable line-rate percentage is quoted for any core, because none is published. Those come from a synthesis run on your target.
  • It is layer 2 only. IP, UDP, TCP, ARP and any offload of them sit above the MAC. Precision time protocol timestamping, which straddles the MAC/PCS boundary, is out of scope.
  • Jumbo frames are outside the standard. What is said about them describes common practice and the configuration a MAC exposes, not a normative requirement.

In summary

The layering is the point. A 10G Ethernet MAC owns the frame — preamble and delimiter, addresses, Length/Type, pad, FCS, inter-frame gap — plus the decisions built on top of it: which addresses to accept, whether to forward the CRC, when to emit a pause frame, how long a frame may be. The PCS owns the line code, the block lock and the fault signalling. The PMA is the transceiver, and it belongs to the silicon vendor. Draw those boundaries correctly and most 10 Gb/s integration problems become tractable, because each symptom maps onto exactly one layer.

The corollary is that the pieces have different lifetimes: framing logic written against IEEE 802.3 is stable across device generations and vendors, while transceiver configuration should be expected to be redone for every target. Amendments keep arriving underneath, which is precisely what the stable MAC-to-PCS seam is for.

Frequently asked questions

What does a 10G Ethernet MAC do that the PCS does not?

The MAC works in frames, the PCS works in bits. The MAC builds and parses the frame structure — preamble, addresses, Length/Type, pad and the 32-bit frame check sequence — enforces the inter-frame gap, filters destination addresses and handles PAUSE flow control. The PCS never sees a frame: it takes whatever crosses XGMII, encodes it into 66-bit blocks, scrambles it and hands it to the transceiver. Error counters split on the same line — CRC errors are the MAC’s, block lock and fault indications are the PCS’s.

Why is the MAC-to-PCS boundary stable when new PHYs keep appearing?

Because IEEE 802.3 specifies the media independent interface as the point of separation. A new amendment such as IEEE Std 802.3dk-2026, published on 24 April 2026, adds Physical Layer specifications — new reaches, new optics, new signalling — below that interface. The MAC service definition and the frame format above it are untouched. In FPGA terms a new PHY generation means a different transceiver configuration and possibly a different PCS variant, not a rewrite of the framing logic.

What is forward CRC and when should it be enabled?

Forward CRC is a receive-side option that delivers the four-byte frame check sequence to the client instead of stripping it after verification. Enable it when the frame will be stored or forwarded rather than consumed — a recorder writing raw frames to disk, a bridge re-transmitting on another port, a test system that must prove exactly what arrived. It does not disable checking: the MAC still recomputes the CRC and still reports a CRC error, it simply keeps the bytes in the delivered frame.

How do jumbo frames relate to the IEEE 802.3 maximum frame size?

They exceed it. The standard maximum untagged frame is 1518 bytes from the destination address through the frame check sequence, and IEEE 802.3 defines nothing larger. Jumbo frames are a widely implemented convention rather than a specification, reached through a MAC’s configurable maximum frame length. Storage traffic benefits most, since fixed per-frame overhead becomes a smaller fraction of each transfer — which is why storage-oriented designs commonly accept frames of 9216 bytes. Every device on the path must agree, or large frames are silently dropped.

Is a pause frame the same thing as a data frame?

Structurally yes, functionally no. A PAUSE frame is an ordinary Ethernet frame addressed to a reserved multicast address, carrying the MAC Control EtherType and a PAUSE opcode with one parameter: the pause time, expressed in quanta of 512 bits. At 10 Gb/s one quantum is 51.2 ns. It is consumed by the far end’s MAC rather than passed to its client, unless that MAC is configured to forward pause frames, and a pause time of zero cancels an outstanding request.

Why does a single-clock-domain MAC matter during integration?

It removes a clock-domain crossing from inside the core and moves it somewhere you control. When the MAC and the PCS/PMA share one clock domain there is no asynchronous FIFO between them to size, no elastic buffer, and one coherent set of timing constraints across the interface. The trade is that the crossing between your application clock and the Ethernet clock must be handled at the data FIFO interfaces instead — size those buffers against real burst behaviour rather than assuming the core absorbs it.

  1. IEEE Standards Association — IEEE Std 802.3dk-2026, Amendment 11 to IEEE Std 802.3-2022, 24 April 2026: the amendment adding bidirectional 100 Gb/s Physical Layer specifications over a single strand of single-mode fibre at 10, 20 and 40 km.
  2. IEEE Standards Association — IEEE Std 802.3-2022, IEEE Standard for Ethernet, published 29 July 2022: the base standard: frame format and fields, the Reconciliation Sublayer and XGMII, the 64b/66b PCS, the serial PMA and the PAUSE operation.
  3. IEEE 802.3 Ethernet Working Group — IEEE 802.3 Ethernet Working Group: the working group index of task forces and published amendments, for checking which project owns a given PHY.
  4. IEEE Standards Association — IEEE Std 802.1Q-2022, Bridges and Bridged Networks, published 22 December 2022: the source of VLAN tagging: tag protocol identifier, priority code point, drop-eligible indicator, the 12-bit VLAN identifier and provider bridging.
  5. Ethernet Alliance — Ethernet’s Q1 2026: Momentum, Scale, and Interoperability, 20 April 2026: the OFC 2026 multi-vendor interoperability demonstration, fourteen named member companies, optics scaling from 200G, 400G and 800G toward 1.6T.
  6. Logic Design Solutions — ETH_MAC_10G_SFP — 10G Ethernet MAC IP: the published feature list referenced here: transmit and receive status FIFO interfaces, configuration options, hash-table interface and per-frame-type statistics.
  7. Microchip — PolarFire SoC FPGAs: one of the three FPGA vendors whose hardened transceivers provide the PMA beneath a 10 Gb/s MAC.
  8. Altera — Altera FPGA product families: the Agilex, Stratix, Arria and Cyclone families and their transceiver capability.