github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

clk: zte: Add regmap-based clocks

Browse Source 
This is based on meson/clk-regmap.c, although slightly simplified. I
have kept the copyright lines at the top of the file to indicate its
origin.

Signed-off-by: Stefan Dösinger <stefandoesinger@gmail.com>
Signed-off-by: Brian Masney <bmasney@redhat.com>
This commit is contained in:
Stefan Dösinger 2026-09-27 23:13:35 +03:00 committed by Brian Masney
parent 8a9b53cc13
commit 04b24f1dca
1 changed files with 214 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

223
drivers/clk/zte/clk-regmap.c
View File

@ -1,32 +1,237 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2018 BayLibre, SAS.
* Copyright (c) 2026 Stefan Dösinger
*/
#include <linux/bits.h>
#include <linux/clk-provider.h>
#include <linux/container_of.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/regmap.h>
#include <linux/types.h>
#include "clk-zx.h"
struct clk_hw *zx_clk_register_gate(struct device *dev, struct regmap *regmap,
const struct zx_gate_desc *desc,
struct clk_hw * const *clocks)
struct zte_clk_regmap {
struct clk_hw hw;
struct regmap *map;
u16 reg;
u8 shift;
u8 size;
};
static inline struct zte_clk_regmap *to_zte_clk_regmap(struct clk_hw *hw)
{
return ERR_PTR(-ENODEV);
return container_of(hw, struct zte_clk_regmap, hw);
}
static int zte_clk_regmap_gate_enable(struct clk_hw *hw)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
return regmap_set_bits(clk->map, clk->reg, BIT(clk->shift));
}
static void zte_clk_regmap_gate_disable(struct clk_hw *hw)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
regmap_clear_bits(clk->map, clk->reg, BIT(clk->shift));
}
static int zte_clk_regmap_gate_is_enabled(struct clk_hw *hw)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
return regmap_test_bits(clk->map, clk->reg, BIT(clk->shift));
}
static const struct clk_ops zte_clk_regmap_gate_ops = {
.enable = zte_clk_regmap_gate_enable,
.disable = zte_clk_regmap_gate_disable,
.is_enabled = zte_clk_regmap_gate_is_enabled,
};
struct clk_hw *zx_clk_register_gate(struct device *dev, struct regmap *regmap,
const struct zx_gate_desc *desc, struct clk_hw * const *clocks)
{
struct clk_parent_data parent = zx_get_parent(&desc->parent, clocks);
struct clk_init_data init = {};
struct zte_clk_regmap *clk;
int res;
clk = devm_kzalloc(dev, sizeof(*clk), GFP_KERNEL);
if (!clk)
return ERR_PTR(-ENOMEM);
init.name = desc->name;
init.ops = &zte_clk_regmap_gate_ops;
init.parent_data = &parent;
init.num_parents = 1;
init.flags = CLK_SET_RATE_PARENT | desc->flags;
clk->hw.init = &init;
clk->map = regmap;
clk->reg = desc->reg;
clk->shift = desc->shift;
clk->size = 1;
res = devm_clk_hw_register(dev, &clk->hw);
if (res)
return ERR_PTR(res);
return &clk->hw;
}
static unsigned long zte_clk_regmap_div_recalc_rate(struct clk_hw *hw,
unsigned long prate)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
unsigned int val;
int ret;
ret = regmap_read(clk->map, clk->reg, &val);
if (ret)
return 0; /* Gives a hint that something is wrong */
val >>= clk->shift;
val &= clk_div_mask(clk->size);
return divider_recalc_rate(hw, prate, val, NULL, 0, clk->size);
}
static int zte_clk_regmap_div_determine_rate(struct clk_hw *hw,
struct clk_rate_request *req)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
return divider_determine_rate(hw, req, NULL, clk->size, 0);
}
static int zte_clk_regmap_div_set_rate(struct clk_hw *hw, unsigned long rate,
unsigned long parent_rate)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
unsigned int val;
int ret;
ret = divider_get_val(rate, parent_rate, NULL, clk->size, 0);
if (ret < 0)
return ret;
val = (unsigned int)ret << clk->shift;
return regmap_update_bits(clk->map, clk->reg, clk_div_mask(clk->size) << clk->shift, val);
}
static const struct clk_ops zte_clk_regmap_divider_ops = {
.recalc_rate = zte_clk_regmap_div_recalc_rate,
.determine_rate = zte_clk_regmap_div_determine_rate,
.set_rate = zte_clk_regmap_div_set_rate,
};
struct clk_hw *zx_clk_register_divider(struct device *dev, struct regmap *regmap,
const struct zx_div_desc *desc,
struct clk_hw * const *clocks)
{
return ERR_PTR(-ENODEV);
struct clk_parent_data parent = zx_get_parent(&desc->parent, clocks);
struct clk_init_data init = {};
struct zte_clk_regmap *clk;
int res;
clk = devm_kzalloc(dev, sizeof(*clk), GFP_KERNEL);
if (!clk)
return ERR_PTR(-ENOMEM);
init.name = desc->name;
init.ops = &zte_clk_regmap_divider_ops;
init.parent_data = &parent;
init.num_parents = 1;
init.flags = CLK_SET_RATE_PARENT;
clk->hw.init = &init;
clk->map = regmap;
clk->reg = desc->reg;
clk->shift = desc->shift;
clk->size = desc->size;
res = devm_clk_hw_register(dev, &clk->hw);
if (res)
return ERR_PTR(res);
return &clk->hw;
}
struct clk_hw *zx_clk_register_mux(struct device *dev, struct regmap *regmap,
const struct zx_mux_desc *desc,
struct clk_hw * const *clocks)
static u8 zte_clk_regmap_mux_get_parent(struct clk_hw *hw)
{
return ERR_PTR(-ENODEV);
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
unsigned int val;
int ret;
ret = regmap_read(clk->map, clk->reg, &val);
if (ret)
return 0xff;
val >>= clk->shift;
val &= GENMASK(clk->size - 1, 0);
return clk_mux_val_to_index(hw, NULL, 0, val);
}
static int zte_clk_regmap_mux_set_parent(struct clk_hw *hw, u8 index)
{
struct zte_clk_regmap *clk = to_zte_clk_regmap(hw);
unsigned int val = clk_mux_index_to_val(NULL, 0, index);
return regmap_update_bits(clk->map, clk->reg,
GENMASK(clk->size - 1, 0) << clk->shift,
val << clk->shift);
}
static int zte_clk_regmap_mux_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
{
return clk_mux_determine_rate_flags(hw, req, 0);
}
static const struct clk_ops zte_clk_regmap_mux_ops = {
.get_parent = zte_clk_regmap_mux_get_parent,
.set_parent = zte_clk_regmap_mux_set_parent,
.determine_rate = zte_clk_regmap_mux_determine_rate,
};
struct clk_hw *zx_clk_register_mux(struct device *dev, struct regmap *regmap,
const struct zx_mux_desc *desc, struct clk_hw * const *clocks)
{
struct clk_parent_data parents[CLK_ZX_MAX_PARENTS];
struct clk_init_data init = {};
struct zte_clk_regmap *clk;
unsigned int i;
int res;
if (WARN_ON(desc->num_parents > ARRAY_SIZE(parents)))
return ERR_PTR(-EINVAL);
for (i = 0; i < desc->num_parents; ++i)
parents[i] = zx_get_parent(&desc->parents[i], clocks);
clk = devm_kzalloc(dev, sizeof(*clk), GFP_KERNEL);
if (!clk)
return ERR_PTR(-ENOMEM);
init.name = desc->name;
init.ops = &zte_clk_regmap_mux_ops;
init.parent_data = parents;
init.num_parents = desc->num_parents;
clk->hw.init = &init;
clk->map = regmap;
clk->reg = desc->reg;
clk->shift = desc->shift;
clk->size = desc->size;
res = devm_clk_hw_register(dev, &clk->hw);
if (res)
return ERR_PTR(res);
return &clk->hw;
}