What You Will Learn

Prerequisites

Memory-Mapped Devices and the simple-bus Node

Unlike I2C or SPI peripherals, a memory-mapped platform device sits directly on the system’s address bus — the CPU can read and write its registers with ordinary load/store instructions, no bus controller driver required. Device Tree groups this kind of device under a parent node with compatible = "simple-bus". That single string tells the kernel: “walk my children and register each one as a plain platform device — no special bus driver needed.”

Here, both halves of the tuple carry real meaning: the first cells give the physical base address of the device’s register block, and the second cells give the number of bytes that block occupies. The number of cells used on each side still comes from the parent’s #address-cells and #size-cells, exactly as in the previous lecture — the difference is that #size-cells is no longer zero, because there really is a size to describe.

An Original simple-bus Example

Below is an original, simplified example modelling a memory-mapped watchdog-timer-like peripheral sitting under a simple-bus node:

soc {
    #address-cells = <1>;
    #size-cells = <1>;
    compatible = "simple-bus";

    ep_periph_bus: peripherals@40000000 {
        compatible = "ep,periph-bus", "simple-bus";
        #address-cells = <1>;
        #size-cells = <1>;
        reg = <0x40000000 0x100000>;
        ranges;

        ep_wdt: watchdog@40010000 {
            compatible = "ep,ep-wdt1";
            reg = <0x40010000 0x1000>;
            status = "okay";
        };
    };
};

Reading this from the outside in: soc sets one cell each for address and size. Its child peripherals@40000000 inherits that rule, so its own reg is read as base 0x40000000, length 0x100000. Because that child is itself simple-bus-compatible and re-declares #address-cells/#size-cells, its child ep_wdt is addressed the same way: base 0x40010000, length 0x1000.

Hands-On: Reading a Memory-Mapped reg in a Driver

Let’s write an original platform driver, ep_simplebus_demo, that binds to ep_wdt and prints the base address and size the kernel resolved from Device Tree, using of_address_to_resource():

#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_address.h>

static int ep_simplebus_probe(struct platform_device *pdev)
{
    struct resource res;
    int ret;

    ret = of_address_to_resource(pdev->dev.of_node, 0, &res);
    if (ret) {
        dev_err(&pdev->dev, "ep_simplebus_demo: failed to resolve reg\n");
        return ret;
    }

    dev_info(&pdev->dev,
             "ep_simplebus_demo: base=0x%llx size=0x%llx\n",
             (unsigned long long)res.start,
             (unsigned long long)resource_size(&res));
    return 0;
}

static void ep_simplebus_remove(struct platform_device *pdev)
{
    dev_info(&pdev->dev, "ep_simplebus_demo: removed\n");
}

static const struct of_device_id ep_simplebus_of_match[] = {
    { .compatible = "ep,ep-wdt1" },
    { }
};
MODULE_DEVICE_TABLE(of, ep_simplebus_of_match);

static struct platform_driver ep_simplebus_driver = {
    .probe = ep_simplebus_probe,
    .remove = ep_simplebus_remove,
    .driver = {
        .name = "ep_simplebus_demo",
        .of_match_table = ep_simplebus_of_match,
    },
};
module_platform_driver(ep_simplebus_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("EmbeddedPathashala simple-bus reg demo driver");

The remove() callback above already uses the modern void-returning signature that became standard from kernel 6.11 onward, so this driver needs no changes on the latest LTS trees.

Build and Load

$ make -C /lib/modules/$(uname -r)/build M=$PWD modules
$ sudo insmod ep_simplebus_demo.ko
$ dmesg | tail -n 3

Expected Output

[ 2011.442017] ep_simplebus_demo: base=0x40010000 size=0x1000

Compare this against the reg = <0x40010000 0x1000>; line in the Device Tree source — of_address_to_resource() did the cell-counting arithmetic for us and handed back a ready-to-use struct resource.

From reg to Resources: What Comes Next

A memory-mapped reg range is only one piece of what a device needs to function. A real peripheral node in Device Tree usually also lists an interrupt line, one or more clocks, and sometimes DMA channels — each described with its own property and each requiring its own kernel API to extract. Collectively, the kernel treats all of these — memory regions, IRQ lines, DMA channels — as device resources. The next lecture in this free Linux kernel development course walks through platform_get_resource() and friends, showing how a driver pulls a fully-populated node — reg, interrupts, clocks, and DMA — into working code.

Common Mistakes and Troubleshooting

Best Practices

Key Takeaways

Conclusion

With I2C, SPI, and now memory-mapped addressing covered, you have the full picture of how device tree platform addressing and the reg property work across every bus type the kernel supports. The next lecture builds directly on this by showing how a single, fully-described device node — carrying reg, interrupts, clocks, and DMA together — gets turned into a working driver using the kernel’s resource APIs.

Frequently Asked Questions