Device Tree vs ACPI: Why Embedded Linux Needs It but x86 PCs Don’t

Stage 1: Why the Kernel Needs Hardware Knowledge

When a Linux kernel boots, it must know what hardware exists and how to talk to it. But here’s the tricky part: the kernel itself doesn’t magically know where the UART controller is, or how many I²C buses are wired.

Think about it: without a description, the kernel would be blind. That’s why embedded systems rely on the Device Tree (DT) : a hardware description file that tells the kernel exactly what components are present and how they’re connected.

On x86 PCs, however, decades of standardization mean the kernel can rely on firmware interfaces like BIOS, UEFI, ACPI tables, and PCI bus enumeration. These mechanisms already describe the hardware in a consistent way, so no DT is needed.

Stage 2: Booting with Device Tree (Embedded)

In an embedded boot process, once the bootloader (often U‑Boot) has brought up RAM and basic hardware, it loads:

• The Linux kernel binary
• The Device Tree Blob (DTB)

The DTB is passed to the kernel at startup. The kernel then parses this tree to:

• Identify CPU cores, memory regions, and interrupts
• Locate buses like I²C, SPI, and CAN
• Initialize peripherals such as UART, Ethernet, and GPIO

Without the DT, the kernel would have no way of knowing how to interact with the hardware on the board.

Stage 3: Booting with ACPI/PCI (x86 PCs)

On a PC, the story is different. The firmware provides ACPI tables, and the kernel can probe the PCI bus to discover devices dynamically:

• ACPI (Advanced Configuration and Power Interface): Describes system devices, CPU topology, power states, and configuration. It standardizes how the OS interacts with hardware.
• PCI (Peripheral Component Interconnect): A bus standard that allows the kernel to automatically discover connected devices and their resources.

Together, ACPI and PCI give the kernel a complete picture of the hardware without requiring a Device Tree.

Stage 4: Trade-offs in Practice

Conclusion

The difference isn’t arbitrary, it reflects decades of architectural evolution:

• Embedded platforms need DT because hardware is diverse and non-standard.
• x86 PCs rely on ACPI and PCI, which provide a standardized discovery mechanism.

Official References

If you’d like to dive deeper into how Linux discovers and describes hardware, here are some authoritative resources:

Linux Device Tree — Official Kernel Documentation https://docs.kernel.org/devicetree/usage-model.html

ACPI Support in the Linux Kernel https://docs.kernel.org/firmware-guide/acpi/index.html