USB Topology

Chapter 2.6 settled who decides. This chapter settles shape — and its real work is separating two pictures that a single drawing tends to fuse.

Draw a USB system and you get a tree: a host at the top, hubs branching, devices at the leaves. That drawing is accurate and it is the source of Module 2's most persistent misconception, because it depicts wiring while readers interpret it as relationships. A tree of wires looks like a network of participants, and USB is emphatically not one.

So this chapter draws the system twice.

1. The Physical Picture — a Tree of Point-to-Point Links

Physically, USB is built from point-to-point links. Each link connects exactly two things: a port and whatever is plugged into it. There is no shared multi-drop wire that every device taps, which is a genuine departure from older bus designs and has real consequences.

Devices reach the host by cascading those links through hubs. The root hub's ports offer the first set; a hub plugged into one of them offers more; a hub plugged into that offers more again. Each hop is its own electrical link.

Three properties of the physical picture matter.

Each link is independent electrically. A device's signalling obligations concern its own link and nothing else, which is why a slow device and a fast one can coexist in the same tree — they are not sharing a wire, they are attached to a component that bridges between them.

Depth accumulates. Device E's traffic traverses three links and passes through two hubs. Every hop adds propagation delay and every hub adds handling delay, and Chapter 2.8 shows that this accumulation is what ultimately bounds how deep a tree may be.

Bandwidth does not branch. Everything below a hub reaches the host through that hub's single upstream link. Branching multiplies attachment points and divides the capacity already present — the point Chapter 2.3 made about hubs, now visible as geometry.

2. The Logical Picture — a Star

Now redraw the same system by who talks to whom, and the tree disappears.

Every device has exactly one conversational partner and it is always the host. Device E, three links deep, has precisely the same relationship with the host as Device A plugged directly into it. The hubs between them are not parties to the conversation — they carry it, which is a different thing entirely.

And crucially, there are no edges between devices in Figure 2, because there is no relationship to draw. Two devices on the same hub are related only in sharing a path and competing for bus time.

3. What the Two Pictures Each Explain

Being fluent in both means knowing which to reach for.

Use the physical picture to reason about: signal integrity and cable length; where propagation and handling delay accumulate; which devices share bandwidth through a common upstream link; power delivery and where a bus-powered hub's budget runs out; which port to unplug; and — under USB 2.0's repeater semantics — which devices see each other's traffic.

Use the logical picture to reason about: addressing, since the host addresses a device and not a path; configuration, since a device is configured the same way wherever it sits; transfers, since every one is between the host and one device; and the fact that a device's software model is identical regardless of depth.

The practical payoff is knowing which properties change with position and which do not. A device moved from a root port to a position three tiers down keeps its address semantics, its configuration, its driver, and its entire software model. What changes is its share of bandwidth, its accumulated latency, its power source, and which siblings' traffic it must ignore. Logical properties are position-independent; physical properties are not — and nearly every “it works here but not there” report is a physical-picture problem described in logical-picture language.

4. Why the Tree Is Not a Network

Make the refutation explicit, because the drawing works against it.

There is no device addressing. A device cannot name another device. Chapter 2.2 gave it no means to originate a transfer and no field in which to put a destination — so peer traffic is not restricted, it is unrepresentable.

Hubs do not route between siblings. A USB 2.0 hub forwards downstream from its upstream port and upstream toward the host; there is no path from one downstream port to another. USB 3.x routes toward an addressed device, which is genuinely more switch-like, but the routing is still along the host-to-device path and there is still no peer addressing to route between siblings.

No device learns about another. A switch builds knowledge of who is where. Nothing in USB gives a device any way to acquire that, because nothing would ever use it.

Transfers between peripherals are two host transfers. Camera to drive is camera-to-host, then host-to-drive. Twice the bus time, and the host is an endpoint of both even though neither peripheral wanted anything from it.

5. Topology as an Engineering Variable

For verification, topology is a stimulus dimension, and it is one of the most commonly under-tested. A device attached directly to a root port is in the easiest possible configuration: minimum latency, maximum available bandwidth, no sibling traffic, and direct power. Move it three tiers down behind two hubs sharing an upstream link with three other active devices and every one of those changes — yet it is the same DUT, passing the same tests.

