This post builds on the EthTrcv series, in particular on EthTrcv Part 1 — Basics & Classification and Part 4 — WakeUp Handling & Diagnostics. It zooms in on a single parameter that shows up in almost every EthTrcv configuration but is rarely truly understood: the master/slave role of the 100BASE-T1 PHY.

Anyone who has ever sat in front of an ECU that stubbornly refuses to bring up an Ethernet link — even though the cable, connector, and power supply all check out — has very likely run into exactly this problem, just usually without recognizing it right away.

Why Does 100BASE-T1 Need a Master/Slave Role at All?

No Separate TX/RX Pair

The Hardware Deep Dive in this series already showed this: 100BASE-T1 transmits and receives simultaneously on the same twisted wire pair.

100BASE-TX:   ──[TX+/TX-]──  ──[RX+/RX-]──   (2 pairs, separate directions)
100BASE-T1:   ──[T1+/T1-]──                   (1 pair, both directions at once)

With 100BASE-TX the situation is simple: each side has its own transmit pair with its own clock. There is no need to agree on a shared timing reference — each side just sends using its own free-running oscillator.

That does not work with 100BASE-T1. Because both sides transmit and receive simultaneously on the same pair, the PHY has to separate its own transmit signal from the receive signal — via echo cancellation, as described in the hardware post. That echo cancellation is an adaptive digital filter, and adaptive filters only work reliably when transmitter and receiver run on the same clock frequency.

A Shared Clock for Both Sides

Two independent, free-running crystals on either end of the cable inevitably drift apart slightly — even with tight tolerances (e.g. ±50 ppm). For a unidirectional line like 100BASE-TX this is not a problem, because each transmission direction has its own clock domain. On 100BASE-T1, however, this frequency difference would systematically disrupt the echo-cancellation filter: the filter implicitly assumes that its own transmit signal runs at exactly the same frequency as the one it is trying to subtract out of the receive signal.

The solution: one side of the link — the Master — generates the transmit clock from its own free-running crystal oscillator. The other side — the Slave — synchronizes to that clock by recovering it from the received signal (clock recovery) and using that same recovered clock for its own transmit side as well (loop timing).

MASTER                                    SLAVE
┌─────────────┐                       ┌─────────────┐
│  Crystal PLL │                      │              │
│ (free-running)│                      │  Clock       │
│      │       │                      │  Recovery    │
│      ▼       │                      │  (CDR)       │
│  TX clock    │──── T1+/T1- ────────►│      │       │
│              │                      │      ▼       │
│  RX ◄────────┼─── (echo signal) ────┤  TX clock =  │
│  (corrected  │                      │  RX clock    │
│   locally)   │                      │  (loop timing)│
└─────────────┘                       └─────────────┘

Loop timing means the Slave has no free-running transmit clock of its own. Its transmit clock is exactly the clock recovered from the Master’s receive signal. That forces both sides of the link onto the same frequency, regardless of the crystal tolerances of either component.

Without this role split, every PHY would constantly have to compensate for a frequency difference relative to its link partner. In practice that shows up as elastic-buffer overflow or underflow (the buffer used to absorb clock differences fills up or runs dry) and as degraded echo-cancellation performance — in the worst case, a link that comes up briefly and then drops sporadically.

A useful mnemonic: the Master sets the pace, the Slave follows. The same principle applies to 1000BASE-T1 and most 1000BASE-T copper variants — except that there (on 1000BASE-T, not 100BASE-T1) the role can additionally be negotiated via auto-negotiation. More on that below.

Who Is Master, Who Is Slave?

One Role per Segment, No Exceptions

Every 100BASE-T1 segment connects exactly two participants: one Master and one Slave. Unlike classic 10BASE-T coax or CAN, 100BASE-T1 has no multidrop segment and no shared bus with multiple participants — every physical connection is strictly point-to-point.

Valid:                                  Invalid (not specified):

  Master ──────────── Slave              Master ──┬──────── Slave A
  (one segment,                                    └──────── Slave B
   two participants)                    (multidrop — not supported
                                          by 100BASE-T1)

Networks Are Built With Switches, Not Multidrop

Because a single segment only ever knows two participants, larger vehicle networks are built exclusively by chaining point-to-point segments together through switches (EthSwt). Topologically the result is usually a star around a central switch or gateway, occasionally multi-tier (a tree topology across several cascaded switches).

                        ┌────────────────┐
                        │ Central Switch  │
                        │   / Gateway     │
                        └───┬───┬───┬─────┘
                    Master  │   │   │  Master
                       ┌────┘   │   └────┐
                       │        │        │
                    Slave     Slave    Slave
                  ┌───────┐ ┌───────┐ ┌───────┐
                  │Camera │ │ Radar │ │  ECU  │
                  └───────┘ └───────┘ └───────┘

Each individual segment (switch port to end device) is, on its own, an ordinary point-to-point connection with a fixed master/slave assignment — the star topology only emerges from the number of switch ports, not from any property of 100BASE-T1 itself.

ElementTypical RoleRationale

Central switch / gateway

Master (on all ports)

A chip with many ports is easier to design as a consistent clock source; reduces variant complexity in switch firmware

Peripheral ECU (camera, radar, simple ECU)

Slave

Inherits the clock from the switch; needs no clock reference of its own for the link

Two peer ECUs with no switch in between

To be decided per project

There is no "natural" role — the assignment must be explicitly defined in the network requirements specification

There is no universal IEEE or AUTOSAR rule that dictates which device must be Master and which Slave in a given constellation. The role assignment is a project decision, typically documented in an OEM-specific network or physical-layer requirements document — usually as a table mapping ECU type or connector pin to master/slave. Without knowing that requirement, a supplier cannot correctly configure the role.

Configuring the Role in the PHY

Access via MDIO

As described in the Hardware Deep Dive, PHY configuration runs over the MDIO bus. The master/slave role is no special case here — it is simply another bit or register field that EthTrcv_Init sets while bringing up the PHY.

EthTrcv_Init()
   │
   ├─► MDIO write: reset register
   ├─► MDIO write: master/slave configuration bit  ◄── here
   ├─► MDIO write: other PHY-specific setup registers
   └─► MDIO read:  status register (wait for link-up)

Importantly, this configuration is static on a 100BASE-T1 PHY — it is written once during init and stays unchanged for the lifetime of the link. Unlike some copper Gigabit PHYs (see below), there is no negotiation mechanism that changes this configuration at runtime.

Example: NXP TJA1100

The TJA1100 (100BASE-T1, RMII interface) is one of the most widely deployed 100BASE-T1 PHYs in the field. Its master/slave role can be set two ways:

Configuration PathDescription

Pin strapping

Dedicated configuration pins (CONFIG1/CONFIG2) set a base mode at power-up, including a default role. These pins are hardwired via PCB pull-up/pull-down resistors.

Register override via MDIO

After power-up, EthTrcv_Init can write the CONFIGURATION register over MDIO and explicitly set a master/slave bit — independent of the pin-strapping default.

CONFIGURATION register (simplified)
Bit 15    MASTER_SLAVE   0 = Slave, 1 = Master
Bit 14    AUTO_OP        Automatic transition to normal operation
                          after configuration (independent of master/slave)
Bit ...   other chip-specific configuration bits

Pin strapping and register override can drift apart in practice: a board that is hardwired as "Slave" per schematic, but whose EthTrcv driver writes "Master" in software, ends up in Master mode — software wins. This is a common failure mode when a board redesign changes the pin wiring but the EthTrcv ARXML configuration is not updated to match.

Example: Broadcom BCM89810

The BCM89810 is another widely used 100BASE-T1 PHY, also with an RMII interface on the MAC side. The underlying principle is identical to the TJA1100: a dedicated configuration bit in the register space controls the role, with a hardware-pin-set default that can be overridden via MDIO.

AspectNXP TJA1100Broadcom BCM89810

MAC interface

RMII

RMII

Master/slave default

Pin strapping (CONFIG1/CONFIG2)

Pin strapping (mode pins)

Software override

Yes, via MDIO register

Yes, via MDIO register

Auto-negotiation of the role

Not available

Not available

The exact register addresses and bit positions differ between chip vendors and sometimes even between chip revisions from the same vendor. The respective datasheet is the only reliable source — the tables in this post illustrate the operating principle, not a specific register map.

ARXML Configuration

The Standard AUTOSAR Parameter EthTrcvConnNeg

A detail that surprises many people: the AUTOSAR standard does in fact define a unified parameter for connection negotiation (and thereby the master/slave role) on 100BASE-T1 in the generic EthTrcv configuration container — EthTrcvConnNeg ([ECUC_EthTrcv_00025]). It lives in the EthTrcvConfig container, right alongside parameters like EthTrcvDuplexMode or EthTrcvSpeed, and is specified as an EcucEnumerationParamDef with the following literals:

LiteralMeaning

TRCV_CONN_NEG_AUTO

Automatic negotiation (auto-negotiation)

TRCV_CONN_NEG_MASTER

Fixed Master role

TRCV_CONN_NEG_SLAVE

Fixed Slave role

TRCV_CONN_NEG_NONE

PLCA (Physical Layer Collision Avoidance) — relevant for 10BASE-T1S, not for 100BASE-T1

The master/slave configuration is therefore not an MCAL-specific vendor extension parameter — it is part of the generic EthTrcvConfig container in the standard AUTOSAR schema. The parameter name (EthTrcvConnNeg) and the enum literals (TRCV_CONN_NEG_MASTER / TRCV_CONN_NEG_SLAVE / TRCV_CONN_NEG_AUTO) are identical across all MCAL suppliers — what happens underneath (which PHY register actually gets written) remains, of course, an MCAL implementation detail.

The specification also notes an important dependency: if EthTrcvEnablePLCA = TRUE, EthTrcvConnNeg must be set to TRCV_CONN_NEG_NONE. If instead EthTrcvPhysLayerType is configured as TRCV_PHYS_LAYER_TYPE_10BASE_T1S and PLCA is not enabled, EthTrcvConnNeg must be explicitly configured as master or slave — because 10BASE-T1S can run with either PLCA or classic CSMA/CD media access. For 100BASE-T1 (without PLCA), only TRCV_CONN_NEG_MASTER and TRCV_CONN_NEG_SLAVE are relevant.

EthTrcvConnNeg in ARXML

A simplified but realistic example of how the standard parameter is set in ARXML:

<ECUC-CONTAINER-VALUE>
  <SHORT-NAME>EthTrcvConfig_Camera_Front</SHORT-NAME>
  <DEFINITION-REF DEST="ECUC-PARAM-CONF-CONTAINER-DEF">
    /MCAL/EthTrcv/EthTrcvConfigSet/EthTrcvConfig
  </DEFINITION-REF>
  <PARAMETER-VALUES>
    <ECUC-NUMERICAL-PARAM-VALUE>
      <DEFINITION-REF DEST="ECUC-INTEGER-PARAM-DEF">
        /MCAL/EthTrcv/EthTrcvConfigSet/EthTrcvConfig/EthTrcvIdx
      </DEFINITION-REF>
      <VALUE>3</VALUE>
    </ECUC-NUMERICAL-PARAM-VALUE>
    <ECUC-TEXTUAL-PARAM-VALUE>
      <DEFINITION-REF DEST="ECUC-ENUMERATION-PARAM-DEF">
        /MCAL/EthTrcv/EthTrcvConfigSet/EthTrcvConfig/EthTrcvConnNeg
      </DEFINITION-REF>
      <VALUE>TRCV_CONN_NEG_SLAVE</VALUE>
    </ECUC-TEXTUAL-PARAM-VALUE>
  </PARAMETER-VALUES>
