clk: spacemit: set up reset auxiliary devices

Add a new reset_name field to the spacemit_ccu_data structure.  If it is
non-null, the CCU implements a reset controller, and the name will be
used in the name for the auxiliary device that implements it.

Define a new type to hold an auxiliary device as well as the regmap
pointer that will be needed by CCU reset controllers.  Set up code to
initialize and add an auxiliary device for any CCU that implements reset
functionality.

Make it optional for a CCU to implement a clock controller.  This
doesn't apply to any of the existing CCUs but will for some new ones
that will be added soon.

Signed-off-by: Alex Elder <elder@riscstar.com>
Reviewed-by: Haylen Chu <heylenay@4d2.org>
Reviewed-by: Yixun Lan <dlan@gentoo.org>
Link: https://lore.kernel.org/r/20250702113709.291748-4-elder@riscstar.com
Signed-off-by: Yixun Lan <dlan@gentoo.org>

diff --git a/drivers/clk/spacemit/Kconfig b/drivers/clk/spacemit/Kconfig
index 4c4df845b3cb2b03c84c1b07e878cdb50193d5d7..3854f6ae6d0eae17df1cb2fdd7ad5895f0254797 100644 (file)
--- a/drivers/clk/spacemit/Kconfig
+++ b/drivers/clk/spacemit/Kconfig
@@ -3,6 +3,7 @@
 config SPACEMIT_CCU
        tristate "Clock support for SpacemiT SoCs"
        depends on ARCH_SPACEMIT || COMPILE_TEST
+       select AUXILIARY_BUS
        select MFD_SYSCON
        help
          Say Y to enable clock controller unit support for SpacemiT SoCs.

diff --git a/drivers/clk/spacemit/ccu-k1.c b/drivers/clk/spacemit/ccu-k1.c
index 801150f4ff0f59666a95c402f4331af4df07831f..1c9ed434ae93eb231bee12e1cd7168cf0d169af1 100644 (file)
--- a/drivers/clk/spacemit/ccu-k1.c
+++ b/drivers/clk/spacemit/ccu-k1.c
@@ -5,12 +5,15 @@
  */
 
 #include <linux/array_size.h>
+#include <linux/auxiliary_bus.h>
 #include <linux/clk-provider.h>
 #include <linux/delay.h>
+#include <linux/idr.h>
 #include <linux/mfd/syscon.h>
 #include <linux/minmax.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
+#include <linux/slab.h>
 #include <soc/spacemit/k1-syscon.h>
 
 #include "ccu_common.h"
@@ -21,10 +24,13 @@
 #include <dt-bindings/clock/spacemit,k1-syscon.h>
 
 struct spacemit_ccu_data {
+       const char *reset_name;
        struct clk_hw **hws;
        size_t num;
 };
 
+static DEFINE_IDA(auxiliary_ids);
+
 /* APBS clocks start, APBS region contains and only contains all PLL clocks */
 
 /*
@@ -710,8 +716,9 @@ static struct clk_hw *k1_ccu_pll_hws[] = {
 };
 
 static const struct spacemit_ccu_data k1_ccu_pll_data = {
-       .hws    = k1_ccu_pll_hws,
-       .num    = ARRAY_SIZE(k1_ccu_pll_hws),
+       /* The PLL CCU implements no resets */
+       .hws            = k1_ccu_pll_hws,
+       .num            = ARRAY_SIZE(k1_ccu_pll_hws),
 };
 
 static struct clk_hw *k1_ccu_mpmu_hws[] = {
@@ -751,8 +758,9 @@ static struct clk_hw *k1_ccu_mpmu_hws[] = {
 };
 
 static const struct spacemit_ccu_data k1_ccu_mpmu_data = {
-       .hws    = k1_ccu_mpmu_hws,
-       .num    = ARRAY_SIZE(k1_ccu_mpmu_hws),
+       .reset_name     = "mpmu-reset",
+       .hws            = k1_ccu_mpmu_hws,
+       .num            = ARRAY_SIZE(k1_ccu_mpmu_hws),
 };
 
 static struct clk_hw *k1_ccu_apbc_hws[] = {
@@ -859,8 +867,9 @@ static struct clk_hw *k1_ccu_apbc_hws[] = {
 };
 
 static const struct spacemit_ccu_data k1_ccu_apbc_data = {
-       .hws    = k1_ccu_apbc_hws,
-       .num    = ARRAY_SIZE(k1_ccu_apbc_hws),
+       .reset_name     = "apbc-reset",
+       .hws            = k1_ccu_apbc_hws,
+       .num            = ARRAY_SIZE(k1_ccu_apbc_hws),
 };
 
 static struct clk_hw *k1_ccu_apmu_hws[] = {
@@ -929,8 +938,9 @@ static struct clk_hw *k1_ccu_apmu_hws[] = {
 };
 
 static const struct spacemit_ccu_data k1_ccu_apmu_data = {
-       .hws    = k1_ccu_apmu_hws,
-       .num    = ARRAY_SIZE(k1_ccu_apmu_hws),
+       .reset_name     = "apmu-reset",
+       .hws            = k1_ccu_apmu_hws,
+       .num            = ARRAY_SIZE(k1_ccu_apmu_hws),
 };
 
 static int spacemit_ccu_register(struct device *dev,
@@ -941,6 +951,10 @@ static int spacemit_ccu_register(struct device *dev,
        struct clk_hw_onecell_data *clk_data;
        int i, ret;
 
+       /* Nothing to do if the CCU does not implement any clocks */
+       if (!data->hws)
+               return 0;
+
        clk_data = devm_kzalloc(dev, struct_size(clk_data, hws, data->num),
                                GFP_KERNEL);
        if (!clk_data)
@@ -981,9 +995,74 @@ static int spacemit_ccu_register(struct device *dev,
        return ret;
 }
 
+static void spacemit_cadev_release(struct device *dev)
+{
+       struct auxiliary_device *adev = to_auxiliary_dev(dev);
+
+       ida_free(&auxiliary_ids, adev->id);
+       kfree(to_spacemit_ccu_adev(adev));
+}
+
+static void spacemit_adev_unregister(void *data)
+{
+       struct auxiliary_device *adev = data;
+
+       auxiliary_device_delete(adev);
+       auxiliary_device_uninit(adev);
+}
+
+static int spacemit_ccu_reset_register(struct device *dev,
+                                      struct regmap *regmap,
+                                      const char *reset_name)
+{
+       struct spacemit_ccu_adev *cadev;
+       struct auxiliary_device *adev;
+       int ret;
+
+       /* Nothing to do if the CCU does not implement a reset controller */
+       if (!reset_name)
+               return 0;
+
+       cadev = kzalloc(sizeof(*cadev), GFP_KERNEL);
+       if (!cadev)
+               return -ENOMEM;
+
+       cadev->regmap = regmap;
+
+       adev = &cadev->adev;
+       adev->name = reset_name;
+       adev->dev.parent = dev;
+       adev->dev.release = spacemit_cadev_release;
+       adev->dev.of_node = dev->of_node;
+       ret = ida_alloc(&auxiliary_ids, GFP_KERNEL);
+       if (ret < 0)
+               goto err_free_cadev;
+       adev->id = ret;
+
+       ret = auxiliary_device_init(adev);
+       if (ret)
+               goto err_free_aux_id;
+
+       ret = auxiliary_device_add(adev);
+       if (ret) {
+               auxiliary_device_uninit(adev);
+               return ret;
+       }
+
+       return devm_add_action_or_reset(dev, spacemit_adev_unregister, adev);
+
+err_free_aux_id:
+       ida_free(&auxiliary_ids, adev->id);
+err_free_cadev:
+       kfree(cadev);
+
+       return ret;
+}
+
 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;
 
@@ -1012,11 +1091,16 @@ 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_ccu_reset_register(dev, base_regmap, data->reset_name);
+       if (ret)
+               return dev_err_probe(dev, ret, "failed to register resets\n");
+
        return 0;
 }
 

diff --git a/include/soc/spacemit/k1-syscon.h b/include/soc/spacemit/k1-syscon.h
index 039a448c51a0709e2bdb140350a83b96e2a2f6b7..53eff7691f33d1cf25f17b77e6e0781a7c954ffb 100644 (file)
--- a/include/soc/spacemit/k1-syscon.h
+++ b/include/soc/spacemit/k1-syscon.h
@@ -5,6 +5,18 @@
 #ifndef __SOC_K1_SYSCON_H__
 #define __SOC_K1_SYSCON_H__
 
+/* Auxiliary device used to represent a CCU reset controller */
+struct spacemit_ccu_adev {
+       struct auxiliary_device adev;
+       struct regmap *regmap;
+};
+
+static inline struct spacemit_ccu_adev *
+to_spacemit_ccu_adev(struct auxiliary_device *adev)
+{
+       return container_of(adev, struct spacemit_ccu_adev, adev);
+}
+
 /* APBS register offset */
 #define APBS_PLL1_SWCR1                        0x100
 #define APBS_PLL1_SWCR2                        0x104