2023-07-04 09:44:13

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 00/26] Add perf support to the rockchip-dfi driver

No functional change in this series, only the accidently slipped in link:
tags have been removed and some Acked-by: from Conor Dooley are added.

I hope that someone steps forward and applies this series. Unfortunately
I haven't heard a word from the official maintainers to this series. So
maybe Heiko, how about you?

Sascha

Changes since v6:
- Add some Acked-by
- remove link: tags

Changes since v5:
- Add missing initialization of &dfi->last_perf_count which resulted
in wrong data sometimes
- Drop interrupt-names property from binding
- Add patch to add rockchip,rk3588-pmugrf to dt-bindings
- Add more reviewed-by tags

Changes since v4:
- Add device tree changes for RK3588
- Use seqlock to protect perf counter values from hrtimer
- Unconditionally enable DFI when perf is enabled
- Bring back changes to dts/binding patches that were lost in v4

Changes since v3:
- Add RK3588 support

Changes since v2:
- Fix broken reference to binding
- Add Reviewed-by from Rob

Changes since v1:
- Fix example to actually match the binding and fix the warnings resulted thereof
- Make addition of rockchip,rk3568-dfi an extra patch

Sascha Hauer (26):
PM / devfreq: rockchip-dfi: Make pmu regmap mandatory
PM / devfreq: rockchip-dfi: Embed desc into private data struct
PM / devfreq: rockchip-dfi: use consistent name for private data
struct
PM / devfreq: rockchip-dfi: Add SoC specific init function
PM / devfreq: rockchip-dfi: dfi store raw values in counter struct
PM / devfreq: rockchip-dfi: Use free running counter
PM / devfreq: rockchip-dfi: introduce channel mask
PM / devfreq: rk3399_dmc,dfi: generalize DDRTYPE defines
PM / devfreq: rockchip-dfi: Clean up DDR type register defines
PM / devfreq: rockchip-dfi: Add RK3568 support
PM / devfreq: rockchip-dfi: Handle LPDDR2 correctly
PM / devfreq: rockchip-dfi: Handle LPDDR4X
PM / devfreq: rockchip-dfi: Pass private data struct to internal
functions
PM / devfreq: rockchip-dfi: Prepare for multiple users
PM / devfreq: rockchip-dfi: give variable a better name
PM / devfreq: rockchip-dfi: Add perf support
PM / devfreq: rockchip-dfi: make register stride SoC specific
PM / devfreq: rockchip-dfi: account for multiple DDRMON_CTRL registers
PM / devfreq: rockchip-dfi: add support for RK3588
dt-bindings: devfreq: event: convert Rockchip DFI binding to yaml
dt-bindings: devfreq: event: rockchip,dfi: Add rk3568 support
dt-bindings: devfreq: event: rockchip,dfi: Add rk3588 support
dt-bindings: soc: rockchip: grf: add rockchip,rk3588-pmugrf
arm64: dts: rockchip: rk3399: Enable DFI
arm64: dts: rockchip: rk356x: Add DFI
arm64: dts: rockchip: rk3588s: Add DFI

.../bindings/devfreq/event/rockchip,dfi.yaml | 74 ++
.../bindings/devfreq/event/rockchip-dfi.txt | 18 -
.../rockchip,rk3399-dmc.yaml | 2 +-
.../devicetree/bindings/soc/rockchip/grf.yaml | 1 +
arch/arm64/boot/dts/rockchip/rk3399.dtsi | 1 -
arch/arm64/boot/dts/rockchip/rk356x.dtsi | 7 +
arch/arm64/boot/dts/rockchip/rk3588s.dtsi | 16 +
drivers/devfreq/event/rockchip-dfi.c | 799 +++++++++++++++---
drivers/devfreq/rk3399_dmc.c | 10 +-
include/soc/rockchip/rk3399_grf.h | 9 +-
include/soc/rockchip/rk3568_grf.h | 13 +
include/soc/rockchip/rk3588_grf.h | 18 +
include/soc/rockchip/rockchip_grf.h | 18 +
13 files changed, 848 insertions(+), 138 deletions(-)
create mode 100644 Documentation/devicetree/bindings/devfreq/event/rockchip,dfi.yaml
delete mode 100644 Documentation/devicetree/bindings/devfreq/event/rockchip-dfi.txt
create mode 100644 include/soc/rockchip/rk3568_grf.h
create mode 100644 include/soc/rockchip/rk3588_grf.h
create mode 100644 include/soc/rockchip/rockchip_grf.h

--
2.39.2



2023-07-04 09:44:20

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 18/26] PM / devfreq: rockchip-dfi: account for multiple DDRMON_CTRL registers

The currently supported RK3399 has a set of registers per channel, but
it has only a single DDRMON_CTRL register. With upcoming RK3588 this
will be different, the RK3588 has a DDRMON_CTRL register per channel.

Instead of expecting a single DDRMON_CTRL register, loop over the
channels and write the channel specific DDRMON_CTRL register. Break
out early out of the loop when there is only a single DDRMON_CTRL
register like on the RK3399.

Reviewed-by: Jonathan Cameron <[email protected]>
Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 72 ++++++++++++++++++----------
1 file changed, 48 insertions(+), 24 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 85ec93fd41858..2362d3953ba40 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -113,12 +113,13 @@ struct rockchip_dfi {
int burst_len;
int buswidth[DMC_MAX_CHANNELS];
int ddrmon_stride;
+ bool ddrmon_ctrl_single;
};

static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
{
void __iomem *dfi_regs = dfi->regs;
- int ret = 0;
+ int i, ret = 0;

mutex_lock(&dfi->mutex);

@@ -132,29 +133,41 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
goto out;
}

- /* clear DDRMON_CTRL setting */
- writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
- DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
+ for (i = 0; i < DMC_MAX_CHANNELS; i++) {
+ u32 ctrl = 0;

- /* set ddr type to dfi */
- switch (dfi->ddr_type) {
- case ROCKCHIP_DDRTYPE_LPDDR2:
- case ROCKCHIP_DDRTYPE_LPDDR3:
- writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
- dfi_regs + DDRMON_CTRL);
- break;
- case ROCKCHIP_DDRTYPE_LPDDR4:
- case ROCKCHIP_DDRTYPE_LPDDR4X:
- writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
- dfi_regs + DDRMON_CTRL);
- break;
- default:
- break;
- }
+ if (!(dfi->channel_mask & BIT(i)))
+ continue;

- /* enable count, use software mode */
- writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
- dfi_regs + DDRMON_CTRL);
+ /* clear DDRMON_CTRL setting */
+ writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN |
+ DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN),
+ dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
+
+ /* set ddr type to dfi */
+ switch (dfi->ddr_type) {
+ case ROCKCHIP_DDRTYPE_LPDDR2:
+ case ROCKCHIP_DDRTYPE_LPDDR3:
+ ctrl = DDRMON_CTRL_LPDDR23;
+ break;
+ case ROCKCHIP_DDRTYPE_LPDDR4:
+ case ROCKCHIP_DDRTYPE_LPDDR4X:
+ ctrl = DDRMON_CTRL_LPDDR4;
+ break;
+ default:
+ break;
+ }
+
+ writel_relaxed(HIWORD_UPDATE(ctrl, DDRMON_CTRL_DDR_TYPE_MASK),
+ dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
+
+ /* enable count, use software mode */
+ writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
+ dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
+
+ if (dfi->ddrmon_ctrl_single)
+ break;
+ }
out:
mutex_unlock(&dfi->mutex);

@@ -164,6 +177,7 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
{
void __iomem *dfi_regs = dfi->regs;
+ int i;

mutex_lock(&dfi->mutex);

@@ -174,8 +188,17 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
if (dfi->usecount > 0)
goto out;

- writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
- dfi_regs + DDRMON_CTRL);
+ for (i = 0; i < DMC_MAX_CHANNELS; i++) {
+ if (!(dfi->channel_mask & BIT(i)))
+ continue;
+
+ writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
+ dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
+
+ if (dfi->ddrmon_ctrl_single)
+ break;
+ }
+
clk_disable_unprepare(dfi->clk);
out:
mutex_unlock(&dfi->mutex);
@@ -666,6 +689,7 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;

dfi->ddrmon_stride = 0x14;
+ dfi->ddrmon_ctrl_single = true;

return 0;
};
--
2.39.2


2023-07-04 09:44:21

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 01/26] PM / devfreq: rockchip-dfi: Make pmu regmap mandatory

As a matter of fact the regmap_pmu already is mandatory because
it is used unconditionally in the driver. Bail out gracefully in
probe() rather than crashing later.

Fixes: b9d1262bca0af ("PM / devfreq: event: support rockchip dfi controller")
Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---

Notes:
Changes since v4:
- move to beginning of the series to make it easier to backport to stable
- Add a Fixes: tag
- add missing of_node_put()

drivers/devfreq/event/rockchip-dfi.c | 15 ++++++++-------
1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 39ac069cabc75..74893c06aa087 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -193,14 +193,15 @@ static int rockchip_dfi_probe(struct platform_device *pdev)
return dev_err_probe(dev, PTR_ERR(data->clk),
"Cannot get the clk pclk_ddr_mon\n");

- /* try to find the optional reference to the pmu syscon */
node = of_parse_phandle(np, "rockchip,pmu", 0);
- if (node) {
- data->regmap_pmu = syscon_node_to_regmap(node);
- of_node_put(node);
- if (IS_ERR(data->regmap_pmu))
- return PTR_ERR(data->regmap_pmu);
- }
+ if (!node)
+ return dev_err_probe(&pdev->dev, -ENODEV, "Can't find pmu_grf registers\n");
+
+ data->regmap_pmu = syscon_node_to_regmap(node);
+ of_node_put(node);
+ if (IS_ERR(data->regmap_pmu))
+ return PTR_ERR(data->regmap_pmu);
+
data->dev = dev;

desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
--
2.39.2


2023-07-04 09:44:27

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 08/26] PM / devfreq: rk3399_dmc,dfi: generalize DDRTYPE defines

The DDRTYPE defines are named to be RK3399 specific, but they can be
used for other Rockchip SoCs as well, so replace the RK3399_PMUGRF_
prefix with ROCKCHIP_. They are defined in a SoC specific header
file, so when generalizing the prefix also move the new defines to
a SoC agnostic header file. While at it use GENMASK to define the
DDRTYPE bitfield and give it a name including the full register name.

Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 9 +++++----
drivers/devfreq/rk3399_dmc.c | 10 +++++-----
include/soc/rockchip/rk3399_grf.h | 7 +------
include/soc/rockchip/rockchip_grf.h | 17 +++++++++++++++++
4 files changed, 28 insertions(+), 15 deletions(-)
create mode 100644 include/soc/rockchip/rockchip_grf.h

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 82de24a027579..6bccb6fbcfc0c 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -18,8 +18,10 @@
#include <linux/list.h>
#include <linux/of.h>
#include <linux/of_device.h>
+#include <linux/bitfield.h>
#include <linux/bits.h>

+#include <soc/rockchip/rockchip_grf.h>
#include <soc/rockchip/rk3399_grf.h>

#define DMC_MAX_CHANNELS 2
@@ -74,9 +76,9 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);

/* set ddr type to dfi */
- if (dfi->ddr_type == RK3399_PMUGRF_DDRTYPE_LPDDR3)
+ if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
- else if (dfi->ddr_type == RK3399_PMUGRF_DDRTYPE_LPDDR4)
+ else if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR4)
writel_relaxed(LPDDR4_EN, dfi_regs + DDRMON_CTRL);

/* enable count, use software mode */
@@ -191,8 +193,7 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)

/* get ddr type */
regmap_read(regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
- dfi->ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
- RK3399_PMUGRF_DDRTYPE_MASK;
+ dfi->ddr_type = FIELD_GET(RK3399_PMUGRF_OS_REG2_DDRTYPE, val);

dfi->channel_mask = GENMASK(1, 0);

diff --git a/drivers/devfreq/rk3399_dmc.c b/drivers/devfreq/rk3399_dmc.c
index daff407026157..fd2c5ffedf41e 100644
--- a/drivers/devfreq/rk3399_dmc.c
+++ b/drivers/devfreq/rk3399_dmc.c
@@ -22,6 +22,7 @@
#include <linux/suspend.h>

#include <soc/rockchip/pm_domains.h>
+#include <soc/rockchip/rockchip_grf.h>
#include <soc/rockchip/rk3399_grf.h>
#include <soc/rockchip/rockchip_sip.h>

@@ -381,17 +382,16 @@ static int rk3399_dmcfreq_probe(struct platform_device *pdev)
}

regmap_read(data->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
- ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
- RK3399_PMUGRF_DDRTYPE_MASK;
+ ddr_type = FIELD_GET(RK3399_PMUGRF_OS_REG2_DDRTYPE, val);

switch (ddr_type) {
- case RK3399_PMUGRF_DDRTYPE_DDR3:
+ case ROCKCHIP_DDRTYPE_DDR3:
data->odt_dis_freq = data->ddr3_odt_dis_freq;
break;
- case RK3399_PMUGRF_DDRTYPE_LPDDR3:
+ case ROCKCHIP_DDRTYPE_LPDDR3:
data->odt_dis_freq = data->lpddr3_odt_dis_freq;
break;
- case RK3399_PMUGRF_DDRTYPE_LPDDR4:
+ case ROCKCHIP_DDRTYPE_LPDDR4:
data->odt_dis_freq = data->lpddr4_odt_dis_freq;
break;
default:
diff --git a/include/soc/rockchip/rk3399_grf.h b/include/soc/rockchip/rk3399_grf.h
index 3eebabcb28123..775f8444bea8d 100644
--- a/include/soc/rockchip/rk3399_grf.h
+++ b/include/soc/rockchip/rk3399_grf.h
@@ -11,11 +11,6 @@

/* PMU GRF Registers */
#define RK3399_PMUGRF_OS_REG2 0x308
-#define RK3399_PMUGRF_DDRTYPE_SHIFT 13
-#define RK3399_PMUGRF_DDRTYPE_MASK 7
-#define RK3399_PMUGRF_DDRTYPE_DDR3 3
-#define RK3399_PMUGRF_DDRTYPE_LPDDR2 5
-#define RK3399_PMUGRF_DDRTYPE_LPDDR3 6
-#define RK3399_PMUGRF_DDRTYPE_LPDDR4 7
+#define RK3399_PMUGRF_OS_REG2_DDRTYPE GENMASK(15, 13)

#endif
diff --git a/include/soc/rockchip/rockchip_grf.h b/include/soc/rockchip/rockchip_grf.h
new file mode 100644
index 0000000000000..dde1a9796ccb5
--- /dev/null
+++ b/include/soc/rockchip/rockchip_grf.h
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Rockchip General Register Files definitions
+ */
+
+#ifndef __SOC_ROCKCHIP_GRF_H
+#define __SOC_ROCKCHIP_GRF_H
+
+/* Rockchip DDRTYPE defines */
+enum {
+ ROCKCHIP_DDRTYPE_DDR3 = 3,
+ ROCKCHIP_DDRTYPE_LPDDR2 = 5,
+ ROCKCHIP_DDRTYPE_LPDDR3 = 6,
+ ROCKCHIP_DDRTYPE_LPDDR4 = 7,
+};
+
+#endif /* __SOC_ROCKCHIP_GRF_H */
--
2.39.2


2023-07-04 09:44:30

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 26/26] arm64: dts: rockchip: rk3588s: Add DFI

The DFI unit can be used to measure DRAM utilization using perf. Add the
node to the device tree. The DFI needs a rockchip,pmu phandle to the pmu
containing registers for SDRAM configuration details. This is added in
this patch as well.

Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---

Notes:
Changes since v4:
- new patch

arch/arm64/boot/dts/rockchip/rk3588s.dtsi | 16 ++++++++++++++++
1 file changed, 16 insertions(+)

diff --git a/arch/arm64/boot/dts/rockchip/rk3588s.dtsi b/arch/arm64/boot/dts/rockchip/rk3588s.dtsi
index a3124bd2e092c..723a17ec04361 100644
--- a/arch/arm64/boot/dts/rockchip/rk3588s.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3588s.dtsi
@@ -397,6 +397,11 @@ scmi_shmem: sram@0 {
};
};

+ pmu1grf: syscon@fd58a000 {
+ compatible = "rockchip,rk3588-pmugrf", "syscon", "simple-mfd";
+ reg = <0x0 0xfd58a000 0x0 0x10000>;
+ };
+
sys_grf: syscon@fd58c000 {
compatible = "rockchip,rk3588-sys-grf", "syscon";
reg = <0x0 0xfd58c000 0x0 0x1000>;
@@ -1121,6 +1126,17 @@ qos_vop_m1: qos@fdf82200 {
reg = <0x0 0xfdf82200 0x0 0x20>;
};

+ dfi: dfi@fe060000 {
+ reg = <0x00 0xfe060000 0x00 0x10000>;
+ compatible = "rockchip,rk3588-dfi";
+ interrupts = <GIC_SPI 28 IRQ_TYPE_LEVEL_HIGH 0>,
+ <GIC_SPI 38 IRQ_TYPE_LEVEL_HIGH 0>,
+ <GIC_SPI 48 IRQ_TYPE_LEVEL_HIGH 0>,
+ <GIC_SPI 58 IRQ_TYPE_LEVEL_HIGH 0>;
+ interrupt-names = "ch0", "ch1", "ch2", "ch3";
+ rockchip,pmu = <&pmu1grf>;
+ };
+
gmac1: ethernet@fe1c0000 {
compatible = "rockchip,rk3588-gmac", "snps,dwmac-4.20a";
reg = <0x0 0xfe1c0000 0x0 0x10000>;
--
2.39.2


2023-07-04 09:45:30

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 14/26] PM / devfreq: rockchip-dfi: Prepare for multiple users

When adding perf support later the DFI must be enabled when
either of devfreq-event or perf is active. Prepare for that
by adding a usage counter for the DFI. Also move enabling
and disabling of the clock away from the devfreq-event specific
functions to which the perf specific part won't have access.

Reviewed-by: Jonathan Cameron <[email protected]>
Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 57 +++++++++++++++++++---------
1 file changed, 40 insertions(+), 17 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index d39db5de7f19c..8a7af7c32ae0d 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -68,13 +68,28 @@ struct rockchip_dfi {
void __iomem *regs;
struct regmap *regmap_pmu;
struct clk *clk;
+ int usecount;
+ struct mutex mutex;
u32 ddr_type;
unsigned int channel_mask;
};

-static void rockchip_dfi_start_hardware_counter(struct rockchip_dfi *dfi)
+static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
{
void __iomem *dfi_regs = dfi->regs;
+ int ret = 0;
+
+ mutex_lock(&dfi->mutex);
+
+ dfi->usecount++;
+ if (dfi->usecount > 1)
+ goto out;
+
+ ret = clk_prepare_enable(dfi->clk);
+ if (ret) {
+ dev_err(&dfi->edev->dev, "failed to enable dfi clk: %d\n", ret);
+ goto out;
+ }

/* clear DDRMON_CTRL setting */
writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
@@ -99,14 +114,30 @@ static void rockchip_dfi_start_hardware_counter(struct rockchip_dfi *dfi)
/* enable count, use software mode */
writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
dfi_regs + DDRMON_CTRL);
+out:
+ mutex_unlock(&dfi->mutex);
+
+ return ret;
}

-static void rockchip_dfi_stop_hardware_counter(struct rockchip_dfi *dfi)
+static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
{
void __iomem *dfi_regs = dfi->regs;

+ mutex_lock(&dfi->mutex);
+
+ dfi->usecount--;
+
+ WARN_ON_ONCE(dfi->usecount < 0);
+
+ if (dfi->usecount > 0)
+ goto out;
+
writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
dfi_regs + DDRMON_CTRL);
+ clk_disable_unprepare(dfi->clk);
+out:
+ mutex_unlock(&dfi->mutex);
}

static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *count)
@@ -124,29 +155,20 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
}
}

-static int rockchip_dfi_disable(struct devfreq_event_dev *edev)
+static int rockchip_dfi_event_disable(struct devfreq_event_dev *edev)
{
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);

