[PATCH v3 3/7] clk: spacemit: add reset controller support

Alex Elder
2025-04-09T21:17:50Z

Define ccu_reset_data as a structure that contains the constant
register offset and bitmasks used to assert and deassert a reset
control on a SpacemiT K1 CCU. Add a pointer to an array of those
structures to the spacemit_ccu_data structure, along with a field
indicating how many elements are in that array. Resets will be
optional, and if none are defined the reset array pointer will be
null.

Define a new ccu_reset_controller structure, which (for a CCU with
resets) contains a pointer to the constant reset data, the regmap
to be used for the controller, and an embedded a reset controller
structure.

Each reset control is asserted or deasserted by updating bits in
a register. The bits used are defined by an assert mask and a
deassert mask. In some cases, one (non-zero) mask asserts reset
and a different (non-zero) mask deasserts it. Otherwise one mask
is nonzero, and the other is zero. Either way, the bits in
both masks are cleared, then either the assert mask or the deassert
mask is set in a register to affect the state of a reset control.

Signed-off-by: Alex Elder <elder@riscstar.com>
---
v3: - The spacemit_ccu_data structure is now used, rather than
creating a new ccu_reset_controller_data structure
- There might have been a few other minor changes, but generally
all that's been done is a rebase on top of the new clock code

drivers/clk/spacemit/ccu-k1.c | 86 +++++++++++++++++++++++++++++++++--
1 file changed, 83 insertions(+), 3 deletions(-)

diff --git a/drivers/clk/spacemit/ccu-k1.c b/drivers/clk/spacemit/ccu-k1.c
index 8a8d228b46c3f..2a8c514be4b2c 100644
--- a/drivers/clk/spacemit/ccu-k1.c
+++ b/drivers/clk/spacemit/ccu-k1.c
@@ -11,6 +11,7 @@
#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/platform_device.h>
+#include <linux/reset-controller.h>

#include "ccu_common.h"
#include "ccu_pll.h"
@@ -129,9 +130,23 @@
#define APMU_EMAC0_CLK_RES_CTRL 0x3e4
#define APMU_EMAC1_CLK_RES_CTRL 0x3ec

+struct ccu_reset_data {
+ u32 offset;
+ u32 assert_mask;
+ u32 deassert_mask;
+};
+
struct spacemit_ccu_data {
- struct clk_hw **clk_hws;
+ struct clk_hw **clk_hws; /* array */
size_t clk_num;
+ const struct ccu_reset_data *reset_data; /* array */
+ size_t reset_num;
+};
+
+struct ccu_reset_controller {
+ struct regmap *regmap;
+ const struct spacemit_ccu_data *data;
+ struct reset_controller_dev rcdev;
};

/* APBS clocks start, APBS region contains and only contains all PLL clocks */
@@ -1200,6 +1215,39 @@ static const struct spacemit_ccu_data k1_ccu_apmu_data = {
.clk_num = ARRAY_SIZE(k1_ccu_apmu_hws),
};

+static int spacemit_reset_update(struct reset_controller_dev *rcdev,
+ unsigned long id, bool assert)
+{
+ struct ccu_reset_controller *controller;
+ const struct ccu_reset_data *data;
+ u32 mask;
+ u32 val;
+
+ controller = container_of(rcdev, struct ccu_reset_controller, rcdev);
+ data = &controller->data->reset_data[id];
+ mask = data->assert_mask | data->deassert_mask;
+ val = assert ? data->assert_mask : data->deassert_mask;
+
+ return regmap_update_bits(controller->regmap, data->offset, mask, val);
+}
+
+static int spacemit_reset_assert(struct reset_controller_dev *rcdev,
+ unsigned long id)
+{
+ return spacemit_reset_update(rcdev, id, true);
+}
+
+static int spacemit_reset_deassert(struct reset_controller_dev *rcdev,
+ unsigned long id)
+{
+ return spacemit_reset_update(rcdev, id, false);
+}
+
+static const struct reset_control_ops spacemit_reset_control_ops = {
+ .assert = spacemit_reset_assert,
+ .deassert = spacemit_reset_deassert,
+};
+
static int spacemit_ccu_register(struct device *dev,
struct regmap *regmap, struct regmap *lock_regmap,
const struct spacemit_ccu_data *data)
@@ -1247,9 +1295,37 @@ static int spacemit_ccu_register(struct device *dev,
return ret;
}

+static int spacemit_reset_controller_register(struct device *dev,
+ struct regmap *regmap,
+ const struct spacemit_ccu_data *data)
+{
+ struct ccu_reset_controller *controller;
+ struct reset_controller_dev *rcdev;
+
+ /* Resets are optional */
+ if (!data->reset_data)
+ return 0;
+
+ controller = devm_kzalloc(dev, sizeof(*controller), GFP_KERNEL);
+ if (!controller)
+ return -ENOMEM;
+
+ controller->regmap = regmap;
+ controller->data = data;
+
+ rcdev = &controller->rcdev;
+ rcdev->ops = &spacemit_reset_control_ops;
+ rcdev->owner = THIS_MODULE;
+ rcdev->of_node = dev->of_node;
+ rcdev->nr_resets = data->reset_num;
+
+ return devm_reset_controller_register(dev, rcdev);
+}
+
static int k1_ccu_probe(struct platform_device *pdev)
{
struct regmap *base_regmap, *lock_regmap = NULL;
+ const struct spacemit_ccu_data *data;
struct device *dev = &pdev->dev;
int ret;

@@ -1278,11 +1354,15 @@ static int k1_ccu_probe(struct platform_device *pdev)
"failed to get lock regmap\n");
}

- ret = spacemit_ccu_register(dev, base_regmap, lock_regmap,
- of_device_get_match_data(dev));
+ data = of_device_get_match_data(dev);
+ ret = spacemit_ccu_register(dev, base_regmap, lock_regmap, data);
if (ret)
return dev_err_probe(dev, ret, "failed to register clocks\n");

+ ret = spacemit_reset_controller_register(dev, base_regmap, data);
+ if (ret)
+ return dev_err_probe(dev, ret, "failed to register reset controller\n");
+
return 0;
}

--
2.45.2