What You Will Learn

• All four syscon regmap lookup functions and when to use each one
• A complete driver demonstrating every lookup method against the same node
• How the simple-mfd compatible string spawns subdevices automatically
• How simple-mfd and syscon combine to remove the need for a custom MFD driver
• A chapter-wide summary tying MFD, device tree binding, and syscon together

Prerequisites

• The syscon framework basics (covered in Lecture 7)
• MFD cell and device tree binding rules (covered in Lecture 6)
• Regmap fundamentals (covered in our Regmap API series)

The Four Syscon Regmap Lookup Functions

A consumer driver can reach a syscon’s regmap in four different ways, depending on what information is available to it at probe time:

All four eventually resolve to the exact same underlying struct regmap * if they are pointed at the same syscon node — the choice is purely about what’s most convenient to reach from your driver.

Example Device Tree

The following original binding declares a syscon node with a child consumer device, so the demo driver below has something concrete to look up against:

ep_gpr: ep-gpr@20e0000 {
    compatible = "ep,soc-gpr", "syscon";
    reg = <0x020e0000 0x38>;

    ep_consumer: ep-consumer {
        compatible = "ep,regmap-consumer";
        ep-syscon-phandle = <&ep_gpr>;
    };
};

A Single Driver Demonstrating All Four Lookups

The following original probe function exercises all four APIs against the node above, purely to illustrate how each one is called:

static int ep_consumer_probe(struct platform_device *pdev)
{
    struct device_node *np = pdev->dev.of_node;
    struct device_node *syscon_np;
    struct regmap *by_node, *by_compat, *by_phandle;

    /* 1. by node: walk up to the syscon's own device_node */
    syscon_np = of_get_parent(np);
    if (!syscon_np)
        return -ENODEV;

    by_node = syscon_node_to_regmap(syscon_np);
    of_node_put(syscon_np);
    if (IS_ERR(by_node))
        return PTR_ERR(by_node);

    /* 2. by compatible string */
    by_compat = syscon_regmap_lookup_by_compatible("ep,soc-gpr");
    if (IS_ERR(by_compat))
        return PTR_ERR(by_compat);

    /* 3. by phandle property on our own node */
    by_phandle = syscon_regmap_lookup_by_phandle(np, "ep-syscon-phandle");
    if (IS_ERR(by_phandle))
        return PTR_ERR(by_phandle);

    dev_info(&pdev->dev, "all three lookups resolved to regmap %p\n", by_node);

    return 0;
}

syscon_regmap_lookup_by_pdevname() is intentionally left out of the demo above — it is the rare fallback used by a single in-tree serial driver, and expects a platform device name string like "syscon.1" rather than anything tied to the device tree.

Build and Run the Demo

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

Expected output:

[ 455.10021] ep-consumer ep-consumer: all three lookups resolved to regmap ffffbf8021340c00

Seeing the same pointer value confirms that all three lookup styles indeed resolved to the same underlying regmap instance.

Introducing simple-mfd

For MMIO-based MFD chips, subdevices frequently need zero configuration before being added to the system — no dummy clients, no per-subdevice resource tables, nothing beyond “this child node is a device, please instantiate it.” Writing a full MFD core driver just to loop over child nodes and call mfd_add_devices() is unnecessary busywork the kernel already automates.

Adding "simple-mfd" to a node’s compatible string list makes the OF core spawn a platform device for every child node automatically, using the generic for_each_child_of_node() iterator — no custom probe function required on the parent side at all. Combined with syscon, this removes the need to write an MFD driver entirely for many MMIO devices.

Example: simple-mfd Combined With syscon

ep_pmu: ep-pmu@30000 {
    compatible = "ep,soc-pmu", "syscon", "simple-mfd";
    reg = <0x30000 0x1000>;

    ep_pmu_rtc: ep-pmu-rtc {
        compatible = "ep,soc-pmu-rtc";
        regmap = <&ep_pmu>;
        offset = <0x40>;
    };

    ep_pmu_poweroff: ep-pmu-poweroff {
        compatible = "syscon-poweroff";
        regmap = <&ep_pmu>;
        offset = <0x44>;
        value = <0x1>;
        mask = <0x1>;
    };
};

Here, ep_pmu gets its regmap from syscon automatically, and both ep_pmu_rtc and ep_pmu_poweroff are instantiated automatically as child platform devices by simple-mfd — the parent node needs no dedicated driver of its own.

Custom MFD Driver vs simple-mfd

Common Mistakes

• Calling syscon_regmap_lookup_by_pdevname() expecting it to accept a device tree phandle
• Forgetting of_node_put() after of_get_parent() before calling syscon_node_to_regmap()
• Adding "simple-mfd" without also adding "syscon" when subdevices need regmap access
• Expecting simple-mfd to configure per-subdevice resources — it only instantiates the device, nothing more

Best Practices

• Prefer syscon_regmap_lookup_by_phandle() for new drivers — it is the most explicit and DT-idiomatic choice
• Reach for simple-mfd first for MMIO chips before writing a custom MFD core driver
• Always release device_node references obtained from of_get_parent() with of_node_put()

Chapter Summary: MFD Subsystem and Syscon API

Across this chapter you’ve built up the full picture of Linux’s multi-function-device tooling: registering MFD cells and letting the core spawn platform subdevices, attaching per-subdevice resources and IRQ domains, handling chips where a subdevice needs its own I2C client, matching device tree nodes to platform drivers with of_compatible, and finally sharing miscellaneous MMIO register blocks safely through syscon. Combined with simple-mfd, these tools cover the overwhelming majority of real-world MFD chips — from I2C PMICs with several internal blocks to MMIO system-controller regions shared across unrelated drivers.

Key Takeaways

• MFD cells connect one physical chip to several independent subdevice drivers
• Dummy I2C clients let subdevices at a different address still use a regular regmap
• Device tree compatible matching, not naming, should drive most new subdevice bindings
• Syscon turns miscellaneous MMIO blocks into a shareable regmap with almost no code
• simple-mfd removes the need for a parent driver entirely on many MMIO chips

FAQ