- rockchip_dfi_stop_hardware_counter(dfi);
- clk_disable_unprepare(dfi->clk);
+ rockchip_dfi_disable(dfi);

return 0;
}

-static int rockchip_dfi_enable(struct devfreq_event_dev *edev)
+static int rockchip_dfi_event_enable(struct devfreq_event_dev *edev)
{
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
- int ret;
-
- ret = clk_prepare_enable(dfi->clk);
- if (ret) {
- dev_err(&edev->dev, "failed to enable dfi clk: %d\n", ret);
- return ret;
- }

- rockchip_dfi_start_hardware_counter(dfi);
- return 0;
+ return rockchip_dfi_enable(dfi);
}

static int rockchip_dfi_set_event(struct devfreq_event_dev *edev)
@@ -190,8 +212,8 @@ static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
}

static const struct devfreq_event_ops rockchip_dfi_ops = {
- .disable = rockchip_dfi_disable,
- .enable = rockchip_dfi_enable,
+ .disable = rockchip_dfi_event_disable,
+ .enable = rockchip_dfi_event_enable,
.get_event = rockchip_dfi_get_event,
.set_event = rockchip_dfi_set_event,
};
@@ -272,6 +294,7 @@ static int rockchip_dfi_probe(struct platform_device *pdev)
return PTR_ERR(dfi->regmap_pmu);

dfi->dev = dev;
+ mutex_init(&dfi->mutex);

desc = &dfi->desc;
desc->ops = &rockchip_dfi_ops;
--
2.39.2


2023-07-04 09:46:21

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 16/26] PM / devfreq: rockchip-dfi: Add perf support

The DFI is a unit which is suitable for measuring DDR utilization, but
so far it could only be used as an event driver for the DDR frequency
scaling driver. This adds perf support to the DFI driver.

Usage with the 'perf' tool can look like:

perf stat -a -e rockchip_ddr/cycles/,\
rockchip_ddr/read-bytes/,\
rockchip_ddr/write-bytes/,\
rockchip_ddr/bytes/ sleep 1

Performance counter stats for 'system wide':

1582524826 rockchip_ddr/cycles/
1802.25 MB rockchip_ddr/read-bytes/
1793.72 MB rockchip_ddr/write-bytes/
3595.90 MB rockchip_ddr/bytes/

1.014369709 seconds time elapsed

perf support has been tested on a RK3568 and a RK3399, the latter with
dual channel DDR.

Signed-off-by: Sascha Hauer <[email protected]>
Reviewed-by: Sebastian Reichel <[email protected]>
---

Notes:
Changes since v5:
- Add missing initialization of &dfi->last_perf_count

Changes since v4:

- use __stringify to ensure event type definitions and event numbers in sysfs are consistent
- only use 64bit values in structs holding counters
- support monitoring individual DDR channels
- fix return value in rockchip_ddr_perf_event_init(): -EOPNOTSUPP -> -EINVAL
- check for invalid event->attr.config values
- start hrtimer to trigger in one second, not immediately
- use devm_add_action_or_reset()
- add suppress_bind_attrs
- enable DDRMON during probe when perf is enabled
- use a seqlock to protect perf reading the counters from the hrtimer callback modifying them

drivers/devfreq/event/rockchip-dfi.c | 442 ++++++++++++++++++++++++++-
include/soc/rockchip/rk3399_grf.h | 2 +
include/soc/rockchip/rk3568_grf.h | 1 +
3 files changed, 440 insertions(+), 5 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 50e497455dc69..969b62f071b83 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -16,10 +16,12 @@
#include <linux/regmap.h>
#include <linux/slab.h>
#include <linux/list.h>
+#include <linux/seqlock.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
+#include <linux/perf_event.h>

#include <soc/rockchip/rockchip_grf.h>
#include <soc/rockchip/rk3399_grf.h>
@@ -41,19 +43,39 @@
DDRMON_CTRL_LPDDR4 | \
DDRMON_CTRL_LPDDR23)

+#define DDRMON_CH0_WR_NUM 0x20
+#define DDRMON_CH0_RD_NUM 0x24
#define DDRMON_CH0_COUNT_NUM 0x28
#define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
#define DDRMON_CH1_COUNT_NUM 0x3c
#define DDRMON_CH1_DFI_ACCESS_NUM 0x40

+#define PERF_EVENT_CYCLES 0x0
+#define PERF_EVENT_READ_BYTES 0x1
+#define PERF_EVENT_WRITE_BYTES 0x2
+#define PERF_EVENT_READ_BYTES0 0x3
+#define PERF_EVENT_WRITE_BYTES0 0x4
+#define PERF_EVENT_READ_BYTES1 0x5
+#define PERF_EVENT_WRITE_BYTES1 0x6
+#define PERF_EVENT_READ_BYTES2 0x7
+#define PERF_EVENT_WRITE_BYTES2 0x8
+#define PERF_EVENT_READ_BYTES3 0x9
+#define PERF_EVENT_WRITE_BYTES3 0xa
+#define PERF_EVENT_BYTES 0xb
+#define PERF_ACCESS_TYPE_MAX 0xc
+
/**
* struct dmc_count_channel - structure to hold counter values from the DDR controller
* @access: Number of read and write accesses
* @clock_cycles: DDR clock cycles
+ * @read_access: number of read accesses
+ * @write_acccess: number of write accesses
*/
struct dmc_count_channel {
- u32 access;
- u32 clock_cycles;
+ u64 access;
+ u64 clock_cycles;
+ u64 read_access;
+ u64 write_access;
};

struct dmc_count {
@@ -69,6 +91,11 @@ struct rockchip_dfi {
struct devfreq_event_dev *edev;
struct devfreq_event_desc desc;
struct dmc_count last_event_count;
+
+ struct dmc_count last_perf_count;
+ struct dmc_count total_count;
+ seqlock_t count_seqlock; /* protects last_perf_count and total_count */
+
struct device *dev;
void __iomem *regs;
struct regmap *regmap_pmu;
@@ -77,6 +104,14 @@ struct rockchip_dfi {
struct mutex mutex;
u32 ddr_type;
unsigned int channel_mask;
+ enum cpuhp_state cpuhp_state;
+ struct hlist_node node;
+ struct pmu pmu;
+ struct hrtimer timer;
+ unsigned int cpu;
+ int active_events;
+ int burst_len;
+ int buswidth[DMC_MAX_CHANNELS];
};

static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
@@ -145,7 +180,7 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
mutex_unlock(&dfi->mutex);
}

-static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *count)
+static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *c)
{
u32 i;
void __iomem *dfi_regs = dfi->regs;
@@ -153,13 +188,36 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
for (i = 0; i < DMC_MAX_CHANNELS; i++) {
if (!(dfi->channel_mask & BIT(i)))
continue;
- count->c[i].access = readl_relaxed(dfi_regs +
+ c->c[i].read_access = readl_relaxed(dfi_regs +
+ DDRMON_CH0_RD_NUM + i * 20);
+ c->c[i].write_access = readl_relaxed(dfi_regs +
+ DDRMON_CH0_WR_NUM + i * 20);
+ c->c[i].access = readl_relaxed(dfi_regs +
DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
- count->c[i].clock_cycles = readl_relaxed(dfi_regs +
+ c->c[i].clock_cycles = readl_relaxed(dfi_regs +
DDRMON_CH0_COUNT_NUM + i * 20);
}
}

+static void rockchip_ddr_perf_counters_add(struct rockchip_dfi *dfi,
+ const struct dmc_count *now,
+ struct dmc_count *res)
+{
+ const struct dmc_count *last = &dfi->last_perf_count;
+ int i;
+
+ for (i = 0; i < DMC_MAX_CHANNELS; i++) {
+ res->c[i].read_access = dfi->total_count.c[i].read_access +
+ (u32)(now->c[i].read_access - last->c[i].read_access);
+ res->c[i].write_access = dfi->total_count.c[i].write_access +
+ (u32)(now->c[i].write_access - last->c[i].write_access);
+ res->c[i].access = dfi->total_count.c[i].access +
+ (u32)(now->c[i].access - last->c[i].access);
+ res->c[i].clock_cycles = dfi->total_count.c[i].clock_cycles +
+ (u32)(now->c[i].clock_cycles - last->c[i].clock_cycles);
+ }
+}
+
static int rockchip_dfi_event_disable(struct devfreq_event_dev *edev)
{
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
@@ -223,6 +281,370 @@ static const struct devfreq_event_ops rockchip_dfi_ops = {
.set_event = rockchip_dfi_set_event,
};

+#ifdef CONFIG_PERF_EVENTS
+
+static ssize_t ddr_perf_cpumask_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct pmu *pmu = dev_get_drvdata(dev);
+ struct rockchip_dfi *dfi = container_of(pmu, struct rockchip_dfi, pmu);
+
+ return cpumap_print_to_pagebuf(true, buf, cpumask_of(dfi->cpu));
+}
+
+static struct device_attribute ddr_perf_cpumask_attr =
+ __ATTR(cpumask, 0444, ddr_perf_cpumask_show, NULL);
+
+static struct attribute *ddr_perf_cpumask_attrs[] = {
+ &ddr_perf_cpumask_attr.attr,
+ NULL,
+};
+
+static const struct attribute_group ddr_perf_cpumask_attr_group = {
+ .attrs = ddr_perf_cpumask_attrs,
+};
+
+PMU_EVENT_ATTR_STRING(cycles, ddr_pmu_cycles, "event="__stringify(PERF_EVENT_CYCLES))
+
+#define DFI_PMU_EVENT_ATTR(_name, _var, _str) \
+ PMU_EVENT_ATTR_STRING(_name, _var, _str); \
+ PMU_EVENT_ATTR_STRING(_name.unit, _var##_unit, "MB"); \
+ PMU_EVENT_ATTR_STRING(_name.scale, _var##_scale, "9.536743164e-07")
+
+DFI_PMU_EVENT_ATTR(read-bytes0, ddr_pmu_read_bytes0, "event="__stringify(PERF_EVENT_READ_BYTES0));
+DFI_PMU_EVENT_ATTR(write-bytes0, ddr_pmu_write_bytes0, "event="__stringify(PERF_EVENT_WRITE_BYTES0));
+
+DFI_PMU_EVENT_ATTR(read-bytes1, ddr_pmu_read_bytes1, "event="__stringify(PERF_EVENT_READ_BYTES1));
+DFI_PMU_EVENT_ATTR(write-bytes1, ddr_pmu_write_bytes1, "event="__stringify(PERF_EVENT_WRITE_BYTES1));
+
+DFI_PMU_EVENT_ATTR(read-bytes2, ddr_pmu_read_bytes2, "event="__stringify(PERF_EVENT_READ_BYTES2));
+DFI_PMU_EVENT_ATTR(write-bytes2, ddr_pmu_write_bytes2, "event="__stringify(PERF_EVENT_WRITE_BYTES2));
+
+DFI_PMU_EVENT_ATTR(read-bytes3, ddr_pmu_read_bytes3, "event="__stringify(PERF_EVENT_READ_BYTES3));
+DFI_PMU_EVENT_ATTR(write-bytes3, ddr_pmu_write_bytes3, "event="__stringify(PERF_EVENT_WRITE_BYTES3));
+
+DFI_PMU_EVENT_ATTR(read-bytes, ddr_pmu_read_bytes, "event="__stringify(PERF_EVENT_READ_BYTES));
+DFI_PMU_EVENT_ATTR(write-bytes, ddr_pmu_write_bytes, "event="__stringify(PERF_EVENT_WRITE_BYTES));
+
+DFI_PMU_EVENT_ATTR(bytes, ddr_pmu_bytes, "event="__stringify(PERF_EVENT_BYTES));
+
+#define DFI_ATTR_MB(_name) \
+ &_name.attr.attr, \
+ &_name##_unit.attr.attr, \
+ &_name##_scale.attr.attr
+
+static struct attribute *ddr_perf_events_attrs[] = {
+ &ddr_pmu_cycles.attr.attr,
+ DFI_ATTR_MB(ddr_pmu_read_bytes),
+ DFI_ATTR_MB(ddr_pmu_write_bytes),
+ DFI_ATTR_MB(ddr_pmu_read_bytes0),
+ DFI_ATTR_MB(ddr_pmu_write_bytes0),
+ DFI_ATTR_MB(ddr_pmu_read_bytes1),
+ DFI_ATTR_MB(ddr_pmu_write_bytes1),
+ DFI_ATTR_MB(ddr_pmu_read_bytes2),
+ DFI_ATTR_MB(ddr_pmu_write_bytes2),
+ DFI_ATTR_MB(ddr_pmu_read_bytes3),
+ DFI_ATTR_MB(ddr_pmu_write_bytes3),
+ DFI_ATTR_MB(ddr_pmu_bytes),
+ NULL,
+};
+
+static const struct attribute_group ddr_perf_events_attr_group = {
+ .name = "events",
+ .attrs = ddr_perf_events_attrs,
+};
+
+PMU_FORMAT_ATTR(event, "config:0-7");
+
+static struct attribute *ddr_perf_format_attrs[] = {
+ &format_attr_event.attr,
+ NULL,
+};
+
+static const struct attribute_group ddr_perf_format_attr_group = {
+ .name = "format",
+ .attrs = ddr_perf_format_attrs,
+};
+
+static const struct attribute_group *attr_groups[] = {
+ &ddr_perf_events_attr_group,
+ &ddr_perf_cpumask_attr_group,
+ &ddr_perf_format_attr_group,
+ NULL,
+};
+
+static int rockchip_ddr_perf_event_init(struct perf_event *event)
+{
+ struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
+
+ if (event->attr.type != event->pmu->type)
+ return -ENOENT;
+
+ if (event->attach_state & PERF_ATTACH_TASK)
+ return -EINVAL;
+
+ if (event->cpu < 0) {
+ dev_warn(dfi->dev, "Can't provide per-task data!\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static u64 rockchip_ddr_perf_event_get_count(struct perf_event *event)
+{
+ struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
+ int blen = dfi->burst_len;
+ struct dmc_count total, now;
+ unsigned int seq;
+ u64 c = 0;
+ int i;
+
+ rockchip_dfi_read_counters(dfi, &now);
+
+ do {
+ seq = read_seqbegin(&dfi->count_seqlock);
+
+ rockchip_ddr_perf_counters_add(dfi, &now, &total);
+
+ } while (read_seqretry(&dfi->count_seqlock, seq));
+
+ switch (event->attr.config) {
+ case PERF_EVENT_CYCLES:
+ c = total.c[0].clock_cycles;
+ break;
+ case PERF_EVENT_READ_BYTES:
+ for (i = 0; i < DMC_MAX_CHANNELS; i++)
+ c += total.c[i].read_access * blen * dfi->buswidth[i];
+ break;
+ case PERF_EVENT_WRITE_BYTES:
+ for (i = 0; i < DMC_MAX_CHANNELS; i++)
+ c += total.c[i].write_access * blen * dfi->buswidth[i];
+ break;
+ case PERF_EVENT_READ_BYTES0:
+ c = total.c[0].read_access * blen * dfi->buswidth[0];
+ break;
+ case PERF_EVENT_WRITE_BYTES0:
+ c = total.c[0].write_access * blen * dfi->buswidth[0];
+ break;
+ case PERF_EVENT_READ_BYTES1:
+ c = total.c[1].read_access * blen * dfi->buswidth[1];
+ break;
+ case PERF_EVENT_WRITE_BYTES1:
+ c = total.c[1].write_access * blen * dfi->buswidth[1];
+ break;
+ case PERF_EVENT_READ_BYTES2:
+ c = total.c[2].read_access * blen * dfi->buswidth[2];
+ break;
+ case PERF_EVENT_WRITE_BYTES2:
+ c = total.c[2].write_access * blen * dfi->buswidth[2];
+ break;
+ case PERF_EVENT_READ_BYTES3:
+ c = total.c[3].read_access * blen * dfi->buswidth[3];
+ break;
+ case PERF_EVENT_WRITE_BYTES3:
+ c = total.c[3].write_access * blen * dfi->buswidth[3];
+ break;
+ case PERF_EVENT_BYTES:
+ for (i = 0; i < DMC_MAX_CHANNELS; i++)
+ c += total.c[i].access * blen * dfi->buswidth[i];
+ break;
+ }
+
+ return c;
+}
+
+static void rockchip_ddr_perf_event_update(struct perf_event *event)
+{
+ u64 now;
+ s64 prev;
+
+ if (event->attr.config >= PERF_ACCESS_TYPE_MAX)
+ return;
+
+ now = rockchip_ddr_perf_event_get_count(event);
+ prev = local64_xchg(&event->hw.prev_count, now);
+ local64_add(now - prev, &event->count);
+}
+
+static void rockchip_ddr_perf_event_start(struct perf_event *event, int flags)
+{
+ u64 now = rockchip_ddr_perf_event_get_count(event);
+
+ local64_set(&event->hw.prev_count, now);
+}
+
+static int rockchip_ddr_perf_event_add(struct perf_event *event, int flags)
+{
+ struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
+
+ dfi->active_events++;
+
+ if (dfi->active_events == 1) {
+ dfi->total_count = (struct dmc_count){};
+ rockchip_dfi_read_counters(dfi, &dfi->last_perf_count);
+ hrtimer_start(&dfi->timer, ns_to_ktime(NSEC_PER_SEC), HRTIMER_MODE_REL);
+ }
+
+ if (flags & PERF_EF_START)
+ rockchip_ddr_perf_event_start(event, flags);
+
+ return 0;
+}
+
+static void rockchip_ddr_perf_event_stop(struct perf_event *event, int flags)
+{
+ rockchip_ddr_perf_event_update(event);
+}
+
+static void rockchip_ddr_perf_event_del(struct perf_event *event, int flags)
+{
+ struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
+
+ rockchip_ddr_perf_event_stop(event, PERF_EF_UPDATE);
+
+ dfi->active_events--;
+
+ if (dfi->active_events == 0)
+ hrtimer_cancel(&dfi->timer);
+}
+
+static enum hrtimer_restart rockchip_dfi_timer(struct hrtimer *timer)
+{
+ struct rockchip_dfi *dfi = container_of(timer, struct rockchip_dfi, timer);
+ struct dmc_count now, total;
+
+ rockchip_dfi_read_counters(dfi, &now);
+
+ write_seqlock(&dfi->count_seqlock);
+
+ rockchip_ddr_perf_counters_add(dfi, &now, &total);
+ dfi->total_count = total;
+ dfi->last_perf_count = now;
+
+ write_sequnlock(&dfi->count_seqlock);
+
+ hrtimer_forward_now(&dfi->timer, ns_to_ktime(NSEC_PER_SEC));
+
+ return HRTIMER_RESTART;
+};
+
+static int ddr_perf_offline_cpu(unsigned int cpu, struct hlist_node *node)
+{
+ struct rockchip_dfi *dfi = hlist_entry_safe(node, struct rockchip_dfi, node);
+ int target;
+
+ if (cpu != dfi->cpu)
+ return 0;
+
+ target = cpumask_any_but(cpu_online_mask, cpu);
+ if (target >= nr_cpu_ids)
+ return 0;
+
+ perf_pmu_migrate_context(&dfi->pmu, cpu, target);
+ dfi->cpu = target;
+
+ return 0;
+}
+
+static void rockchip_ddr_cpuhp_remove_state(void *data)
+{
+ struct rockchip_dfi *dfi = data;
+
+ cpuhp_remove_multi_state(dfi->cpuhp_state);
+
+ rockchip_dfi_disable(dfi);
+}
+
+static void rockchip_ddr_cpuhp_remove_instance(void *data)
+{
+ struct rockchip_dfi *dfi = data;
+
+ cpuhp_state_remove_instance_nocalls(dfi->cpuhp_state, &dfi->node);
+}
+
+static void rockchip_ddr_perf_remove(void *data)
+{
+ struct rockchip_dfi *dfi = data;
+
+ perf_pmu_unregister(&dfi->pmu);
+}
+
+static int rockchip_ddr_perf_init(struct rockchip_dfi *dfi)
+{
+ struct pmu *pmu = &dfi->pmu;
+ int ret;
+
+ seqlock_init(&dfi->count_seqlock);
+
+ pmu->module = THIS_MODULE;
+ pmu->capabilities = PERF_PMU_CAP_NO_EXCLUDE;
+ pmu->task_ctx_nr = perf_invalid_context;
+ pmu->attr_groups = attr_groups;
+ pmu->event_init = rockchip_ddr_perf_event_init;
+ pmu->add = rockchip_ddr_perf_event_add;
+ pmu->del = rockchip_ddr_perf_event_del;
+ pmu->start = rockchip_ddr_perf_event_start;
+ pmu->stop = rockchip_ddr_perf_event_stop;
+ pmu->read = rockchip_ddr_perf_event_update;
+
+ dfi->cpu = raw_smp_processor_id();
+
+ ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN,
+ "rockchip_ddr_perf_pmu",
+ NULL,
+ ddr_perf_offline_cpu);
+
+ if (ret < 0) {
+ dev_err(dfi->dev, "cpuhp_setup_state_multi failed: %d\n", ret);
+ return ret;
+ }
+
+ dfi->cpuhp_state = ret;
+
+ rockchip_dfi_enable(dfi);
+
+ ret = devm_add_action_or_reset(dfi->dev, rockchip_ddr_cpuhp_remove_state, dfi);
+ if (ret)
+ return ret;
+
+ ret = cpuhp_state_add_instance_nocalls(dfi->cpuhp_state, &dfi->node);
+ if (ret) {
+ dev_err(dfi->dev, "Error %d registering hotplug\n", ret);
+ return ret;
+ }
+
+ ret = devm_add_action_or_reset(dfi->dev, rockchip_ddr_cpuhp_remove_instance, dfi);
+ if (ret)
+ return ret;
+
+ hrtimer_init(&dfi->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+ dfi->timer.function = rockchip_dfi_timer;
+
+ switch (dfi->ddr_type) {
+ case ROCKCHIP_DDRTYPE_LPDDR2:
+ case ROCKCHIP_DDRTYPE_LPDDR3:
+ dfi->burst_len = 8;
+ break;
+ case ROCKCHIP_DDRTYPE_LPDDR4:
+ case ROCKCHIP_DDRTYPE_LPDDR4X:
+ dfi->burst_len = 16;
+ break;
+ }
+
+ ret = perf_pmu_register(pmu, "rockchip_ddr", -1);
+ if (ret)
+ return ret;
+
+ return devm_add_action_or_reset(dfi->dev, rockchip_ddr_perf_remove, dfi);
+}
+#else
+static int rockchip_ddr_perf_init(struct rockchip_dfi *dfi)
+{
+ return 0;
+}
+#endif
+
static int rk3399_dfi_init(struct rockchip_dfi *dfi)
{
struct regmap *regmap_pmu = dfi->regmap_pmu;
@@ -239,6 +661,9 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)

dfi->channel_mask = GENMASK(1, 0);

+ dfi->buswidth[0] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH0, val) == 0 ? 4 : 2;
+ dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;
+
return 0;
};

@@ -255,6 +680,8 @@ static int rk3568_dfi_init(struct rockchip_dfi *dfi)
if (FIELD_GET(RK3568_PMUGRF_OS_REG3_SYSREG_VERSION, reg3) >= 0x3)
dfi->ddr_type |= FIELD_GET(RK3568_PMUGRF_OS_REG3_DRAMTYPE_INFO_V3, reg3) << 3;

+ dfi->buswidth[0] = FIELD_GET(RK3568_PMUGRF_OS_REG2_BW_CH0, reg2) == 0 ? 4 : 2;
+
dfi->channel_mask = 1;

return 0;
@@ -317,6 +744,10 @@ static int rockchip_dfi_probe(struct platform_device *pdev)
return PTR_ERR(dfi->edev);
}

+ ret = rockchip_ddr_perf_init(dfi);
+ if (ret)
+ return ret;
+
platform_set_drvdata(pdev, dfi);

return 0;
@@ -327,6 +758,7 @@ static struct platform_driver rockchip_dfi_driver = {
.driver = {
.name = "rockchip-dfi",
.of_match_table = rockchip_dfi_id_match,
+ .suppress_bind_attrs = true,
},
};
module_platform_driver(rockchip_dfi_driver);
diff --git a/include/soc/rockchip/rk3399_grf.h b/include/soc/rockchip/rk3399_grf.h
index 775f8444bea8d..39cd44cec982f 100644
--- a/include/soc/rockchip/rk3399_grf.h
+++ b/include/soc/rockchip/rk3399_grf.h
@@ -12,5 +12,7 @@
/* PMU GRF Registers */
#define RK3399_PMUGRF_OS_REG2 0x308
#define RK3399_PMUGRF_OS_REG2_DDRTYPE GENMASK(15, 13)
+#define RK3399_PMUGRF_OS_REG2_BW_CH0 GENMASK(3, 2)
+#define RK3399_PMUGRF_OS_REG2_BW_CH1 GENMASK(19, 18)

#endif
diff --git a/include/soc/rockchip/rk3568_grf.h b/include/soc/rockchip/rk3568_grf.h
index 575584e9d8834..52853efd6720e 100644
--- a/include/soc/rockchip/rk3568_grf.h
+++ b/include/soc/rockchip/rk3568_grf.h
@@ -4,6 +4,7 @@

#define RK3568_PMUGRF_OS_REG2 0x208
#define RK3568_PMUGRF_OS_REG2_DRAMTYPE_INFO GENMASK(15, 13)
+#define RK3568_PMUGRF_OS_REG2_BW_CH0 GENMASK(3, 2)

#define RK3568_PMUGRF_OS_REG3 0x20c
#define RK3568_PMUGRF_OS_REG3_DRAMTYPE_INFO_V3 GENMASK(13, 12)
--
2.39.2


2023-07-04 09:47:31

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 17/26] PM / devfreq: rockchip-dfi: make register stride SoC specific

The currently supported RK3399 has a stride of 20 between the channel
specific registers. Upcoming RK3588 has a different stride, so put
the stride into driver data to make it configurable.
While at it convert decimal 20 to hex 0x14 for consistency with RK3588
which has a register stride 0x4000 and we want to write that in hex
as well.

Reviewed-by: Jonathan Cameron <[email protected]>
Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 11 +++++++----
1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 969b62f071b83..85ec93fd41858 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -112,6 +112,7 @@ struct rockchip_dfi {
int active_events;
int burst_len;
int buswidth[DMC_MAX_CHANNELS];
+ int ddrmon_stride;
};

static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
@@ -189,13 +190,13 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
if (!(dfi->channel_mask & BIT(i)))
continue;
c->c[i].read_access = readl_relaxed(dfi_regs +
- DDRMON_CH0_RD_NUM + i * 20);
+ DDRMON_CH0_RD_NUM + i * dfi->ddrmon_stride);
c->c[i].write_access = readl_relaxed(dfi_regs +
- DDRMON_CH0_WR_NUM + i * 20);
+ DDRMON_CH0_WR_NUM + i * dfi->ddrmon_stride);
c->c[i].access = readl_relaxed(dfi_regs +
- DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
+ DDRMON_CH0_DFI_ACCESS_NUM + i * dfi->ddrmon_stride);
c->c[i].clock_cycles = readl_relaxed(dfi_regs +
- DDRMON_CH0_COUNT_NUM + i * 20);
+ DDRMON_CH0_COUNT_NUM + i * dfi->ddrmon_stride);
}
}