</ECUC-CONTAINER-VALUE>

The parameter name (EthTrcvConnNeg) and the enum value range (TRCV_CONN_NEG_MASTER / TRCV_CONN_NEG_SLAVE / TRCV_CONN_NEG_AUTO / TRCV_CONN_NEG_NONE) are defined in the AUTOSAR standard document itself ([ECUC_EthTrcv_00025]) — not a vendor-specific detail, but part of the EthTrcv base model.

Practical Tip: Consistency Checks in ARXML Review

A classic copy-paste mistake: an integrator takes the EthTrcv configuration of an already-working ECU as a template for a new one — and forgets to adjust the master/slave role for the new position in the network. Result: two switch ports end up configured as Master because the template was originally written for a different segment. A consistency check between the ARXML splits of both ends of a segment (ideally automated in CI) catches exactly this mistake before it reaches the lab or the vehicle.

Automatic Resolution — Does Auto-Negotiation Exist for 100BASE-T1?

Short Answer: No, Not for the Role

Classic 1000BASE-T (copper, IEEE 802.3ab, Clause 40) negotiates the master/slave role by default via auto-negotiation: both sides exchange capabilities, and a defined resolve algorithm decides who becomes Master and who becomes Slave — with the option to force either side into a fixed role manually (Master-Slave Manual Config Enable).

100BASE-T1 (IEEE 802.3bw) does not have this concept. There is no auto-negotiation mechanism that negotiates the role at runtime. The role is configured exclusively statically — via pin strapping and/or software override over MDIO, as described above.

Aspect1000BASE-T (copper, Clause 40)100BASE-T1 (Clause 96 / 802.3bw)

Role determination

Auto-negotiation with a resolve algorithm, optionally forced manually

Exclusively static configuration

Behavior on role conflict (both sides want the same role)

Resolved by a tie-breaking rule in the resolve algorithm (e.g. the PHY with the higher seed value wins as Master)

No link — there is no resolution mechanism

Time spent negotiating during link-up

Extra time for the negotiation exchange

None — link-up can start immediately with a fixed role

Why It Works This Way — and Why It Is Not a Drawback

At first glance, the absence of auto-negotiation looks like a step backwards. For the automotive use case, however, it is a deliberate design decision with clear advantages:

  • Topology is known at design time. Unlike the consumer world, where a laptop must be able to plug into any arbitrary switch, a vehicle’s network topology is fully known during development — exactly which ECU connects to which other ECU. A dynamic negotiation does not solve any real problem here.

  • Faster link-up. Automotive networks often have hard time budgets for bringing up the link after waking from sleep (see Part 4 of this series). Every millisecond not spent on a negotiation phase helps meet those budgets.

  • Smaller attack/failure surface. A negotiation protocol is additional logic that can itself fail or be interpreted differently across chip revisions. Static configuration is simpler and more predictable in this respect.

The price for this simplicity: responsibility for a correct role assignment shifts entirely to humans — from the network requirements document through the PCB wiring to the EthTrcv ARXML configuration. There is no automatism that "repairs" a mistake at runtime. That is exactly what makes role conflicts one of the most common 100BASE-T1 failure patterns in the field — see the next section.

Typical Failure: Both Sides Configured With the Same Role

If both ends of a 100BASE-T1 segment are configured as Master (or both as Slave), no link comes up at all. There is no error signal, no error message in the classic sense — the PHY simply reports "no link" permanently, exactly as it would with a broken cable or missing power supply.

Case 1: Role conflict (both Master)

  ECU A                                   ECU B
  PHY: Master                             PHY: Master
  (generates own clock)                   (generates own clock)
       │                                        │
       └──────────── T1+/T1- ──────────────────┘
              Both sides transmit with their
             own clock, neither synchronizes –
                     NO LINK

Case 2: Role conflict (both Slave)

  ECU A                                   ECU B
  PHY: Slave                              PHY: Slave
  (waiting for a clock                    (waiting for a clock
   to recover)                             to recover)
       │                                        │
       └──────────── T1+/T1- ──────────────────┘
           Neither side generates a clock,
          there is nothing to recover from –
                     NO LINK

