What You Will Learn

Prerequisites

Why struct clk_gate Does Not Work for I2C/SPI Chips

Two separate assumptions baked into last lecture’s gate clock quietly break once the
hardware sits behind I2C or SPI instead of MMIO:

• struct clk_gate stores an __iomem register pointer, which is meaningless for a discrete bus-attached chip
• clk_gate_ops’s .enable/.disable are called with a spinlock held and must never sleep, but I2C/SPI register accesses always can sleep

Both problems have the same solution, and it is one this course already previewed
back in the clk_ops callback reference lecture.

The Workaround: Gate Through prepare/unprepare Instead

Since prepare/unprepare/is_prepared are
explicitly allowed to sleep, moving your gating logic into those callbacks instead of
enable/disable resolves both problems at once: no MMIO
register is assumed, and sleeping I2C/SPI transactions are safe to perform.

This is guaranteed to behave correctly because of a rule on the consumer side that
this course covered early in this chapter: every consumer must call
clk_prepare() before clk_enable(), and must follow
clk_disable() with clk_unprepare(). That ordering means:

Because clk_enable() is always preceded by clk_prepare(),
and your .prepare callback already turned the clock on by that point, your
.enable callback (if you provide one at all) can simply do nothing and
return success. The same logic applies in reverse for
clk_disable()/clk_unprepare() and your
.unprepare callback.

Original Demo: An I2C-Based Gate Clock

/* ep_i2c_gate_clk.c - gating logic lives in prepare/unprepare, since I2C access may sleep */
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/clk-provider.h>
#include <linux/of.h>

#define EP_GATE_CTRL_REG   0x10
#define EP_GATE_ENABLE_BIT BIT(0)

struct ep_i2c_gate_clk {
    struct clk_hw hw;
    struct i2c_client *client;
    bool prepared;
};

static inline struct ep_i2c_gate_clk *to_ep_i2c_gate(struct clk_hw *hw)
{
    return container_of(hw, struct ep_i2c_gate_clk, hw);
}

static int ep_i2c_gate_prepare(struct clk_hw *hw)
{
    struct ep_i2c_gate_clk *gate = to_ep_i2c_gate(hw);
    int ret;

    /* i2c_smbus_write_byte_data() may sleep - safe here, unsafe in .enable */
    ret = i2c_smbus_write_byte_data(gate->client, EP_GATE_CTRL_REG,
                                     EP_GATE_ENABLE_BIT);
    if (ret)
        return ret;

    gate->prepared = true;
    return 0;
}

static void ep_i2c_gate_unprepare(struct clk_hw *hw)
{
    struct ep_i2c_gate_clk *gate = to_ep_i2c_gate(hw);

    i2c_smbus_write_byte_data(gate->client, EP_GATE_CTRL_REG, 0);
    gate->prepared = false;
}

static int ep_i2c_gate_is_prepared(struct clk_hw *hw)
{
    return to_ep_i2c_gate(hw)->prepared;
}

static const struct clk_ops ep_i2c_gate_ops = {
    .prepare     = ep_i2c_gate_prepare,
    .unprepare   = ep_i2c_gate_unprepare,
    .is_prepared = ep_i2c_gate_is_prepared,
    /* no .enable/.disable at all - gating fully happens in prepare/unprepare */
};

static int ep_i2c_gate_probe(struct i2c_client *client)
{
    struct device *dev = &client->dev;
    struct ep_i2c_gate_clk *gate;
    struct clk_init_data init = {};

    gate = devm_kzalloc(dev, sizeof(*gate), GFP_KERNEL);
    if (!gate)
        return -ENOMEM;

    gate->client = client;

    init.name = "ep_i2c_gate_clk";
    init.ops = &ep_i2c_gate_ops;
    init.flags = 0;
    gate->hw.init = &init;

    return devm_clk_hw_register(dev, &gate->hw);
}

static const struct of_device_id ep_i2c_gate_of_match[] = {
    { .compatible = "ep,clk-i2c-gate-demo" },
    { }
};
MODULE_DEVICE_TABLE(of, ep_i2c_gate_of_match);

static struct i2c_driver ep_i2c_gate_driver = {
    .probe = ep_i2c_gate_probe,
    .driver = {
        .name = "ep_clk_i2c_gate_demo",
        .of_match_table = ep_i2c_gate_of_match,
    },
};
module_i2c_driver(ep_i2c_gate_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("EmbeddedPathashala I2C gate clock demo");

Notice this driver uses the low-level clk_hw_register() interface
directly rather than a type-specific helper, exactly the pattern from the registration
styles lecture earlier in this chapter — there is no dedicated
clk_hw_register_i2c_gate() helper, since I2C/SPI gate chips vary too much
from one another for a single generic helper to cover.

The gpio-gate-clock DT-Only Alternative

A third option exists for the simplest case of all: a clock gated purely by toggling
a GPIO line, with no register interface of any kind, MMIO or otherwise. Like
fixed-clock and pwm-clock from an earlier lecture, this is a
DT-only compatible string already handled by an existing in-tree driver, requiring no
code from you.

ep_gpio_gated_clk: ep-gpio-gated-clk {
    compatible = "gpio-gate-clock";
    #clock-cells = <0>;
    clocks = <&ep_ext_osc>;
    enable-gpios = <&gpio3 5 GPIO_ACTIVE_HIGH>;
};

/* consumer */
ep_wifi_module: wifi@0 {
    compatible = "ep,fake-wifi-module";
    reg = <0>;
    clocks = <&ep_gpio_gated_clk>;
};

The required properties are compatible = "gpio-gate-clock",
#clock-cells = <0>, and enable-gpios; an optional
clocks property can name a single upstream parent, and up to one parent is
supported. Under the hood, an existing kernel driver toggles the GPIO line whenever the
clock is enabled or disabled — you only describe the wiring in the device tree.

Three Ways to Gate a Clock

Common Mistakes

Best Practices

Summary and Key Takeaways

Frequently Asked Questions

Suggested Images For This Lecture