DisplayPort Micro-Packet Stuffing Explained

DisplayPort decouples the native video pixel clock from the physical link rate by converting continuous raster data into packetized streams. Because DisplayPort operates at fixed transmission speeds—such as 1.62, 2.7, 5.4, or 8.1 Gbps per lane—the bandwidth provided by the link rarely matches the exact data rate dictated by a display's unique resolution, refresh rate, and blanking intervals. Micro-packet stuffing resolves this mismatch by dynamically injecting dummy symbols into structured micro-packets, known as Transfer Units, padding the data stream to fill the high-speed link without altering the underlying video timing.

The Mismatch Between Video Clocks and Link Rates

Traditional display interfaces like VGA, DVI, and early versions of HDMI scaled their physical transmission frequency to match the exact pixel clock of the incoming video signal. If a display mode required a 148.5 MHz pixel clock, the physical serializer ran at a frequency directly derived from that 148.5 MHz clock.

DisplayPort functions more like a data network. It relies on fixed physical link rates, independent of the video format being carried. Transmitting an arbitrary pixel clock (for instance, a custom 73.4 MHz clock) over a rigid 2.7 Gbps physical link creates an inherent bandwidth discrepancy: the link provides significantly more capacity than the video stream consumes.

The Role of Transfer Units (TUs)

To transmit continuous raster video across a fixed-rate link, DisplayPort organizes active video data into discrete framing blocks called Transfer Units (TUs).

• A Transfer Unit is a fixed-size container, typically configured to 32 to 64 link symbols per lane.
• Active pixel components are serialized and packed sequentially into these TUs.
• Because the link rate is higher than the pixel data rate, valid pixel data arrives from the rendering pipeline slower than the rate at which the link can emit symbols.

How Micro-Packet Stuffing Works

Micro-packet stuffing is the mechanism that maintains physical link continuity when valid pixel data is not immediately available to fill a Transfer Unit.

1. Active Data Allocation: The DisplayPort transmitter fills a Transfer Unit with incoming valid pixel data until no more current pixel data is ready in the source buffer.
2. Stuffing Injection: To complete the Transfer Unit without stalling the high-speed physical layer, the transmitter injects special non-data symbols—known as Stuffing Symbols (FS)—into the remaining slots of the TU.
3. Framing Demarcation: Control symbols, such as Framing End (FE) or Fill Start, mark the boundary between real pixel data and the padding symbols.
4. Sink Discard: When the receiving display (sink) decodes the Transfer Unit, its link layer automatically strips out the stuffing symbols, directing only the valid pixel data into its internal elastic buffer.

By varying the ratio of valid pixel data to stuffing symbols inside each Transfer Unit, the transmitter dynamically matches the variable pixel data rate to the static link rate.

Clock Recovery Using M and N Values

Stuffing fills the bandwidth gap, but the receiving monitor still needs to know the exact original pixel clock frequency to drive its internal panel timing. DisplayPort achieves this without dedicated clock lanes by using dynamic frequency multipliers known as \(M\) and \(N\) values.

The source continuously measures its internal video pixel clock (\(f_{vid}\)) against the fixed link clock (\(f_{link}\)) and transmits two integers:

• \(M_{vid}\): A dynamically calculated numerator.
• \(N_{vid}\): A fixed or pre-negotiated denominator (typically 32,768).

The relationship is governed by the formula:

\[f_{vid} = f_{link} \times \left(\frac{M_{vid}}{N_{vid}}\right)\]

The display's receiver uses a Phase-Locked Loop (PLL) combined with the \(M_{vid}\) and \(N_{vid}\) parameters embedded within the Main Stream Attribute (MSA) packets. This allows the display to mathematically regenerate the original pixel clock down to fractional Hertz accuracy, while the elastic buffer prevents underruns or overflows caused by the bursty arrival of packetized data.