That exact symptom pattern — "everything else checks out, but there is no link" — is what makes the failure tricky: the cable, the connectors, the power supply, and even MDIO communication with the PHY itself all work fine, because the master/slave configuration was successfully written over MDIO. It is just the wrong value.

Diagnostic Procedure

  1. Read the PHY status register on both sides. The link-status bit shows "no link", but that alone does not narrow down whether it is a role conflict or something else (e.g. a broken cable — see Part 4 for further diagnostic accesses).

  2. Read the master/slave configuration register on both sides via MDIO. Most PHYs let you read back the actually active mode (not just the intended value written during init) — this also covers cases where a pin-strapping value overrode the software configuration.

  3. Cross-check against the ARXML of both ECUs. Does the readback register value match the intended value stored in the EthTrcv configuration? If not, check pin strapping vs. software override (see the TJA1100 example above).

  4. Check the role assignment against the network requirements document. The most common real-world cause is not a technical defect but an incorrectly copied ARXML template — both sides are "correct" according to their own configuration, but the same role was accidentally assigned twice.

A role conflict looks harmless on an oscilloscope or protocol analyzer at first glance: there is a signal on the line, just no stable link. Jumping straight to a hardware conclusion (defective PHY, bad solder joint) wastes valuable time — the first place to look should always be the configuration, not the multimeter.

Practical Recommendation: When Master, When Slave?

There is no technical requirement that any particular device class must be Master — the choice is free as long as both sides of a segment agree. Still, in practice, a set of conventions has proven itself, and it significantly simplifies configuration work across a project:

RecommendationRationale

Consistently configure switch/gateway ports as Master

Reduces variant complexity: every switch firmware image uses the same role configuration, regardless of which end device is actually connected

Consistently configure peripheral ECUs (sensors, actuators, simple ECUs) as Slave

These devices are often reused across multiple vehicle projects — a fixed Slave role makes them independent of which switch port they end up connected to

Document the role assignment explicitly in the network requirements document, not only implicitly in ARXML

Prevents the "switch = Master" convention from being silently broken in edge cases (e.g. a point-to-point connection between two peer ECUs with no switch involved)

Introduce an automated consistency check between ARXML splits

A script that verifies, for every known segment, that exactly one side is Master and the other Slave catches copy-paste mistakes before they reach the lab or the vehicle

For new designs: fix the role as early as possible during schematic review

Pin strapping is a hardware decision — changing the role later via software override works technically, but should remain the exception rather than the rule

For point-to-point connections between two peer ECUs with no switch in between (e.g. a direct link between two domain controllers), there is no "natural" Master side. A project-wide rule — for instance "the ECU with the lower diagnostic address is Master" — avoids having to re-litigate the decision for every new connection pair.

Summary

AspectKey Takeaway

Why master/slave is needed

100BASE-T1 transmits and receives simultaneously on one wire pair; echo cancellation needs a shared clock — the Master generates it, the Slave recovers it via clock recovery

Topology rule

Every segment has exactly one Master and one Slave; larger networks are built with switches, not multidrop

PHY configuration

Usually pin strapping as the default, overridable via MDIO register in EthTrcv_Init — details vary by chip vendor

ARXML

Standard parameter EthTrcvConnNeg in the EthTrcvConfig container ([ECUC_EthTrcv_00025]); literals TRCV_CONN_NEG_MASTER / TRCV_CONN_NEG_SLAVE / TRCV_CONN_NEG_AUTO

Auto-negotiation

Does not exist for 100BASE-T1 — unlike 1000BASE-T, the role is configured exclusively statically

Typical failure

Both sides on the same role → no link, no error message; usually caused by an incorrectly copied ARXML template

Practical recommendation

A fixed convention per device class (switch = Master, periphery = Slave) plus an automated consistency check between ARXML splits