@@ -664,6 +665,8 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
dfi->buswidth[0] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH0, val) == 0 ? 4 : 2;
dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;

+ dfi->ddrmon_stride = 0x14;
+
return 0;
};

--
2.39.2


2023-07-04 09:47:42

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 09/26] PM / devfreq: rockchip-dfi: Clean up DDR type register defines

Use the HIWORD_UPDATE() define known from other rockchip drivers to
make the defines look less odd to the readers who've seen other
rockchip drivers.

The HIWORD registers have their functional bits in the lower 16 bits
whereas the upper 16 bits contain a mask. Only the functional bits that
have the corresponding mask bit set are modified during a write. Although
the register writes look different, the end result should be the same,
at least there's no functional change intended with this patch.

Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 33 ++++++++++++++++++----------
1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 6bccb6fbcfc0c..6b3ef97b3be09 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -26,15 +26,19 @@

#define DMC_MAX_CHANNELS 2

+#define HIWORD_UPDATE(val, mask) ((val) | (mask) << 16)
+
/* DDRMON_CTRL */
#define DDRMON_CTRL 0x04
-#define CLR_DDRMON_CTRL (0x1f0000 << 0)
-#define LPDDR4_EN (0x10001 << 4)
-#define HARDWARE_EN (0x10001 << 3)
-#define LPDDR3_EN (0x10001 << 2)
-#define SOFTWARE_EN (0x10001 << 1)
-#define SOFTWARE_DIS (0x10000 << 1)
-#define TIME_CNT_EN (0x10001 << 0)
+#define DDRMON_CTRL_DDR4 BIT(5)
+#define DDRMON_CTRL_LPDDR4 BIT(4)
+#define DDRMON_CTRL_HARDWARE_EN BIT(3)
+#define DDRMON_CTRL_LPDDR23 BIT(2)
+#define DDRMON_CTRL_SOFTWARE_EN BIT(1)
+#define DDRMON_CTRL_TIMER_CNT_EN BIT(0)
+#define DDRMON_CTRL_DDR_TYPE_MASK (DDRMON_CTRL_DDR4 | \
+ DDRMON_CTRL_LPDDR4 | \
+ DDRMON_CTRL_LPDDR23)

#define DDRMON_CH0_COUNT_NUM 0x28
#define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
@@ -73,16 +77,20 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
void __iomem *dfi_regs = dfi->regs;

/* clear DDRMON_CTRL setting */
- writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);
+ writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
+ DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);

/* set ddr type to dfi */
if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
- writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
+ writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
+ dfi_regs + DDRMON_CTRL);
else if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR4)
- writel_relaxed(LPDDR4_EN, dfi_regs + DDRMON_CTRL);
+ writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
+ dfi_regs + DDRMON_CTRL);

/* enable count, use software mode */
- writel_relaxed(SOFTWARE_EN, dfi_regs + DDRMON_CTRL);
+ writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
+ dfi_regs + DDRMON_CTRL);
}

static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
@@ -90,7 +98,8 @@ static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
void __iomem *dfi_regs = dfi->regs;

- writel_relaxed(SOFTWARE_DIS, dfi_regs + DDRMON_CTRL);
+ writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
+ dfi_regs + DDRMON_CTRL);
}

static void rockchip_dfi_read_counters(struct devfreq_event_dev *edev, struct dmc_count *count)
--
2.39.2


2023-07-04 09:48:51

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 06/26] PM / devfreq: rockchip-dfi: Use free running counter

The DDR_MON counters are free running counters. These are resetted to 0
when starting them over like currently done when reading the current
counter values.

Resetting the counters becomes a problem with perf support we want to
add later, because perf needs counters that are not modified elsewhere.

This patch removes resetting the counters and keeps them running
instead. That means we no longer use the absolute counter values but
instead compare them with the counter values we read last time. Not
stopping the counters also has the impact that they are running while
we are reading them. We cannot read multiple timers atomically, so
the values do not exactly fit together. The effect should be negligible
though as the time between two measurements is some orders of magnitude
bigger than the time we need to read multiple registers.

Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---

Notes:
Changes since v4:
- rephrase commit message
- Drop unused variable

drivers/devfreq/event/rockchip-dfi.c | 52 ++++++++++++++++------------
1 file changed, 30 insertions(+), 22 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 680f629da64fc..126bb744645b6 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -38,11 +38,15 @@
#define DDRMON_CH1_COUNT_NUM 0x3c
#define DDRMON_CH1_DFI_ACCESS_NUM 0x40

-struct dmc_usage {
+struct dmc_count_channel {
u32 access;
u32 total;
};

+struct dmc_count {
+ struct dmc_count_channel c[RK3399_DMC_NUM_CH];
+};
+
/*
* The dfi controller can monitor DDR load. It has an upper and lower threshold
* for the operating points. Whenever the usage leaves these bounds an event is
@@ -51,7 +55,7 @@ struct dmc_usage {
struct rockchip_dfi {
struct devfreq_event_dev *edev;
struct devfreq_event_desc desc;
- struct dmc_usage ch_usage[RK3399_DMC_NUM_CH];
+ struct dmc_count last_event_count;
struct device *dev;
void __iomem *regs;
struct regmap *regmap_pmu;
@@ -85,30 +89,18 @@ static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
writel_relaxed(SOFTWARE_DIS, dfi_regs + DDRMON_CTRL);
}

-static int rockchip_dfi_get_busier_ch(struct devfreq_event_dev *edev)
+static void rockchip_dfi_read_counters(struct devfreq_event_dev *edev, struct dmc_count *count)
{
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
- u32 tmp, max = 0;
- u32 i, busier_ch = 0;
+ u32 i;
void __iomem *dfi_regs = dfi->regs;

- rockchip_dfi_stop_hardware_counter(edev);
-
- /* Find out which channel is busier */
for (i = 0; i < RK3399_DMC_NUM_CH; i++) {
- dfi->ch_usage[i].access = readl_relaxed(dfi_regs +
+ count->c[i].access = readl_relaxed(dfi_regs +
DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
- dfi->ch_usage[i].total = readl_relaxed(dfi_regs +
+ count->c[i].total = readl_relaxed(dfi_regs +
DDRMON_CH0_COUNT_NUM + i * 20);
- tmp = dfi->ch_usage[i].access;
- if (tmp > max) {
- busier_ch = i;
- max = tmp;
- }
}
- rockchip_dfi_start_hardware_counter(edev);
-
- return busier_ch;
}

static int rockchip_dfi_disable(struct devfreq_event_dev *edev)
@@ -145,12 +137,28 @@ static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
struct devfreq_event_data *edata)
{
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
- int busier_ch;
+ struct dmc_count count;
+ struct dmc_count *last = &dfi->last_event_count;
+ u32 access = 0, total = 0;
+ int i;
+
+ rockchip_dfi_read_counters(edev, &count);
+
+ /* We can only report one channel, so find the busiest one */
+ for (i = 0; i < RK3399_DMC_NUM_CH; i++) {
+ u32 a = count.c[i].access - last->c[i].access;
+ u32 t = count.c[i].total - last->c[i].total;
+
+ if (a > access) {
+ access = a;
+ total = t;
+ }
+ }

- busier_ch = rockchip_dfi_get_busier_ch(edev);
+ edata->load_count = access * 4;
+ edata->total_count = total;

- edata->load_count = dfi->ch_usage[busier_ch].access * 4;
- edata->total_count = dfi->ch_usage[busier_ch].total;
+ dfi->last_event_count = count;

return 0;
}
--
2.39.2


2023-07-04 09:49:47

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 15/26] PM / devfreq: rockchip-dfi: give variable a better name

struct dmc_count_channel::total counts the clock cycles of the DDR
controller. Rename it accordingly to give the reader a better idea
what this is about. While at it, at some documentation to struct
dmc_count_channel.

Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 19 ++++++++++++-------
1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 8a7af7c32ae0d..50e497455dc69 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -46,9 +46,14 @@
#define DDRMON_CH1_COUNT_NUM 0x3c
#define DDRMON_CH1_DFI_ACCESS_NUM 0x40

+/**
+ * struct dmc_count_channel - structure to hold counter values from the DDR controller
+ * @access: Number of read and write accesses
+ * @clock_cycles: DDR clock cycles
+ */
struct dmc_count_channel {
u32 access;
- u32 total;
+ u32 clock_cycles;
};

struct dmc_count {
@@ -150,7 +155,7 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
continue;
count->c[i].access = readl_relaxed(dfi_regs +
DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
- count->c[i].total = readl_relaxed(dfi_regs +
+ count->c[i].clock_cycles = readl_relaxed(dfi_regs +
DDRMON_CH0_COUNT_NUM + i * 20);
}
}
@@ -182,29 +187,29 @@ static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
struct dmc_count count;
struct dmc_count *last = &dfi->last_event_count;
- u32 access = 0, total = 0;
+ u32 access = 0, clock_cycles = 0;
int i;

rockchip_dfi_read_counters(dfi, &count);

/* We can only report one channel, so find the busiest one */
for (i = 0; i < DMC_MAX_CHANNELS; i++) {
- u32 a, t;
+ u32 a, c;

if (!(dfi->channel_mask & BIT(i)))
continue;

a = count.c[i].access - last->c[i].access;
- t = count.c[i].total - last->c[i].total;
+ c = count.c[i].clock_cycles - last->c[i].clock_cycles;

if (a > access) {
access = a;
- total = t;
+ clock_cycles = c;
}
}

edata->load_count = access * 4;
- edata->total_count = total;
+ edata->total_count = clock_cycles;

dfi->last_event_count = count;

--
2.39.2


2023-07-04 09:49:52

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 11/26] PM / devfreq: rockchip-dfi: Handle LPDDR2 correctly

According to the downstream driver the DDRMON_CTRL_LPDDR23 bit must be
set for both LPDDR2 and LPDDR3. Add the missing LPDDR2 case and while
at it turn the if/else if/else into switch/case which makes it easier
to read.

Reviewed-by: Jonathan Cameron <[email protected]>
Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 11 +++++++++--
1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 261d112580c9e..16cd5365671f7 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -82,12 +82,19 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);

/* set ddr type to dfi */
- if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
+ switch (dfi->ddr_type) {
+ case ROCKCHIP_DDRTYPE_LPDDR2:
+ case ROCKCHIP_DDRTYPE_LPDDR3:
writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
dfi_regs + DDRMON_CTRL);
- else if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR4)
+ break;
+ case ROCKCHIP_DDRTYPE_LPDDR4:
writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
dfi_regs + DDRMON_CTRL);
+ break;
+ default:
+ break;
+ }

/* enable count, use software mode */
writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
--
2.39.2


2023-07-04 09:49:54

by Sascha Hauer

[permalink] [raw]
Subject: [PATCH v7 03/26] PM / devfreq: rockchip-dfi: use consistent name for private data struct

The variable name for the private data struct is 'info' in some
functions and 'data' in others. Both names do not give a clue what
type the variable has, so consistently use 'dfi'.

Reviewed-by: Heiko Stuebner <[email protected]>
Reviewed-by: Jonathan Cameron <[email protected]>
Reviewed-by: Sebastian Reichel <[email protected]>
Signed-off-by: Sascha Hauer <[email protected]>
---
drivers/devfreq/event/rockchip-dfi.c | 72 ++++++++++++++--------------
1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
index 467f9f42d38f7..e19e5acaa362c 100644
--- a/drivers/devfreq/event/rockchip-dfi.c
+++ b/drivers/devfreq/event/rockchip-dfi.c
@@ -59,13 +59,13 @@ struct rockchip_dfi {

static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
{
- struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
- void __iomem *dfi_regs = info->regs;
+ struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
+ void __iomem *dfi_regs = dfi->regs;
u32 val;
u32 ddr_type;

/* get ddr type */
- regmap_read(info->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
+ regmap_read(dfi->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
RK3399_PMUGRF_DDRTYPE_MASK;

@@ -84,28 +84,28 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)

static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
{
- struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
- void __iomem *dfi_regs = info->regs;
+ struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
+ void __iomem *dfi_regs = dfi->regs;

writel_relaxed(SOFTWARE_DIS, dfi_regs + DDRMON_CTRL);
}

static int rockchip_dfi_get_busier_ch(struct devfreq_event_dev *edev)
{
- struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
+ struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
u32 tmp, max = 0;
u32 i, busier_ch = 0;
- void __iomem *dfi_regs = info->regs;
+ void __iomem *dfi_regs = dfi->regs;

rockchip_dfi_stop_hardware_counter(edev);

/* Find out which channel is busier */
for (i = 0; i < RK3399_DMC_NUM_CH; i++) {
- info->ch_usage[i].access = readl_relaxed(dfi_regs +
+ dfi->ch_usage[i].access = readl_relaxed(dfi_regs +
DDRMON_CH0_DFI_ACCESS_NUM + i * 20) * 4;
- info->ch_usage[i].total = readl_relaxed(dfi_regs +
+ dfi->ch_usage[i].total = readl_relaxed(dfi_regs +
DDRMON_CH0_COUNT_NUM + i * 20);
- tmp = info->ch_usage[i].access;
+ tmp = dfi->ch_usage[i].access;
if (tmp > max) {
busier_ch = i;
max = tmp;
@@ -118,20 +118,20 @@ static int rockchip_dfi_get_busier_ch(struct devfreq_event_dev *edev)

static int rockchip_dfi_disable(struct devfreq_event_dev *edev)
{
- struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
+ struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);

rockchip_dfi_stop_hardware_counter(edev);
- clk_disable_unprepare(info->clk);
+ clk_disable_unprepare(dfi->clk);

return 0;
}

static int rockchip_dfi_enable(struct devfreq_event_dev *edev)
{
- struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
+ struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
int ret;

- ret = clk_prepare_enable(info->clk);
+ ret = clk_prepare_enable(dfi->clk);
if (ret) {
dev_err(&edev->dev, "failed to enable dfi clk: %d\n", ret);
return ret;
@@ -149,13 +149,13 @@ static int rockchip_dfi_set_event(struct devfreq_event_dev *edev)
static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
struct devfreq_event_data *edata)
{
- struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
+ struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
int busier_ch;

busier_ch = rockchip_dfi_get_busier_ch(edev);

- edata->load_count = info->ch_usage[busier_ch].access;
- edata->total_count = info->ch_usage[busier_ch].total;
+ edata->load_count = dfi->ch_usage[busier_ch].access;
+ edata->total_count = dfi->ch_usage[busier_ch].total;

return 0;
}
@@ -176,47 +176,47 @@ MODULE_DEVICE_TABLE(of, rockchip_dfi_id_match);
static int rockchip_dfi_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
- struct rockchip_dfi *data;
+ struct rockchip_dfi *dfi;
struct devfreq_event_desc *desc;
struct device_node *np = pdev->dev.of_node, *node;

- data = devm_kzalloc(dev, sizeof(struct rockchip_dfi), GFP_KERNEL);
- if (!data)
+ dfi = devm_kzalloc(dev, sizeof(*dfi), GFP_KERNEL);
+ if (!dfi)
return -ENOMEM;

- data->regs = devm_platform_ioremap_resource(pdev, 0);
- if (IS_ERR(data->regs))
- return PTR_ERR(data->regs);
+ dfi->regs = devm_platform_ioremap_resource(pdev, 0);
+ if (IS_ERR(dfi->regs))
+ return PTR_ERR(dfi->regs);

- data->clk = devm_clk_get(dev, "pclk_ddr_mon");
- if (IS_ERR(data->clk))
- return dev_err_probe(dev, PTR_ERR(data->clk),
+ dfi->clk = devm_clk_get(dev, "pclk_ddr_mon");
+ if (IS_ERR(dfi->clk))
+ return dev_err_probe(dev, PTR_ERR(dfi->clk),
"Cannot get the clk pclk_ddr_mon\n");

node = of_parse_phandle(np, "rockchip,pmu", 0);
if (!node)
return dev_err_probe(&pdev->dev, -ENODEV, "Can't find pmu_grf registers\n");

- data->regmap_pmu = syscon_node_to_regmap(node);
+ dfi->regmap_pmu = syscon_node_to_regmap(node);
of_node_put(node);
- if (IS_ERR(data->regmap_pmu))
- return PTR_ERR(data->regmap_pmu);
+ if (IS_ERR(dfi->regmap_pmu))
+ return PTR_ERR(dfi->regmap_pmu);

- data->dev = dev;
+ dfi->dev = dev;

- desc = &data->desc;
+ desc = &dfi->desc;
desc->ops = &rockchip_dfi_ops;
- desc->driver_data = data;
+ desc->driver_data = dfi;
desc->name = np->name;

- data->edev = devm_devfreq_event_add_edev(&pdev->dev, desc);
- if (IS_ERR(data->edev)) {
+ dfi->edev = devm_devfreq_event_add_edev(&pdev->dev, desc);
+ if (IS_ERR(dfi->edev)) {
dev_err(&pdev->dev,
"failed to add devfreq-event device\n");
- return PTR_ERR(data->edev);
+ return PTR_ERR(dfi->edev);
}

- platform_set_drvdata(pdev, data);
+ platform_set_drvdata(pdev, dfi);

return 0;
}
--
2.39.2


2023-10-06 16:03:30

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 01/26] PM / devfreq: rockchip-dfi: Make pmu regmap mandatory

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> As a matter of fact the regmap_pmu already is mandatory because
> it is used unconditionally in the driver. Bail out gracefully in
> probe() rather than crashing later.
>
> Fixes: b9d1262bca0af ("PM / devfreq: event: support rockchip dfi controller")
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
>
> Notes:
> Changes since v4:
> - move to beginning of the series to make it easier to backport to stable
> - Add a Fixes: tag
> - add missing of_node_put()
>
> drivers/devfreq/event/rockchip-dfi.c | 15 ++++++++-------
> 1 file changed, 8 insertions(+), 7 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 39ac069cabc75..74893c06aa087 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -193,14 +193,15 @@ static int rockchip_dfi_probe(struct platform_device *pdev)
> return dev_err_probe(dev, PTR_ERR(data->clk),
> "Cannot get the clk pclk_ddr_mon\n");
>
> - /* try to find the optional reference to the pmu syscon */
> node = of_parse_phandle(np, "rockchip,pmu", 0);
> - if (node) {
> - data->regmap_pmu = syscon_node_to_regmap(node);
> - of_node_put(node);
> - if (IS_ERR(data->regmap_pmu))
> - return PTR_ERR(data->regmap_pmu);
> - }
> + if (!node)
> + return dev_err_probe(&pdev->dev, -ENODEV, "Can't find pmu_grf registers\n");
> +
> + data->regmap_pmu = syscon_node_to_regmap(node);
> + of_node_put(node);
> + if (IS_ERR(data->regmap_pmu))
> + return PTR_ERR(data->regmap_pmu);
> +
> data->dev = dev;
>
> desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);

Applied it. Thanks.

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 16:07:47

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 03/26] PM / devfreq: rockchip-dfi: use consistent name for private data struct

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> The variable name for the private data struct is 'info' in some
> functions and 'data' in others. Both names do not give a clue what
> type the variable has, so consistently use 'dfi'.
>
> Reviewed-by: Heiko Stuebner <[email protected]>
> Reviewed-by: Jonathan Cameron <[email protected]>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 72 ++++++++++++++--------------
> 1 file changed, 36 insertions(+), 36 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 467f9f42d38f7..e19e5acaa362c 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -59,13 +59,13 @@ struct rockchip_dfi {
>
> static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
> {
> - struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
> - void __iomem *dfi_regs = info->regs;
> + struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> + void __iomem *dfi_regs = dfi->regs;
> u32 val;
> u32 ddr_type;
>
> /* get ddr type */
> - regmap_read(info->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
> + regmap_read(dfi->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
> ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
> RK3399_PMUGRF_DDRTYPE_MASK;
>
> @@ -84,28 +84,28 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
>
> static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
> {
> - struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
> - void __iomem *dfi_regs = info->regs;
> + struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> + void __iomem *dfi_regs = dfi->regs;
>
> writel_relaxed(SOFTWARE_DIS, dfi_regs + DDRMON_CTRL);
> }
>
> static int rockchip_dfi_get_busier_ch(struct devfreq_event_dev *edev)
> {
> - struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
> + struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> u32 tmp, max = 0;
> u32 i, busier_ch = 0;
> - void __iomem *dfi_regs = info->regs;
> + void __iomem *dfi_regs = dfi->regs;
>
> rockchip_dfi_stop_hardware_counter(edev);
>
> /* Find out which channel is busier */
> for (i = 0; i < RK3399_DMC_NUM_CH; i++) {
> - info->ch_usage[i].access = readl_relaxed(dfi_regs +
> + dfi->ch_usage[i].access = readl_relaxed(dfi_regs +
> DDRMON_CH0_DFI_ACCESS_NUM + i * 20) * 4;
> - info->ch_usage[i].total = readl_relaxed(dfi_regs +
> + dfi->ch_usage[i].total = readl_relaxed(dfi_regs +
> DDRMON_CH0_COUNT_NUM + i * 20);
> - tmp = info->ch_usage[i].access;
> + tmp = dfi->ch_usage[i].access;
> if (tmp > max) {
> busier_ch = i;
> max = tmp;
> @@ -118,20 +118,20 @@ static int rockchip_dfi_get_busier_ch(struct devfreq_event_dev *edev)
>
> static int rockchip_dfi_disable(struct devfreq_event_dev *edev)
> {
> - struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
> + struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
>
> rockchip_dfi_stop_hardware_counter(edev);
> - clk_disable_unprepare(info->clk);
> + clk_disable_unprepare(dfi->clk);
>
> return 0;
> }
>
> static int rockchip_dfi_enable(struct devfreq_event_dev *edev)
> {
> - struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
> + struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> int ret;
>
> - ret = clk_prepare_enable(info->clk);
> + ret = clk_prepare_enable(dfi->clk);
> if (ret) {
> dev_err(&edev->dev, "failed to enable dfi clk: %d\n", ret);
> return ret;
> @@ -149,13 +149,13 @@ static int rockchip_dfi_set_event(struct devfreq_event_dev *edev)
> static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
> struct devfreq_event_data *edata)
> {
> - struct rockchip_dfi *info = devfreq_event_get_drvdata(edev);
> + struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> int busier_ch;
>
> busier_ch = rockchip_dfi_get_busier_ch(edev);
>
> - edata->load_count = info->ch_usage[busier_ch].access;
> - edata->total_count = info->ch_usage[busier_ch].total;
> + edata->load_count = dfi->ch_usage[busier_ch].access;
> + edata->total_count = dfi->ch_usage[busier_ch].total;
>
> return 0;
> }
> @@ -176,47 +176,47 @@ MODULE_DEVICE_TABLE(of, rockchip_dfi_id_match);
> static int rockchip_dfi_probe(struct platform_device *pdev)
> {
> struct device *dev = &pdev->dev;
> - struct rockchip_dfi *data;
> + struct rockchip_dfi *dfi;
> struct devfreq_event_desc *desc;
> struct device_node *np = pdev->dev.of_node, *node;
>
> - data = devm_kzalloc(dev, sizeof(struct rockchip_dfi), GFP_KERNEL);
> - if (!data)
> + dfi = devm_kzalloc(dev, sizeof(*dfi), GFP_KERNEL);
> + if (!dfi)
> return -ENOMEM;
>
> - data->regs = devm_platform_ioremap_resource(pdev, 0);
> - if (IS_ERR(data->regs))
> - return PTR_ERR(data->regs);
> + dfi->regs = devm_platform_ioremap_resource(pdev, 0);
> + if (IS_ERR(dfi->regs))
> + return PTR_ERR(dfi->regs);
>
> - data->clk = devm_clk_get(dev, "pclk_ddr_mon");
> - if (IS_ERR(data->clk))
> - return dev_err_probe(dev, PTR_ERR(data->clk),
> + dfi->clk = devm_clk_get(dev, "pclk_ddr_mon");
> + if (IS_ERR(dfi->clk))
> + return dev_err_probe(dev, PTR_ERR(dfi->clk),
> "Cannot get the clk pclk_ddr_mon\n");
>
> node = of_parse_phandle(np, "rockchip,pmu", 0);
> if (!node)
> return dev_err_probe(&pdev->dev, -ENODEV, "Can't find pmu_grf registers\n");
>
> - data->regmap_pmu = syscon_node_to_regmap(node);
> + dfi->regmap_pmu = syscon_node_to_regmap(node);
> of_node_put(node);
> - if (IS_ERR(data->regmap_pmu))
> - return PTR_ERR(data->regmap_pmu);
> + if (IS_ERR(dfi->regmap_pmu))
> + return PTR_ERR(dfi->regmap_pmu);
>
> - data->dev = dev;
> + dfi->dev = dev;
>
> - desc = &data->desc;
> + desc = &dfi->desc;
> desc->ops = &rockchip_dfi_ops;
> - desc->driver_data = data;
> + desc->driver_data = dfi;
> desc->name = np->name;
>
> - data->edev = devm_devfreq_event_add_edev(&pdev->dev, desc);
> - if (IS_ERR(data->edev)) {
> + dfi->edev = devm_devfreq_event_add_edev(&pdev->dev, desc);
> + if (IS_ERR(dfi->edev)) {
> dev_err(&pdev->dev,
> "failed to add devfreq-event device\n");
> - return PTR_ERR(data->edev);
> + return PTR_ERR(dfi->edev);
> }
>
> - platform_set_drvdata(pdev, data);
> + platform_set_drvdata(pdev, dfi);
>
> return 0;
> }

Applied it. Thanks.

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 17:22:03

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 06/26] PM / devfreq: rockchip-dfi: Use free running counter

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> The DDR_MON counters are free running counters. These are resetted to 0
> when starting them over like currently done when reading the current
> counter values.
>
> Resetting the counters becomes a problem with perf support we want to
> add later, because perf needs counters that are not modified elsewhere.
>
> This patch removes resetting the counters and keeps them running
> instead. That means we no longer use the absolute counter values but
> instead compare them with the counter values we read last time. Not
> stopping the counters also has the impact that they are running while
> we are reading them. We cannot read multiple timers atomically, so
> the values do not exactly fit together. The effect should be negligible
> though as the time between two measurements is some orders of magnitude
> bigger than the time we need to read multiple registers.
>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
>
> Notes:
> Changes since v4:
> - rephrase commit message
> - Drop unused variable
>
> drivers/devfreq/event/rockchip-dfi.c | 52 ++++++++++++++++------------
> 1 file changed, 30 insertions(+), 22 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 680f629da64fc..126bb744645b6 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -38,11 +38,15 @@
> #define DDRMON_CH1_COUNT_NUM 0x3c
> #define DDRMON_CH1_DFI_ACCESS_NUM 0x40
>
> -struct dmc_usage {
> +struct dmc_count_channel {
> u32 access;
> u32 total;
> };
>
> +struct dmc_count {
> + struct dmc_count_channel c[RK3399_DMC_NUM_CH];
> +};
> +
> /*
> * The dfi controller can monitor DDR load. It has an upper and lower threshold
> * for the operating points. Whenever the usage leaves these bounds an event is
> @@ -51,7 +55,7 @@ struct dmc_usage {
> struct rockchip_dfi {
> struct devfreq_event_dev *edev;
> struct devfreq_event_desc desc;
> - struct dmc_usage ch_usage[RK3399_DMC_NUM_CH];
> + struct dmc_count last_event_count;
> struct device *dev;
> void __iomem *regs;
> struct regmap *regmap_pmu;
> @@ -85,30 +89,18 @@ static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
> writel_relaxed(SOFTWARE_DIS, dfi_regs + DDRMON_CTRL);
> }
>
> -static int rockchip_dfi_get_busier_ch(struct devfreq_event_dev *edev)
> +static void rockchip_dfi_read_counters(struct devfreq_event_dev *edev, struct dmc_count *count)
> {
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> - u32 tmp, max = 0;
> - u32 i, busier_ch = 0;
> + u32 i;
> void __iomem *dfi_regs = dfi->regs;
>
> - rockchip_dfi_stop_hardware_counter(edev);
> -
> - /* Find out which channel is busier */
> for (i = 0; i < RK3399_DMC_NUM_CH; i++) {
> - dfi->ch_usage[i].access = readl_relaxed(dfi_regs +
> + count->c[i].access = readl_relaxed(dfi_regs +
> DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
> - dfi->ch_usage[i].total = readl_relaxed(dfi_regs +
> + count->c[i].total = readl_relaxed(dfi_regs +
> DDRMON_CH0_COUNT_NUM + i * 20);
> - tmp = dfi->ch_usage[i].access;
> - if (tmp > max) {
> - busier_ch = i;
> - max = tmp;
> - }
> }
> - rockchip_dfi_start_hardware_counter(edev);
> -
> - return busier_ch;
> }
>
> static int rockchip_dfi_disable(struct devfreq_event_dev *edev)
> @@ -145,12 +137,28 @@ static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
> struct devfreq_event_data *edata)
> {
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> - int busier_ch;
> + struct dmc_count count;
> + struct dmc_count *last = &dfi->last_event_count;
> + u32 access = 0, total = 0;
> + int i;
> +
> + rockchip_dfi_read_counters(edev, &count);
> +
> + /* We can only report one channel, so find the busiest one */
> + for (i = 0; i < RK3399_DMC_NUM_CH; i++) {
> + u32 a = count.c[i].access - last->c[i].access;
> + u32 t = count.c[i].total - last->c[i].total;
> +
> + if (a > access) {
> + access = a;
> + total = t;
> + }
> + }
>
> - busier_ch = rockchip_dfi_get_busier_ch(edev);
> + edata->load_count = access * 4;
> + edata->total_count = total;
>
> - edata->load_count = dfi->ch_usage[busier_ch].access * 4;
> - edata->total_count = dfi->ch_usage[busier_ch].total;
> + dfi->last_event_count = count;
>
> return 0;
> }

Acked-by: Chanwoo Choi <[email protected]>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 17:43:35

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 08/26] PM / devfreq: rk3399_dmc,dfi: generalize DDRTYPE defines

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> The DDRTYPE defines are named to be RK3399 specific, but they can be
> used for other Rockchip SoCs as well, so replace the RK3399_PMUGRF_
> prefix with ROCKCHIP_. They are defined in a SoC specific header
> file, so when generalizing the prefix also move the new defines to
> a SoC agnostic header file. While at it use GENMASK to define the
> DDRTYPE bitfield and give it a name including the full register name.
>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 9 +++++----
> drivers/devfreq/rk3399_dmc.c | 10 +++++-----
> include/soc/rockchip/rk3399_grf.h | 7 +------
> include/soc/rockchip/rockchip_grf.h | 17 +++++++++++++++++
> 4 files changed, 28 insertions(+), 15 deletions(-)
> create mode 100644 include/soc/rockchip/rockchip_grf.h
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 82de24a027579..6bccb6fbcfc0c 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -18,8 +18,10 @@
> #include <linux/list.h>
> #include <linux/of.h>
> #include <linux/of_device.h>
> +#include <linux/bitfield.h>
> #include <linux/bits.h>
>
> +#include <soc/rockchip/rockchip_grf.h>
> #include <soc/rockchip/rk3399_grf.h>
>
> #define DMC_MAX_CHANNELS 2
> @@ -74,9 +76,9 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
> writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);
>
> /* set ddr type to dfi */
> - if (dfi->ddr_type == RK3399_PMUGRF_DDRTYPE_LPDDR3)
> + if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
> writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
> - else if (dfi->ddr_type == RK3399_PMUGRF_DDRTYPE_LPDDR4)
> + else if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR4)
> writel_relaxed(LPDDR4_EN, dfi_regs + DDRMON_CTRL);
>
> /* enable count, use software mode */
> @@ -191,8 +193,7 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
>
> /* get ddr type */
> regmap_read(regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
> - dfi->ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
> - RK3399_PMUGRF_DDRTYPE_MASK;
> + dfi->ddr_type = FIELD_GET(RK3399_PMUGRF_OS_REG2_DDRTYPE, val);
>
> dfi->channel_mask = GENMASK(1, 0);
>
> diff --git a/drivers/devfreq/rk3399_dmc.c b/drivers/devfreq/rk3399_dmc.c
> index daff407026157..fd2c5ffedf41e 100644
> --- a/drivers/devfreq/rk3399_dmc.c
> +++ b/drivers/devfreq/rk3399_dmc.c
> @@ -22,6 +22,7 @@
> #include <linux/suspend.h>
>
> #include <soc/rockchip/pm_domains.h>
> +#include <soc/rockchip/rockchip_grf.h>
> #include <soc/rockchip/rk3399_grf.h>
> #include <soc/rockchip/rockchip_sip.h>
>
> @@ -381,17 +382,16 @@ static int rk3399_dmcfreq_probe(struct platform_device *pdev)
> }
>
> regmap_read(data->regmap_pmu, RK3399_PMUGRF_OS_REG2, &val);
> - ddr_type = (val >> RK3399_PMUGRF_DDRTYPE_SHIFT) &
> - RK3399_PMUGRF_DDRTYPE_MASK;
> + ddr_type = FIELD_GET(RK3399_PMUGRF_OS_REG2_DDRTYPE, val);
>
> switch (ddr_type) {
> - case RK3399_PMUGRF_DDRTYPE_DDR3:
> + case ROCKCHIP_DDRTYPE_DDR3:
> data->odt_dis_freq = data->ddr3_odt_dis_freq;
> break;
> - case RK3399_PMUGRF_DDRTYPE_LPDDR3:
> + case ROCKCHIP_DDRTYPE_LPDDR3:
> data->odt_dis_freq = data->lpddr3_odt_dis_freq;
> break;
> - case RK3399_PMUGRF_DDRTYPE_LPDDR4:
> + case ROCKCHIP_DDRTYPE_LPDDR4:
> data->odt_dis_freq = data->lpddr4_odt_dis_freq;
> break;
> default:
> diff --git a/include/soc/rockchip/rk3399_grf.h b/include/soc/rockchip/rk3399_grf.h
> index 3eebabcb28123..775f8444bea8d 100644
> --- a/include/soc/rockchip/rk3399_grf.h
> +++ b/include/soc/rockchip/rk3399_grf.h
> @@ -11,11 +11,6 @@
>
> /* PMU GRF Registers */
> #define RK3399_PMUGRF_OS_REG2 0x308
> -#define RK3399_PMUGRF_DDRTYPE_SHIFT 13
> -#define RK3399_PMUGRF_DDRTYPE_MASK 7
> -#define RK3399_PMUGRF_DDRTYPE_DDR3 3
> -#define RK3399_PMUGRF_DDRTYPE_LPDDR2 5
> -#define RK3399_PMUGRF_DDRTYPE_LPDDR3 6
> -#define RK3399_PMUGRF_DDRTYPE_LPDDR4 7
> +#define RK3399_PMUGRF_OS_REG2_DDRTYPE GENMASK(15, 13)
>
> #endif
> diff --git a/include/soc/rockchip/rockchip_grf.h b/include/soc/rockchip/rockchip_grf.h
> new file mode 100644
> index 0000000000000..dde1a9796ccb5
> --- /dev/null
> +++ b/include/soc/rockchip/rockchip_grf.h
> @@ -0,0 +1,17 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Rockchip General Register Files definitions
> + */
> +
> +#ifndef __SOC_ROCKCHIP_GRF_H
> +#define __SOC_ROCKCHIP_GRF_H
> +
> +/* Rockchip DDRTYPE defines */
> +enum {
> + ROCKCHIP_DDRTYPE_DDR3 = 3,
> + ROCKCHIP_DDRTYPE_LPDDR2 = 5,
> + ROCKCHIP_DDRTYPE_LPDDR3 = 6,
> + ROCKCHIP_DDRTYPE_LPDDR4 = 7,
> +};
> +
> +#endif /* __SOC_ROCKCHIP_GRF_H */


Acked-by: Chanwoo Choi <[email protected]>

This patch must require Ack of rockchip Maintainer (Heiko Stuebner)
because of include/soc/rockchip.

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 18:24:58

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 11/26] PM / devfreq: rockchip-dfi: Handle LPDDR2 correctly

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> According to the downstream driver the DDRMON_CTRL_LPDDR23 bit must be
> set for both LPDDR2 and LPDDR3. Add the missing LPDDR2 case and while
> at it turn the if/else if/else into switch/case which makes it easier
> to read.
>
> Reviewed-by: Jonathan Cameron <[email protected]>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 11 +++++++++--
> 1 file changed, 9 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 261d112580c9e..16cd5365671f7 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -82,12 +82,19 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
> DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
>
> /* set ddr type to dfi */
> - if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
> + switch (dfi->ddr_type) {
> + case ROCKCHIP_DDRTYPE_LPDDR2:
> + case ROCKCHIP_DDRTYPE_LPDDR3:
> writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
> dfi_regs + DDRMON_CTRL);
> - else if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR4)
> + break;
> + case ROCKCHIP_DDRTYPE_LPDDR4:
> writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
> dfi_regs + DDRMON_CTRL);
> + break;
> + default:
> + break;
> + }
>
> /* enable count, use software mode */
> writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),

Acked-by: Chanwoo Choi <[email protected]>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 18:38:03

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 15/26] PM / devfreq: rockchip-dfi: give variable a better name

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> struct dmc_count_channel::total counts the clock cycles of the DDR
> controller. Rename it accordingly to give the reader a better idea
> what this is about. While at it, at some documentation to struct
> dmc_count_channel.
>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 19 ++++++++++++-------
> 1 file changed, 12 insertions(+), 7 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 8a7af7c32ae0d..50e497455dc69 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -46,9 +46,14 @@
> #define DDRMON_CH1_COUNT_NUM 0x3c
> #define DDRMON_CH1_DFI_ACCESS_NUM 0x40
>
> +/**
> + * struct dmc_count_channel - structure to hold counter values from the DDR controller
> + * @access: Number of read and write accesses
> + * @clock_cycles: DDR clock cycles
> + */
> struct dmc_count_channel {
> u32 access;
> - u32 total;
> + u32 clock_cycles;
> };
>
> struct dmc_count {
> @@ -150,7 +155,7 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
> continue;
> count->c[i].access = readl_relaxed(dfi_regs +
> DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
> - count->c[i].total = readl_relaxed(dfi_regs +
> + count->c[i].clock_cycles = readl_relaxed(dfi_regs +
> DDRMON_CH0_COUNT_NUM + i * 20);
> }
> }
> @@ -182,29 +187,29 @@ static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> struct dmc_count count;
> struct dmc_count *last = &dfi->last_event_count;
> - u32 access = 0, total = 0;
> + u32 access = 0, clock_cycles = 0;
> int i;
>
> rockchip_dfi_read_counters(dfi, &count);
>
> /* We can only report one channel, so find the busiest one */
> for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> - u32 a, t;
> + u32 a, c;
>
> if (!(dfi->channel_mask & BIT(i)))
> continue;
>
> a = count.c[i].access - last->c[i].access;
> - t = count.c[i].total - last->c[i].total;
> + c = count.c[i].clock_cycles - last->c[i].clock_cycles;
>
> if (a > access) {
> access = a;
> - total = t;
> + clock_cycles = c;
> }
> }
>
> edata->load_count = access * 4;
> - edata->total_count = total;
> + edata->total_count = clock_cycles;
>
> dfi->last_event_count = count;
>

Acked-by: Chanwoo Choi <[email protected]>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 18:47:28

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 14/26] PM / devfreq: rockchip-dfi: Prepare for multiple users

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> When adding perf support later the DFI must be enabled when
> either of devfreq-event or perf is active. Prepare for that
> by adding a usage counter for the DFI. Also move enabling
> and disabling of the clock away from the devfreq-event specific
> functions to which the perf specific part won't have access.
>
> Reviewed-by: Jonathan Cameron <[email protected]>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 57 +++++++++++++++++++---------
> 1 file changed, 40 insertions(+), 17 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index d39db5de7f19c..8a7af7c32ae0d 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -68,13 +68,28 @@ struct rockchip_dfi {
> void __iomem *regs;
> struct regmap *regmap_pmu;
> struct clk *clk;
> + int usecount;
> + struct mutex mutex;
> u32 ddr_type;
> unsigned int channel_mask;
> };
>
> -static void rockchip_dfi_start_hardware_counter(struct rockchip_dfi *dfi)
> +static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> {
> void __iomem *dfi_regs = dfi->regs;
> + int ret = 0;
> +
> + mutex_lock(&dfi->mutex);
> +
> + dfi->usecount++;
> + if (dfi->usecount > 1)
> + goto out;
> +
> + ret = clk_prepare_enable(dfi->clk);
> + if (ret) {
> + dev_err(&dfi->edev->dev, "failed to enable dfi clk: %d\n", ret);
> + goto out;
> + }
>
> /* clear DDRMON_CTRL setting */
> writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
> @@ -99,14 +114,30 @@ static void rockchip_dfi_start_hardware_counter(struct rockchip_dfi *dfi)
> /* enable count, use software mode */
> writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
> dfi_regs + DDRMON_CTRL);
> +out:
> + mutex_unlock(&dfi->mutex);
> +
> + return ret;
> }
>
> -static void rockchip_dfi_stop_hardware_counter(struct rockchip_dfi *dfi)
> +static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> {
> void __iomem *dfi_regs = dfi->regs;
>
> + mutex_lock(&dfi->mutex);
> +
> + dfi->usecount--;
> +
> + WARN_ON_ONCE(dfi->usecount < 0);
> +
> + if (dfi->usecount > 0)
> + goto out;
> +
> writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
> dfi_regs + DDRMON_CTRL);
> + clk_disable_unprepare(dfi->clk);
> +out:
> + mutex_unlock(&dfi->mutex);
> }
>
> static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *count)
> @@ -124,29 +155,20 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
> }
> }
>
> -static int rockchip_dfi_disable(struct devfreq_event_dev *edev)
> +static int rockchip_dfi_event_disable(struct devfreq_event_dev *edev)
> {
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
>
> - rockchip_dfi_stop_hardware_counter(dfi);
> - clk_disable_unprepare(dfi->clk);
> + rockchip_dfi_disable(dfi);
>
> return 0;
> }
>
> -static int rockchip_dfi_enable(struct devfreq_event_dev *edev)
> +static int rockchip_dfi_event_enable(struct devfreq_event_dev *edev)
> {
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> - int ret;
> -
> - ret = clk_prepare_enable(dfi->clk);
> - if (ret) {
> - dev_err(&edev->dev, "failed to enable dfi clk: %d\n", ret);
> - return ret;
> - }
>
> - rockchip_dfi_start_hardware_counter(dfi);
> - return 0;
> + return rockchip_dfi_enable(dfi);
> }
>
> static int rockchip_dfi_set_event(struct devfreq_event_dev *edev)
> @@ -190,8 +212,8 @@ static int rockchip_dfi_get_event(struct devfreq_event_dev *edev,
> }
>
> static const struct devfreq_event_ops rockchip_dfi_ops = {
> - .disable = rockchip_dfi_disable,
> - .enable = rockchip_dfi_enable,
> + .disable = rockchip_dfi_event_disable,
> + .enable = rockchip_dfi_event_enable,
> .get_event = rockchip_dfi_get_event,
> .set_event = rockchip_dfi_set_event,
> };
> @@ -272,6 +294,7 @@ static int rockchip_dfi_probe(struct platform_device *pdev)
> return PTR_ERR(dfi->regmap_pmu);
>
> dfi->dev = dev;
> + mutex_init(&dfi->mutex);
>
> desc = &dfi->desc;
> desc->ops = &rockchip_dfi_ops;

Acked-by: Chanwoo Choi <[email protected]>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-06 19:11:45

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 09/26] PM / devfreq: rockchip-dfi: Clean up DDR type register defines

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> Use the HIWORD_UPDATE() define known from other rockchip drivers to
> make the defines look less odd to the readers who've seen other
> rockchip drivers.
>
> The HIWORD registers have their functional bits in the lower 16 bits
> whereas the upper 16 bits contain a mask. Only the functional bits that
> have the corresponding mask bit set are modified during a write. Although
> the register writes look different, the end result should be the same,
> at least there's no functional change intended with this patch.
>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 33 ++++++++++++++++++----------
> 1 file changed, 21 insertions(+), 12 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 6bccb6fbcfc0c..6b3ef97b3be09 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -26,15 +26,19 @@
>
> #define DMC_MAX_CHANNELS 2
>
> +#define HIWORD_UPDATE(val, mask) ((val) | (mask) << 16)
> +
> /* DDRMON_CTRL */
> #define DDRMON_CTRL 0x04
> -#define CLR_DDRMON_CTRL (0x1f0000 << 0)
> -#define LPDDR4_EN (0x10001 << 4)
> -#define HARDWARE_EN (0x10001 << 3)
> -#define LPDDR3_EN (0x10001 << 2)
> -#define SOFTWARE_EN (0x10001 << 1)
> -#define SOFTWARE_DIS (0x10000 << 1)
> -#define TIME_CNT_EN (0x10001 << 0)
> +#define DDRMON_CTRL_DDR4 BIT(5)
> +#define DDRMON_CTRL_LPDDR4 BIT(4)
> +#define DDRMON_CTRL_HARDWARE_EN BIT(3)
> +#define DDRMON_CTRL_LPDDR23 BIT(2)
> +#define DDRMON_CTRL_SOFTWARE_EN BIT(1)
> +#define DDRMON_CTRL_TIMER_CNT_EN BIT(0)
> +#define DDRMON_CTRL_DDR_TYPE_MASK (DDRMON_CTRL_DDR4 | \
> + DDRMON_CTRL_LPDDR4 | \
> + DDRMON_CTRL_LPDDR23)
>
> #define DDRMON_CH0_COUNT_NUM 0x28
> #define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
> @@ -73,16 +77,20 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
> void __iomem *dfi_regs = dfi->regs;
>
> /* clear DDRMON_CTRL setting */
> - writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);
> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
> + DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);

You mentioned that there are no behavior changes even if the different value is written.
But, it looks strange. Could you please explain more detailed about it?


CLR_DDRMON_CTRL is 0x1f0000
vs.
HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN) = (0 | (BIT(0)|BIT(1)|BIT(3))<<16) = 0xb0000

>
> /* set ddr type to dfi */
> if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
> - writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
> + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
> + dfi_regs + DDRMON_CTRL);

LPDDR3_EN (0x10001 << 2) = 0x40004
vs.
HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK) = (BIT(2) | (BIT(5)|BIT(4)|BIT(2))<<16) = 0x340004


> else if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR4)
> - writel_relaxed(LPDDR4_EN, dfi_regs + DDRMON_CTRL);
> + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
> + dfi_regs + DDRMON_CTRL);
>
> /* enable count, use software mode */
> - writel_relaxed(SOFTWARE_EN, dfi_regs + DDRMON_CTRL);
> + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
> + dfi_regs + DDRMON_CTRL);
> }
>
> static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
> @@ -90,7 +98,8 @@ static void rockchip_dfi_stop_hardware_counter(struct devfreq_event_dev *edev)
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> void __iomem *dfi_regs = dfi->regs;
>
> - writel_relaxed(SOFTWARE_DIS, dfi_regs + DDRMON_CTRL);
> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
> + dfi_regs + DDRMON_CTRL);
> }
>
> static void rockchip_dfi_read_counters(struct devfreq_event_dev *edev, struct dmc_count *count)

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-08 21:48:59

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 16/26] PM / devfreq: rockchip-dfi: Add perf support

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> The DFI is a unit which is suitable for measuring DDR utilization, but
> so far it could only be used as an event driver for the DDR frequency
> scaling driver. This adds perf support to the DFI driver.
>
> Usage with the 'perf' tool can look like:
>
> perf stat -a -e rockchip_ddr/cycles/,\
> rockchip_ddr/read-bytes/,\
> rockchip_ddr/write-bytes/,\
> rockchip_ddr/bytes/ sleep 1
>
> Performance counter stats for 'system wide':
>
> 1582524826 rockchip_ddr/cycles/
> 1802.25 MB rockchip_ddr/read-bytes/
> 1793.72 MB rockchip_ddr/write-bytes/
> 3595.90 MB rockchip_ddr/bytes/
>
> 1.014369709 seconds time elapsed
>
> perf support has been tested on a RK3568 and a RK3399, the latter with
> dual channel DDR.
>
> Signed-off-by: Sascha Hauer <[email protected]>
> Reviewed-by: Sebastian Reichel <[email protected]>
> ---
>
> Notes:
> Changes since v5:
> - Add missing initialization of &dfi->last_perf_count
>
> Changes since v4:
>
> - use __stringify to ensure event type definitions and event numbers in sysfs are consistent
> - only use 64bit values in structs holding counters
> - support monitoring individual DDR channels
> - fix return value in rockchip_ddr_perf_event_init(): -EOPNOTSUPP -> -EINVAL
> - check for invalid event->attr.config values
> - start hrtimer to trigger in one second, not immediately
> - use devm_add_action_or_reset()
> - add suppress_bind_attrs
> - enable DDRMON during probe when perf is enabled
> - use a seqlock to protect perf reading the counters from the hrtimer callback modifying them
>
> drivers/devfreq/event/rockchip-dfi.c | 442 ++++++++++++++++++++++++++-
> include/soc/rockchip/rk3399_grf.h | 2 +
> include/soc/rockchip/rk3568_grf.h | 1 +
> 3 files changed, 440 insertions(+), 5 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 50e497455dc69..969b62f071b83 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -16,10 +16,12 @@
> #include <linux/regmap.h>
> #include <linux/slab.h>
> #include <linux/list.h>
> +#include <linux/seqlock.h>
> #include <linux/of.h>
> #include <linux/of_device.h>
> #include <linux/bitfield.h>
> #include <linux/bits.h>
> +#include <linux/perf_event.h>
>
> #include <soc/rockchip/rockchip_grf.h>
> #include <soc/rockchip/rk3399_grf.h>
> @@ -41,19 +43,39 @@
> DDRMON_CTRL_LPDDR4 | \
> DDRMON_CTRL_LPDDR23)
>
> +#define DDRMON_CH0_WR_NUM 0x20
> +#define DDRMON_CH0_RD_NUM 0x24
> #define DDRMON_CH0_COUNT_NUM 0x28
> #define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
> #define DDRMON_CH1_COUNT_NUM 0x3c
> #define DDRMON_CH1_DFI_ACCESS_NUM 0x40
>
> +#define PERF_EVENT_CYCLES 0x0
> +#define PERF_EVENT_READ_BYTES 0x1
> +#define PERF_EVENT_WRITE_BYTES 0x2
> +#define PERF_EVENT_READ_BYTES0 0x3
> +#define PERF_EVENT_WRITE_BYTES0 0x4
> +#define PERF_EVENT_READ_BYTES1 0x5
> +#define PERF_EVENT_WRITE_BYTES1 0x6
> +#define PERF_EVENT_READ_BYTES2 0x7
> +#define PERF_EVENT_WRITE_BYTES2 0x8
> +#define PERF_EVENT_READ_BYTES3 0x9
> +#define PERF_EVENT_WRITE_BYTES3 0xa
> +#define PERF_EVENT_BYTES 0xb
> +#define PERF_ACCESS_TYPE_MAX 0xc
> +
> /**
> * struct dmc_count_channel - structure to hold counter values from the DDR controller
> * @access: Number of read and write accesses
> * @clock_cycles: DDR clock cycles
> + * @read_access: number of read accesses
> + * @write_acccess: number of write accesses
> */
> struct dmc_count_channel {
> - u32 access;
> - u32 clock_cycles;
> + u64 access;
> + u64 clock_cycles;
> + u64 read_access;
> + u64 write_access;
> };
>
> struct dmc_count {
> @@ -69,6 +91,11 @@ struct rockchip_dfi {
> struct devfreq_event_dev *edev;
> struct devfreq_event_desc desc;
> struct dmc_count last_event_count;
> +
> + struct dmc_count last_perf_count;
> + struct dmc_count total_count;
> + seqlock_t count_seqlock; /* protects last_perf_count and total_count */
> +
> struct device *dev;
> void __iomem *regs;
> struct regmap *regmap_pmu;
> @@ -77,6 +104,14 @@ struct rockchip_dfi {
> struct mutex mutex;
> u32 ddr_type;
> unsigned int channel_mask;
> + enum cpuhp_state cpuhp_state;
> + struct hlist_node node;
> + struct pmu pmu;
> + struct hrtimer timer;
> + unsigned int cpu;
> + int active_events;
> + int burst_len;
> + int buswidth[DMC_MAX_CHANNELS];
> };
>
> static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> @@ -145,7 +180,7 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> mutex_unlock(&dfi->mutex);
> }
>
> -static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *count)
> +static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *c)

Actually, this change is not related to the patch's role which supports perf.
Also, it is better to use 'res' argument name because rockchip_ddr_perf_counters_add()
used the 'struct dmc_count *res' argument name.


> {
> u32 i;
> void __iomem *dfi_regs = dfi->regs;
> @@ -153,13 +188,36 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
> for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> if (!(dfi->channel_mask & BIT(i)))
> continue;
> - count->c[i].access = readl_relaxed(dfi_regs +
> + c->c[i].read_access = readl_relaxed(dfi_regs +
> + DDRMON_CH0_RD_NUM + i * 20);
> + c->c[i].write_access = readl_relaxed(dfi_regs +
> + DDRMON_CH0_WR_NUM + i * 20);
> + c->c[i].access = readl_relaxed(dfi_regs +
> DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
> - count->c[i].clock_cycles = readl_relaxed(dfi_regs +
> + c->c[i].clock_cycles = readl_relaxed(dfi_regs +
> DDRMON_CH0_COUNT_NUM + i * 20);
> }
> }
>
> +static void rockchip_ddr_perf_counters_add(struct rockchip_dfi *dfi,
> + const struct dmc_count *now,
> + struct dmc_count *res)
> +{
> + const struct dmc_count *last = &dfi->last_perf_count;
> + int i;
> +
> + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> + res->c[i].read_access = dfi->total_count.c[i].read_access +
> + (u32)(now->c[i].read_access - last->c[i].read_access);
> + res->c[i].write_access = dfi->total_count.c[i].write_access +
> + (u32)(now->c[i].write_access - last->c[i].write_access);
> + res->c[i].access = dfi->total_count.c[i].access +
> + (u32)(now->c[i].access - last->c[i].access);
> + res->c[i].clock_cycles = dfi->total_count.c[i].clock_cycles +
> + (u32)(now->c[i].clock_cycles - last->c[i].clock_cycles);
> + }
> +}
> +
> static int rockchip_dfi_event_disable(struct devfreq_event_dev *edev)
> {
> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> @@ -223,6 +281,370 @@ static const struct devfreq_event_ops rockchip_dfi_ops = {
> .set_event = rockchip_dfi_set_event,
> };
>
> +#ifdef CONFIG_PERF_EVENTS
> +
> +static ssize_t ddr_perf_cpumask_show(struct device *dev,
> + struct device_attribute *attr, char *buf)
> +{
> + struct pmu *pmu = dev_get_drvdata(dev);
> + struct rockchip_dfi *dfi = container_of(pmu, struct rockchip_dfi, pmu);
> +
> + return cpumap_print_to_pagebuf(true, buf, cpumask_of(dfi->cpu));
> +}
> +
> +static struct device_attribute ddr_perf_cpumask_attr =
> + __ATTR(cpumask, 0444, ddr_perf_cpumask_show, NULL);
> +
> +static struct attribute *ddr_perf_cpumask_attrs[] = {
> + &ddr_perf_cpumask_attr.attr,
> + NULL,
> +};
> +
> +static const struct attribute_group ddr_perf_cpumask_attr_group = {
> + .attrs = ddr_perf_cpumask_attrs,
> +};
> +
> +PMU_EVENT_ATTR_STRING(cycles, ddr_pmu_cycles, "event="__stringify(PERF_EVENT_CYCLES))
> +
> +#define DFI_PMU_EVENT_ATTR(_name, _var, _str) \
> + PMU_EVENT_ATTR_STRING(_name, _var, _str); \
> + PMU_EVENT_ATTR_STRING(_name.unit, _var##_unit, "MB"); \
> + PMU_EVENT_ATTR_STRING(_name.scale, _var##_scale, "9.536743164e-07")
> +
> +DFI_PMU_EVENT_ATTR(read-bytes0, ddr_pmu_read_bytes0, "event="__stringify(PERF_EVENT_READ_BYTES0));
> +DFI_PMU_EVENT_ATTR(write-bytes0, ddr_pmu_write_bytes0, "event="__stringify(PERF_EVENT_WRITE_BYTES0));
> +
> +DFI_PMU_EVENT_ATTR(read-bytes1, ddr_pmu_read_bytes1, "event="__stringify(PERF_EVENT_READ_BYTES1));
> +DFI_PMU_EVENT_ATTR(write-bytes1, ddr_pmu_write_bytes1, "event="__stringify(PERF_EVENT_WRITE_BYTES1));
> +
> +DFI_PMU_EVENT_ATTR(read-bytes2, ddr_pmu_read_bytes2, "event="__stringify(PERF_EVENT_READ_BYTES2));
> +DFI_PMU_EVENT_ATTR(write-bytes2, ddr_pmu_write_bytes2, "event="__stringify(PERF_EVENT_WRITE_BYTES2));
> +
> +DFI_PMU_EVENT_ATTR(read-bytes3, ddr_pmu_read_bytes3, "event="__stringify(PERF_EVENT_READ_BYTES3));
> +DFI_PMU_EVENT_ATTR(write-bytes3, ddr_pmu_write_bytes3, "event="__stringify(PERF_EVENT_WRITE_BYTES3));
> +
> +DFI_PMU_EVENT_ATTR(read-bytes, ddr_pmu_read_bytes, "event="__stringify(PERF_EVENT_READ_BYTES));
> +DFI_PMU_EVENT_ATTR(write-bytes, ddr_pmu_write_bytes, "event="__stringify(PERF_EVENT_WRITE_BYTES));
> +
> +DFI_PMU_EVENT_ATTR(bytes, ddr_pmu_bytes, "event="__stringify(PERF_EVENT_BYTES));
> +
> +#define DFI_ATTR_MB(_name) \
> + &_name.attr.attr, \
> + &_name##_unit.attr.attr, \
> + &_name##_scale.attr.attr
> +
> +static struct attribute *ddr_perf_events_attrs[] = {
> + &ddr_pmu_cycles.attr.attr,
> + DFI_ATTR_MB(ddr_pmu_read_bytes),
> + DFI_ATTR_MB(ddr_pmu_write_bytes),
> + DFI_ATTR_MB(ddr_pmu_read_bytes0),
> + DFI_ATTR_MB(ddr_pmu_write_bytes0),
> + DFI_ATTR_MB(ddr_pmu_read_bytes1),
> + DFI_ATTR_MB(ddr_pmu_write_bytes1),
> + DFI_ATTR_MB(ddr_pmu_read_bytes2),
> + DFI_ATTR_MB(ddr_pmu_write_bytes2),
> + DFI_ATTR_MB(ddr_pmu_read_bytes3),
> + DFI_ATTR_MB(ddr_pmu_write_bytes3),
> + DFI_ATTR_MB(ddr_pmu_bytes),
> + NULL,
> +};
> +
> +static const struct attribute_group ddr_perf_events_attr_group = {
> + .name = "events",
> + .attrs = ddr_perf_events_attrs,
> +};
> +
> +PMU_FORMAT_ATTR(event, "config:0-7");
> +
> +static struct attribute *ddr_perf_format_attrs[] = {
> + &format_attr_event.attr,
> + NULL,
> +};
> +
> +static const struct attribute_group ddr_perf_format_attr_group = {
> + .name = "format",
> + .attrs = ddr_perf_format_attrs,
> +};
> +
> +static const struct attribute_group *attr_groups[] = {
> + &ddr_perf_events_attr_group,
> + &ddr_perf_cpumask_attr_group,
> + &ddr_perf_format_attr_group,
> + NULL,
> +};
> +
> +static int rockchip_ddr_perf_event_init(struct perf_event *event)
> +{
> + struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
> +
> + if (event->attr.type != event->pmu->type)
> + return -ENOENT;
> +
> + if (event->attach_state & PERF_ATTACH_TASK)
> + return -EINVAL;
> +
> + if (event->cpu < 0) {
> + dev_warn(dfi->dev, "Can't provide per-task data!\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +static u64 rockchip_ddr_perf_event_get_count(struct perf_event *event)
> +{
> + struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
> + int blen = dfi->burst_len;
> + struct dmc_count total, now;
> + unsigned int seq;
> + u64 c = 0;

Actually, it is difficult to understand the meaning of 'c' local variable name.
Need to use the more clear vairable name instead of 'c'.

> + int i;
> +
> + rockchip_dfi_read_counters(dfi, &now);
> +
> + do {
> + seq = read_seqbegin(&dfi->count_seqlock);
> +
> + rockchip_ddr_perf_counters_add(dfi, &now, &total);
> +

Remove unneeded blank line.

> + } while (read_seqretry(&dfi->count_seqlock, seq));
(snip)

I added the some comment. If you are fixing the comment, feel free to add my ack.
Acked-by: Chanwoo Choi <[email protected]>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-08 21:57:36

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 17/26] PM / devfreq: rockchip-dfi: make register stride SoC specific

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> The currently supported RK3399 has a stride of 20 between the channel
> specific registers. Upcoming RK3588 has a different stride, so put
> the stride into driver data to make it configurable.
> While at it convert decimal 20 to hex 0x14 for consistency with RK3588
> which has a register stride 0x4000 and we want to write that in hex
> as well.
>
> Reviewed-by: Jonathan Cameron <[email protected]>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 11 +++++++----
> 1 file changed, 7 insertions(+), 4 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 969b62f071b83..85ec93fd41858 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -112,6 +112,7 @@ struct rockchip_dfi {
> int active_events;
> int burst_len;
> int buswidth[DMC_MAX_CHANNELS];
> + int ddrmon_stride;
> };
>
> static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> @@ -189,13 +190,13 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
> if (!(dfi->channel_mask & BIT(i)))
> continue;
> c->c[i].read_access = readl_relaxed(dfi_regs +
> - DDRMON_CH0_RD_NUM + i * 20);
> + DDRMON_CH0_RD_NUM + i * dfi->ddrmon_stride);
> c->c[i].write_access = readl_relaxed(dfi_regs +
> - DDRMON_CH0_WR_NUM + i * 20);
> + DDRMON_CH0_WR_NUM + i * dfi->ddrmon_stride);
> c->c[i].access = readl_relaxed(dfi_regs +
> - DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
> + DDRMON_CH0_DFI_ACCESS_NUM + i * dfi->ddrmon_stride);
> c->c[i].clock_cycles = readl_relaxed(dfi_regs +
> - DDRMON_CH0_COUNT_NUM + i * 20);
> + DDRMON_CH0_COUNT_NUM + i * dfi->ddrmon_stride);

Before this path, rk3399 and rk3568 have used the same stride.
But, this patch add the ddrmon_stride for only rk3399.

It seems that the behavior of rk3568 is changed.
If ddrmon_stride is not required for rk3568,
you must move this patch before adding rk3568 support patch ("PM / devfreq: rockchip-dfi: Add RK3568 support").

> }
> }
>
> @@ -664,6 +665,8 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
> dfi->buswidth[0] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH0, val) == 0 ? 4 : 2;
> dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;
>
> + dfi->ddrmon_stride = 0x14;
> +
> return 0;
> };
>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-08 22:19:17

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 18/26] PM / devfreq: rockchip-dfi: account for multiple DDRMON_CTRL registers

On 23. 7. 4. 18:32, Sascha Hauer wrote:
> The currently supported RK3399 has a set of registers per channel, but
> it has only a single DDRMON_CTRL register. With upcoming RK3588 this
> will be different, the RK3588 has a DDRMON_CTRL register per channel.
>
> Instead of expecting a single DDRMON_CTRL register, loop over the
> channels and write the channel specific DDRMON_CTRL register. Break
> out early out of the loop when there is only a single DDRMON_CTRL
> register like on the RK3399.
>
> Reviewed-by: Jonathan Cameron <[email protected]>
> Reviewed-by: Sebastian Reichel <[email protected]>
> Signed-off-by: Sascha Hauer <[email protected]>
> ---
> drivers/devfreq/event/rockchip-dfi.c | 72 ++++++++++++++++++----------
> 1 file changed, 48 insertions(+), 24 deletions(-)
>
> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> index 85ec93fd41858..2362d3953ba40 100644
> --- a/drivers/devfreq/event/rockchip-dfi.c
> +++ b/drivers/devfreq/event/rockchip-dfi.c
> @@ -113,12 +113,13 @@ struct rockchip_dfi {
> int burst_len;
> int buswidth[DMC_MAX_CHANNELS];
> int ddrmon_stride;
> + bool ddrmon_ctrl_single;
> };
>
> static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> {
> void __iomem *dfi_regs = dfi->regs;
> - int ret = 0;
> + int i, ret = 0;
>
> mutex_lock(&dfi->mutex);
>
> @@ -132,29 +133,41 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> goto out;
> }
>
> - /* clear DDRMON_CTRL setting */
> - writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
> - DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
> + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> + u32 ctrl = 0;
>
> - /* set ddr type to dfi */
> - switch (dfi->ddr_type) {
> - case ROCKCHIP_DDRTYPE_LPDDR2:
> - case ROCKCHIP_DDRTYPE_LPDDR3:
> - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
> - dfi_regs + DDRMON_CTRL);
> - break;
> - case ROCKCHIP_DDRTYPE_LPDDR4:
> - case ROCKCHIP_DDRTYPE_LPDDR4X:
> - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
> - dfi_regs + DDRMON_CTRL);
> - break;
> - default:
> - break;
> - }
> + if (!(dfi->channel_mask & BIT(i)))
> + continue;
>
> - /* enable count, use software mode */
> - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
> - dfi_regs + DDRMON_CTRL);
> + /* clear DDRMON_CTRL setting */
> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN |
> + DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN),
> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> +
> + /* set ddr type to dfi */
> + switch (dfi->ddr_type) {
> + case ROCKCHIP_DDRTYPE_LPDDR2:
> + case ROCKCHIP_DDRTYPE_LPDDR3:
> + ctrl = DDRMON_CTRL_LPDDR23;
> + break;
> + case ROCKCHIP_DDRTYPE_LPDDR4:
> + case ROCKCHIP_DDRTYPE_LPDDR4X:
> + ctrl = DDRMON_CTRL_LPDDR4;
> + break;
> + default:
> + break;
> + }
> +
> + writel_relaxed(HIWORD_UPDATE(ctrl, DDRMON_CTRL_DDR_TYPE_MASK),
> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> +
> + /* enable count, use software mode */
> + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> +
> + if (dfi->ddrmon_ctrl_single)
> + break;
> + }
> out:
> mutex_unlock(&dfi->mutex);
>
> @@ -164,6 +177,7 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> {
> void __iomem *dfi_regs = dfi->regs;
> + int i;
>
> mutex_lock(&dfi->mutex);
>
> @@ -174,8 +188,17 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> if (dfi->usecount > 0)
> goto out;
>
> - writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
> - dfi_regs + DDRMON_CTRL);
> + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> + if (!(dfi->channel_mask & BIT(i)))
> + continue;
> +
> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> +
> + if (dfi->ddrmon_ctrl_single)
> + break;
> + }
> +
> clk_disable_unprepare(dfi->clk);
> out:
> mutex_unlock(&dfi->mutex);
> @@ -666,6 +689,7 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
> dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;
>
> dfi->ddrmon_stride = 0x14;
> + dfi->ddrmon_ctrl_single = true;
>
> return 0;
> };

Even if rk3568 has the only one channle and don't need to check whether 'dfi->ddrmon_ctrl_single'
is true or not because of 'if (!(dfi->channel_mask & BIT(i)))',
I recommand the add 'dfi->ddrmon_ctrl_single = true;' for rk3568 in order to
provide the number of DDRMON_CTRL reigster of rk3568.

If rk3568 doesn't have the 'ddrmon_ctrl_single', actually it is not easy
to catch what why are there no initilization for rk3568.

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-16 12:04:42

by Sascha Hauer

[permalink] [raw]
Subject: Re: [PATCH v7 09/26] PM / devfreq: rockchip-dfi: Clean up DDR type register defines

On Sat, Oct 07, 2023 at 04:11:22AM +0900, Chanwoo Choi wrote:
> On 23. 7. 4. 18:32, Sascha Hauer wrote:
> > Use the HIWORD_UPDATE() define known from other rockchip drivers to
> > make the defines look less odd to the readers who've seen other
> > rockchip drivers.
> >
> > The HIWORD registers have their functional bits in the lower 16 bits
> > whereas the upper 16 bits contain a mask. Only the functional bits that
> > have the corresponding mask bit set are modified during a write. Although
> > the register writes look different, the end result should be the same,
> > at least there's no functional change intended with this patch.
> >
> > Reviewed-by: Sebastian Reichel <[email protected]>
> > Signed-off-by: Sascha Hauer <[email protected]>
> > ---
> > drivers/devfreq/event/rockchip-dfi.c | 33 ++++++++++++++++++----------
> > 1 file changed, 21 insertions(+), 12 deletions(-)
> >
> > diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> > index 6bccb6fbcfc0c..6b3ef97b3be09 100644
> > --- a/drivers/devfreq/event/rockchip-dfi.c
> > +++ b/drivers/devfreq/event/rockchip-dfi.c
> > @@ -26,15 +26,19 @@
> >
> > #define DMC_MAX_CHANNELS 2
> >
> > +#define HIWORD_UPDATE(val, mask) ((val) | (mask) << 16)
> > +
> > /* DDRMON_CTRL */
> > #define DDRMON_CTRL 0x04
> > -#define CLR_DDRMON_CTRL (0x1f0000 << 0)
> > -#define LPDDR4_EN (0x10001 << 4)
> > -#define HARDWARE_EN (0x10001 << 3)
> > -#define LPDDR3_EN (0x10001 << 2)
> > -#define SOFTWARE_EN (0x10001 << 1)
> > -#define SOFTWARE_DIS (0x10000 << 1)
> > -#define TIME_CNT_EN (0x10001 << 0)
> > +#define DDRMON_CTRL_DDR4 BIT(5)
> > +#define DDRMON_CTRL_LPDDR4 BIT(4)
> > +#define DDRMON_CTRL_HARDWARE_EN BIT(3)
> > +#define DDRMON_CTRL_LPDDR23 BIT(2)
> > +#define DDRMON_CTRL_SOFTWARE_EN BIT(1)
> > +#define DDRMON_CTRL_TIMER_CNT_EN BIT(0)
> > +#define DDRMON_CTRL_DDR_TYPE_MASK (DDRMON_CTRL_DDR4 | \
> > + DDRMON_CTRL_LPDDR4 | \
> > + DDRMON_CTRL_LPDDR23)
> >
> > #define DDRMON_CH0_COUNT_NUM 0x28
> > #define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
> > @@ -73,16 +77,20 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
> > void __iomem *dfi_regs = dfi->regs;
> >
> > /* clear DDRMON_CTRL setting */
> > - writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);
> > + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
> > + DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
>
> You mentioned that there are no behavior changes even if the different value is written.
> But, it looks strange. Could you please explain more detailed about it?

Many registers on Rockchip SoCs are effectively only 16 bits wide. The
lower 16 bits are the functional bits. The upper 16 bits contain a mask
value. The lower 16 bits are only modified when the coresponding bit in
the upper 16bits is set.

For example writing 0x0001dead has the same effect as writing
0x00010001: The lower bit is set, the remaining are unchanged due to the
mask value being 0.

>
>
> CLR_DDRMON_CTRL is 0x1f0000

This clears the lower 5 bits.

> vs.
> HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN) = (0 | (BIT(0)|BIT(1)|BIT(3))<<16) = 0xb0000

This clears BIT(0), BIT(1) and BIT(3), so it clears:

DDRMON_CTRL_TIMER_CNT_EN, DDRMON_CTRL_SOFTWARE_EN and DDRMON_CTRL_HARDWARE_EN.

In fact it doesn't clear DDRMON_CTRL_LPDDR23 and DDRMON_CTRL_LPDDR4 like
the operation with CLR_DDRMON_CTRL does, but the LPDDR type bits are
handled below:

>
> >
> > /* set ddr type to dfi */
> > if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
> > - writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
> > + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
> > + dfi_regs + DDRMON_CTRL);
>
> LPDDR3_EN (0x10001 << 2) = 0x40004

This sets BIT(2) aka DDRMON_CTRL_LPDDR23

> vs.
> HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK) = (BIT(2) | (BIT(5)|BIT(4)|BIT(2))<<16) = 0x340004

This sets BIT(2) and *clears* BIT(4) (DDRMON_CTRL_LPDDR4) and BIT(5)
(DDRMON_CTRL_DDR4). So effectively we no longer clear BIT(4) in the
first register access as we do with CLR_DDRMON_CTRL, but in the second
register access instead.

This also clears BIT(5) which was untouched previously, but this bit had
never been set by the driver, so should be 0 anyway.

Sascha

--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |

2023-10-16 12:17:09

by Sascha Hauer

[permalink] [raw]
Subject: Re: [PATCH v7 16/26] PM / devfreq: rockchip-dfi: Add perf support

On Mon, Oct 09, 2023 at 06:48:43AM +0900, Chanwoo Choi wrote:
> On 23. 7. 4. 18:32, Sascha Hauer wrote:
> > The DFI is a unit which is suitable for measuring DDR utilization, but
> > so far it could only be used as an event driver for the DDR frequency
> > scaling driver. This adds perf support to the DFI driver.
> >
> > Usage with the 'perf' tool can look like:
> >
> > perf stat -a -e rockchip_ddr/cycles/,\
> > rockchip_ddr/read-bytes/,\
> > rockchip_ddr/write-bytes/,\
> > rockchip_ddr/bytes/ sleep 1
> >
> > Performance counter stats for 'system wide':
> >
> > 1582524826 rockchip_ddr/cycles/
> > 1802.25 MB rockchip_ddr/read-bytes/
> > 1793.72 MB rockchip_ddr/write-bytes/
> > 3595.90 MB rockchip_ddr/bytes/
> >
> > 1.014369709 seconds time elapsed
> >
> > perf support has been tested on a RK3568 and a RK3399, the latter with
> > dual channel DDR.
> >
> > Signed-off-by: Sascha Hauer <[email protected]>
> > Reviewed-by: Sebastian Reichel <[email protected]>
> > ---
> >
> > Notes:
> > Changes since v5:
> > - Add missing initialization of &dfi->last_perf_count
> >
> > Changes since v4:
> >
> > - use __stringify to ensure event type definitions and event numbers in sysfs are consistent
> > - only use 64bit values in structs holding counters
> > - support monitoring individual DDR channels
> > - fix return value in rockchip_ddr_perf_event_init(): -EOPNOTSUPP -> -EINVAL
> > - check for invalid event->attr.config values
> > - start hrtimer to trigger in one second, not immediately
> > - use devm_add_action_or_reset()
> > - add suppress_bind_attrs
> > - enable DDRMON during probe when perf is enabled
> > - use a seqlock to protect perf reading the counters from the hrtimer callback modifying them
> >
> > drivers/devfreq/event/rockchip-dfi.c | 442 ++++++++++++++++++++++++++-
> > include/soc/rockchip/rk3399_grf.h | 2 +
> > include/soc/rockchip/rk3568_grf.h | 1 +
> > 3 files changed, 440 insertions(+), 5 deletions(-)
> >
> > diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> > index 50e497455dc69..969b62f071b83 100644
> > --- a/drivers/devfreq/event/rockchip-dfi.c
> > +++ b/drivers/devfreq/event/rockchip-dfi.c
> > @@ -16,10 +16,12 @@
> > #include <linux/regmap.h>
> > #include <linux/slab.h>
> > #include <linux/list.h>
> > +#include <linux/seqlock.h>
> > #include <linux/of.h>
> > #include <linux/of_device.h>
> > #include <linux/bitfield.h>
> > #include <linux/bits.h>
> > +#include <linux/perf_event.h>
> >
> > #include <soc/rockchip/rockchip_grf.h>
> > #include <soc/rockchip/rk3399_grf.h>
> > @@ -41,19 +43,39 @@
> > DDRMON_CTRL_LPDDR4 | \
> > DDRMON_CTRL_LPDDR23)
> >
> > +#define DDRMON_CH0_WR_NUM 0x20
> > +#define DDRMON_CH0_RD_NUM 0x24
> > #define DDRMON_CH0_COUNT_NUM 0x28
> > #define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
> > #define DDRMON_CH1_COUNT_NUM 0x3c
> > #define DDRMON_CH1_DFI_ACCESS_NUM 0x40
> >
> > +#define PERF_EVENT_CYCLES 0x0
> > +#define PERF_EVENT_READ_BYTES 0x1
> > +#define PERF_EVENT_WRITE_BYTES 0x2
> > +#define PERF_EVENT_READ_BYTES0 0x3
> > +#define PERF_EVENT_WRITE_BYTES0 0x4
> > +#define PERF_EVENT_READ_BYTES1 0x5
> > +#define PERF_EVENT_WRITE_BYTES1 0x6
> > +#define PERF_EVENT_READ_BYTES2 0x7
> > +#define PERF_EVENT_WRITE_BYTES2 0x8
> > +#define PERF_EVENT_READ_BYTES3 0x9
> > +#define PERF_EVENT_WRITE_BYTES3 0xa
> > +#define PERF_EVENT_BYTES 0xb
> > +#define PERF_ACCESS_TYPE_MAX 0xc
> > +
> > /**
> > * struct dmc_count_channel - structure to hold counter values from the DDR controller
> > * @access: Number of read and write accesses
> > * @clock_cycles: DDR clock cycles
> > + * @read_access: number of read accesses
> > + * @write_acccess: number of write accesses
> > */
> > struct dmc_count_channel {
> > - u32 access;
> > - u32 clock_cycles;
> > + u64 access;
> > + u64 clock_cycles;
> > + u64 read_access;
> > + u64 write_access;
> > };
> >
> > struct dmc_count {
> > @@ -69,6 +91,11 @@ struct rockchip_dfi {
> > struct devfreq_event_dev *edev;
> > struct devfreq_event_desc desc;
> > struct dmc_count last_event_count;
> > +
> > + struct dmc_count last_perf_count;
> > + struct dmc_count total_count;
> > + seqlock_t count_seqlock; /* protects last_perf_count and total_count */
> > +
> > struct device *dev;
> > void __iomem *regs;
> > struct regmap *regmap_pmu;
> > @@ -77,6 +104,14 @@ struct rockchip_dfi {
> > struct mutex mutex;
> > u32 ddr_type;
> > unsigned int channel_mask;
> > + enum cpuhp_state cpuhp_state;
> > + struct hlist_node node;
> > + struct pmu pmu;
> > + struct hrtimer timer;
> > + unsigned int cpu;
> > + int active_events;
> > + int burst_len;
> > + int buswidth[DMC_MAX_CHANNELS];
> > };
> >
> > static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> > @@ -145,7 +180,7 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> > mutex_unlock(&dfi->mutex);
> > }
> >
> > -static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *count)
> > +static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *c)
>
> Actually, this change is not related to the patch's role which supports perf.
> Also, it is better to use 'res' argument name because rockchip_ddr_perf_counters_add()
> used the 'struct dmc_count *res' argument name.

Indeed the variable rename is not required here and for consistency
with rockchip_ddr_perf_counters_add() 'res' would be a better name.

Are you fine with renaming 'c' to 'res' in this patch or do you want me
to make a separate patch from the renaming?

>
>
> > {
> > u32 i;
> > void __iomem *dfi_regs = dfi->regs;
> > @@ -153,13 +188,36 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
> > for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> > if (!(dfi->channel_mask & BIT(i)))
> > continue;
> > - count->c[i].access = readl_relaxed(dfi_regs +
> > + c->c[i].read_access = readl_relaxed(dfi_regs +
> > + DDRMON_CH0_RD_NUM + i * 20);
> > + c->c[i].write_access = readl_relaxed(dfi_regs +
> > + DDRMON_CH0_WR_NUM + i * 20);
> > + c->c[i].access = readl_relaxed(dfi_regs +
> > DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
> > - count->c[i].clock_cycles = readl_relaxed(dfi_regs +
> > + c->c[i].clock_cycles = readl_relaxed(dfi_regs +
> > DDRMON_CH0_COUNT_NUM + i * 20);
> > }
> > }
> >
> > +static void rockchip_ddr_perf_counters_add(struct rockchip_dfi *dfi,
> > + const struct dmc_count *now,
> > + struct dmc_count *res)
> > +{
> > + const struct dmc_count *last = &dfi->last_perf_count;
> > + int i;
> > +
> > + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> > + res->c[i].read_access = dfi->total_count.c[i].read_access +
> > + (u32)(now->c[i].read_access - last->c[i].read_access);
> > + res->c[i].write_access = dfi->total_count.c[i].write_access +
> > + (u32)(now->c[i].write_access - last->c[i].write_access);
> > + res->c[i].access = dfi->total_count.c[i].access +
> > + (u32)(now->c[i].access - last->c[i].access);
> > + res->c[i].clock_cycles = dfi->total_count.c[i].clock_cycles +
> > + (u32)(now->c[i].clock_cycles - last->c[i].clock_cycles);
> > + }
> > +}
> > +
> > static int rockchip_dfi_event_disable(struct devfreq_event_dev *edev)
> > {
> > struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
> > @@ -223,6 +281,370 @@ static const struct devfreq_event_ops rockchip_dfi_ops = {
> > .set_event = rockchip_dfi_set_event,
> > };
> >

[...]

> > +static u64 rockchip_ddr_perf_event_get_count(struct perf_event *event)
> > +{
> > + struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
> > + int blen = dfi->burst_len;
> > + struct dmc_count total, now;
> > + unsigned int seq;
> > + u64 c = 0;
>
> Actually, it is difficult to understand the meaning of 'c' local variable name.
> Need to use the more clear vairable name instead of 'c'.

'c' is short for 'count' as in the function name xxx_get_count(). It is
initialized to 0, filled with values throughout the function and
returned at the end. Which other name do you suggest?

Sascha

--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |

2023-10-16 12:49:52

by Sascha Hauer

[permalink] [raw]
Subject: Re: [PATCH v7 18/26] PM / devfreq: rockchip-dfi: account for multiple DDRMON_CTRL registers

On Mon, Oct 09, 2023 at 07:19:04AM +0900, Chanwoo Choi wrote:
> On 23. 7. 4. 18:32, Sascha Hauer wrote:
> > The currently supported RK3399 has a set of registers per channel, but
> > it has only a single DDRMON_CTRL register. With upcoming RK3588 this
> > will be different, the RK3588 has a DDRMON_CTRL register per channel.
> >
> > Instead of expecting a single DDRMON_CTRL register, loop over the
> > channels and write the channel specific DDRMON_CTRL register. Break
> > out early out of the loop when there is only a single DDRMON_CTRL
> > register like on the RK3399.
> >
> > Reviewed-by: Jonathan Cameron <[email protected]>
> > Reviewed-by: Sebastian Reichel <[email protected]>
> > Signed-off-by: Sascha Hauer <[email protected]>
> > ---
> > drivers/devfreq/event/rockchip-dfi.c | 72 ++++++++++++++++++----------
> > 1 file changed, 48 insertions(+), 24 deletions(-)
> >
> > diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
> > index 85ec93fd41858..2362d3953ba40 100644
> > --- a/drivers/devfreq/event/rockchip-dfi.c
> > +++ b/drivers/devfreq/event/rockchip-dfi.c
> > @@ -113,12 +113,13 @@ struct rockchip_dfi {
> > int burst_len;
> > int buswidth[DMC_MAX_CHANNELS];
> > int ddrmon_stride;
> > + bool ddrmon_ctrl_single;
> > };
> >
> > static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> > {
> > void __iomem *dfi_regs = dfi->regs;
> > - int ret = 0;
> > + int i, ret = 0;
> >
> > mutex_lock(&dfi->mutex);
> >
> > @@ -132,29 +133,41 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> > goto out;
> > }
> >
> > - /* clear DDRMON_CTRL setting */
> > - writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
> > - DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
> > + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> > + u32 ctrl = 0;
> >
> > - /* set ddr type to dfi */
> > - switch (dfi->ddr_type) {
> > - case ROCKCHIP_DDRTYPE_LPDDR2:
> > - case ROCKCHIP_DDRTYPE_LPDDR3:
> > - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
> > - dfi_regs + DDRMON_CTRL);
> > - break;
> > - case ROCKCHIP_DDRTYPE_LPDDR4:
> > - case ROCKCHIP_DDRTYPE_LPDDR4X:
> > - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
> > - dfi_regs + DDRMON_CTRL);
> > - break;
> > - default:
> > - break;
> > - }
> > + if (!(dfi->channel_mask & BIT(i)))
> > + continue;
> >
> > - /* enable count, use software mode */
> > - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
> > - dfi_regs + DDRMON_CTRL);
> > + /* clear DDRMON_CTRL setting */
> > + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN |
> > + DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN),
> > + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> > +
> > + /* set ddr type to dfi */
> > + switch (dfi->ddr_type) {
> > + case ROCKCHIP_DDRTYPE_LPDDR2:
> > + case ROCKCHIP_DDRTYPE_LPDDR3:
> > + ctrl = DDRMON_CTRL_LPDDR23;
> > + break;
> > + case ROCKCHIP_DDRTYPE_LPDDR4:
> > + case ROCKCHIP_DDRTYPE_LPDDR4X:
> > + ctrl = DDRMON_CTRL_LPDDR4;
> > + break;
> > + default:
> > + break;
> > + }
> > +
> > + writel_relaxed(HIWORD_UPDATE(ctrl, DDRMON_CTRL_DDR_TYPE_MASK),
> > + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> > +
> > + /* enable count, use software mode */
> > + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
> > + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> > +
> > + if (dfi->ddrmon_ctrl_single)
> > + break;
> > + }
> > out:
> > mutex_unlock(&dfi->mutex);
> >
> > @@ -164,6 +177,7 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
> > static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> > {
> > void __iomem *dfi_regs = dfi->regs;
> > + int i;
> >
> > mutex_lock(&dfi->mutex);
> >
> > @@ -174,8 +188,17 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
> > if (dfi->usecount > 0)
> > goto out;
> >
> > - writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
> > - dfi_regs + DDRMON_CTRL);
> > + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
> > + if (!(dfi->channel_mask & BIT(i)))
> > + continue;
> > +
> > + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
> > + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
> > +
> > + if (dfi->ddrmon_ctrl_single)
> > + break;
> > + }
> > +
> > clk_disable_unprepare(dfi->clk);
> > out:
> > mutex_unlock(&dfi->mutex);
> > @@ -666,6 +689,7 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
> > dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;
> >
> > dfi->ddrmon_stride = 0x14;
> > + dfi->ddrmon_ctrl_single = true;
> >
> > return 0;
> > };
>
> Even if rk3568 has the only one channle and don't need to check whether 'dfi->ddrmon_ctrl_single'
> is true or not because of 'if (!(dfi->channel_mask & BIT(i)))',
> I recommand the add 'dfi->ddrmon_ctrl_single = true;' for rk3568 in order to
> provide the number of DDRMON_CTRL reigster of rk3568.
>
> If rk3568 doesn't have the 'ddrmon_ctrl_single', actually it is not easy
> to catch what why are there no initilization for rk3568.

Ok, will change.

Sascha

--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |

2023-10-16 13:12:11

by Sascha Hauer

[permalink] [raw]
Subject: Re: [PATCH v7 08/26] PM / devfreq: rk3399_dmc,dfi: generalize DDRTYPE defines

Heiko,

On Sat, Oct 07, 2023 at 02:43:04AM +0900, Chanwoo Choi wrote:
> On 23. 7. 4. 18:32, Sascha Hauer wrote:
> > The DDRTYPE defines are named to be RK3399 specific, but they can be
> > used for other Rockchip SoCs as well, so replace the RK3399_PMUGRF_
> > prefix with ROCKCHIP_. They are defined in a SoC specific header
> > file, so when generalizing the prefix also move the new defines to
> > a SoC agnostic header file. While at it use GENMASK to define the
> > DDRTYPE bitfield and give it a name including the full register name.
> >
> > Reviewed-by: Sebastian Reichel <[email protected]>
> > Signed-off-by: Sascha Hauer <[email protected]>
> > ---

[...]

> > + ROCKCHIP_DDRTYPE_LPDDR2 = 5,
> > + ROCKCHIP_DDRTYPE_LPDDR3 = 6,
> > + ROCKCHIP_DDRTYPE_LPDDR4 = 7,
> > +};
> > +
> > +#endif /* __SOC_ROCKCHIP_GRF_H */
>
>
> Acked-by: Chanwoo Choi <[email protected]>
>
> This patch must require Ack of rockchip Maintainer (Heiko Stuebner)
> because of include/soc/rockchip.

Could you provide your Acked-by: for this patch?

Sascha

--
Pengutronix e.K. | |
Steuerwalder Str. 21 | http://www.pengutronix.de/ |
31137 Hildesheim, Germany | Phone: +49-5121-206917-0 |
Amtsgericht Hildesheim, HRA 2686 | Fax: +49-5121-206917-5555 |

2023-10-17 08:34:22

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 09/26] PM / devfreq: rockchip-dfi: Clean up DDR type register defines

On 23. 10. 16. 21:03, Sascha Hauer wrote:
> On Sat, Oct 07, 2023 at 04:11:22AM +0900, Chanwoo Choi wrote:
>> On 23. 7. 4. 18:32, Sascha Hauer wrote:
>>> Use the HIWORD_UPDATE() define known from other rockchip drivers to
>>> make the defines look less odd to the readers who've seen other
>>> rockchip drivers.
>>>
>>> The HIWORD registers have their functional bits in the lower 16 bits
>>> whereas the upper 16 bits contain a mask. Only the functional bits that
>>> have the corresponding mask bit set are modified during a write. Although
>>> the register writes look different, the end result should be the same,
>>> at least there's no functional change intended with this patch.
>>>
>>> Reviewed-by: Sebastian Reichel <[email protected]>
>>> Signed-off-by: Sascha Hauer <[email protected]>
>>> ---
>>> drivers/devfreq/event/rockchip-dfi.c | 33 ++++++++++++++++++----------
>>> 1 file changed, 21 insertions(+), 12 deletions(-)
>>>
>>> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
>>> index 6bccb6fbcfc0c..6b3ef97b3be09 100644
>>> --- a/drivers/devfreq/event/rockchip-dfi.c
>>> +++ b/drivers/devfreq/event/rockchip-dfi.c
>>> @@ -26,15 +26,19 @@
>>>
>>> #define DMC_MAX_CHANNELS 2
>>>
>>> +#define HIWORD_UPDATE(val, mask) ((val) | (mask) << 16)
>>> +
>>> /* DDRMON_CTRL */
>>> #define DDRMON_CTRL 0x04
>>> -#define CLR_DDRMON_CTRL (0x1f0000 << 0)
>>> -#define LPDDR4_EN (0x10001 << 4)
>>> -#define HARDWARE_EN (0x10001 << 3)
>>> -#define LPDDR3_EN (0x10001 << 2)
>>> -#define SOFTWARE_EN (0x10001 << 1)
>>> -#define SOFTWARE_DIS (0x10000 << 1)
>>> -#define TIME_CNT_EN (0x10001 << 0)
>>> +#define DDRMON_CTRL_DDR4 BIT(5)
>>> +#define DDRMON_CTRL_LPDDR4 BIT(4)
>>> +#define DDRMON_CTRL_HARDWARE_EN BIT(3)
>>> +#define DDRMON_CTRL_LPDDR23 BIT(2)
>>> +#define DDRMON_CTRL_SOFTWARE_EN BIT(1)
>>> +#define DDRMON_CTRL_TIMER_CNT_EN BIT(0)
>>> +#define DDRMON_CTRL_DDR_TYPE_MASK (DDRMON_CTRL_DDR4 | \
>>> + DDRMON_CTRL_LPDDR4 | \
>>> + DDRMON_CTRL_LPDDR23)
>>>
>>> #define DDRMON_CH0_COUNT_NUM 0x28
>>> #define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
>>> @@ -73,16 +77,20 @@ static void rockchip_dfi_start_hardware_counter(struct devfreq_event_dev *edev)
>>> void __iomem *dfi_regs = dfi->regs;
>>>
>>> /* clear DDRMON_CTRL setting */
>>> - writel_relaxed(CLR_DDRMON_CTRL, dfi_regs + DDRMON_CTRL);
>>> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
>>> + DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
>>
>> You mentioned that there are no behavior changes even if the different value is written.
>> But, it looks strange. Could you please explain more detailed about it?
>
> Many registers on Rockchip SoCs are effectively only 16 bits wide. The
> lower 16 bits are the functional bits. The upper 16 bits contain a mask
> value. The lower 16 bits are only modified when the coresponding bit in
> the upper 16bits is set.
>
> For example writing 0x0001dead has the same effect as writing
> 0x00010001: The lower bit is set, the remaining are unchanged due to the
> mask value being 0.
>
>>
>>
>> CLR_DDRMON_CTRL is 0x1f0000
>
> This clears the lower 5 bits.
>
>> vs.
>> HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN) = (0 | (BIT(0)|BIT(1)|BIT(3))<<16) = 0xb0000
>
> This clears BIT(0), BIT(1) and BIT(3), so it clears:
>
> DDRMON_CTRL_TIMER_CNT_EN, DDRMON_CTRL_SOFTWARE_EN and DDRMON_CTRL_HARDWARE_EN.
>
> In fact it doesn't clear DDRMON_CTRL_LPDDR23 and DDRMON_CTRL_LPDDR4 like
> the operation with CLR_DDRMON_CTRL does, but the LPDDR type bits are
> handled below:
>
>>
>>>
>>> /* set ddr type to dfi */
>>> if (dfi->ddr_type == ROCKCHIP_DDRTYPE_LPDDR3)
>>> - writel_relaxed(LPDDR3_EN, dfi_regs + DDRMON_CTRL);
>>> + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
>>> + dfi_regs + DDRMON_CTRL);
>>
>> LPDDR3_EN (0x10001 << 2) = 0x40004
>
> This sets BIT(2) aka DDRMON_CTRL_LPDDR23
>
>> vs.
>> HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK) = (BIT(2) | (BIT(5)|BIT(4)|BIT(2))<<16) = 0x340004
>
> This sets BIT(2) and *clears* BIT(4) (DDRMON_CTRL_LPDDR4) and BIT(5)
> (DDRMON_CTRL_DDR4). So effectively we no longer clear BIT(4) in the
> first register access as we do with CLR_DDRMON_CTRL, but in the second
> register access instead.
>
> This also clears BIT(5) which was untouched previously, but this bit had
> never been set by the driver, so should be 0 anyway.
>
> Sascha
>

