Skip to main content
skill CX Codex

device-tree — Claude Code skill: what it does, how to install

Guides coding agents through Linux device tree syntax, bindings, and debugging kernel platform driver probe mismatches.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mohitmishra786/low-level-dev-skills --skill device-tree -a claude-code
Open on GitHub

What device-tree does

The skill gives agents reference patterns for Linux Devicetree source files. It covers key node properties like compatible or reg, showing how the kernel OF layer parses nodes into platform_device entries to match of_match_table.

It covers tree inspection in /proc/device-tree and runtime overlays via configfs. Runtime overlay loading will fail if the kernel is built without CONFIG_OF_OVERLAY.

The guide also covers hardware description bugs. These include #address-cells mismatches in MMIO blocks, broken IRQ specifiers, and -EPROBE_DEFER loops caused by missing clock phandles. The driver will skip probing.

What it helps with

  • write DTS fragments and overlays for onboard peripheral devices
  • fix driver probe failures caused by mismatched compatible strings
  • calculate MMIO address and length fields using parent cell counts
  • link clock providers and interrupt lines to device nodes with phandles

Example prompts for the agent

  • /device-tree Write a DTS fragment for an I2C sensor on i2c1 with an interrupt on GPIO5
  • /device-tree Debug why the platform driver fails to match the serial@40011000 node
  • /device-tree Create a DT overlay to enable an extra UART via configfs

How to install device-tree

1Skills CLI (Vercel)

npx skills add mohitmishra786/low-level-dev-skills --skill device-tree -a claude-code

2Manually: put the files in place

~/.claude/skills/device-tree/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/device-tree/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about device-tree

How to install device-tree in Claude Code?

Run npx skills add mohitmishra786/low-level-dev-skills --skill device-tree -a claude-code. It places the skill at ~/.claude/skills/device-tree/SKILL.md.

What does the device-tree skill do?

It provides syntax rules and debugging steps for Linux DTS, device bindings, phandle references, and Open Firmware driver probing.

What kernel option is required for runtime overlays?

The Linux kernel must have CONFIG_OF_OVERLAY enabled to accept .dtbo files pushed into /config/device-tree/overlays/.

Source text

SKILL.md · MIT
---
name: device-tree
description: Device tree skill for Linux hardware description. Use when writing DTS/DTSI, bindings, overlays, phandles, or debugging OF platform probe failures. Activates on queries about device tree, DTS syntax, phandle, devicetree bindings, DT overlay, or OF graph.
---

# Device Tree (Devicetree)

## Purpose

Guide agents through Linux device tree source (DTS): syntax, bindings, phandles, overlays, and how the kernel OF (Open Firmware) layer parses hardware description into `platform_device` instances.

## When to Use

- Platform driver not probing — DT mismatch
- Adding a new board `.dts` or fragment overlay
- Understanding `compatible`, `reg`, `interrupts`, `clocks` properties
- Cross-checking hardware with `skills/kernel-dev/platform-device-model`

## Workflow

### 1. DTS structure

```dts
/dts-v1/;
#include "soc.dtsi"

/ {
    model = "My Board";
    compatible = "vendor,my-board", "vendor,soc-family";

    soc {
        uart0: serial@40011000 {
            compatible = "vendor,uart";
            reg = <0x40011000 0x400>;
            interrupts = <GIC_SPI 38 IRQ_TYPE_LEVEL_HIGH>;
            clocks = <&clk_uart0>;
            status = "okay";
        };
    };
};
```

### 2. Key properties

| Property | Meaning |
|----------|---------|
| `compatible` | Driver match string (most specific first) |
| `reg` | MMIO address + length ( `#address-cells`, `#size-cells` ) |
| `interrupts` | IRQ specifier (interrupt parent defines cells) |
| `clocks` / `clock-names` | phandle to clock provider |
| `status` | `"disabled"` skips probe |

### 3. Phandles

```dts
clk_uart0: clock-uart {
    compatible = "vendor,clk";
    #clock-cells = <0>;
};

serial@... {
    clocks = <&clk_uart0>;  /* phandle reference */
};
```

### 4. Kernel parsing

```
OF core reads DTB at boot
├── of_platform_populate() creates platform_devices
└── driver `.of_match_table` matches `compatible`
```

```c
static const struct of_device_id my_of_match[] = {
    { .compatible = "vendor,uart" },
    { }
};
MODULE_DEVICE_TABLE(of, my_of_match);
```

### 5. Compile and inspect

```bash
dtc -I dts -O dtb -o board.dtb board.dts
dtc -I fs -O dts /proc/device-tree 2>/dev/null | less
ls /sys/firmware/devicetree/base/
```

Bindings live at [devicetree.org](https://www.devicetree.org/) — always cite binding name in commits.

### 6. Overlays (configfs)

```bash
# Runtime overlay apply (when CONFIG_OF_OVERLAY)
mkdir -p /config/device-tree/overlays/my-overlay
cat my-overlay.dtbo > /config/device-tree/overlays/my-overlay/dtbo
```

### 7. Agent usage

```
/device-tree Write DTS fragment for I2C sensor on i2c1 with interrupt on GPIO5
```

## Common Problems

| Symptom | Cause | Fix |
|---------|-------|-----|
| Driver not bound | `compatible` typo | Match driver's `of_match_table` |
| Wrong MMIO | `#address-cells` mismatch | Follow SoC `.dtsi` |
| IRQ not firing | Wrong interrupt parent/cells | Copy from working board DTS |
| Probe defer loop | Clock/regulator missing | `-EPROBE_DEFER` supplier in DT |
| Overlay fails | Symbol unresolved | `__fixups__` / label exports |

## Related Skills

- `skills/kernel-dev/platform-device-model` — probe and sysfs
- `skills/kernel/device-drivers` — `devm_of_iomap`
- `skills/baremetal/datasheet-and-refmanual-reading` — HW to DT mapping
- `skills/embedded/zephyr` — Zephyr devicetree (different tooling)
- `skills/kernel-dev/bus-drivers-i2c-spi` — bus node children

© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set90

qemu-for-kernel-development Guides agents in booting custom Linux kernels and testing drivers inside QEMU. Useful for rapid module development, Buildroot rootfs integration, and GDB debugging. CX Codex +1 319installs kernel-debugging-advanced A skill for Linux kernel tracing: ftrace, trace-cmd, perf, kprobes, kgdb and vmcore analysis. Useful when a driver stalls with no obvious bug. CX Codex +1 317installs virtual-memory-paging-and-tlb This skill guides coding agents through virtual memory translation, x86-64 multi-level page tables, and TLB lookups. It helps troubleshoot page faults and huge page tuning. CX Codex +1 316installs cuda-profiling Walks your agent through CUDA profiling: Nsight Systems timelines, Nsight Compute kernel metrics, roofline reading and bottleneck diagnosis. CX Codex +1 316installs datasheet-and-refmanual-reading A methodology for agents reading MCU datasheets and reference manuals: register maps, bit fields, clock trees, errata. CX Codex +1 314installs cpu-pipelines-and-hazards Walks through CPU pipeline stages, data and control hazards, forwarding and stalls. Useful when a hot loop slows down and the reason is not obvious. CX Codex +1 311installs interrupts-and-exceptions-baremetal Guides coding agents through Cortex-M NVIC setup, non-blocking ISR design, and HardFault debugging. Useful when building bare-metal firmware without an RTOS. CX Codex +1 306installs qemu-kvm Walks the agent through QEMU VMs with KVM acceleration: flags, virtio devices, VFIO passthrough and booting custom kernels. CX Codex +1 304installs

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor