Skip to contentSkip to conversation

Introduce MediaTek CCI devfreq driver

PATCH RESEND Superseded Johnson Wang 3 participants 10 messages May 13, 2022 – May 20, 2022

Subsystems (4)

v4 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v4 cover Introduce MediaTek CCI devfreq driver

The Cache Coherent Interconnect (CCI) is the management of cache coherency by hardware. CCI DEVFREQ is DVFS driver for power saving by scaling clock frequency and supply voltage of CCI. CCI uses the same input clock source and power rail as LITTLE CPUs on Mediatek SoCs.

This series depends on:
Chanwoo's repo: kernel/git/chanwoo/linux.git
branch: devfreq-testing
[1]: PM / devfreq: Export devfreq_get_freq_range symbol within devfreq [2]: PM / devfreq: Add cpu based scaling support to passive governor [3]: PM / devfreq: passive: Reduce duplicate code when passive_devfreq case [4]: PM / devfreq: passive: Update frequency when start governor

Resend v4:
- CC interconnect maintainer.
- Change sign-off sequence in commit message.

Changes in v4:
- Add a maintainer in the binding document.
- Modify clock description.
- Add binding document into MAINTAINERS.
- Replace format specifier %d with %ld.

Changes in v3:
- Move binding document to 'interconnect' and rename it.
- Add COMPILE_TEST dependence symbol.
- Remove need_voltage_tracking variable.
- Move mtk_ccifreq_voltage_tracking() code into mtk_ccifreq_set_voltage().
- Add an interation limit in the while() loop.
- Replace 'cci_dev' with 'dev'
- Replace old_* with pre_*
- Remove of_match_ptr()
- Use module_platform_driver()

Changes in v2:
- Take MT8183 as example in binding document.
- Use dev_err() instead of pr_err().
- Use 'goto' statement to handle error case.
- Clean up driver code.

Johnson Wang (2):
dt-bindings: interconnect: Add MediaTek CCI dt-bindings PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

 .../bindings/interconnect/mediatek,cci.yaml   | 140 ++++++
 MAINTAINERS                                   |   1 +
 drivers/devfreq/Kconfig                       |  10 +
 drivers/devfreq/Makefile                      |   1 +
 drivers/devfreq/mtk-cci-devfreq.c             | 474 ++++++++++++++++++
 5 files changed, 626 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
Signature · 1 line
2.18.0
#1 lore raw

PATCH RESEND v4 1/2 dt-bindings: interconnect: Add MediaTek CCI dt-bindings

Add devicetree binding of MediaTek CCI on MT8183 and MT8186.

---
 .../bindings/interconnect/mediatek,cci.yaml   | 140 ++++++++++++++++++
 MAINTAINERS                                   |   1 +
 2 files changed, 141 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml
Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +140 -0
new file mode 100644
index 000000000000..034c3b38ca3d
@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/interconnect/mediatek,cci.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: MediaTek Cache Coherent Interconnect (CCI) frequency and voltage scaling
+
+maintainers:
+  - Jia-Wei Chang <[email protected]>
+  - Johnson Wang <[email protected]>
+
+description: |
+  MediaTek Cache Coherent Interconnect (CCI) is a hardware engine used by
+  MT8183 and MT8186 SoCs to scale the frequency and adjust the voltage in
+  hardware. It can also optimize the voltage to reduce the power consumption.
+
+properties:
+  compatible:
+    enum:
+      - mediatek,mt8183-cci
+      - mediatek,mt8186-cci
+
+  clocks:
+    items:
+      - description:
+          The multiplexer for clock input of the bus.
+      - description:
+          A parent of "cpu" clock which is used as an intermediate clock source
+          when the original CPU is under transition and not stable yet.
+
+  clock-names:
+    items:
+      - const: cci
+      - const: intermediate
+
+  operating-points-v2: true
+  opp-table: true
+
+  proc-supply:
+    description:
+      Phandle of the regulator for CCI that provides the supply voltage.
+
+  sram-supply:
+    description:
+      Phandle of the regulator for sram of CCI that provides the supply
+      voltage. When it is present, the implementation needs to do
+      "voltage tracking" to step by step scale up/down Vproc and Vsram to fit
+      SoC specific needs. When absent, the voltage scaling flow is handled by
+      hardware, hence no software "voltage tracking" is needed.
+
+required:
+  - compatible
+  - clocks
+  - clock-names
+  - operating-points-v2
+  - proc-supply
+
+additionalProperties: false
+
+examples:
+  - |
+    #include <dt-bindings/clock/mt8183-clk.h>
+    cci: cci {
+        compatible = "mediatek,mt8183-cci";
+        clocks = <&mcucfg CLK_MCU_BUS_SEL>,
+                 <&topckgen CLK_TOP_ARMPLL_DIV_PLL1>;
+        clock-names = "cci", "intermediate";
+        operating-points-v2 = <&cci_opp>;
+        proc-supply = <&mt6358_vproc12_reg>;
+    };
+
+    cci_opp: opp-table-cci {
+        compatible = "operating-points-v2";
+        opp-shared;
+        opp2_00: opp-273000000 {
+            opp-hz = /bits/ 64 <273000000>;
+            opp-microvolt = <650000>;
+        };
+        opp2_01: opp-338000000 {
+            opp-hz = /bits/ 64 <338000000>;
+            opp-microvolt = <687500>;
+        };
+        opp2_02: opp-403000000 {
+            opp-hz = /bits/ 64 <403000000>;
+            opp-microvolt = <718750>;
+        };
+        opp2_03: opp-463000000 {
+            opp-hz = /bits/ 64 <463000000>;
+            opp-microvolt = <756250>;
+        };
+        opp2_04: opp-546000000 {
+            opp-hz = /bits/ 64 <546000000>;
+            opp-microvolt = <800000>;
+        };
+        opp2_05: opp-624000000 {
+            opp-hz = /bits/ 64 <624000000>;
+            opp-microvolt = <818750>;
+        };
+        opp2_06: opp-689000000 {
+            opp-hz = /bits/ 64 <689000000>;
+            opp-microvolt = <850000>;
+        };
+        opp2_07: opp-767000000 {
+            opp-hz = /bits/ 64 <767000000>;
+            opp-microvolt = <868750>;
+        };
+        opp2_08: opp-845000000 {
+            opp-hz = /bits/ 64 <845000000>;
+            opp-microvolt = <893750>;
+        };
+        opp2_09: opp-871000000 {
+            opp-hz = /bits/ 64 <871000000>;
+            opp-microvolt = <906250>;
+        };
+        opp2_10: opp-923000000 {
+            opp-hz = /bits/ 64 <923000000>;
+            opp-microvolt = <931250>;
+        };
+        opp2_11: opp-962000000 {
+            opp-hz = /bits/ 64 <962000000>;
+            opp-microvolt = <943750>;
+        };
+        opp2_12: opp-1027000000 {
+            opp-hz = /bits/ 64 <1027000000>;
+            opp-microvolt = <975000>;
+        };
+        opp2_13: opp-1092000000 {
+            opp-hz = /bits/ 64 <1092000000>;
+            opp-microvolt = <1000000>;
+        };
+        opp2_14: opp-1144000000 {
+            opp-hz = /bits/ 64 <1144000000>;
+            opp-microvolt = <1025000>;
+        };
+        opp2_15: opp-1196000000 {
+            opp-hz = /bits/ 64 <1196000000>;
+            opp-microvolt = <1050000>;
+        };
+    };
MAINTAINERS +1 -0
index e8c52d0192a6..69f03077f77c 100644
@@ -5698,6 +5698,7 @@ L:	[email protected]
 S:	Maintained
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git
 F:	Documentation/devicetree/bindings/devfreq/
+F:	Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml
 F:	drivers/devfreq/
 F:	include/linux/devfreq.h
 F:	include/trace/events/devfreq.h
Signature · 1 line
2.18.0
Reviewed-by on v4 1/2
#2 lore raw

Re: [RESEND v4 1/2] dt-bindings: interconnect: Add MediaTek CCI dt-bindings

Quoted 38 lines · Johnson Wang

Add devicetree binding of MediaTek CCI on MT8183 and MT8186.

---
 .../bindings/interconnect/mediatek,cci.yaml   | 140 ++++++++++++++++++
 MAINTAINERS                                   |   1 +
 2 files changed, 141 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml
Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +19 -0
new file mode 100644
index 000000000000..034c3b38ca3d
@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: http://devicetree.org/schemas/interconnect/mediatek,cci.yaml#
+$schema: http://devicetree.org/meta-schemas/core.yaml#
+
+title: MediaTek Cache Coherent Interconnect (CCI) frequency and voltage scaling
+
+maintainers:
+  - Jia-Wei Chang <[email protected]>
+  - Johnson Wang <[email protected]>
+
+description: |
+  MediaTek Cache Coherent Interconnect (CCI) is a hardware engine used by
+  MT8183 and MT8186 SoCs to scale the frequency and adjust the voltage in
+  hardware. It can also optimize the voltage to reduce the power consumption.
+
+properties:
+  compatible:

Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml line 29

Quoted 10 lines
Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +10 -0
+    enum:
+      - mediatek,mt8183-cci
+      - mediatek,mt8186-cci
+
+  clocks:
+    items:
+      - description:
+          The multiplexer for clock input of the bus.
+      - description:
+          A parent of "cpu" clock which is used as an intermediate clock source

Replace "cpu" with "bus"?

Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml line 30

Quoted 1 line
Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +1 -0
+          when the original CPU is under transition and not stable yet.

And also, "when the original clock source (PLL) is under transition ..."

Otherwise,

#3 lore raw

Re: [RESEND v4 1/2] dt-bindings: interconnect: Add MediaTek CCI dt-bindings

Quoted 71 lines · Chen-Yu Tsai
Quoted 61 lines · Johnson Wang

Add devicetree binding of MediaTek CCI on MT8183 and MT8186.

---
 .../bindings/interconnect/mediatek,cci.yaml   | 140
++++++++++++++++++
 MAINTAINERS                                   |   1 +
 2 files changed, 141 insertions(+)
 create mode 100644

Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml

diff --git a/Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml b/Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file mode 100644
index 000000000000..034c3b38ca3d
--- /dev/null
+++
b/Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml

Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +4 -0
@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+%YAML 1.2
+---
+$id: 

https://urldefense.com/v3/__http://devicetree.org/schemas/interconnect/mediatek,cci.yaml*__;Iw!!CTRNKA9wMg0ARbw!0vYE2yw5meNp-VKz6-Xp4C_qT8rz0tpzc0iPAGI__dVczbtBVpOcQfxdrQADjIdqtgDrrni0ZKWuBFP1QcwD0mHhOw$

+$schema:
https://urldefense.com/v3/__http://devicetree.org/meta-schemas/core.yaml*__;Iw!!CTRNKA9wMg0ARbw!0vYE2yw5meNp-VKz6-Xp4C_qT8rz0tpzc0iPAGI__dVczbtBVpOcQfxdrQADjIdqtgDrrni0ZKWuBFP1QcxLQ8hn_A$

(quoted diff) +2 -0
+
+title: MediaTek Cache Coherent Interconnect (CCI) frequency and

voltage scaling

Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +7 -0
+
+maintainers:
+  - Jia-Wei Chang <[email protected]>
+  - Johnson Wang <[email protected]>
+
+description: |
+  MediaTek Cache Coherent Interconnect (CCI) is a hardware engine

used by
+ MT8183 and MT8186 SoCs to scale the frequency and adjust the voltage in
+ hardware. It can also optimize the voltage to reduce the power consumption.

Documentation/devicetree/bindings/interconnect/mediatek,cci.yaml new file +13 -0
+
+properties:
+  compatible:
+    enum:
+      - mediatek,mt8183-cci
+      - mediatek,mt8186-cci
+
+  clocks:
+    items:
+      - description:
+          The multiplexer for clock input of the bus.
+      - description:
+          A parent of "cpu" clock which is used as an intermediate
Quoted 1 line

clock source

Replace "cpu" with "bus"?

Quoted 2 lines

+ when the original CPU is under transition and not stable
yet.

Quoted 6 lines

And also, "when the original clock source (PLL) is under transition ..."

Otherwise,

Hi Chen-Yu,

I will modify them in the next version.

BRs,
Johnson Wang

#4 lore raw

PATCH RESEND v4 2/2 PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

In reply to Johnson Wang

We introduce a devfreq driver for the MediaTek Cache Coherent Interconnect (CCI) used by some MediaTek SoCs.

In this driver, we use the passive devfreq driver to get target frequencies and adjust voltages accordingly. In MT8183 and MT8186, the MediaTek CCI is supplied by the same regulators with the little core CPUs.

---
This patch depends on "devfreq-testing"[1]. [1]https://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git/log/?h=devfreq-testing

---
 drivers/devfreq/Kconfig           |  10 +
 drivers/devfreq/Makefile          |   1 +
 drivers/devfreq/mtk-cci-devfreq.c | 474 ++++++++++++++++++++++++++++++
 3 files changed, 485 insertions(+)
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
drivers/devfreq/Kconfig +10 -0
index 87eb2b837e68..9754d8b31621 100644
@@ -120,6 +120,16 @@ config ARM_TEGRA_DEVFREQ
 	  It reads ACTMON counters of memory controllers and adjusts the
 	  operating frequencies and voltages with OPP support.
 
+config ARM_MEDIATEK_CCI_DEVFREQ
+	tristate "MEDIATEK CCI DEVFREQ Driver"
+	depends on ARM_MEDIATEK_CPUFREQ || COMPILE_TEST
+	select DEVFREQ_GOV_PASSIVE
+	help
+	  This adds a devfreq driver for MediaTek Cache Coherent Interconnect
+	  which is shared the same regulators with the cpu cluster. It can track
+	  buck voltages and update a proper CCI frequency. Use the notification
+	  to get the regulator status.
+
 config ARM_RK3399_DMC_DEVFREQ
 	tristate "ARM RK3399 DMC DEVFREQ Driver"
 	depends on (ARCH_ROCKCHIP && HAVE_ARM_SMCCC) || \
drivers/devfreq/Makefile +1 -0
index 0b6be92a25d9..bf40d04928d0 100644
@@ -11,6 +11,7 @@ obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)	+= governor_passive.o
 obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ)	+= exynos-bus.o
 obj-$(CONFIG_ARM_IMX_BUS_DEVFREQ)	+= imx-bus.o
 obj-$(CONFIG_ARM_IMX8M_DDRC_DEVFREQ)	+= imx8m-ddrc.o
+obj-$(CONFIG_ARM_MEDIATEK_CCI_DEVFREQ)	+= mtk-cci-devfreq.o
 obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ)	+= rk3399_dmc.o
 obj-$(CONFIG_ARM_SUN8I_A33_MBUS_DEVFREQ)	+= sun8i-a33-mbus.o
 obj-$(CONFIG_ARM_TEGRA_DEVFREQ)		+= tegra30-devfreq.o
drivers/devfreq/mtk-cci-devfreq.c new file +474 -0

474 lines not on this page · raw message

Signature · 1 line
2.18.0
#5 lore raw

Re: [RESEND v4 2/2] PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

Quoted 213 lines · Johnson Wang

We introduce a devfreq driver for the MediaTek Cache Coherent Interconnect (CCI) used by some MediaTek SoCs.

In this driver, we use the passive devfreq driver to get target frequencies and adjust voltages accordingly. In MT8183 and MT8186, the MediaTek CCI is supplied by the same regulators with the little core CPUs.

---
This patch depends on "devfreq-testing"[1]. [1]https://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git/log/?h=devfreq-testing

---
 drivers/devfreq/Kconfig           |  10 +
 drivers/devfreq/Makefile          |   1 +
 drivers/devfreq/mtk-cci-devfreq.c | 474 ++++++++++++++++++++++++++++++
 3 files changed, 485 insertions(+)
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
drivers/devfreq/Kconfig +10 -0
index 87eb2b837e68..9754d8b31621 100644
@@ -120,6 +120,16 @@ config ARM_TEGRA_DEVFREQ
          It reads ACTMON counters of memory controllers and adjusts the
          operating frequencies and voltages with OPP support.
 
+config ARM_MEDIATEK_CCI_DEVFREQ
+       tristate "MEDIATEK CCI DEVFREQ Driver"
+       depends on ARM_MEDIATEK_CPUFREQ || COMPILE_TEST
+       select DEVFREQ_GOV_PASSIVE
+       help
+         This adds a devfreq driver for MediaTek Cache Coherent Interconnect
+         which is shared the same regulators with the cpu cluster. It can track
+         buck voltages and update a proper CCI frequency. Use the notification
+         to get the regulator status.
+
 config ARM_RK3399_DMC_DEVFREQ
        tristate "ARM RK3399 DMC DEVFREQ Driver"
        depends on (ARCH_ROCKCHIP && HAVE_ARM_SMCCC) || \
drivers/devfreq/Makefile +1 -0
index 0b6be92a25d9..bf40d04928d0 100644
@@ -11,6 +11,7 @@ obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)     += governor_passive.o
 obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ)   += exynos-bus.o
 obj-$(CONFIG_ARM_IMX_BUS_DEVFREQ)      += imx-bus.o
 obj-$(CONFIG_ARM_IMX8M_DDRC_DEVFREQ)   += imx8m-ddrc.o
+obj-$(CONFIG_ARM_MEDIATEK_CCI_DEVFREQ) += mtk-cci-devfreq.o
 obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ)   += rk3399_dmc.o
 obj-$(CONFIG_ARM_SUN8I_A33_MBUS_DEVFREQ)       += sun8i-a33-mbus.o
 obj-$(CONFIG_ARM_TEGRA_DEVFREQ)                += tegra30-devfreq.o
drivers/devfreq/mtk-cci-devfreq.c new file +153 -0
new file mode 100644
index 000000000000..aa8c37eb4a06
@@ -0,0 +1,474 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2022 MediaTek Inc.
+ */
+
+#include <linux/clk.h>
+#include <linux/devfreq.h>
+#include <linux/minmax.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/pm_opp.h>
+#include <linux/regulator/consumer.h>
+
+struct mtk_ccifreq_platform_data {
+       int min_volt_shift;
+       int max_volt_shift;
+       int proc_max_volt;
+       int sram_min_volt;
+       int sram_max_volt;
+};
+
+struct mtk_ccifreq_drv {
+       struct device *dev;
+       struct devfreq *devfreq;
+       struct regulator *proc_reg;
+       struct regulator *sram_reg;
+       struct clk *cci_clk;
+       struct clk *inter_clk;
+       int inter_voltage;
+       int pre_voltage;
+       unsigned long pre_freq;
+       /* Avoid race condition for regulators between notify and policy */
+       struct mutex reg_lock;
+       struct notifier_block opp_nb;
+       const struct mtk_ccifreq_platform_data *soc_data;
+       int vtrack_max;
+};
+
+static int mtk_ccifreq_set_voltage(struct mtk_ccifreq_drv *drv, int new_voltage)
+{
+       const struct mtk_ccifreq_platform_data *soc_data = drv->soc_data;
+       struct device *dev = drv->dev;
+       int pre_voltage, pre_vsram, new_vsram, vsram, voltage, ret;
+       int retry_max = drv->vtrack_max;
+
+       if (!drv->sram_reg) {
+               ret = regulator_set_voltage(drv->proc_reg, new_voltage,
+                                           drv->soc_data->proc_max_volt);
+               goto out_set_voltage;
+       }
+
+       pre_voltage = regulator_get_voltage(drv->proc_reg);
+       if (pre_voltage < 0) {
+               dev_err(dev, "invalid vproc value: %d\n", pre_voltage);
+               return pre_voltage;
+       }
+
+       pre_vsram = regulator_get_voltage(drv->sram_reg);
+       if (pre_vsram < 0) {
+               dev_err(dev, "invalid vsram value: %d\n", pre_vsram);
+               return pre_vsram;
+       }
+
+       new_vsram = clamp(new_voltage + soc_data->min_volt_shift,
+                         soc_data->sram_min_volt, soc_data->sram_max_volt);
+
+       do {
+               if (pre_voltage <= new_voltage) {
+                       vsram = clamp(pre_voltage + soc_data->max_volt_shift,
+                                     soc_data->sram_min_volt, new_vsram);
+                       ret = regulator_set_voltage(drv->sram_reg, vsram,
+                                                   soc_data->sram_max_volt);
+                       if (ret)
+                               return ret;
+
+                       if (vsram == soc_data->sram_max_volt ||
+                           new_vsram == soc_data->sram_min_volt)
+                               voltage = new_voltage;
+                       else
+                               voltage = vsram - soc_data->min_volt_shift;
+
+                       ret = regulator_set_voltage(drv->proc_reg, voltage,
+                                                   soc_data->proc_max_volt);
+                       if (ret) {
+                               regulator_set_voltage(drv->sram_reg, pre_vsram,
+                                                     soc_data->sram_max_volt);
+                               return ret;
+                       }
+               } else if (pre_voltage > new_voltage) {
+                       voltage = max(new_voltage,
+                                     pre_vsram - soc_data->max_volt_shift);
+                       ret = regulator_set_voltage(drv->proc_reg, voltage,
+                                                   soc_data->proc_max_volt);
+                       if (ret)
+                               return ret;
+
+                       if (voltage == new_voltage)
+                               vsram = new_vsram;
+                       else
+                               vsram = max(new_vsram,
+                                           voltage + soc_data->min_volt_shift);
+
+                       ret = regulator_set_voltage(drv->sram_reg, vsram,
+                                                   soc_data->sram_max_volt);
+                       if (ret) {
+                               regulator_set_voltage(drv->proc_reg, pre_voltage,
+                                                     soc_data->proc_max_volt);
+                               return ret;
+                       }
+               }
+
+               pre_voltage = voltage;
+               pre_vsram = vsram;
+
+               if (--retry_max < 0) {
+                       dev_err(dev,
+                               "over loop count, failed to set voltage\n");
+                       return -EINVAL;
+               }
+       } while (voltage != new_voltage || vsram != new_vsram);
+
+out_set_voltage:
+       if (!ret)
+               drv->pre_voltage = new_voltage;
+
+       return ret;
+}
+
+static int mtk_ccifreq_target(struct device *dev, unsigned long *freq,
+                             u32 flags)
+{
+       struct mtk_ccifreq_drv *drv = dev_get_drvdata(dev);
+       struct clk *cci_pll = clk_get_parent(drv->cci_clk);
+       struct dev_pm_opp *opp;
+       unsigned long opp_rate;
+       int voltage, pre_voltage, inter_voltage, target_voltage, ret;
+
+       if (!drv)
+               return -EINVAL;
+
+       if (drv->pre_freq == *freq)
+               return 0;
+
+       inter_voltage = drv->inter_voltage;
+
+       opp_rate = *freq;
+       opp = devfreq_recommended_opp(dev, &opp_rate, 1);
+       if (IS_ERR(opp)) {
+               dev_err(dev, "failed to find opp for freq: %ld\n", opp_rate);
+               return PTR_ERR(opp);
+       }

drivers/devfreq/mtk-cci-devfreq.c line 163

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+
+       mutex_lock(&drv->reg_lock);
+
+       voltage = dev_pm_opp_get_voltage(opp);
+       dev_pm_opp_put(opp);
+
+       if (unlikely(drv->pre_voltage <= 0))
+               pre_voltage = regulator_get_voltage(drv->proc_reg);
+       else
+               pre_voltage = drv->pre_voltage;

Could you explain why the previous voltage setting is cached like this?

The CCI is sharing the regulator supply with one of the CPU clusters, and cpufreq could also change the voltage, so it's better to always retrieve the current setting directly from the regulator core. And those values might be cached iun the core, so it's unlikely to incur a significant cost.

Quoted 131 lines
drivers/devfreq/mtk-cci-devfreq.c new file +131 -0
+
+       if (pre_voltage < 0) {
+               dev_err(dev, "invalid vproc value: %d\n", pre_voltage);
+               return pre_voltage;
+       }
+
+       /* scale up: set voltage first then freq. */
+       target_voltage = max(inter_voltage, voltage);
+       if (pre_voltage <= target_voltage) {
+               ret = mtk_ccifreq_set_voltage(drv, target_voltage);
+               if (ret) {
+                       dev_err(dev, "failed to scale up voltage\n");
+                       goto out_restore_voltage;
+               }
+       }
+
+       /* switch the cci clock to intermediate clock source. */
+       ret = clk_set_parent(drv->cci_clk, drv->inter_clk);
+       if (ret) {
+               dev_err(dev, "failed to re-parent cci clock\n");
+               goto out_restore_voltage;
+       }
+
+       /* set the original clock to target rate. */
+       ret = clk_set_rate(cci_pll, *freq);
+       if (ret) {
+               dev_err(dev, "failed to set cci pll rate: %d\n", ret);
+               clk_set_parent(drv->cci_clk, cci_pll);
+               goto out_restore_voltage;
+       }
+
+       /* switch the cci clock back to the original clock source. */
+       ret = clk_set_parent(drv->cci_clk, cci_pll);
+       if (ret) {
+               dev_err(dev, "failed to re-parent cci clock\n");
+               mtk_ccifreq_set_voltage(drv, inter_voltage);
+               goto out_unlock;
+       }
+
+       /*
+        * If the new voltage is lower than the intermediate voltage or the
+        * original voltage, scale down to the new voltage.
+        */
+       if (voltage < inter_voltage || voltage < pre_voltage) {
+               ret = mtk_ccifreq_set_voltage(drv, voltage);
+               if (ret) {
+                       dev_err(dev, "failed to scale down voltage\n");
+                       goto out_unlock;
+               }
+       }
+
+       drv->pre_freq = *freq;
+       mutex_unlock(&drv->reg_lock);
+
+       return 0;
+
+out_restore_voltage:
+       mtk_ccifreq_set_voltage(drv, pre_voltage);
+
+out_unlock:
+       mutex_unlock(&drv->reg_lock);
+       return ret;
+}
+
+static int mtk_ccifreq_opp_notifier(struct notifier_block *nb,
+                                   unsigned long event, void *data)
+{
+       struct dev_pm_opp *opp = data;
+       struct mtk_ccifreq_drv *drv;
+       unsigned long freq, volt;
+
+       drv = container_of(nb, struct mtk_ccifreq_drv, opp_nb);
+
+       if (event == OPP_EVENT_ADJUST_VOLTAGE) {
+               freq = dev_pm_opp_get_freq(opp);
+
+               mutex_lock(&drv->reg_lock);
+               /* current opp item is changed */
+               if (freq == drv->pre_freq) {
+                       volt = dev_pm_opp_get_voltage(opp);
+                       mtk_ccifreq_set_voltage(drv, volt);
+               }
+               mutex_unlock(&drv->reg_lock);
+       }
+
+       return 0;
+}
+
+static struct devfreq_dev_profile mtk_ccifreq_profile = {
+       .target = mtk_ccifreq_target,
+};
+
+static int mtk_ccifreq_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct mtk_ccifreq_drv *drv;
+       struct devfreq_passive_data *passive_data;
+       struct dev_pm_opp *opp;
+       unsigned long rate, opp_volt;
+       int ret;
+
+       drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);
+       if (!drv)
+               return -ENOMEM;
+
+       drv->dev = dev;
+       drv->soc_data = (const struct mtk_ccifreq_platform_data *)
+                               of_device_get_match_data(&pdev->dev);
+       mutex_init(&drv->reg_lock);
+       platform_set_drvdata(pdev, drv);
+
+       drv->cci_clk = devm_clk_get(dev, "cci");
+       if (IS_ERR(drv->cci_clk)) {
+               ret = PTR_ERR(drv->cci_clk);
+               return dev_err_probe(dev, ret,
+                                    "failed to get cci clk: %d\n", ret);
+       }
+
+       drv->inter_clk = devm_clk_get(dev, "intermediate");
+       if (IS_ERR(drv->inter_clk)) {
+               ret = PTR_ERR(drv->inter_clk);
+               dev_err_probe(dev, ret,
+                             "failed to get intermediate clk: %d\n", ret);
+               goto out_free_resources;
+       }
+
+       drv->proc_reg = devm_regulator_get_optional(dev, "proc");
+       if (IS_ERR(drv->proc_reg)) {
+               ret = PTR_ERR(drv->proc_reg);
+               dev_err_probe(dev, ret,
+                             "failed to get proc regulator: %d\n", ret);

drivers/devfreq/mtk-cci-devfreq.c line 304

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+               goto out_free_resources;
+       }
+
+       ret = regulator_enable(drv->proc_reg);
+       if (ret) {
+               dev_err(dev, "failed to enable proc regulator\n");
+               goto out_free_resources;
+       }
+
+       drv->sram_reg = regulator_get_optional(dev, "sram");

devm_ for this as well?

Quoted 4 lines
drivers/devfreq/mtk-cci-devfreq.c new file +4 -0
+       if (IS_ERR(drv->sram_reg))
+               drv->sram_reg = NULL;
+       else {
+               ret = regulator_enable(drv->sram_reg);

drivers/devfreq/mtk-cci-devfreq.c line 318

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+               if (ret) {
+                       dev_err(dev, "failed to enable sram regulator\n");
+                       goto out_free_resources;
+               }
+       }
+
+       /*
+        * We assume min voltage is 0 and tracking target voltage using
+        * min_volt_shift for each iteration.
+        * The retry_max is 3 times of expeted iteration count.

expected?

drivers/devfreq/mtk-cci-devfreq.c line 328

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+        */
+       drv->vtrack_max = 3 * DIV_ROUND_UP(max(drv->soc_data->sram_max_volt,
+                                              drv->soc_data->proc_max_volt),
+                                          drv->soc_data->min_volt_shift);
+
+       ret = clk_prepare_enable(drv->cci_clk);
+       if (ret)
+               goto out_free_resources;
+
+       ret = clk_prepare_enable(drv->inter_clk);

You don't need to enable the intermediate clock here. You shouldn't need to at all, as the CCF core will do it when the CCI clock is reparented over to it.

Quoted 78 lines
drivers/devfreq/mtk-cci-devfreq.c new file +78 -0
+       if (ret)
+               goto out_disable_cci_clk;
+
+       ret = dev_pm_opp_of_add_table(dev);
+       if (ret) {
+               dev_err(dev, "failed to add opp table: %d\n", ret);
+               goto out_disable_inter_clk;
+       }
+
+       rate = clk_get_rate(drv->inter_clk);
+       opp = dev_pm_opp_find_freq_ceil(dev, &rate);
+       if (IS_ERR(opp)) {
+               ret = PTR_ERR(opp);
+               dev_err(dev, "failed to get intermediate opp: %d\n", ret);
+               goto out_remove_opp_table;
+       }
+       drv->inter_voltage = dev_pm_opp_get_voltage(opp);
+       dev_pm_opp_put(opp);
+
+       rate = U32_MAX;
+       opp = dev_pm_opp_find_freq_floor(drv->dev, &rate);
+       if (IS_ERR(opp)) {
+               dev_err(dev, "failed to get opp\n");
+               ret = PTR_ERR(opp);
+               goto out_remove_opp_table;
+       }
+
+       opp_volt = dev_pm_opp_get_voltage(opp);
+       dev_pm_opp_put(opp);
+       ret = mtk_ccifreq_set_voltage(drv, opp_volt);
+       if (ret) {
+               dev_err(dev, "failed to scale to highest voltage %lu in proc_reg\n",
+                       opp_volt);
+               goto out_remove_opp_table;
+       }
+
+       passive_data = devm_kzalloc(dev, sizeof(struct devfreq_passive_data),
+                                   GFP_KERNEL);
+       if (!passive_data) {
+               ret = -ENOMEM;
+               goto out_remove_opp_table;
+       }
+
+       passive_data->parent_type = CPUFREQ_PARENT_DEV;
+       drv->devfreq = devm_devfreq_add_device(dev, &mtk_ccifreq_profile,
+                                              DEVFREQ_GOV_PASSIVE,
+                                              passive_data);
+       if (IS_ERR(drv->devfreq)) {
+               ret = -EPROBE_DEFER;
+               dev_err(dev, "failed to add devfreq device: %ld\n",
+                       PTR_ERR(drv->devfreq));
+               goto out_remove_opp_table;
+       }
+
+       drv->opp_nb.notifier_call = mtk_ccifreq_opp_notifier;
+       ret = dev_pm_opp_register_notifier(dev, &drv->opp_nb);
+       if (ret) {
+               dev_err(dev, "failed to register opp notifier: %d\n", ret);
+               goto out_remove_devfreq_device;
+       }
+       return 0;
+
+out_remove_devfreq_device:
+       devm_devfreq_remove_device(dev, drv->devfreq);
+
+out_remove_opp_table:
+       dev_pm_opp_of_remove_table(dev);
+
+out_disable_inter_clk:
+       clk_disable_unprepare(drv->inter_clk);
+
+out_disable_cci_clk:
+       clk_disable_unprepare(drv->cci_clk);
+
+out_free_resources:
+       if (regulator_is_enabled(drv->proc_reg))
+               regulator_disable(drv->proc_reg);
+       if (drv->sram_reg && regulator_is_enabled(drv->sram_reg))

drivers/devfreq/mtk-cci-devfreq.c line 416

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+               regulator_disable(drv->sram_reg);
+
+       if (!IS_ERR(drv->proc_reg))
+               regulator_put(drv->proc_reg);
+       if (!IS_ERR(drv->sram_reg))
+               regulator_put(drv->sram_reg);
+       if (!IS_ERR(drv->cci_clk))
+               clk_put(drv->cci_clk);
+       if (!IS_ERR(drv->inter_clk))
+               clk_put(drv->inter_clk);

You don't need to "put" the resources you got using devm_ variants. If you really want to, you need to use devm_(clk|regulator)_put.

Quoted 18 lines
drivers/devfreq/mtk-cci-devfreq.c new file +18 -0
+
+       return ret;
+}
+
+static int mtk_ccifreq_remove(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct mtk_ccifreq_drv *drv;
+
+       drv = platform_get_drvdata(pdev);
+
+       dev_pm_opp_unregister_notifier(dev, &drv->opp_nb);
+       dev_pm_opp_of_remove_table(dev);
+       clk_disable_unprepare(drv->inter_clk);
+       clk_disable_unprepare(drv->cci_clk);
+       regulator_disable(drv->proc_reg);
+       if (drv->sram_reg)
+               regulator_disable(drv->sram_reg);

drivers/devfreq/mtk-cci-devfreq.c line 444

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+
+       return 0;
+}
+
+static const struct mtk_ccifreq_platform_data mt8183_platform_data = {
+       .min_volt_shift = 100000,
+       .max_volt_shift = 200000,
+       .proc_max_volt = 1150000,
+       .sram_min_volt = 0,
+       .sram_max_volt = 1150000,

AFAICT there's no sram supply for MT8183, so set max to zero as well? And you can just drop the two lines instead of explicitly setting them to zero.

drivers/devfreq/mtk-cci-devfreq.c line 452

Quoted 8 lines
drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+};
+
+static const struct mtk_ccifreq_platform_data mt8186_platform_data = {
+       .min_volt_shift = 100000,
+       .max_volt_shift = 250000,
+       .proc_max_volt = 1118750,
+       .sram_min_volt = 850000,
+       .sram_max_volt = 1118750,

A side note about this: the min/max voltage values should also be set on the regulator nodes in the device tree. The range then gets enforced by the regulator core.

Regards
ChenYu

Quoted 30 lines
drivers/devfreq/mtk-cci-devfreq.c new file +22 -1
+};
+
+static const struct of_device_id mtk_ccifreq_machines[] = {
+       { .compatible = "mediatek,mt8183-cci", .data = &mt8183_platform_data },
+       { .compatible = "mediatek,mt8186-cci", .data = &mt8186_platform_data },
+       { },
+};
+MODULE_DEVICE_TABLE(of, mtk_ccifreq_machines);
+
+static struct platform_driver mtk_ccifreq_platdrv = {
+       .probe  = mtk_ccifreq_probe,
+       .remove = mtk_ccifreq_remove,
+       .driver = {
+               .name = "mtk-ccifreq",
+               .of_match_table = mtk_ccifreq_machines,
+       },
+};
+module_platform_driver(mtk_ccifreq_platdrv);
+
+MODULE_DESCRIPTION("MediaTek CCI devfreq driver");
+MODULE_AUTHOR("Jia-Wei Chang <[email protected]>");
+MODULE_LICENSE("GPL v2");
--

2.18.0

_______________________________________________
Linux-mediatek mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-mediatek

#6 lore raw

Re: [RESEND v4 2/2] PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

Hi Chen-Yu,

Quoted 271 lines · Chen-Yu Tsai
Quoted 255 lines · Johnson Wang

We introduce a devfreq driver for the MediaTek Cache Coherent Interconnect
(CCI) used by some MediaTek SoCs.

In this driver, we use the passive devfreq driver to get target frequencies
and adjust voltages accordingly. In MT8183 and MT8186, the MediaTek CCI
is supplied by the same regulators with the little core CPUs.

---
This patch depends on "devfreq-testing"[1].
[1]
https://urldefense.com/v3/__https://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git/log/?h=devfreq-testing__;!!CTRNKA9wMg0ARbw!zzOSoso9udvDV3h6kYlmizFtbn3ACA5aS2jCAjKyvtu4z0fobv1mD5uF9YbPSme8l_NnR05unTxkZfDdzohu8asWZQ$

---
 drivers/devfreq/Kconfig           |  10 +
 drivers/devfreq/Makefile          |   1 +
 drivers/devfreq/mtk-cci-devfreq.c | 474
++++++++++++++++++++++++++++++
 3 files changed, 485 insertions(+)
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
drivers/devfreq/Kconfig +0 -0
index 87eb2b837e68..9754d8b31621 100644
@@ -120,6 +120,16 @@ config ARM_TEGRA_DEVFREQ
          It reads ACTMON counters of memory controllers and

adjusts the
operating frequencies and voltages with OPP support.

drivers/devfreq/Kconfig +6 -0
+config ARM_MEDIATEK_CCI_DEVFREQ
+       tristate "MEDIATEK CCI DEVFREQ Driver"
+       depends on ARM_MEDIATEK_CPUFREQ || COMPILE_TEST
+       select DEVFREQ_GOV_PASSIVE
+       help
+         This adds a devfreq driver for MediaTek Cache Coherent

Interconnect
+ which is shared the same regulators with the cpu cluster.
It can track
+ buck voltages and update a proper CCI frequency. Use the
notification

drivers/devfreq/Kconfig +2 -0
+         to get the regulator status.
+
 config ARM_RK3399_DMC_DEVFREQ
        tristate "ARM RK3399 DMC DEVFREQ Driver"
        depends on (ARCH_ROCKCHIP && HAVE_ARM_SMCCC) || \
drivers/devfreq/Makefile +0 -0
index 0b6be92a25d9..bf40d04928d0 100644
@@ -11,6 +11,7 @@ obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)     +=

governor_passive.o

 obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ)   += exynos-bus.o
 obj-$(CONFIG_ARM_IMX_BUS_DEVFREQ)      += imx-bus.o
 obj-$(CONFIG_ARM_IMX8M_DDRC_DEVFREQ)   += imx8m-ddrc.o

+obj-$(CONFIG_ARM_MEDIATEK_CCI_DEVFREQ) += mtk-cci-devfreq.o
obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ) += rk3399_dmc.o
obj-$(CONFIG_ARM_SUN8I_A33_MBUS_DEVFREQ) += sun8i-a33-mbus.o
obj-$(CONFIG_ARM_TEGRA_DEVFREQ) += tegra30-
devfreq.o

drivers/devfreq/mtk-cci-devfreq.c new file +34 -0
new file mode 100644
index 000000000000..aa8c37eb4a06
@@ -0,0 +1,474 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2022 MediaTek Inc.
+ */
+
+#include <linux/clk.h>
+#include <linux/devfreq.h>
+#include <linux/minmax.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/pm_opp.h>
+#include <linux/regulator/consumer.h>
+
+struct mtk_ccifreq_platform_data {
+       int min_volt_shift;
+       int max_volt_shift;
+       int proc_max_volt;
+       int sram_min_volt;
+       int sram_max_volt;
+};
+
+struct mtk_ccifreq_drv {
+       struct device *dev;
+       struct devfreq *devfreq;
+       struct regulator *proc_reg;
+       struct regulator *sram_reg;
+       struct clk *cci_clk;
+       struct clk *inter_clk;
+       int inter_voltage;
+       int pre_voltage;
+       unsigned long pre_freq;
+       /* Avoid race condition for regulators between notify and

policy */

drivers/devfreq/mtk-cci-devfreq.c new file +7 -0
+       struct mutex reg_lock;
+       struct notifier_block opp_nb;
+       const struct mtk_ccifreq_platform_data *soc_data;
+       int vtrack_max;
+};
+
+static int mtk_ccifreq_set_voltage(struct mtk_ccifreq_drv *drv,

int new_voltage)

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+{
+       const struct mtk_ccifreq_platform_data *soc_data = drv-
Quoted 1 line

soc_data;

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+       struct device *dev = drv->dev;
+       int pre_voltage, pre_vsram, new_vsram, vsram, voltage, ret;
+       int retry_max = drv->vtrack_max;
+
+       if (!drv->sram_reg) {
+               ret = regulator_set_voltage(drv->proc_reg,

new_voltage,
+ drv->soc_data-

Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+               goto out_set_voltage;
+       }
+
+       pre_voltage = regulator_get_voltage(drv->proc_reg);
+       if (pre_voltage < 0) {
+               dev_err(dev, "invalid vproc value: %d\n",

pre_voltage);

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+               return pre_voltage;
+       }
+
+       pre_vsram = regulator_get_voltage(drv->sram_reg);
+       if (pre_vsram < 0) {
+               dev_err(dev, "invalid vsram value: %d\n",

pre_vsram);

drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+               return pre_vsram;
+       }
+
+       new_vsram = clamp(new_voltage + soc_data->min_volt_shift,
+                         soc_data->sram_min_volt, soc_data-
Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +4 -0
+
+       do {
+               if (pre_voltage <= new_voltage) {
+                       vsram = clamp(pre_voltage + soc_data-
Quoted 1 line

max_volt_shift,

+ soc_data->sram_min_volt,
new_vsram);
+ ret = regulator_set_voltage(drv->sram_reg,
vsram,
+ soc_data-

Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+                       if (ret)
+                               return ret;
+
+                       if (vsram == soc_data->sram_max_volt ||
+                           new_vsram == soc_data->sram_min_volt)
+                               voltage = new_voltage;
+                       else
+                               voltage = vsram - soc_data-
Quoted 1 line

min_volt_shift;

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+
+                       ret = regulator_set_voltage(drv->proc_reg,

voltage,
+ soc_data-

Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+                       if (ret) {
+                               regulator_set_voltage(drv-
Quoted 1 line

sram_reg, pre_vsram,

+ soc_data-

Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+                               return ret;
+                       }
+               } else if (pre_voltage > new_voltage) {
+                       voltage = max(new_voltage,
+                                     pre_vsram - soc_data-
Quoted 1 line

max_volt_shift);

+ ret = regulator_set_voltage(drv->proc_reg,
voltage,
+ soc_data-

Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+                       if (ret)
+                               return ret;
+
+                       if (voltage == new_voltage)
+                               vsram = new_vsram;
+                       else
+                               vsram = max(new_vsram,
+                                           voltage + soc_data-
Quoted 1 line

min_volt_shift);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+
+                       ret = regulator_set_voltage(drv->sram_reg,

vsram,
+ soc_data-

Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+                       if (ret) {
+                               regulator_set_voltage(drv-
Quoted 1 line

proc_reg, pre_voltage,

+ soc_data-

Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+                               return ret;
+                       }
+               }
+
+               pre_voltage = voltage;
+               pre_vsram = vsram;
+
+               if (--retry_max < 0) {
+                       dev_err(dev,
+                               "over loop count, failed to set

voltage\n");

drivers/devfreq/mtk-cci-devfreq.c new file +12 -0
+                       return -EINVAL;
+               }
+       } while (voltage != new_voltage || vsram != new_vsram);
+
+out_set_voltage:
+       if (!ret)
+               drv->pre_voltage = new_voltage;
+
+       return ret;
+}
+
+static int mtk_ccifreq_target(struct device *dev, unsigned long

*freq,

drivers/devfreq/mtk-cci-devfreq.c new file +7 -0
+                             u32 flags)
+{
+       struct mtk_ccifreq_drv *drv = dev_get_drvdata(dev);
+       struct clk *cci_pll = clk_get_parent(drv->cci_clk);
+       struct dev_pm_opp *opp;
+       unsigned long opp_rate;
+       int voltage, pre_voltage, inter_voltage, target_voltage,

ret;

drivers/devfreq/mtk-cci-devfreq.c new file +13 -0
+
+       if (!drv)
+               return -EINVAL;
+
+       if (drv->pre_freq == *freq)
+               return 0;
+
+       inter_voltage = drv->inter_voltage;
+
+       opp_rate = *freq;
+       opp = devfreq_recommended_opp(dev, &opp_rate, 1);
+       if (IS_ERR(opp)) {
+               dev_err(dev, "failed to find opp for freq: %ld\n",

opp_rate);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+               return PTR_ERR(opp);
+       }

drivers/devfreq/mtk-cci-devfreq.c line 163

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+
+       mutex_lock(&drv->reg_lock);
+
+       voltage = dev_pm_opp_get_voltage(opp);
+       dev_pm_opp_put(opp);
+
+       if (unlikely(drv->pre_voltage <= 0))
+               pre_voltage = regulator_get_voltage(drv->proc_reg);
+       else
+               pre_voltage = drv->pre_voltage;

Could you explain why the previous voltage setting is cached like this?

Quoted 5 lines

The CCI is sharing the regulator supply with one of the CPU clusters, and cpufreq could also change the voltage, so it's better to always retrieve the current setting directly from the regulator core. And those values might be cached iun the core, so it's unlikely to incur a significant cost.

Thanks for your suggestion.
I will modify it as mtk_ccifreq_set_voltage() does.
In that way I will try to remove pre_voltage member because it's no longer needed.

Quoted 146 lines
Quoted 146 lines
drivers/devfreq/mtk-cci-devfreq.c new file +3 -0
+
+       if (pre_voltage < 0) {
+               dev_err(dev, "invalid vproc value: %d\n",

pre_voltage);

drivers/devfreq/mtk-cci-devfreq.c new file +9 -0
+               return pre_voltage;
+       }
+
+       /* scale up: set voltage first then freq. */
+       target_voltage = max(inter_voltage, voltage);
+       if (pre_voltage <= target_voltage) {
+               ret = mtk_ccifreq_set_voltage(drv, target_voltage);
+               if (ret) {
+                       dev_err(dev, "failed to scale up

voltage\n");

drivers/devfreq/mtk-cci-devfreq.c new file +15 -0
+                       goto out_restore_voltage;
+               }
+       }
+
+       /* switch the cci clock to intermediate clock source. */
+       ret = clk_set_parent(drv->cci_clk, drv->inter_clk);
+       if (ret) {
+               dev_err(dev, "failed to re-parent cci clock\n");
+               goto out_restore_voltage;
+       }
+
+       /* set the original clock to target rate. */
+       ret = clk_set_rate(cci_pll, *freq);
+       if (ret) {
+               dev_err(dev, "failed to set cci pll rate: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+               clk_set_parent(drv->cci_clk, cci_pll);
+               goto out_restore_voltage;
+       }
+
+       /* switch the cci clock back to the original clock source.

*/

drivers/devfreq/mtk-cci-devfreq.c new file +9 -0
+       ret = clk_set_parent(drv->cci_clk, cci_pll);
+       if (ret) {
+               dev_err(dev, "failed to re-parent cci clock\n");
+               mtk_ccifreq_set_voltage(drv, inter_voltage);
+               goto out_unlock;
+       }
+
+       /*
+        * If the new voltage is lower than the intermediate

voltage or the

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+        * original voltage, scale down to the new voltage.
+        */
+       if (voltage < inter_voltage || voltage < pre_voltage) {
+               ret = mtk_ccifreq_set_voltage(drv, voltage);
+               if (ret) {
+                       dev_err(dev, "failed to scale down

voltage\n");

drivers/devfreq/mtk-cci-devfreq.c new file +19 -0
+                       goto out_unlock;
+               }
+       }
+
+       drv->pre_freq = *freq;
+       mutex_unlock(&drv->reg_lock);
+
+       return 0;
+
+out_restore_voltage:
+       mtk_ccifreq_set_voltage(drv, pre_voltage);
+
+out_unlock:
+       mutex_unlock(&drv->reg_lock);
+       return ret;
+}
+
+static int mtk_ccifreq_opp_notifier(struct notifier_block *nb,
+                                   unsigned long event, void

*data)

drivers/devfreq/mtk-cci-devfreq.c new file +42 -0
+{
+       struct dev_pm_opp *opp = data;
+       struct mtk_ccifreq_drv *drv;
+       unsigned long freq, volt;
+
+       drv = container_of(nb, struct mtk_ccifreq_drv, opp_nb);
+
+       if (event == OPP_EVENT_ADJUST_VOLTAGE) {
+               freq = dev_pm_opp_get_freq(opp);
+
+               mutex_lock(&drv->reg_lock);
+               /* current opp item is changed */
+               if (freq == drv->pre_freq) {
+                       volt = dev_pm_opp_get_voltage(opp);
+                       mtk_ccifreq_set_voltage(drv, volt);
+               }
+               mutex_unlock(&drv->reg_lock);
+       }
+
+       return 0;
+}
+
+static struct devfreq_dev_profile mtk_ccifreq_profile = {
+       .target = mtk_ccifreq_target,
+};
+
+static int mtk_ccifreq_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct mtk_ccifreq_drv *drv;
+       struct devfreq_passive_data *passive_data;
+       struct dev_pm_opp *opp;
+       unsigned long rate, opp_volt;
+       int ret;
+
+       drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);
+       if (!drv)
+               return -ENOMEM;
+
+       drv->dev = dev;
+       drv->soc_data = (const struct mtk_ccifreq_platform_data *)
+                               of_device_get_match_data(&pdev-
Quoted 1 line

dev);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+       mutex_init(&drv->reg_lock);
+       platform_set_drvdata(pdev, drv);
+
+       drv->cci_clk = devm_clk_get(dev, "cci");
+       if (IS_ERR(drv->cci_clk)) {
+               ret = PTR_ERR(drv->cci_clk);
+               return dev_err_probe(dev, ret,
+                                    "failed to get cci clk: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +7 -0
+       }
+
+       drv->inter_clk = devm_clk_get(dev, "intermediate");
+       if (IS_ERR(drv->inter_clk)) {
+               ret = PTR_ERR(drv->inter_clk);
+               dev_err_probe(dev, ret,
+                             "failed to get intermediate clk:

%d\n", ret);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+               goto out_free_resources;
+       }
+
+       drv->proc_reg = devm_regulator_get_optional(dev, "proc");
+       if (IS_ERR(drv->proc_reg)) {
+               ret = PTR_ERR(drv->proc_reg);
+               dev_err_probe(dev, ret,
+                             "failed to get proc regulator: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +4 -0
+               goto out_free_resources;
+       }
+
+       ret = regulator_enable(drv->proc_reg);
Quoted 9 lines

drivers/devfreq/mtk-cci-devfreq.c line 304

Quoted 6 lines
drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+       if (ret) {
+               dev_err(dev, "failed to enable proc regulator\n");
+               goto out_free_resources;
+       }
+
+       drv->sram_reg = regulator_get_optional(dev, "sram");

devm_ for this as well?

I will modify it in the next version.

Quoted 17 lines
Quoted 14 lines
drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+       if (IS_ERR(drv->sram_reg))
+               drv->sram_reg = NULL;
+       else {
+               ret = regulator_enable(drv->sram_reg);
+               if (ret) {
+                       dev_err(dev, "failed to enable sram

regulator\n");

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+                       goto out_free_resources;
+               }
+       }
+
+       /*
+        * We assume min voltage is 0 and tracking target voltage

using

drivers/devfreq/mtk-cci-devfreq.c line 318

Quoted 2 lines
drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+        * min_volt_shift for each iteration.
+        * The retry_max is 3 times of expeted iteration count.
Quoted 2 lines

expected?

Maybe "the maximum" will be more appropriate?

Quoted 7 lines
Quoted 7 lines
drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+        */
+       drv->vtrack_max = 3 * DIV_ROUND_UP(max(drv->soc_data-
Quoted 1 line

sram_max_volt,

+ drv->soc_data-

Quoted 1 line

proc_max_volt),

+ drv->soc_data-

Quoted 1 line

min_volt_shift);

Quoted 12 lines

drivers/devfreq/mtk-cci-devfreq.c line 328

Quoted 6 lines
drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+
+       ret = clk_prepare_enable(drv->cci_clk);
+       if (ret)
+               goto out_free_resources;
+
+       ret = clk_prepare_enable(drv->inter_clk);

You don't need to enable the intermediate clock here. You shouldn't need
to at all, as the CCF core will do it when the CCI clock is reparented
over to it.

I will remove it and all of clk_disable_unprepare(drv->inter_clk) in this file.

Quoted 89 lines
Quoted 89 lines
drivers/devfreq/mtk-cci-devfreq.c new file +14 -0
+       if (ret)
+               goto out_disable_cci_clk;
+
+       ret = dev_pm_opp_of_add_table(dev);
+       if (ret) {
+               dev_err(dev, "failed to add opp table: %d\n", ret);
+               goto out_disable_inter_clk;
+       }
+
+       rate = clk_get_rate(drv->inter_clk);
+       opp = dev_pm_opp_find_freq_ceil(dev, &rate);
+       if (IS_ERR(opp)) {
+               ret = PTR_ERR(opp);
+               dev_err(dev, "failed to get intermediate opp:

%d\n", ret);

drivers/devfreq/mtk-cci-devfreq.c new file +18 -0
+               goto out_remove_opp_table;
+       }
+       drv->inter_voltage = dev_pm_opp_get_voltage(opp);
+       dev_pm_opp_put(opp);
+
+       rate = U32_MAX;
+       opp = dev_pm_opp_find_freq_floor(drv->dev, &rate);
+       if (IS_ERR(opp)) {
+               dev_err(dev, "failed to get opp\n");
+               ret = PTR_ERR(opp);
+               goto out_remove_opp_table;
+       }
+
+       opp_volt = dev_pm_opp_get_voltage(opp);
+       dev_pm_opp_put(opp);
+       ret = mtk_ccifreq_set_voltage(drv, opp_volt);
+       if (ret) {
+               dev_err(dev, "failed to scale to highest voltage

%lu in proc_reg\n",

drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+                       opp_volt);
+               goto out_remove_opp_table;
+       }
+
+       passive_data = devm_kzalloc(dev, sizeof(struct

devfreq_passive_data),

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+                                   GFP_KERNEL);
+       if (!passive_data) {
+               ret = -ENOMEM;
+               goto out_remove_opp_table;
+       }
+
+       passive_data->parent_type = CPUFREQ_PARENT_DEV;
+       drv->devfreq = devm_devfreq_add_device(dev,

&mtk_ccifreq_profile,

drivers/devfreq/mtk-cci-devfreq.c new file +13 -0
+                                              DEVFREQ_GOV_PASSIVE,
+                                              passive_data);
+       if (IS_ERR(drv->devfreq)) {
+               ret = -EPROBE_DEFER;
+               dev_err(dev, "failed to add devfreq device: %ld\n",
+                       PTR_ERR(drv->devfreq));
+               goto out_remove_opp_table;
+       }
+
+       drv->opp_nb.notifier_call = mtk_ccifreq_opp_notifier;
+       ret = dev_pm_opp_register_notifier(dev, &drv->opp_nb);
+       if (ret) {
+               dev_err(dev, "failed to register opp notifier:

%d\n", ret);

drivers/devfreq/mtk-cci-devfreq.c new file +25 -0
+               goto out_remove_devfreq_device;
+       }
+       return 0;
+
+out_remove_devfreq_device:
+       devm_devfreq_remove_device(dev, drv->devfreq);
+
+out_remove_opp_table:
+       dev_pm_opp_of_remove_table(dev);
+
+out_disable_inter_clk:
+       clk_disable_unprepare(drv->inter_clk);
+
+out_disable_cci_clk:
+       clk_disable_unprepare(drv->cci_clk);
+
+out_free_resources:
+       if (regulator_is_enabled(drv->proc_reg))
+               regulator_disable(drv->proc_reg);
+       if (drv->sram_reg && regulator_is_enabled(drv->sram_reg))
+               regulator_disable(drv->sram_reg);
+
+       if (!IS_ERR(drv->proc_reg))
+               regulator_put(drv->proc_reg);
+       if (!IS_ERR(drv->sram_reg))
Quoted 9 lines

drivers/devfreq/mtk-cci-devfreq.c line 416

Quoted 5 lines
drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+               regulator_put(drv->sram_reg);
+       if (!IS_ERR(drv->cci_clk))
+               clk_put(drv->cci_clk);
+       if (!IS_ERR(drv->inter_clk))
+               clk_put(drv->inter_clk);

You don't need to "put" the resources you got using devm_ variants. If you really want to, you need to use devm_(clk|regulator)_put.

I think I will remove these lines in the next version.

Quoted 25 lines
Quoted 25 lines
drivers/devfreq/mtk-cci-devfreq.c new file +23 -0
+
+       return ret;
+}
+
+static int mtk_ccifreq_remove(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       struct mtk_ccifreq_drv *drv;
+
+       drv = platform_get_drvdata(pdev);
+
+       dev_pm_opp_unregister_notifier(dev, &drv->opp_nb);
+       dev_pm_opp_of_remove_table(dev);
+       clk_disable_unprepare(drv->inter_clk);
+       clk_disable_unprepare(drv->cci_clk);
+       regulator_disable(drv->proc_reg);
+       if (drv->sram_reg)
+               regulator_disable(drv->sram_reg);
+
+       return 0;
+}
+
+static const struct mtk_ccifreq_platform_data mt8183_platform_data

= {
+ .min_volt_shift = 100000,

Quoted 9 lines

drivers/devfreq/mtk-cci-devfreq.c line 444

Quoted 4 lines
drivers/devfreq/mtk-cci-devfreq.c new file +4 -0
+       .max_volt_shift = 200000,
+       .proc_max_volt = 1150000,
+       .sram_min_volt = 0,
+       .sram_max_volt = 1150000,

AFAICT there's no sram supply for MT8183, so set max to zero as well? And you can just drop the two lines instead of explicitly setting them to zero.

Sure, I will drop these two line.

Quoted 6 lines
Quoted 6 lines
drivers/devfreq/mtk-cci-devfreq.c new file +3 -0
+};
+
+static const struct mtk_ccifreq_platform_data mt8186_platform_data

= {

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+       .min_volt_shift = 100000,
+       .max_volt_shift = 250000,
Quoted 9 lines

drivers/devfreq/mtk-cci-devfreq.c line 452

Quoted 3 lines
drivers/devfreq/mtk-cci-devfreq.c new file +3 -0
+       .proc_max_volt = 1118750,
+       .sram_min_volt = 850000,
+       .sram_max_volt = 1118750,

A side note about this: the min/max voltage values should also be set on the regulator nodes in the device tree. The range then gets enforced
by the regulator core.

Thanks for your reminder.
We will notice this when we are sending dts patches.

BRs,
Johnson Wang

Quoted 36 lines

Regards
ChenYu

Quoted 32 lines
drivers/devfreq/mtk-cci-devfreq.c new file +4 -0
+};
+
+static const struct of_device_id mtk_ccifreq_machines[] = {
+       { .compatible = "mediatek,mt8183-cci", .data =

&mt8183_platform_data },
+ { .compatible = "mediatek,mt8186-cci", .data =
&mt8186_platform_data },

drivers/devfreq/mtk-cci-devfreq.c new file +17 -1
+       { },
+};
+MODULE_DEVICE_TABLE(of, mtk_ccifreq_machines);
+
+static struct platform_driver mtk_ccifreq_platdrv = {
+       .probe  = mtk_ccifreq_probe,
+       .remove = mtk_ccifreq_remove,
+       .driver = {
+               .name = "mtk-ccifreq",
+               .of_match_table = mtk_ccifreq_machines,
+       },
+};
+module_platform_driver(mtk_ccifreq_platdrv);
+
+MODULE_DESCRIPTION("MediaTek CCI devfreq driver");
+MODULE_AUTHOR("Jia-Wei Chang <[email protected]>");
+MODULE_LICENSE("GPL v2");
--

2.18.0

_______________________________________________
Linux-mediatek mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-mediatek

#7 lore raw

Re: [RESEND v4 2/2] PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

Quoted 79 lines · Johnson Wang

Hi Chen-Yu,

Quoted 75 lines · Chen-Yu Tsai
Quoted 73 lines · Johnson Wang

We introduce a devfreq driver for the MediaTek Cache Coherent Interconnect
(CCI) used by some MediaTek SoCs.

In this driver, we use the passive devfreq driver to get target frequencies
and adjust voltages accordingly. In MT8183 and MT8186, the MediaTek CCI
is supplied by the same regulators with the little core CPUs.

---
This patch depends on "devfreq-testing"[1].
[1]
https://urldefense.com/v3/__https://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git/log/?h=devfreq-testing__;!!CTRNKA9wMg0ARbw!zzOSoso9udvDV3h6kYlmizFtbn3ACA5aS2jCAjKyvtu4z0fobv1mD5uF9YbPSme8l_NnR05unTxkZfDdzohu8asWZQ$

---
 drivers/devfreq/Kconfig           |  10 +
 drivers/devfreq/Makefile          |   1 +
 drivers/devfreq/mtk-cci-devfreq.c | 474
++++++++++++++++++++++++++++++
 3 files changed, 485 insertions(+)
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
drivers/devfreq/Kconfig +0 -0
index 87eb2b837e68..9754d8b31621 100644
@@ -120,6 +120,16 @@ config ARM_TEGRA_DEVFREQ
          It reads ACTMON counters of memory controllers and

adjusts the
operating frequencies and voltages with OPP support.

drivers/devfreq/Kconfig +6 -0
+config ARM_MEDIATEK_CCI_DEVFREQ
+       tristate "MEDIATEK CCI DEVFREQ Driver"
+       depends on ARM_MEDIATEK_CPUFREQ || COMPILE_TEST
+       select DEVFREQ_GOV_PASSIVE
+       help
+         This adds a devfreq driver for MediaTek Cache Coherent

Interconnect
+ which is shared the same regulators with the cpu cluster.
It can track
+ buck voltages and update a proper CCI frequency. Use the
notification

drivers/devfreq/Kconfig +2 -0
+         to get the regulator status.
+
 config ARM_RK3399_DMC_DEVFREQ
        tristate "ARM RK3399 DMC DEVFREQ Driver"
        depends on (ARCH_ROCKCHIP && HAVE_ARM_SMCCC) || \
drivers/devfreq/Makefile +0 -0
index 0b6be92a25d9..bf40d04928d0 100644
@@ -11,6 +11,7 @@ obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)     +=

governor_passive.o

 obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ)   += exynos-bus.o
 obj-$(CONFIG_ARM_IMX_BUS_DEVFREQ)      += imx-bus.o
 obj-$(CONFIG_ARM_IMX8M_DDRC_DEVFREQ)   += imx8m-ddrc.o

+obj-$(CONFIG_ARM_MEDIATEK_CCI_DEVFREQ) += mtk-cci-devfreq.o
obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ) += rk3399_dmc.o
obj-$(CONFIG_ARM_SUN8I_A33_MBUS_DEVFREQ) += sun8i-a33-mbus.o
obj-$(CONFIG_ARM_TEGRA_DEVFREQ) += tegra30-
devfreq.o

drivers/devfreq/mtk-cci-devfreq.c new file +0 -0
new file mode 100644
index 000000000000..aa8c37eb4a06
@@ -0,0 +1,474 @@

[...]

Quoted 17 lines
Quoted 17 lines
Quoted 16 lines
drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+       if (IS_ERR(drv->sram_reg))
+               drv->sram_reg = NULL;
+       else {
+               ret = regulator_enable(drv->sram_reg);
+               if (ret) {
+                       dev_err(dev, "failed to enable sram

regulator\n");

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+                       goto out_free_resources;
+               }
+       }
+
+       /*
+        * We assume min voltage is 0 and tracking target voltage

using

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+        * min_volt_shift for each iteration.
+        * The retry_max is 3 times of expeted iteration count.
Quoted 3 lines
Quoted 2 lines

expected?

Maybe "the maximum" will be more appropriate?

I was merely pointing out a typo in "expeted".

Looking at it again, I'm not sure why retry attempts are tied to the voltage.

ChenYu

#8 lore raw

Re: [RESEND v4 2/2] PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

Quoted 20 lines · Chen-Yu Tsai
Quoted 18 lines · Johnson Wang

Hi Chen-Yu,

Quoted 14 lines · Chen-Yu Tsai
Quoted 12 lines · Johnson Wang

We introduce a devfreq driver for the MediaTek Cache Coherent Interconnect
(CCI) used by some MediaTek SoCs.

In this driver, we use the passive devfreq driver to get target frequencies
and adjust voltages accordingly. In MT8183 and MT8186, the MediaTek
CCI
is supplied by the same regulators with the little core CPUs.

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

---
This patch depends on "devfreq-testing"[1].
[1]

https://urldefense.com/v3/__https://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git/log/?h=devfreq-testing__;!!CTRNKA9wMg0ARbw!zzOSoso9udvDV3h6kYlmizFtbn3ACA5aS2jCAjKyvtu4z0fobv1mD5uF9YbPSme8l_NnR05unTxkZfDdzohu8asWZQ$

Quoted 87 lines
Quoted 60 lines
Quoted 60 lines
Quoted 60 lines
---
 drivers/devfreq/Kconfig           |  10 +
 drivers/devfreq/Makefile          |   1 +
 drivers/devfreq/mtk-cci-devfreq.c | 474
++++++++++++++++++++++++++++++
 3 files changed, 485 insertions(+)
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
drivers/devfreq/Kconfig +0 -0
index 87eb2b837e68..9754d8b31621 100644
@@ -120,6 +120,16 @@ config ARM_TEGRA_DEVFREQ
          It reads ACTMON counters of memory controllers and

adjusts the
operating frequencies and voltages with OPP support.

drivers/devfreq/Kconfig +6 -0
+config ARM_MEDIATEK_CCI_DEVFREQ
+       tristate "MEDIATEK CCI DEVFREQ Driver"
+       depends on ARM_MEDIATEK_CPUFREQ || COMPILE_TEST
+       select DEVFREQ_GOV_PASSIVE
+       help
+         This adds a devfreq driver for MediaTek Cache

Coherent
Interconnect
+ which is shared the same regulators with the cpu
cluster.
It can track
+ buck voltages and update a proper CCI frequency. Use
the
notification

drivers/devfreq/Kconfig +2 -0
+         to get the regulator status.
+
 config ARM_RK3399_DMC_DEVFREQ
        tristate "ARM RK3399 DMC DEVFREQ Driver"
        depends on (ARCH_ROCKCHIP && HAVE_ARM_SMCCC) || \
drivers/devfreq/Makefile +0 -0
index 0b6be92a25d9..bf40d04928d0 100644
@@ -11,6 +11,7 @@ obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)     +=

governor_passive.o

 obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ)   += exynos-bus.o
 obj-$(CONFIG_ARM_IMX_BUS_DEVFREQ)      += imx-bus.o
 obj-$(CONFIG_ARM_IMX8M_DDRC_DEVFREQ)   += imx8m-ddrc.o

+obj-$(CONFIG_ARM_MEDIATEK_CCI_DEVFREQ) += mtk-cci-devfreq.o
obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ) += rk3399_dmc.o
obj-$(CONFIG_ARM_SUN8I_A33_MBUS_DEVFREQ) += sun8i-a33-
mbus.o
obj-$(CONFIG_ARM_TEGRA_DEVFREQ) += tegra30-
devfreq.o

drivers/devfreq/mtk-cci-devfreq.c new file +0 -0
new file mode 100644
index 000000000000..aa8c37eb4a06
@@ -0,0 +1,474 @@

[...]

Quoted 18 lines
Quoted 18 lines
Quoted 17 lines
drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+       if (IS_ERR(drv->sram_reg))
+               drv->sram_reg = NULL;
+       else {
+               ret = regulator_enable(drv->sram_reg);
+               if (ret) {
+                       dev_err(dev, "failed to enable sram

regulator\n");

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+                       goto out_free_resources;
+               }
+       }
+
+       /*
+        * We assume min voltage is 0 and tracking target

voltage
using

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+        * min_volt_shift for each iteration.
+        * The retry_max is 3 times of expeted iteration count.
Quoted 4 lines
Quoted 2 lines

expected?

Maybe "the maximum" will be more appropriate?

Quoted 7 lines

I was merely pointing out a typo in "expeted".

Looking at it again, I'm not sure why retry attempts are tied to the voltage.

ChenYu

Hi Chen-Yu,

Thanks for you reminder.

Whenever the voltages are scaled up/down one step, meaning that there is another iteration in the while loop.

Thus, our thought is to use times of the voltages step up/down to set iteration limit.

BRs,
Johnson Wang

#9 lore raw

Re: [RESEND v4 2/2] PM / devfreq: mediatek: Introduce MediaTek CCI devfreq driver

In reply to Johnson Wang
Quoted 252 lines · Johnson Wang

We introduce a devfreq driver for the MediaTek Cache Coherent Interconnect
(CCI) used by some MediaTek SoCs.

In this driver, we use the passive devfreq driver to get target frequencies
and adjust voltages accordingly. In MT8183 and MT8186, the MediaTek CCI
is supplied by the same regulators with the little core CPUs.

---
This patch depends on "devfreq-testing"[1].
[1]
https://git.kernel.org/pub/scm/linux/kernel/git/chanwoo/linux.git/log/?h=devfreq-testing

---
 drivers/devfreq/Kconfig           |  10 +
 drivers/devfreq/Makefile          |   1 +
 drivers/devfreq/mtk-cci-devfreq.c | 474
++++++++++++++++++++++++++++++
 3 files changed, 485 insertions(+)
 create mode 100644 drivers/devfreq/mtk-cci-devfreq.c
drivers/devfreq/Kconfig +0 -0
index 87eb2b837e68..9754d8b31621 100644
@@ -120,6 +120,16 @@ config ARM_TEGRA_DEVFREQ
 	  It reads ACTMON counters of memory controllers and adjusts

the

drivers/devfreq/Kconfig +6 -0
 	  operating frequencies and voltages with OPP support.
 
+config ARM_MEDIATEK_CCI_DEVFREQ
+	tristate "MEDIATEK CCI DEVFREQ Driver"
+	depends on ARM_MEDIATEK_CPUFREQ || COMPILE_TEST
+	select DEVFREQ_GOV_PASSIVE
+	help
+	  This adds a devfreq driver for MediaTek Cache Coherent

Interconnect

drivers/devfreq/Kconfig +1 -0
+	  which is shared the same regulators with the cpu cluster. It

can track

drivers/devfreq/Kconfig +1 -0
+	  buck voltages and update a proper CCI frequency. Use the

notification

drivers/devfreq/Kconfig +2 -0
+	  to get the regulator status.
+
 config ARM_RK3399_DMC_DEVFREQ
 	tristate "ARM RK3399 DMC DEVFREQ Driver"
 	depends on (ARCH_ROCKCHIP && HAVE_ARM_SMCCC) || \
drivers/devfreq/Makefile +0 -0
index 0b6be92a25d9..bf40d04928d0 100644
@@ -11,6 +11,7 @@ obj-$(CONFIG_DEVFREQ_GOV_PASSIVE)	+=

governor_passive.o
obj-$(CONFIG_ARM_EXYNOS_BUS_DEVFREQ) += exynos-bus.o
obj-$(CONFIG_ARM_IMX_BUS_DEVFREQ) += imx-bus.o
obj-$(CONFIG_ARM_IMX8M_DDRC_DEVFREQ) += imx8m-ddrc.o

drivers/devfreq/Makefile +1 -0
+obj-$(CONFIG_ARM_MEDIATEK_CCI_DEVFREQ)	+= mtk-cci-devfreq.o
 obj-$(CONFIG_ARM_RK3399_DMC_DEVFREQ)	+= rk3399_dmc.o
 obj-$(CONFIG_ARM_SUN8I_A33_MBUS_DEVFREQ)	+= sun8i-a33-mbus.o
 obj-$(CONFIG_ARM_TEGRA_DEVFREQ)		+= tegra30-devfreq.o
drivers/devfreq/mtk- renamed from drivers/devfreq/mtk-cci-devfreq.c +0 -0

cci-devfreq.c
new file mode 100644
index 000000000000..aa8c37eb4a06

drivers/devfreq/mtk-cci-devfreq.c new file +34 -0
@@ -0,0 +1,474 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (C) 2022 MediaTek Inc.
+ */
+
+#include <linux/clk.h>
+#include <linux/devfreq.h>
+#include <linux/minmax.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/pm_opp.h>
+#include <linux/regulator/consumer.h>
+
+struct mtk_ccifreq_platform_data {
+	int min_volt_shift;
+	int max_volt_shift;
+	int proc_max_volt;
+	int sram_min_volt;
+	int sram_max_volt;
+};
+
+struct mtk_ccifreq_drv {
+	struct device *dev;
+	struct devfreq *devfreq;
+	struct regulator *proc_reg;
+	struct regulator *sram_reg;
+	struct clk *cci_clk;
+	struct clk *inter_clk;
+	int inter_voltage;
+	int pre_voltage;
+	unsigned long pre_freq;
+	/* Avoid race condition for regulators between notify and

policy */

drivers/devfreq/mtk-cci-devfreq.c new file +7 -0
+	struct mutex reg_lock;
+	struct notifier_block opp_nb;
+	const struct mtk_ccifreq_platform_data *soc_data;
+	int vtrack_max;
+};
+
+static int mtk_ccifreq_set_voltage(struct mtk_ccifreq_drv *drv, int

new_voltage)

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+{
+	const struct mtk_ccifreq_platform_data *soc_data = drv-
Quoted 1 line

soc_data;

drivers/devfreq/mtk-cci-devfreq.c new file +7 -0
+	struct device *dev = drv->dev;
+	int pre_voltage, pre_vsram, new_vsram, vsram, voltage, ret;
+	int retry_max = drv->vtrack_max;
+
+	if (!drv->sram_reg) {
+		ret = regulator_set_voltage(drv->proc_reg, new_voltage,
+					    drv->soc_data-
Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +17 -0
+		goto out_set_voltage;
+	}
+
+	pre_voltage = regulator_get_voltage(drv->proc_reg);
+	if (pre_voltage < 0) {
+		dev_err(dev, "invalid vproc value: %d\n", pre_voltage);
+		return pre_voltage;
+	}
+
+	pre_vsram = regulator_get_voltage(drv->sram_reg);
+	if (pre_vsram < 0) {
+		dev_err(dev, "invalid vsram value: %d\n", pre_vsram);
+		return pre_vsram;
+	}
+
+	new_vsram = clamp(new_voltage + soc_data->min_volt_shift,
+			  soc_data->sram_min_volt, soc_data-
Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +4 -0
+
+	do {
+		if (pre_voltage <= new_voltage) {
+			vsram = clamp(pre_voltage + soc_data-
Quoted 1 line

max_volt_shift,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+				      soc_data->sram_min_volt,

new_vsram);

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+			ret = regulator_set_voltage(drv->sram_reg,

vsram,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+						    soc_data-
Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+			if (ret)
+				return ret;
+
+			if (vsram == soc_data->sram_max_volt ||
+			    new_vsram == soc_data->sram_min_volt)
+				voltage = new_voltage;
+			else
+				voltage = vsram - soc_data-
Quoted 1 line

min_volt_shift;

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+
+			ret = regulator_set_voltage(drv->proc_reg,

voltage,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+						    soc_data-
Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+			if (ret) {
+				regulator_set_voltage(drv->sram_reg,

pre_vsram,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+						      soc_data-
Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+				return ret;
+			}
+		} else if (pre_voltage > new_voltage) {
+			voltage = max(new_voltage,
+				      pre_vsram - soc_data-
Quoted 1 line

max_volt_shift);

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+			ret = regulator_set_voltage(drv->proc_reg,

voltage,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+						    soc_data-
Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+			if (ret)
+				return ret;
+
+			if (voltage == new_voltage)
+				vsram = new_vsram;
+			else
+				vsram = max(new_vsram,
+					    voltage + soc_data-
Quoted 1 line

min_volt_shift);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+
+			ret = regulator_set_voltage(drv->sram_reg,

vsram,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+						    soc_data-
Quoted 1 line

sram_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +2 -0
+			if (ret) {
+				regulator_set_voltage(drv->proc_reg,

pre_voltage,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+						      soc_data-
Quoted 1 line

proc_max_volt);

drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+				return ret;
+			}
+		}
+
+		pre_voltage = voltage;
+		pre_vsram = vsram;
+
+		if (--retry_max < 0) {
+			dev_err(dev,
+				"over loop count, failed to set

voltage\n");

drivers/devfreq/mtk-cci-devfreq.c new file +12 -0
+			return -EINVAL;
+		}
+	} while (voltage != new_voltage || vsram != new_vsram);
+
+out_set_voltage:
+	if (!ret)
+		drv->pre_voltage = new_voltage;
+
+	return ret;
+}
+
+static int mtk_ccifreq_target(struct device *dev, unsigned long

*freq,

drivers/devfreq/mtk-cci-devfreq.c new file +20 -0
+			      u32 flags)
+{
+	struct mtk_ccifreq_drv *drv = dev_get_drvdata(dev);
+	struct clk *cci_pll = clk_get_parent(drv->cci_clk);
+	struct dev_pm_opp *opp;
+	unsigned long opp_rate;
+	int voltage, pre_voltage, inter_voltage, target_voltage, ret;
+
+	if (!drv)
+		return -EINVAL;
+
+	if (drv->pre_freq == *freq)
+		return 0;
+
+	inter_voltage = drv->inter_voltage;
+
+	opp_rate = *freq;
+	opp = devfreq_recommended_opp(dev, &opp_rate, 1);
+	if (IS_ERR(opp)) {
+		dev_err(dev, "failed to find opp for freq: %ld\n",

opp_rate);

drivers/devfreq/mtk-cci-devfreq.c new file +6 -0
+		return PTR_ERR(opp);
+	}
+
+	mutex_lock(&drv->reg_lock);
+
+	voltage = dev_pm_opp_get_voltage(opp);

drivers/devfreq/mtk-cci-devfreq.c line 167

Quoted 10 lines
drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+	dev_pm_opp_put(opp);
+
+	if (unlikely(drv->pre_voltage <= 0))
+		pre_voltage = regulator_get_voltage(drv->proc_reg);
+	else
+		pre_voltage = drv->pre_voltage;
+
+	if (pre_voltage < 0) {
+		dev_err(dev, "invalid vproc value: %d\n", pre_voltage);
+		return pre_voltage;

this should be:
goto out_restore_voltage;

the mutex will not be unlocked.

Quoted 324 lines
drivers/devfreq/mtk-cci-devfreq.c new file +37 -0
+	}
+
+	/* scale up: set voltage first then freq. */
+	target_voltage = max(inter_voltage, voltage);
+	if (pre_voltage <= target_voltage) {
+		ret = mtk_ccifreq_set_voltage(drv, target_voltage);
+		if (ret) {
+			dev_err(dev, "failed to scale up voltage\n");
+			goto out_restore_voltage;
+		}
+	}
+
+	/* switch the cci clock to intermediate clock source. */
+	ret = clk_set_parent(drv->cci_clk, drv->inter_clk);
+	if (ret) {
+		dev_err(dev, "failed to re-parent cci clock\n");
+		goto out_restore_voltage;
+	}
+
+	/* set the original clock to target rate. */
+	ret = clk_set_rate(cci_pll, *freq);
+	if (ret) {
+		dev_err(dev, "failed to set cci pll rate: %d\n", ret);
+		clk_set_parent(drv->cci_clk, cci_pll);
+		goto out_restore_voltage;
+	}
+
+	/* switch the cci clock back to the original clock source. */
+	ret = clk_set_parent(drv->cci_clk, cci_pll);
+	if (ret) {
+		dev_err(dev, "failed to re-parent cci clock\n");
+		mtk_ccifreq_set_voltage(drv, inter_voltage);
+		goto out_unlock;
+	}
+
+	/*
+	 * If the new voltage is lower than the intermediate voltage or

the

drivers/devfreq/mtk-cci-devfreq.c new file +75 -0
+	 * original voltage, scale down to the new voltage.
+	 */
+	if (voltage < inter_voltage || voltage < pre_voltage) {
+		ret = mtk_ccifreq_set_voltage(drv, voltage);
+		if (ret) {
+			dev_err(dev, "failed to scale down voltage\n");
+			goto out_unlock;
+		}
+	}
+
+	drv->pre_freq = *freq;
+	mutex_unlock(&drv->reg_lock);
+
+	return 0;
+
+out_restore_voltage:
+	mtk_ccifreq_set_voltage(drv, pre_voltage);
+
+out_unlock:
+	mutex_unlock(&drv->reg_lock);
+	return ret;
+}
+
+static int mtk_ccifreq_opp_notifier(struct notifier_block *nb,
+				    unsigned long event, void *data)
+{
+	struct dev_pm_opp *opp = data;
+	struct mtk_ccifreq_drv *drv;
+	unsigned long freq, volt;
+
+	drv = container_of(nb, struct mtk_ccifreq_drv, opp_nb);
+
+	if (event == OPP_EVENT_ADJUST_VOLTAGE) {
+		freq = dev_pm_opp_get_freq(opp);
+
+		mutex_lock(&drv->reg_lock);
+		/* current opp item is changed */
+		if (freq == drv->pre_freq) {
+			volt = dev_pm_opp_get_voltage(opp);
+			mtk_ccifreq_set_voltage(drv, volt);
+		}
+		mutex_unlock(&drv->reg_lock);
+	}
+
+	return 0;
+}
+
+static struct devfreq_dev_profile mtk_ccifreq_profile = {
+	.target = mtk_ccifreq_target,
+};
+
+static int mtk_ccifreq_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct mtk_ccifreq_drv *drv;
+	struct devfreq_passive_data *passive_data;
+	struct dev_pm_opp *opp;
+	unsigned long rate, opp_volt;
+	int ret;
+
+	drv = devm_kzalloc(dev, sizeof(*drv), GFP_KERNEL);
+	if (!drv)
+		return -ENOMEM;
+
+	drv->dev = dev;
+	drv->soc_data = (const struct mtk_ccifreq_platform_data *)
+				of_device_get_match_data(&pdev->dev);
+	mutex_init(&drv->reg_lock);
+	platform_set_drvdata(pdev, drv);
+
+	drv->cci_clk = devm_clk_get(dev, "cci");
+	if (IS_ERR(drv->cci_clk)) {
+		ret = PTR_ERR(drv->cci_clk);
+		return dev_err_probe(dev, ret,
+				     "failed to get cci clk: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +7 -0
+	}
+
+	drv->inter_clk = devm_clk_get(dev, "intermediate");
+	if (IS_ERR(drv->inter_clk)) {
+		ret = PTR_ERR(drv->inter_clk);
+		dev_err_probe(dev, ret,
+			      "failed to get intermediate clk: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+		goto out_free_resources;
+	}
+
+	drv->proc_reg = devm_regulator_get_optional(dev, "proc");
+	if (IS_ERR(drv->proc_reg)) {
+		ret = PTR_ERR(drv->proc_reg);
+		dev_err_probe(dev, ret,
+			      "failed to get proc regulator: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +16 -0
+		goto out_free_resources;
+	}
+
+	ret = regulator_enable(drv->proc_reg);
+	if (ret) {
+		dev_err(dev, "failed to enable proc regulator\n");
+		goto out_free_resources;
+	}
+
+	drv->sram_reg = regulator_get_optional(dev, "sram");
+	if (IS_ERR(drv->sram_reg))
+		drv->sram_reg = NULL;
+	else {
+		ret = regulator_enable(drv->sram_reg);
+		if (ret) {
+			dev_err(dev, "failed to enable sram

regulator\n");

drivers/devfreq/mtk-cci-devfreq.c new file +10 -0
+			goto out_free_resources;
+		}
+	}
+
+	/*
+	 * We assume min voltage is 0 and tracking target voltage using
+	 * min_volt_shift for each iteration.
+	 * The retry_max is 3 times of expeted iteration count.
+	 */
+	drv->vtrack_max = 3 * DIV_ROUND_UP(max(drv->soc_data-
Quoted 1 line

sram_max_volt,

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+					       drv->soc_data-
Quoted 1 line

proc_max_volt),

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+					   drv->soc_data-
Quoted 1 line

min_volt_shift);

drivers/devfreq/mtk-cci-devfreq.c new file +20 -0
+
+	ret = clk_prepare_enable(drv->cci_clk);
+	if (ret)
+		goto out_free_resources;
+
+	ret = clk_prepare_enable(drv->inter_clk);
+	if (ret)
+		goto out_disable_cci_clk;
+
+	ret = dev_pm_opp_of_add_table(dev);
+	if (ret) {
+		dev_err(dev, "failed to add opp table: %d\n", ret);
+		goto out_disable_inter_clk;
+	}
+
+	rate = clk_get_rate(drv->inter_clk);
+	opp = dev_pm_opp_find_freq_ceil(dev, &rate);
+	if (IS_ERR(opp)) {
+		ret = PTR_ERR(opp);
+		dev_err(dev, "failed to get intermediate opp: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +18 -0
+		goto out_remove_opp_table;
+	}
+	drv->inter_voltage = dev_pm_opp_get_voltage(opp);
+	dev_pm_opp_put(opp);
+
+	rate = U32_MAX;
+	opp = dev_pm_opp_find_freq_floor(drv->dev, &rate);
+	if (IS_ERR(opp)) {
+		dev_err(dev, "failed to get opp\n");
+		ret = PTR_ERR(opp);
+		goto out_remove_opp_table;
+	}
+
+	opp_volt = dev_pm_opp_get_voltage(opp);
+	dev_pm_opp_put(opp);
+	ret = mtk_ccifreq_set_voltage(drv, opp_volt);
+	if (ret) {
+		dev_err(dev, "failed to scale to highest voltage %lu in

proc_reg\n",

drivers/devfreq/mtk-cci-devfreq.c new file +5 -0
+			opp_volt);
+		goto out_remove_opp_table;
+	}
+
+	passive_data = devm_kzalloc(dev, sizeof(struct

devfreq_passive_data),

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+				    GFP_KERNEL);
+	if (!passive_data) {
+		ret = -ENOMEM;
+		goto out_remove_opp_table;
+	}
+
+	passive_data->parent_type = CPUFREQ_PARENT_DEV;
+	drv->devfreq = devm_devfreq_add_device(dev,

&mtk_ccifreq_profile,

drivers/devfreq/mtk-cci-devfreq.c new file +13 -0
+					       DEVFREQ_GOV_PASSIVE,
+					       passive_data);
+	if (IS_ERR(drv->devfreq)) {
+		ret = -EPROBE_DEFER;
+		dev_err(dev, "failed to add devfreq device: %ld\n",
+			PTR_ERR(drv->devfreq));
+		goto out_remove_opp_table;
+	}
+
+	drv->opp_nb.notifier_call = mtk_ccifreq_opp_notifier;
+	ret = dev_pm_opp_register_notifier(dev, &drv->opp_nb);
+	if (ret) {
+		dev_err(dev, "failed to register opp notifier: %d\n",

ret);

drivers/devfreq/mtk-cci-devfreq.c new file +53 -0
+		goto out_remove_devfreq_device;
+	}
+	return 0;
+
+out_remove_devfreq_device:
+	devm_devfreq_remove_device(dev, drv->devfreq);
+
+out_remove_opp_table:
+	dev_pm_opp_of_remove_table(dev);
+
+out_disable_inter_clk:
+	clk_disable_unprepare(drv->inter_clk);
+
+out_disable_cci_clk:
+	clk_disable_unprepare(drv->cci_clk);
+
+out_free_resources:
+	if (regulator_is_enabled(drv->proc_reg))
+		regulator_disable(drv->proc_reg);
+	if (drv->sram_reg && regulator_is_enabled(drv->sram_reg))
+		regulator_disable(drv->sram_reg);
+
+	if (!IS_ERR(drv->proc_reg))
+		regulator_put(drv->proc_reg);
+	if (!IS_ERR(drv->sram_reg))
+		regulator_put(drv->sram_reg);
+	if (!IS_ERR(drv->cci_clk))
+		clk_put(drv->cci_clk);
+	if (!IS_ERR(drv->inter_clk))
+		clk_put(drv->inter_clk);
+
+	return ret;
+}
+
+static int mtk_ccifreq_remove(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	struct mtk_ccifreq_drv *drv;
+
+	drv = platform_get_drvdata(pdev);
+
+	dev_pm_opp_unregister_notifier(dev, &drv->opp_nb);
+	dev_pm_opp_of_remove_table(dev);
+	clk_disable_unprepare(drv->inter_clk);
+	clk_disable_unprepare(drv->cci_clk);
+	regulator_disable(drv->proc_reg);
+	if (drv->sram_reg)
+		regulator_disable(drv->sram_reg);
+
+	return 0;
+}
+
+static const struct mtk_ccifreq_platform_data mt8183_platform_data =

{

drivers/devfreq/mtk-cci-devfreq.c new file +8 -0
+	.min_volt_shift = 100000,
+	.max_volt_shift = 200000,
+	.proc_max_volt = 1150000,
+	.sram_min_volt = 0,
+	.sram_max_volt = 1150000,
+};
+
+static const struct mtk_ccifreq_platform_data mt8186_platform_data =

{

drivers/devfreq/mtk-cci-devfreq.c new file +9 -0
+	.min_volt_shift = 100000,
+	.max_volt_shift = 250000,
+	.proc_max_volt = 1118750,
+	.sram_min_volt = 850000,
+	.sram_max_volt = 1118750,
+};
+
+static const struct of_device_id mtk_ccifreq_machines[] = {
+	{ .compatible = "mediatek,mt8183-cci", .data =

&mt8183_platform_data },

drivers/devfreq/mtk-cci-devfreq.c new file +1 -0
+	{ .compatible = "mediatek,mt8186-cci", .data =

&mt8186_platform_data },

drivers/devfreq/mtk-cci-devfreq.c new file +17 -0
+	{ },
+};
+MODULE_DEVICE_TABLE(of, mtk_ccifreq_machines);
+
+static struct platform_driver mtk_ccifreq_platdrv = {
+	.probe	= mtk_ccifreq_probe,
+	.remove	= mtk_ccifreq_remove,
+	.driver = {
+		.name = "mtk-ccifreq",
+		.of_match_table = mtk_ccifreq_machines,
+	},
+};
+module_platform_driver(mtk_ccifreq_platdrv);
+
+MODULE_DESCRIPTION("MediaTek CCI devfreq driver");
+MODULE_AUTHOR("Jia-Wei Chang <[email protected]>");
+MODULE_LICENSE("GPL v2");