git: 316e388aae6e - main - clk/mediatek: Add common MediaTek clock and reset support
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Fri, 20 Nov 2026 01:13:44 UTC
The branch main has been updated by hayzam:
URL: https://cgit.FreeBSD.org/src/commit/?id=316e388aae6ed248454c72968c50988221ba57a6
commit 316e388aae6ed248454c72968c50988221ba57a6
Author: Hayzam Sherif <hayzam@FreeBSD.org>
AuthorDate: 2026-11-04 10:26:50 +0000
Commit: Hayzam Sherif <hayzam@FreeBSD.org>
CommitDate: 2026-11-20 01:10:53 +0000
clk/mediatek: Add common MediaTek clock and reset support
MediaTek SoCs split their clock tree over several controllers built from
the same blocks. Add a base driver that maps a controller's registers
and registers its table of clocks, and the node types the tables use:
- PLL with the MT7986 register layout: the rate is set by the
frequency control word and the post divider. A new control word is
only taken over when the PLL is enabled, so a running PLL is stopped
while its rate is changed, and a PLL that cannot stop keeps its rate.
Without a lock bit, a PLL that was never programmed cannot be told
from a stopped one, so the node has no gate: firmware starts the
PLLs, and a PLL that is off reports 0 Hz and cannot be set.
- Mux with an optional gate bit and an optional update latch, changed
by read-modify-write or, where the mux register is read-only,
through set/clear registers.
- Gate, changed in the same two ways.
Clocks of other controllers are linked clocks, so the registration order
does not matter. A registration failure, including a mux selection the
table does not describe, panics, since nodes cannot be unregistered.
The clocks the system runs on (bus, DRAM) are marked
CLK_NODE_CANNOT_STOP in the tables, together with every node on their
path to the crystal that could stop.
A controller can also be a reset controller, with banks of assert,
deassert and status registers. The single register per bank of older
SoCs is not supported yet.
Reviewed by: mmel
Approved by: markj (mentor)
Sponsored by: Alchemilla Ventures Private Limited
Differential Revision: https://reviews.freebsd.org/D61187
---
sys/conf/files.arm64 | 6 +
sys/dev/clk/mediatek/mtk_clk.c | 227 ++++++++++++++++++++++++++++++++++++
sys/dev/clk/mediatek/mtk_clk.h | 135 +++++++++++++++++++++
sys/dev/clk/mediatek/mtk_clk_gate.c | 112 ++++++++++++++++++
sys/dev/clk/mediatek/mtk_clk_mux.c | 164 ++++++++++++++++++++++++++
sys/dev/clk/mediatek/mtk_clk_pll.c | 214 +++++++++++++++++++++++++++++++++
6 files changed, 858 insertions(+)
diff --git a/sys/conf/files.arm64 b/sys/conf/files.arm64
index 2f914c4efd64..80e58541b4c8 100644
--- a/sys/conf/files.arm64
+++ b/sys/conf/files.arm64
@@ -844,6 +844,12 @@ arm64/rockchip/rk_tsadc.c optional fdt soc_rockchip_rk3399 | fdt soc_rockchip_
arm64/rockchip/rk_pcie.c optional fdt pci soc_rockchip_rk3399
arm64/rockchip/rk_pcie_phy.c optional fdt pci soc_rockchip_rk3399
+# MediaTek Clock support
+dev/clk/mediatek/mtk_clk.c optional fdt soc_mediatek
+dev/clk/mediatek/mtk_clk_gate.c optional fdt soc_mediatek
+dev/clk/mediatek/mtk_clk_mux.c optional fdt soc_mediatek
+dev/clk/mediatek/mtk_clk_pll.c optional fdt soc_mediatek
+
# RockChip Clock support
dev/clk/rockchip/rk_cru.c optional fdt soc_rockchip
dev/clk/rockchip/rk_clk_armclk.c optional fdt soc_rockchip
diff --git a/sys/dev/clk/mediatek/mtk_clk.c b/sys/dev/clk/mediatek/mtk_clk.c
new file mode 100644
index 000000000000..02a18b8bb6c6
--- /dev/null
+++ b/sys/dev/clk/mediatek/mtk_clk.c
@@ -0,0 +1,227 @@
+/*
+ * Copyright (c) 2026 Hayzam Sherif <hayzam@FreeBSD.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+/*
+ * Common part of the MediaTek clock controller drivers. Each controller
+ * supplies a table of clocks. This driver owns the registers and the lock
+ * for read-modify-write access to them.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/rman.h>
+
+#include <machine/bus.h>
+
+#include <dev/clk/mediatek/mtk_clk.h>
+#include <dev/hwreset/hwreset.h>
+
+#include "clkdev_if.h"
+#include "hwreset_if.h"
+
+static int
+mtk_clk_write_4(device_t dev, bus_addr_t addr, uint32_t val)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+
+ bus_write_4(sc->res, addr, val);
+ return (0);
+}
+
+static int
+mtk_clk_read_4(device_t dev, bus_addr_t addr, uint32_t *val)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+
+ *val = bus_read_4(sc->res, addr);
+ return (0);
+}
+
+static int
+mtk_clk_modify_4(device_t dev, bus_addr_t addr, uint32_t clr, uint32_t set)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+ uint32_t val;
+
+ val = bus_read_4(sc->res, addr);
+ val &= ~clr;
+ val |= set;
+ bus_write_4(sc->res, addr, val);
+ return (0);
+}
+
+static void
+mtk_clk_device_lock(device_t dev)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+
+ mtx_lock(&sc->mtx);
+}
+
+static void
+mtk_clk_device_unlock(device_t dev)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+
+ mtx_unlock(&sc->mtx);
+}
+
+static int
+mtk_clk_reset_lookup(struct mtk_clk_softc *sc, intptr_t id, bus_size_t *reg,
+ uint32_t *mask)
+{
+ const struct mtk_clk_reset_desc *rd = sc->resets;
+
+ if (id < 0 || (size_t)(id / 32) >= rd->nbanks)
+ return (EINVAL);
+ *reg = rd->banks[id / 32];
+ *mask = 1u << (id % 32);
+ return (0);
+}
+
+static int
+mtk_clk_reset_assert(device_t dev, intptr_t id, bool reset)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+ bus_size_t reg;
+ uint32_t mask;
+ int rv;
+
+ if ((rv = mtk_clk_reset_lookup(sc, id, ®, &mask)) != 0)
+ return (rv);
+ mtx_lock(&sc->mtx);
+ bus_write_4(sc->res, reset ? reg : reg + 4, mask);
+ mtx_unlock(&sc->mtx);
+ return (0);
+}
+
+static int
+mtk_clk_reset_is_asserted(device_t dev, intptr_t id, bool *reset)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+ bus_size_t reg;
+ uint32_t mask;
+ int rv;
+
+ if ((rv = mtk_clk_reset_lookup(sc, id, ®, &mask)) != 0)
+ return (rv);
+ mtx_lock(&sc->mtx);
+ *reset = (bus_read_4(sc->res, reg + 8) & mask) != 0;
+ mtx_unlock(&sc->mtx);
+ return (0);
+}
+
+static const struct clknode_init_def *
+mtk_clk_def_clkdef(const struct mtk_clk_def *def)
+{
+ switch (def->type) {
+ case MTK_CLK_LINK:
+ return (&def->link.clkdef);
+ case MTK_CLK_FIXED:
+ return (&def->fixed.clkdef);
+ case MTK_CLK_PLL:
+ return (&def->pll.clkdef);
+ case MTK_CLK_MUX:
+ return (&def->mux.clkdef);
+ case MTK_CLK_GATE:
+ return (&def->gate.clkdef);
+ default:
+ return (NULL);
+ }
+}
+
+int
+mtk_clk_attach(device_t dev, const struct mtk_clk_desc *desc)
+{
+ struct mtk_clk_softc *sc = device_get_softc(dev);
+ struct mtk_clk_def *def;
+ size_t i;
+ int rid, rv;
+
+ rid = 0;
+ sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE);
+ if (sc->res == NULL) {
+ device_printf(dev, "cannot allocate registers\n");
+ return (ENXIO);
+ }
+ mtx_init(&sc->mtx, device_get_nameunit(dev), NULL, MTX_DEF);
+
+ sc->clkdom = clkdom_create(dev);
+ if (sc->clkdom == NULL) {
+ device_printf(dev, "cannot create clock domain\n");
+ rv = ENXIO;
+ goto fail;
+ }
+
+ for (i = 0; i < desc->nclks; i++) {
+ def = &desc->clks[i];
+ switch (def->type) {
+ case MTK_CLK_LINK:
+ rv = clknode_link_register(sc->clkdom, &def->link);
+ break;
+ case MTK_CLK_FIXED:
+ rv = clknode_fixed_register(sc->clkdom, &def->fixed);
+ break;
+ case MTK_CLK_PLL:
+ rv = mtk_clk_pll_register(sc->clkdom, &def->pll);
+ break;
+ case MTK_CLK_MUX:
+ rv = mtk_clk_mux_register(sc->clkdom, &def->mux);
+ break;
+ case MTK_CLK_GATE:
+ rv = mtk_clk_gate_register(sc->clkdom, &def->gate);
+ break;
+ default:
+ rv = EINVAL;
+ break;
+ }
+ /*
+ * Nodes cannot be unregistered once others reference them, so
+ * a failure here cannot be undone.
+ */
+ if (rv != 0)
+ panic("%s: cannot register clock %s: %d",
+ device_get_nameunit(dev),
+ mtk_clk_def_clkdef(def)->name, rv);
+ }
+
+ if (clkdom_finit(sc->clkdom) != 0)
+ panic("%s: cannot finalize clock domain",
+ device_get_nameunit(dev));
+ if (bootverbose)
+ clkdom_dump(sc->clkdom);
+
+ if (desc->resets != NULL) {
+ sc->resets = desc->resets;
+ hwreset_register_ofw_provider(dev);
+ }
+
+ return (0);
+
+fail:
+ mtx_destroy(&sc->mtx);
+ bus_release_resource(dev, SYS_RES_MEMORY, rid, sc->res);
+ return (rv);
+}
+
+static device_method_t mtk_clk_methods[] = {
+ DEVMETHOD(clkdev_write_4, mtk_clk_write_4),
+ DEVMETHOD(clkdev_read_4, mtk_clk_read_4),
+ DEVMETHOD(clkdev_modify_4, mtk_clk_modify_4),
+ DEVMETHOD(clkdev_device_lock, mtk_clk_device_lock),
+ DEVMETHOD(clkdev_device_unlock, mtk_clk_device_unlock),
+
+ DEVMETHOD(hwreset_assert, mtk_clk_reset_assert),
+ DEVMETHOD(hwreset_is_asserted, mtk_clk_reset_is_asserted),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(mtk_clk, mtk_clk_driver, mtk_clk_methods,
+ sizeof(struct mtk_clk_softc));
diff --git a/sys/dev/clk/mediatek/mtk_clk.h b/sys/dev/clk/mediatek/mtk_clk.h
new file mode 100644
index 000000000000..ed56bbf8097e
--- /dev/null
+++ b/sys/dev/clk/mediatek/mtk_clk.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2026 Hayzam Sherif <hayzam@FreeBSD.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#ifndef _DEV_CLK_MEDIATEK_MTK_CLK_H_
+#define _DEV_CLK_MEDIATEK_MTK_CLK_H_
+
+#include <dev/clk/clk.h>
+#include <dev/clk/clk_fixed.h>
+#include <dev/clk/clk_link.h>
+
+/* Clock id for nodes that are not exported through the DT binding. */
+#define MTK_CLK_NOID (-1)
+
+/* PLL, see mtk_clk_pll.c for the register layout. */
+struct mtk_clk_pll_def {
+ struct clknode_init_def clkdef;
+ uint32_t con0; /* control register */
+ uint32_t rst_bar; /* CON0 reset bar mask, or 0 */
+};
+
+/*
+ * Mux with an optional gate bit (set means gated) and an optional update
+ * register latching the new selection. The field is changed by
+ * read-modify-write of reg, or, with MTK_MUX_SETCLR for a read-only reg,
+ * through write-1-to-set/clear registers.
+ */
+#define MTK_MUX_SETCLR 0x0001
+
+struct mtk_clk_mux_def {
+ struct clknode_init_def clkdef;
+ uint32_t reg; /* selection */
+ uint32_t set_reg;
+ uint32_t clr_reg;
+ uint32_t shift;
+ uint32_t width;
+ int gate_bit; /* -1 if none */
+ uint32_t upd_reg;
+ int upd_bit; /* -1 if none */
+ uint32_t flags;
+};
+
+/*
+ * Gate bit, changed by read-modify-write of reg, or, with MTK_GATE_SETCLR
+ * for a read-only reg, through write-1-to-set/clear registers. Normally a
+ * set bit means the clock is gated; MTK_GATE_INVERTED reverses this.
+ */
+#define MTK_GATE_SETCLR 0x0001
+#define MTK_GATE_INVERTED 0x0002
+
+struct mtk_clk_gate_def {
+ struct clknode_init_def clkdef;
+ uint32_t reg; /* gate bit */
+ uint32_t set_reg;
+ uint32_t clr_reg;
+ uint32_t bit;
+ uint32_t flags;
+};
+
+enum mtk_clk_type {
+ MTK_CLK_LINK = 1,
+ MTK_CLK_FIXED,
+ MTK_CLK_PLL,
+ MTK_CLK_MUX,
+ MTK_CLK_GATE,
+};
+
+struct mtk_clk_def {
+ enum mtk_clk_type type;
+ union {
+ struct clk_link_def link;
+ struct clk_fixed_def fixed;
+ struct mtk_clk_pll_def pll;
+ struct mtk_clk_mux_def mux;
+ struct mtk_clk_gate_def gate;
+ };
+};
+
+/*
+ * Software resets, in banks of 32. Each bank has a write-1-to-set
+ * (assert) register, a write-1-to-clear (deassert) register at +4 and a
+ * status register at +8. Reset id n is bit n % 32 of bank n / 32.
+ * Older SoCs with a single read-write register per bank would need a
+ * read-modify-write variant, as for gates and muxes. It is left for the
+ * first SoC that needs it: the MT7986 clock controllers need none.
+ */
+struct mtk_clk_reset_desc {
+ const uint32_t *banks; /* set register of each bank */
+ size_t nbanks;
+};
+
+struct mtk_clk_desc {
+ struct mtk_clk_def *clks;
+ size_t nclks;
+ const struct mtk_clk_reset_desc *resets; /* or NULL */
+};
+
+struct mtk_clk_softc {
+ struct resource *res;
+ struct mtx mtx;
+ struct clkdom *clkdom;
+ const struct mtk_clk_reset_desc *resets;
+};
+
+/* Helpers for clock tables. */
+#define MTK_LINK(_name) \
+ { .type = MTK_CLK_LINK, .link = { \
+ .clkdef = { .name = (_name), .id = MTK_CLK_NOID } } }
+
+#define MTK_FIXED(_id, _name, _freq) \
+ { .type = MTK_CLK_FIXED, .fixed = { \
+ .clkdef = { .name = (_name), .id = (_id) }, \
+ .freq = (_freq) } }
+
+#define MTK_FACTOR(_id, _name, _parent, _mult, _div) \
+ { .type = MTK_CLK_FIXED, .fixed = { \
+ .clkdef = { .name = (_name), .id = (_id), \
+ .parent_names = (const char *[]){ _parent }, \
+ .parent_cnt = 1 }, \
+ .mult = (_mult), .div = (_div) } }
+
+int mtk_clk_attach(device_t dev, const struct mtk_clk_desc *desc);
+
+int mtk_clk_pll_register(struct clkdom *clkdom,
+ const struct mtk_clk_pll_def *def);
+int mtk_clk_mux_register(struct clkdom *clkdom,
+ const struct mtk_clk_mux_def *def);
+int mtk_clk_gate_register(struct clkdom *clkdom,
+ const struct mtk_clk_gate_def *def);
+
+DECLARE_CLASS(mtk_clk_driver);
+
+#endif /* _DEV_CLK_MEDIATEK_MTK_CLK_H_ */
diff --git a/sys/dev/clk/mediatek/mtk_clk_gate.c b/sys/dev/clk/mediatek/mtk_clk_gate.c
new file mode 100644
index 000000000000..1b0d17a20b35
--- /dev/null
+++ b/sys/dev/clk/mediatek/mtk_clk_gate.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2026 Hayzam Sherif <hayzam@FreeBSD.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+/*
+ * MediaTek clock gate. The gate bit is read from a register and changed
+ * by read-modify-write of it, or, where that register is read-only,
+ * through separate write-1-to-set and write-1-to-clear registers. A set
+ * bit normally means "gated".
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+
+#include <dev/clk/clk.h>
+#include <dev/clk/mediatek/mtk_clk.h>
+
+#include "clkdev_if.h"
+
+struct mtk_clk_gate_sc {
+ uint32_t reg;
+ uint32_t set_reg;
+ uint32_t clr_reg;
+ uint32_t mask;
+ bool setclr;
+ bool inverted;
+};
+
+#define RD4(_clk, _off, _val) \
+ CLKDEV_READ_4(clknode_get_device(_clk), _off, _val)
+#define WR4(_clk, _off, _val) \
+ CLKDEV_WRITE_4(clknode_get_device(_clk), _off, _val)
+#define MD4(_clk, _off, _clr, _set) \
+ CLKDEV_MODIFY_4(clknode_get_device(_clk), _off, _clr, _set)
+#define DEVICE_LOCK(_clk) \
+ CLKDEV_DEVICE_LOCK(clknode_get_device(_clk))
+#define DEVICE_UNLOCK(_clk) \
+ CLKDEV_DEVICE_UNLOCK(clknode_get_device(_clk))
+
+static int
+mtk_clk_gate_init(struct clknode *clk, device_t dev)
+{
+ clknode_init_parent_idx(clk, 0);
+ return (0);
+}
+
+static int
+mtk_clk_gate_set_gate(struct clknode *clk, bool enable)
+{
+ struct mtk_clk_gate_sc *sc = clknode_get_softc(clk);
+ bool set;
+
+ set = enable == sc->inverted;
+ DEVICE_LOCK(clk);
+ if (!sc->setclr)
+ MD4(clk, sc->reg, sc->mask, set ? sc->mask : 0);
+ else
+ WR4(clk, set ? sc->set_reg : sc->clr_reg, sc->mask);
+ DEVICE_UNLOCK(clk);
+ return (0);
+}
+
+static int
+mtk_clk_gate_get_gate(struct clknode *clk, bool *enabled)
+{
+ struct mtk_clk_gate_sc *sc = clknode_get_softc(clk);
+ uint32_t val;
+
+ DEVICE_LOCK(clk);
+ RD4(clk, sc->reg, &val);
+ DEVICE_UNLOCK(clk);
+ *enabled = ((val & sc->mask) == 0) != sc->inverted;
+ return (0);
+}
+
+static clknode_method_t mtk_clk_gate_methods[] = {
+ CLKNODEMETHOD(clknode_init, mtk_clk_gate_init),
+ CLKNODEMETHOD(clknode_set_gate, mtk_clk_gate_set_gate),
+ CLKNODEMETHOD(clknode_get_gate, mtk_clk_gate_get_gate),
+ CLKNODEMETHOD_END
+};
+
+DEFINE_CLASS_1(mtk_clk_gate_clknode, mtk_clk_gate_clknode_class,
+ mtk_clk_gate_methods, sizeof(struct mtk_clk_gate_sc), clknode_class);
+
+int
+mtk_clk_gate_register(struct clkdom *clkdom,
+ const struct mtk_clk_gate_def *def)
+{
+ struct clknode *clk;
+ struct mtk_clk_gate_sc *sc;
+
+ clk = clknode_create(clkdom, &mtk_clk_gate_clknode_class,
+ &def->clkdef);
+ if (clk == NULL)
+ return (ENXIO);
+
+ sc = clknode_get_softc(clk);
+ sc->reg = def->reg;
+ sc->set_reg = def->set_reg;
+ sc->clr_reg = def->clr_reg;
+ sc->mask = 1u << def->bit;
+ sc->setclr = (def->flags & MTK_GATE_SETCLR) != 0;
+ sc->inverted = (def->flags & MTK_GATE_INVERTED) != 0;
+
+ if (clknode_register(clkdom, clk) == NULL)
+ return (ENXIO);
+ return (0);
+}
diff --git a/sys/dev/clk/mediatek/mtk_clk_mux.c b/sys/dev/clk/mediatek/mtk_clk_mux.c
new file mode 100644
index 000000000000..2af1e77f8e1f
--- /dev/null
+++ b/sys/dev/clk/mediatek/mtk_clk_mux.c
@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2026 Hayzam Sherif <hayzam@FreeBSD.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+/*
+ * MediaTek clock mux. The selection is read from a register and changed
+ * by read-modify-write of it, or, where that register is read-only,
+ * through separate write-1-to-clear and write-1-to-set registers.
+ * Optionally the mux has a gate bit in the same field group (set means
+ * gated) and an update register whose bit latches a new selection.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+
+#include <dev/clk/clk.h>
+#include <dev/clk/mediatek/mtk_clk.h>
+
+#include "clkdev_if.h"
+
+struct mtk_clk_mux_sc {
+ uint32_t reg;
+ uint32_t set_reg;
+ uint32_t clr_reg;
+ uint32_t shift;
+ uint32_t mask;
+ int gate_bit;
+ uint32_t upd_reg;
+ int upd_bit;
+ bool setclr;
+};
+
+#define RD4(_clk, _off, _val) \
+ CLKDEV_READ_4(clknode_get_device(_clk), _off, _val)
+#define WR4(_clk, _off, _val) \
+ CLKDEV_WRITE_4(clknode_get_device(_clk), _off, _val)
+#define MD4(_clk, _off, _clr, _set) \
+ CLKDEV_MODIFY_4(clknode_get_device(_clk), _off, _clr, _set)
+#define DEVICE_LOCK(_clk) \
+ CLKDEV_DEVICE_LOCK(clknode_get_device(_clk))
+#define DEVICE_UNLOCK(_clk) \
+ CLKDEV_DEVICE_UNLOCK(clknode_get_device(_clk))
+
+/* Change the bits in mask to val. Called with the device lock held. */
+static void
+mtk_clk_mux_write(struct clknode *clk, struct mtk_clk_mux_sc *sc,
+ uint32_t mask, uint32_t val)
+{
+ if (!sc->setclr) {
+ MD4(clk, sc->reg, mask, val);
+ return;
+ }
+ if ((mask & ~val) != 0)
+ WR4(clk, sc->clr_reg, mask & ~val);
+ if (val != 0)
+ WR4(clk, sc->set_reg, val);
+}
+
+static void
+mtk_clk_mux_update(struct clknode *clk, struct mtk_clk_mux_sc *sc)
+{
+ if (sc->upd_bit >= 0)
+ WR4(clk, sc->upd_reg, 1u << sc->upd_bit);
+}
+
+static int
+mtk_clk_mux_init(struct clknode *clk, device_t dev)
+{
+ struct mtk_clk_mux_sc *sc = clknode_get_softc(clk);
+ uint32_t val;
+
+ DEVICE_LOCK(clk);
+ RD4(clk, sc->reg, &val);
+ DEVICE_UNLOCK(clk);
+ clknode_init_parent_idx(clk, (val >> sc->shift) & sc->mask);
+ return (0);
+}
+
+static int
+mtk_clk_mux_set_mux(struct clknode *clk, int idx)
+{
+ struct mtk_clk_mux_sc *sc = clknode_get_softc(clk);
+
+ DEVICE_LOCK(clk);
+ mtk_clk_mux_write(clk, sc, sc->mask << sc->shift,
+ (uint32_t)idx << sc->shift);
+ mtk_clk_mux_update(clk, sc);
+ DEVICE_UNLOCK(clk);
+ return (0);
+}
+
+static int
+mtk_clk_mux_set_gate(struct clknode *clk, bool enable)
+{
+ struct mtk_clk_mux_sc *sc = clknode_get_softc(clk);
+
+ /* Without a gate bit the mux always runs. */
+ if (sc->gate_bit < 0)
+ return (enable ? 0 : ENXIO);
+ DEVICE_LOCK(clk);
+ mtk_clk_mux_write(clk, sc, 1u << sc->gate_bit,
+ enable ? 0 : 1u << sc->gate_bit);
+ if (enable)
+ mtk_clk_mux_update(clk, sc);
+ DEVICE_UNLOCK(clk);
+ return (0);
+}
+
+static int
+mtk_clk_mux_get_gate(struct clknode *clk, bool *enabled)
+{
+ struct mtk_clk_mux_sc *sc = clknode_get_softc(clk);
+ uint32_t val;
+
+ if (sc->gate_bit < 0) {
+ *enabled = true;
+ return (0);
+ }
+ DEVICE_LOCK(clk);
+ RD4(clk, sc->reg, &val);
+ DEVICE_UNLOCK(clk);
+ *enabled = (val & (1u << sc->gate_bit)) == 0;
+ return (0);
+}
+
+static clknode_method_t mtk_clk_mux_methods[] = {
+ CLKNODEMETHOD(clknode_init, mtk_clk_mux_init),
+ CLKNODEMETHOD(clknode_set_mux, mtk_clk_mux_set_mux),
+ CLKNODEMETHOD(clknode_set_gate, mtk_clk_mux_set_gate),
+ CLKNODEMETHOD(clknode_get_gate, mtk_clk_mux_get_gate),
+ CLKNODEMETHOD_END
+};
+
+DEFINE_CLASS_1(mtk_clk_mux_clknode, mtk_clk_mux_clknode_class,
+ mtk_clk_mux_methods, sizeof(struct mtk_clk_mux_sc), clknode_class);
+
+int
+mtk_clk_mux_register(struct clkdom *clkdom, const struct mtk_clk_mux_def *def)
+{
+ struct clknode *clk;
+ struct mtk_clk_mux_sc *sc;
+
+ clk = clknode_create(clkdom, &mtk_clk_mux_clknode_class, &def->clkdef);
+ if (clk == NULL)
+ return (ENXIO);
+
+ sc = clknode_get_softc(clk);
+ sc->reg = def->reg;
+ sc->set_reg = def->set_reg;
+ sc->clr_reg = def->clr_reg;
+ sc->shift = def->shift;
+ sc->mask = (1u << def->width) - 1;
+ sc->gate_bit = def->gate_bit;
+ sc->upd_reg = def->upd_reg;
+ sc->upd_bit = def->upd_bit;
+ sc->setclr = (def->flags & MTK_MUX_SETCLR) != 0;
+
+ if (clknode_register(clkdom, clk) == NULL)
+ return (ENXIO);
+ return (0);
+}
diff --git a/sys/dev/clk/mediatek/mtk_clk_pll.c b/sys/dev/clk/mediatek/mtk_clk_pll.c
new file mode 100644
index 000000000000..da40ba519800
--- /dev/null
+++ b/sys/dev/clk/mediatek/mtk_clk_pll.c
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2026 Hayzam Sherif <hayzam@FreeBSD.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+/*
+ * MediaTek PLL clock node, with the MT7986 register layout. CON0 holds the
+ * enable bit, the post divider (bits 6:4, a power of two up to 16) and an
+ * optional reset bar bit. CON1, the register after it, is the 32-bit
+ * frequency control word (PCW) with 7 integer bits.
+ *
+ * rate = parent * PCW / 2^25 / 2^postdiv
+ *
+ * A new PCW only takes effect when the PLL is enabled, so a running PLL is
+ * stopped while its rate is changed. CON1 bit 31, a change strobe on older
+ * SoCs, is part of the PCW here.
+ *
+ * The PLLs have no lock bit, so a PLL that was never programmed cannot be
+ * told from a stopped one. Firmware starts the PLLs and the node has no
+ * gate: a PLL that is off reports 0 Hz and its rate cannot be set.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+
+#include <dev/clk/clk.h>
+#include <dev/clk/mediatek/mtk_clk.h>
+
+#include "clkdev_if.h"
+
+#define PLL_CON0_EN 0x00000001
+#define PLL_POSTDIV_SHIFT 4
+#define PLL_POSTDIV_MASK 0x7
+#define PLL_POSTDIV_MAX 4 /* divide by 16 */
+#define PLL_CON1 0x4 /* PCW, from CON0 */
+#define PLL_PCW_FBITS 25 /* fractional bits of the PCW */
+
+/* The firmware runs the VCOs between 1520 and 2880 MHz. */
+#define PLL_VCO_MIN 1500000000ULL
+#define PLL_VCO_MAX 3000000000ULL
+
+#define PLL_LOCK_DELAY 20 /* us, after enable */
+
+struct mtk_clk_pll_sc {
+ uint32_t con0;
+ uint32_t rst_bar;
+};
+
+#define RD4(_clk, _off, _val) \
+ CLKDEV_READ_4(clknode_get_device(_clk), _off, _val)
+#define WR4(_clk, _off, _val) \
+ CLKDEV_WRITE_4(clknode_get_device(_clk), _off, _val)
+#define MD4(_clk, _off, _clr, _set) \
+ CLKDEV_MODIFY_4(clknode_get_device(_clk), _off, _clr, _set)
+#define DEVICE_LOCK(_clk) \
+ CLKDEV_DEVICE_LOCK(clknode_get_device(_clk))
+#define DEVICE_UNLOCK(_clk) \
+ CLKDEV_DEVICE_UNLOCK(clknode_get_device(_clk))
+
+static int
+mtk_clk_pll_init(struct clknode *clk, device_t dev)
+{
+ clknode_init_parent_idx(clk, 0);
+ return (0);
+}
+
+/* Rate for a PCW and post divider, rounded to the nearest Hz. */
+static uint64_t
+mtk_clk_pll_rate(uint64_t fin, uint32_t pcw, uint32_t postdiv)
+{
+ uint32_t shift = PLL_PCW_FBITS + postdiv;
+
+ return ((fin * pcw + (1ULL << (shift - 1))) >> shift);
+}
+
+static int
+mtk_clk_pll_recalc_freq(struct clknode *clk, uint64_t *freq)
+{
+ struct mtk_clk_pll_sc *sc = clknode_get_softc(clk);
+ uint32_t con0, pcw;
+
+ DEVICE_LOCK(clk);
+ RD4(clk, sc->con0, &con0);
+ RD4(clk, sc->con0 + PLL_CON1, &pcw);
+ DEVICE_UNLOCK(clk);
+
+ if ((con0 & PLL_CON0_EN) == 0)
+ *freq = 0;
+ else
+ *freq = mtk_clk_pll_rate(*freq, pcw,
+ (con0 >> PLL_POSTDIV_SHIFT) & PLL_POSTDIV_MASK);
+ return (0);
+}
+
+/* Enable the PLL and release its reset once it has locked. */
+static void
+mtk_clk_pll_start(struct clknode *clk, struct mtk_clk_pll_sc *sc)
+{
+ MD4(clk, sc->con0, 0, PLL_CON0_EN);
+ DELAY(PLL_LOCK_DELAY);
+ if (sc->rst_bar != 0)
+ MD4(clk, sc->con0, 0, sc->rst_bar);
+}
+
+static void
+mtk_clk_pll_stop(struct clknode *clk, struct mtk_clk_pll_sc *sc)
+{
+ if (sc->rst_bar != 0)
+ MD4(clk, sc->con0, sc->rst_bar, 0);
+ MD4(clk, sc->con0, PLL_CON0_EN, 0);
+}
+
+/* Set a new PCW and post divider, stopping the running PLL for it. */
+static void
+mtk_clk_pll_program(struct clknode *clk, uint32_t pcw, uint32_t postdiv)
+{
+ struct mtk_clk_pll_sc *sc = clknode_get_softc(clk);
+
+ DEVICE_LOCK(clk);
+ mtk_clk_pll_stop(clk, sc);
+ WR4(clk, sc->con0 + PLL_CON1, pcw);
+ MD4(clk, sc->con0, PLL_POSTDIV_MASK << PLL_POSTDIV_SHIFT,
+ postdiv << PLL_POSTDIV_SHIFT);
+ mtk_clk_pll_start(clk, sc);
+ DEVICE_UNLOCK(clk);
+}
+
+/*
+ * Use the smallest post divider that keeps the VCO in its range, as the
+ * firmware does. The PCW has 25 fractional bits, so the rate is then set
+ * to within about 1 Hz, and the rounding only chooses between two
+ * neighbouring PCW values.
+ */
+static int
+mtk_clk_pll_set_freq(struct clknode *clk, uint64_t fin, uint64_t *fout,
+ int flags, int *stop)
+{
+ uint64_t cur, freq, vco;
+ uint32_t pcw, postdiv;
+ int round;
+
+ *stop = 1;
+ round = CLK_SET_ROUND(flags);
+
+ /* A new rate would only take effect when the PLL is started. */
+ cur = fin;
+ mtk_clk_pll_recalc_freq(clk, &cur);
+ if (cur == 0)
+ return (ENXIO);
+
+ /* A request beyond the range can only be rounded to its limit. */
+ vco = *fout;
+ if (vco > PLL_VCO_MAX && (round & CLK_SET_ROUND_DOWN) != 0)
+ vco = PLL_VCO_MAX;
+ else if (vco < (PLL_VCO_MIN >> PLL_POSTDIV_MAX) &&
+ (round & CLK_SET_ROUND_UP) != 0)
+ vco = PLL_VCO_MIN >> PLL_POSTDIV_MAX;
+ for (postdiv = 0; postdiv < PLL_POSTDIV_MAX && vco < PLL_VCO_MIN;
+ postdiv++)
+ vco <<= 1;
+ if (vco < PLL_VCO_MIN || vco > PLL_VCO_MAX)
+ return (ERANGE);
+
+ /* Cannot overflow: the VCO rate is below 2^32. */
+ pcw = ((vco << PLL_PCW_FBITS) + fin / 2) / fin;
+ freq = mtk_clk_pll_rate(fin, pcw, postdiv);
+ if (round == CLK_SET_ROUND_UP && freq < *fout)
+ freq = mtk_clk_pll_rate(fin, ++pcw, postdiv);
+ else if (round == CLK_SET_ROUND_DOWN && freq > *fout)
+ freq = mtk_clk_pll_rate(fin, --pcw, postdiv);
+ else if (round == CLK_SET_ROUND_EXACT && freq != *fout)
+ return (ERANGE);
+
+ if (cur != freq) {
+ /* The PLL would have to stop. */
+ if ((clknode_get_flags(clk) & CLK_NODE_CANNOT_STOP) != 0)
+ return (EBUSY);
+ if ((flags & CLK_SET_DRYRUN) == 0)
+ mtk_clk_pll_program(clk, pcw, postdiv);
+ }
+ *fout = freq;
+ return (0);
+}
+
+static clknode_method_t mtk_clk_pll_methods[] = {
+ CLKNODEMETHOD(clknode_init, mtk_clk_pll_init),
+ CLKNODEMETHOD(clknode_recalc_freq, mtk_clk_pll_recalc_freq),
+ CLKNODEMETHOD(clknode_set_freq, mtk_clk_pll_set_freq),
+ CLKNODEMETHOD_END
+};
+
+DEFINE_CLASS_1(mtk_clk_pll_clknode, mtk_clk_pll_clknode_class,
+ mtk_clk_pll_methods, sizeof(struct mtk_clk_pll_sc), clknode_class);
+
+int
+mtk_clk_pll_register(struct clkdom *clkdom, const struct mtk_clk_pll_def *def)
+{
+ struct clknode *clk;
+ struct mtk_clk_pll_sc *sc;
+
+ clk = clknode_create(clkdom, &mtk_clk_pll_clknode_class, &def->clkdef);
+ if (clk == NULL)
+ return (ENXIO);
+
+ sc = clknode_get_softc(clk);
+ sc->con0 = def->con0;
+ sc->rst_bar = def->rst_bar;
+
+ if (clknode_register(clkdom, clk) == NULL)
+ return (ENXIO);
+ return (0);
+}