The dimensions worth varying: depth, because latency and delay accumulate; sibling activity, because under USB 2.0 the device must ignore traffic addressed to others and because bandwidth is shared; hub versus direct attachment, because a device behind a hub is served through a different path; and mixed-speed trees, because a slower device behind a faster hub is served through compatibility logic rather than directly.

For debug, topology changes the question. A symptom that appears only at depth points at something accumulating — delay, or bandwidth contention, or power. A symptom that appears only with siblings active points at address filtering or at contention. A symptom independent of topology is probably in the device itself. Varying position is therefore a diagnostic instrument, and it is nearly free: move the device and see what changes.

For design, the physical picture sets the budgets a device must meet — how quickly it must respond given that its answer travels back through hubs, and how much power it may draw given where it sits. The logical picture says none of that affects its software model, which is exactly the separation Chapter 1.7 called layers varying independently.

6. Common Misconceptions

7. Reason It Through

A device passes every test attached directly to a host. In the field it intermittently fails when customers use it behind a hub, particularly alongside other active devices. The device's own logic is unchanged and its self-tests pass.

Which picture is the symptom in? The physical one. The failure correlates with position and with neighbours — both physical properties — while everything logical about the device is unchanged.

What are the candidate causes, and how do they differ? Bandwidth: the device now shares an upstream link, so it is served less often or with different spacing, which exposes any assumption about how promptly it gets asked. Latency: answers travel further, through more handling. Sibling traffic: under USB 2.0 repeater semantics the device now sees traffic addressed to others, so a device that filters addresses incorrectly will react to a neighbour's request — and that fault is structurally invisible when attached alone. Power: behind a bus-powered hub the available budget may be lower than direct attachment offered.

How would you separate them cheaply? Vary one physical property at a time, which is nearly free. Behind a hub with no other devices isolates depth and power from sibling effects. Behind a hub with busy neighbours adds contention and sibling traffic back. Behind a self-powered hub removes the power variable. Each configuration implicates a different cause, and topology becomes a diagnostic instrument rather than an environmental nuisance.

Why did the original testing miss all of this? Because direct attachment is the easiest configuration in every dimension simultaneously — minimum latency, maximum bandwidth, no siblings, direct power — and it is the one every engineer uses at their desk. A test environment that only ever uses the easiest topology has not tested the topology, and users will supply the harder ones immediately.

8. Understanding Check

9. Summary

USB has two accurate pictures, and fluency means knowing which answers which question.

Physically it is a tree of point-to-point links, each joining exactly two things, cascaded through hubs. There is no shared multi-drop wire, which is why devices of different speeds coexist in one tree. Depth accumulates propagation and handling delay, and bandwidth does not branch — everything below a hub reaches the host through that hub's single upstream link.

Logically it is a star. Every device has exactly one conversational partner and it is always the host, identically at any depth. Hubs carry conversations without being party to them, and there are no relationships between devices at all.

The tree is not a network. Peer traffic is unrepresentable, not merely disallowed: a device cannot name another device, hubs have no path between downstream ports, and nothing learns about anything. Peripheral-to-peripheral movement is two host-mediated transfers.

The practical distinction is that logical properties are position-independent and physical ones are not. Move a device deeper and its addressing, configuration, driver and software model are unchanged, while its bandwidth share, latency, power source and sibling exposure all change — which is why almost every “works here, not there” report is a physical problem described in logical language.

And topology is an engineering variable: a stimulus dimension that direct-attachment testing systematically fails to cover, and a nearly free diagnostic instrument, because the configuration in which a symptom appears implicates its cause.

10. What Comes Next

The tree can be described. It cannot be unlimited — depth costs delay, every device needs a distinguishable identity, and power has to come from somewhere.

Chapter 2.8 takes the rules: how many tiers a USB tree may have, how many devices may be attached, and — more useful than the numbers — where those limits come from. Each one is derived rather than arbitrary: the depth limit falls out of a timing budget that accumulates with every hop, and the device-count limit falls out of the size of a field. Knowing the derivation is what lets you reason about which limits change between generations and which are structural, rather than memorising constants that will be wrong the next time the architecture grows.

Browse the full path on the USB tutorials index.