Thanks for the detailed reply.

Acked-by: Chanwoo Choi <[email protected]>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-17 08:35:57

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 16/26] PM / devfreq: rockchip-dfi: Add perf support

On 23. 10. 16. 21:16, Sascha Hauer wrote:
> On Mon, Oct 09, 2023 at 06:48:43AM +0900, Chanwoo Choi wrote:
>> On 23. 7. 4. 18:32, Sascha Hauer wrote:
>>> The DFI is a unit which is suitable for measuring DDR utilization, but
>>> so far it could only be used as an event driver for the DDR frequency
>>> scaling driver. This adds perf support to the DFI driver.
>>>
>>> Usage with the 'perf' tool can look like:
>>>
>>> perf stat -a -e rockchip_ddr/cycles/,\
>>> rockchip_ddr/read-bytes/,\
>>> rockchip_ddr/write-bytes/,\
>>> rockchip_ddr/bytes/ sleep 1
>>>
>>> Performance counter stats for 'system wide':
>>>
>>> 1582524826 rockchip_ddr/cycles/
>>> 1802.25 MB rockchip_ddr/read-bytes/
>>> 1793.72 MB rockchip_ddr/write-bytes/
>>> 3595.90 MB rockchip_ddr/bytes/
>>>
>>> 1.014369709 seconds time elapsed
>>>
>>> perf support has been tested on a RK3568 and a RK3399, the latter with
>>> dual channel DDR.
>>>
>>> Signed-off-by: Sascha Hauer <[email protected]>
>>> Reviewed-by: Sebastian Reichel <[email protected]>
>>> ---
>>>
>>> Notes:
>>> Changes since v5:
>>> - Add missing initialization of &dfi->last_perf_count
>>>
>>> Changes since v4:
>>>
>>> - use __stringify to ensure event type definitions and event numbers in sysfs are consistent
>>> - only use 64bit values in structs holding counters
>>> - support monitoring individual DDR channels
>>> - fix return value in rockchip_ddr_perf_event_init(): -EOPNOTSUPP -> -EINVAL
>>> - check for invalid event->attr.config values
>>> - start hrtimer to trigger in one second, not immediately
>>> - use devm_add_action_or_reset()
>>> - add suppress_bind_attrs
>>> - enable DDRMON during probe when perf is enabled
>>> - use a seqlock to protect perf reading the counters from the hrtimer callback modifying them
>>>
>>> drivers/devfreq/event/rockchip-dfi.c | 442 ++++++++++++++++++++++++++-
>>> include/soc/rockchip/rk3399_grf.h | 2 +
>>> include/soc/rockchip/rk3568_grf.h | 1 +
>>> 3 files changed, 440 insertions(+), 5 deletions(-)
>>>
>>> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
>>> index 50e497455dc69..969b62f071b83 100644
>>> --- a/drivers/devfreq/event/rockchip-dfi.c
>>> +++ b/drivers/devfreq/event/rockchip-dfi.c
>>> @@ -16,10 +16,12 @@
>>> #include <linux/regmap.h>
>>> #include <linux/slab.h>
>>> #include <linux/list.h>
>>> +#include <linux/seqlock.h>
>>> #include <linux/of.h>
>>> #include <linux/of_device.h>
>>> #include <linux/bitfield.h>
>>> #include <linux/bits.h>
>>> +#include <linux/perf_event.h>
>>>
>>> #include <soc/rockchip/rockchip_grf.h>
>>> #include <soc/rockchip/rk3399_grf.h>
>>> @@ -41,19 +43,39 @@
>>> DDRMON_CTRL_LPDDR4 | \
>>> DDRMON_CTRL_LPDDR23)
>>>
>>> +#define DDRMON_CH0_WR_NUM 0x20
>>> +#define DDRMON_CH0_RD_NUM 0x24
>>> #define DDRMON_CH0_COUNT_NUM 0x28
>>> #define DDRMON_CH0_DFI_ACCESS_NUM 0x2c
>>> #define DDRMON_CH1_COUNT_NUM 0x3c
>>> #define DDRMON_CH1_DFI_ACCESS_NUM 0x40
>>>
>>> +#define PERF_EVENT_CYCLES 0x0
>>> +#define PERF_EVENT_READ_BYTES 0x1
>>> +#define PERF_EVENT_WRITE_BYTES 0x2
>>> +#define PERF_EVENT_READ_BYTES0 0x3
>>> +#define PERF_EVENT_WRITE_BYTES0 0x4
>>> +#define PERF_EVENT_READ_BYTES1 0x5
>>> +#define PERF_EVENT_WRITE_BYTES1 0x6
>>> +#define PERF_EVENT_READ_BYTES2 0x7
>>> +#define PERF_EVENT_WRITE_BYTES2 0x8
>>> +#define PERF_EVENT_READ_BYTES3 0x9
>>> +#define PERF_EVENT_WRITE_BYTES3 0xa
>>> +#define PERF_EVENT_BYTES 0xb
>>> +#define PERF_ACCESS_TYPE_MAX 0xc
>>> +
>>> /**
>>> * struct dmc_count_channel - structure to hold counter values from the DDR controller
>>> * @access: Number of read and write accesses
>>> * @clock_cycles: DDR clock cycles
>>> + * @read_access: number of read accesses
>>> + * @write_acccess: number of write accesses
>>> */
>>> struct dmc_count_channel {
>>> - u32 access;
>>> - u32 clock_cycles;
>>> + u64 access;
>>> + u64 clock_cycles;
>>> + u64 read_access;
>>> + u64 write_access;
>>> };
>>>
>>> struct dmc_count {
>>> @@ -69,6 +91,11 @@ struct rockchip_dfi {
>>> struct devfreq_event_dev *edev;
>>> struct devfreq_event_desc desc;
>>> struct dmc_count last_event_count;
>>> +
>>> + struct dmc_count last_perf_count;
>>> + struct dmc_count total_count;
>>> + seqlock_t count_seqlock; /* protects last_perf_count and total_count */
>>> +
>>> struct device *dev;
>>> void __iomem *regs;
>>> struct regmap *regmap_pmu;
>>> @@ -77,6 +104,14 @@ struct rockchip_dfi {
>>> struct mutex mutex;
>>> u32 ddr_type;
>>> unsigned int channel_mask;
>>> + enum cpuhp_state cpuhp_state;
>>> + struct hlist_node node;
>>> + struct pmu pmu;
>>> + struct hrtimer timer;
>>> + unsigned int cpu;
>>> + int active_events;
>>> + int burst_len;
>>> + int buswidth[DMC_MAX_CHANNELS];
>>> };
>>>
>>> static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
>>> @@ -145,7 +180,7 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
>>> mutex_unlock(&dfi->mutex);
>>> }
>>>
>>> -static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *count)
>>> +static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_count *c)
>>
>> Actually, this change is not related to the patch's role which supports perf.
>> Also, it is better to use 'res' argument name because rockchip_ddr_perf_counters_add()
>> used the 'struct dmc_count *res' argument name.
>
> Indeed the variable rename is not required here and for consistency
> with rockchip_ddr_perf_counters_add() 'res' would be a better name.
>
> Are you fine with renaming 'c' to 'res' in this patch or do you want me
> to make a separate patch from the renaming?
>
>>
>>
>>> {
>>> u32 i;
>>> void __iomem *dfi_regs = dfi->regs;
>>> @@ -153,13 +188,36 @@ static void rockchip_dfi_read_counters(struct rockchip_dfi *dfi, struct dmc_coun
>>> for (i = 0; i < DMC_MAX_CHANNELS; i++) {
>>> if (!(dfi->channel_mask & BIT(i)))
>>> continue;
>>> - count->c[i].access = readl_relaxed(dfi_regs +
>>> + c->c[i].read_access = readl_relaxed(dfi_regs +
>>> + DDRMON_CH0_RD_NUM + i * 20);
>>> + c->c[i].write_access = readl_relaxed(dfi_regs +
>>> + DDRMON_CH0_WR_NUM + i * 20);
>>> + c->c[i].access = readl_relaxed(dfi_regs +
>>> DDRMON_CH0_DFI_ACCESS_NUM + i * 20);
>>> - count->c[i].clock_cycles = readl_relaxed(dfi_regs +
>>> + c->c[i].clock_cycles = readl_relaxed(dfi_regs +
>>> DDRMON_CH0_COUNT_NUM + i * 20);
>>> }
>>> }
>>>
>>> +static void rockchip_ddr_perf_counters_add(struct rockchip_dfi *dfi,
>>> + const struct dmc_count *now,
>>> + struct dmc_count *res)
>>> +{
>>> + const struct dmc_count *last = &dfi->last_perf_count;
>>> + int i;
>>> +
>>> + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
>>> + res->c[i].read_access = dfi->total_count.c[i].read_access +
>>> + (u32)(now->c[i].read_access - last->c[i].read_access);
>>> + res->c[i].write_access = dfi->total_count.c[i].write_access +
>>> + (u32)(now->c[i].write_access - last->c[i].write_access);
>>> + res->c[i].access = dfi->total_count.c[i].access +
>>> + (u32)(now->c[i].access - last->c[i].access);
>>> + res->c[i].clock_cycles = dfi->total_count.c[i].clock_cycles +
>>> + (u32)(now->c[i].clock_cycles - last->c[i].clock_cycles);
>>> + }
>>> +}
>>> +
>>> static int rockchip_dfi_event_disable(struct devfreq_event_dev *edev)
>>> {
>>> struct rockchip_dfi *dfi = devfreq_event_get_drvdata(edev);
>>> @@ -223,6 +281,370 @@ static const struct devfreq_event_ops rockchip_dfi_ops = {
>>> .set_event = rockchip_dfi_set_event,
>>> };
>>>
>
> [...]
>
>>> +static u64 rockchip_ddr_perf_event_get_count(struct perf_event *event)
>>> +{
>>> + struct rockchip_dfi *dfi = container_of(event->pmu, struct rockchip_dfi, pmu);
>>> + int blen = dfi->burst_len;
>>> + struct dmc_count total, now;
>>> + unsigned int seq;
>>> + u64 c = 0;
>>
>> Actually, it is difficult to understand the meaning of 'c' local variable name.
>> Need to use the more clear vairable name instead of 'c'.
>
> 'c' is short for 'count' as in the function name xxx_get_count(). It is
> initialized to 0, filled with values throughout the function and
> returned at the end. Which other name do you suggest?

If c indicats the 'count', better to use 'count' name.
Actually, 'c' is difficult to catch the meaning from just name.

>
> Sascha
>

--
Best Regards,
Samsung Electronics
Chanwoo Choi

2023-10-17 08:36:27

by Chanwoo Choi

[permalink] [raw]
Subject: Re: [PATCH v7 18/26] PM / devfreq: rockchip-dfi: account for multiple DDRMON_CTRL registers

On 23. 10. 16. 21:49, Sascha Hauer wrote:
> On Mon, Oct 09, 2023 at 07:19:04AM +0900, Chanwoo Choi wrote:
>> On 23. 7. 4. 18:32, Sascha Hauer wrote:
>>> The currently supported RK3399 has a set of registers per channel, but
>>> it has only a single DDRMON_CTRL register. With upcoming RK3588 this
>>> will be different, the RK3588 has a DDRMON_CTRL register per channel.
>>>
>>> Instead of expecting a single DDRMON_CTRL register, loop over the
>>> channels and write the channel specific DDRMON_CTRL register. Break
>>> out early out of the loop when there is only a single DDRMON_CTRL
>>> register like on the RK3399.
>>>
>>> Reviewed-by: Jonathan Cameron <[email protected]>
>>> Reviewed-by: Sebastian Reichel <[email protected]>
>>> Signed-off-by: Sascha Hauer <[email protected]>
>>> ---
>>> drivers/devfreq/event/rockchip-dfi.c | 72 ++++++++++++++++++----------
>>> 1 file changed, 48 insertions(+), 24 deletions(-)
>>>
>>> diff --git a/drivers/devfreq/event/rockchip-dfi.c b/drivers/devfreq/event/rockchip-dfi.c
>>> index 85ec93fd41858..2362d3953ba40 100644
>>> --- a/drivers/devfreq/event/rockchip-dfi.c
>>> +++ b/drivers/devfreq/event/rockchip-dfi.c
>>> @@ -113,12 +113,13 @@ struct rockchip_dfi {
>>> int burst_len;
>>> int buswidth[DMC_MAX_CHANNELS];
>>> int ddrmon_stride;
>>> + bool ddrmon_ctrl_single;
>>> };
>>>
>>> static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
>>> {
>>> void __iomem *dfi_regs = dfi->regs;
>>> - int ret = 0;
>>> + int i, ret = 0;
>>>
>>> mutex_lock(&dfi->mutex);
>>>
>>> @@ -132,29 +133,41 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
>>> goto out;
>>> }
>>>
>>> - /* clear DDRMON_CTRL setting */
>>> - writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN | DDRMON_CTRL_SOFTWARE_EN |
>>> - DDRMON_CTRL_HARDWARE_EN), dfi_regs + DDRMON_CTRL);
>>> + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
>>> + u32 ctrl = 0;
>>>
>>> - /* set ddr type to dfi */
>>> - switch (dfi->ddr_type) {
>>> - case ROCKCHIP_DDRTYPE_LPDDR2:
>>> - case ROCKCHIP_DDRTYPE_LPDDR3:
>>> - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR23, DDRMON_CTRL_DDR_TYPE_MASK),
>>> - dfi_regs + DDRMON_CTRL);
>>> - break;
>>> - case ROCKCHIP_DDRTYPE_LPDDR4:
>>> - case ROCKCHIP_DDRTYPE_LPDDR4X:
>>> - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_LPDDR4, DDRMON_CTRL_DDR_TYPE_MASK),
>>> - dfi_regs + DDRMON_CTRL);
>>> - break;
>>> - default:
>>> - break;
>>> - }
>>> + if (!(dfi->channel_mask & BIT(i)))
>>> + continue;
>>>
>>> - /* enable count, use software mode */
>>> - writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
>>> - dfi_regs + DDRMON_CTRL);
>>> + /* clear DDRMON_CTRL setting */
>>> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_TIMER_CNT_EN |
>>> + DDRMON_CTRL_SOFTWARE_EN | DDRMON_CTRL_HARDWARE_EN),
>>> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
>>> +
>>> + /* set ddr type to dfi */
>>> + switch (dfi->ddr_type) {
>>> + case ROCKCHIP_DDRTYPE_LPDDR2:
>>> + case ROCKCHIP_DDRTYPE_LPDDR3:
>>> + ctrl = DDRMON_CTRL_LPDDR23;
>>> + break;
>>> + case ROCKCHIP_DDRTYPE_LPDDR4:
>>> + case ROCKCHIP_DDRTYPE_LPDDR4X:
>>> + ctrl = DDRMON_CTRL_LPDDR4;
>>> + break;
>>> + default:
>>> + break;
>>> + }
>>> +
>>> + writel_relaxed(HIWORD_UPDATE(ctrl, DDRMON_CTRL_DDR_TYPE_MASK),
>>> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
>>> +
>>> + /* enable count, use software mode */
>>> + writel_relaxed(HIWORD_UPDATE(DDRMON_CTRL_SOFTWARE_EN, DDRMON_CTRL_SOFTWARE_EN),
>>> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
>>> +
>>> + if (dfi->ddrmon_ctrl_single)
>>> + break;
>>> + }
>>> out:
>>> mutex_unlock(&dfi->mutex);
>>>
>>> @@ -164,6 +177,7 @@ static int rockchip_dfi_enable(struct rockchip_dfi *dfi)
>>> static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
>>> {
>>> void __iomem *dfi_regs = dfi->regs;
>>> + int i;
>>>
>>> mutex_lock(&dfi->mutex);
>>>
>>> @@ -174,8 +188,17 @@ static void rockchip_dfi_disable(struct rockchip_dfi *dfi)
>>> if (dfi->usecount > 0)
>>> goto out;
>>>
>>> - writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
>>> - dfi_regs + DDRMON_CTRL);
>>> + for (i = 0; i < DMC_MAX_CHANNELS; i++) {
>>> + if (!(dfi->channel_mask & BIT(i)))
>>> + continue;
>>> +
>>> + writel_relaxed(HIWORD_UPDATE(0, DDRMON_CTRL_SOFTWARE_EN),
>>> + dfi_regs + i * dfi->ddrmon_stride + DDRMON_CTRL);
>>> +
>>> + if (dfi->ddrmon_ctrl_single)
>>> + break;
>>> + }
>>> +
>>> clk_disable_unprepare(dfi->clk);
>>> out:
>>> mutex_unlock(&dfi->mutex);
>>> @@ -666,6 +689,7 @@ static int rk3399_dfi_init(struct rockchip_dfi *dfi)
>>> dfi->buswidth[1] = FIELD_GET(RK3399_PMUGRF_OS_REG2_BW_CH1, val) == 0 ? 4 : 2;
>>>
>>> dfi->ddrmon_stride = 0x14;
>>> + dfi->ddrmon_ctrl_single = true;
>>>
>>> return 0;
>>> };
>>
>> Even if rk3568 has the only one channle and don't need to check whether 'dfi->ddrmon_ctrl_single'
>> is true or not because of 'if (!(dfi->channel_mask & BIT(i)))',
>> I recommand the add 'dfi->ddrmon_ctrl_single = true;' for rk3568 in order to
>> provide the number of DDRMON_CTRL reigster of rk3568.
>>
>> If rk3568 doesn't have the 'ddrmon_ctrl_single', actually it is not easy
>> to catch what why are there no initilization for rk3568.
>
> Ok, will change.
>

Thanks.

--
Best Regards,
Samsung Electronics
Chanwoo Choi