1 From 3e3b85a1064b07a5107504af1e8f0a42ff9d1fc1 Mon Sep 17 00:00:00 2001
2 From: Walker Chen <walker.chen@starfivetech.com>
3 Date: Thu, 19 Jan 2023 17:44:47 +0800
4 Subject: [PATCH 036/122] soc: starfive: Add StarFive JH71XX pmu driver
6 Add pmu driver for the StarFive JH71XX SoC.
8 As the power domains provider, the Power Management Unit (PMU) is
9 designed for including multiple PM domains that can be used for power
10 gating of selected IP blocks for power saving by reduced leakage
11 current. It accepts software encourage command to switch the power mode
14 Signed-off-by: Walker Chen <walker.chen@starfivetech.com>
15 Reviewed-by: Conor Dooley <conor.dooley@microchip.com>
16 Reviewed-by: Heiko Stuebner <heiko@sntech.de>
19 drivers/soc/Kconfig | 1 +
20 drivers/soc/Makefile | 1 +
21 drivers/soc/starfive/Kconfig | 12 +
22 drivers/soc/starfive/Makefile | 3 +
23 drivers/soc/starfive/jh71xx_pmu.c | 383 ++++++++++++++++++++++++++++++
24 6 files changed, 414 insertions(+)
25 create mode 100644 drivers/soc/starfive/Kconfig
26 create mode 100644 drivers/soc/starfive/Makefile
27 create mode 100644 drivers/soc/starfive/jh71xx_pmu.c
31 @@ -19689,6 +19689,20 @@ F: Documentation/devicetree/bindings/res
32 F: drivers/reset/starfive/reset-starfive-jh71*
33 F: include/dt-bindings/reset/starfive?jh71*.h
36 +M: Conor Dooley <conor@kernel.org>
38 +T: git https://git.kernel.org/pub/scm/linux/kernel/git/conor/linux.git/
39 +F: drivers/soc/starfive/
40 +F: include/soc/starfive/
42 +STARFIVE JH71XX PMU CONTROLLER DRIVER
43 +M: Walker Chen <walker.chen@starfivetech.com>
45 +F: Documentation/devicetree/bindings/power/starfive*
46 +F: drivers/soc/starfive/jh71xx_pmu.c
47 +F: include/dt-bindings/power/starfive,jh7110-pmu.h
50 M: Peter Zijlstra <peterz@infradead.org>
51 M: Josh Poimboeuf <jpoimboe@kernel.org>
52 --- a/drivers/soc/Kconfig
53 +++ b/drivers/soc/Kconfig
54 @@ -21,6 +21,7 @@ source "drivers/soc/renesas/Kconfig"
55 source "drivers/soc/rockchip/Kconfig"
56 source "drivers/soc/samsung/Kconfig"
57 source "drivers/soc/sifive/Kconfig"
58 +source "drivers/soc/starfive/Kconfig"
59 source "drivers/soc/sunxi/Kconfig"
60 source "drivers/soc/tegra/Kconfig"
61 source "drivers/soc/ti/Kconfig"
62 --- a/drivers/soc/Makefile
63 +++ b/drivers/soc/Makefile
64 @@ -27,6 +27,7 @@ obj-y += renesas/
66 obj-$(CONFIG_SOC_SAMSUNG) += samsung/
67 obj-$(CONFIG_SOC_SIFIVE) += sifive/
68 +obj-$(CONFIG_SOC_STARFIVE) += starfive/
70 obj-$(CONFIG_ARCH_TEGRA) += tegra/
73 +++ b/drivers/soc/starfive/Kconfig
75 +# SPDX-License-Identifier: GPL-2.0
78 + bool "Support PMU for StarFive JH71XX Soc"
80 + depends on SOC_STARFIVE || COMPILE_TEST
81 + default SOC_STARFIVE
82 + select PM_GENERIC_DOMAINS
84 + Say 'y' here to enable support power domain support.
85 + In order to meet low power requirements, a Power Management Unit (PMU)
86 + is designed for controlling power resources in StarFive JH71XX SoCs.
88 +++ b/drivers/soc/starfive/Makefile
90 +# SPDX-License-Identifier: GPL-2.0
92 +obj-$(CONFIG_JH71XX_PMU) += jh71xx_pmu.o
94 +++ b/drivers/soc/starfive/jh71xx_pmu.c
96 +// SPDX-License-Identifier: GPL-2.0-or-later
98 + * StarFive JH71XX PMU (Power Management Unit) Controller Driver
100 + * Copyright (C) 2022 StarFive Technology Co., Ltd.
103 +#include <linux/interrupt.h>
104 +#include <linux/io.h>
105 +#include <linux/iopoll.h>
106 +#include <linux/module.h>
107 +#include <linux/of.h>
108 +#include <linux/of_device.h>
109 +#include <linux/platform_device.h>
110 +#include <linux/pm_domain.h>
111 +#include <dt-bindings/power/starfive,jh7110-pmu.h>
113 +/* register offset */
114 +#define JH71XX_PMU_SW_TURN_ON_POWER 0x0C
115 +#define JH71XX_PMU_SW_TURN_OFF_POWER 0x10
116 +#define JH71XX_PMU_SW_ENCOURAGE 0x44
117 +#define JH71XX_PMU_TIMER_INT_MASK 0x48
118 +#define JH71XX_PMU_CURR_POWER_MODE 0x80
119 +#define JH71XX_PMU_EVENT_STATUS 0x88
120 +#define JH71XX_PMU_INT_STATUS 0x8C
122 +/* sw encourage cfg */
123 +#define JH71XX_PMU_SW_ENCOURAGE_EN_LO 0x05
124 +#define JH71XX_PMU_SW_ENCOURAGE_EN_HI 0x50
125 +#define JH71XX_PMU_SW_ENCOURAGE_DIS_LO 0x0A
126 +#define JH71XX_PMU_SW_ENCOURAGE_DIS_HI 0xA0
127 +#define JH71XX_PMU_SW_ENCOURAGE_ON 0xFF
129 +/* pmu int status */
130 +#define JH71XX_PMU_INT_SEQ_DONE BIT(0)
131 +#define JH71XX_PMU_INT_HW_REQ BIT(1)
132 +#define JH71XX_PMU_INT_SW_FAIL GENMASK(3, 2)
133 +#define JH71XX_PMU_INT_HW_FAIL GENMASK(5, 4)
134 +#define JH71XX_PMU_INT_PCH_FAIL GENMASK(8, 6)
135 +#define JH71XX_PMU_INT_ALL_MASK GENMASK(8, 0)
138 + * The time required for switching power status is based on the time
139 + * to turn on the largest domain's power, which is at microsecond level
141 +#define JH71XX_PMU_TIMEOUT_US 100
143 +struct jh71xx_domain_info {
144 + const char * const name;
145 + unsigned int flags;
149 +struct jh71xx_pmu_match_data {
150 + const struct jh71xx_domain_info *domain_info;
155 + struct device *dev;
156 + const struct jh71xx_pmu_match_data *match_data;
157 + void __iomem *base;
158 + struct generic_pm_domain **genpd;
159 + struct genpd_onecell_data genpd_data;
161 + spinlock_t lock; /* protects pmu reg */
164 +struct jh71xx_pmu_dev {
165 + const struct jh71xx_domain_info *domain_info;
166 + struct jh71xx_pmu *pmu;
167 + struct generic_pm_domain genpd;
170 +static int jh71xx_pmu_get_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool *is_on)
172 + struct jh71xx_pmu *pmu = pmd->pmu;
177 + *is_on = readl(pmu->base + JH71XX_PMU_CURR_POWER_MODE) & mask;
182 +static int jh71xx_pmu_set_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool on)
184 + struct jh71xx_pmu *pmu = pmd->pmu;
185 + unsigned long flags;
193 + ret = jh71xx_pmu_get_state(pmd, mask, &is_on);
195 + dev_dbg(pmu->dev, "unable to get current state for %s\n",
201 + dev_dbg(pmu->dev, "pm domain [%s] is already %sable status.\n",
202 + pmd->genpd.name, on ? "en" : "dis");
206 + spin_lock_irqsave(&pmu->lock, flags);
209 + * The PMU accepts software encourage to switch power mode in the following 2 steps:
211 + * 1.Configure the register SW_TURN_ON_POWER (offset 0x0c) by writing 1 to
212 + * the bit corresponding to the power domain that will be turned on
213 + * and writing 0 to the others.
214 + * Likewise, configure the register SW_TURN_OFF_POWER (offset 0x10) by
215 + * writing 1 to the bit corresponding to the power domain that will be
216 + * turned off and writing 0 to the others.
219 + mode = JH71XX_PMU_SW_TURN_ON_POWER;
220 + encourage_lo = JH71XX_PMU_SW_ENCOURAGE_EN_LO;
221 + encourage_hi = JH71XX_PMU_SW_ENCOURAGE_EN_HI;
223 + mode = JH71XX_PMU_SW_TURN_OFF_POWER;
224 + encourage_lo = JH71XX_PMU_SW_ENCOURAGE_DIS_LO;
225 + encourage_hi = JH71XX_PMU_SW_ENCOURAGE_DIS_HI;
228 + writel(mask, pmu->base + mode);
231 + * 2.Write SW encourage command sequence to the Software Encourage Reg (offset 0x44)
232 + * First write SW_MODE_ENCOURAGE_ON to JH71XX_PMU_SW_ENCOURAGE. This will reset
233 + * the state machine which parses the command sequence. This register must be
234 + * written every time software wants to power on/off a domain.
235 + * Then write the lower bits of the command sequence, followed by the upper
236 + * bits. The sequence differs between powering on & off a domain.
238 + writel(JH71XX_PMU_SW_ENCOURAGE_ON, pmu->base + JH71XX_PMU_SW_ENCOURAGE);
239 + writel(encourage_lo, pmu->base + JH71XX_PMU_SW_ENCOURAGE);
240 + writel(encourage_hi, pmu->base + JH71XX_PMU_SW_ENCOURAGE);
242 + spin_unlock_irqrestore(&pmu->lock, flags);
244 + /* Wait for the power domain bit to be enabled / disabled */
246 + ret = readl_poll_timeout_atomic(pmu->base + JH71XX_PMU_CURR_POWER_MODE,
248 + 1, JH71XX_PMU_TIMEOUT_US);
250 + ret = readl_poll_timeout_atomic(pmu->base + JH71XX_PMU_CURR_POWER_MODE,
251 + val, !(val & mask),
252 + 1, JH71XX_PMU_TIMEOUT_US);
256 + dev_err(pmu->dev, "%s: failed to power %s\n",
257 + pmd->genpd.name, on ? "on" : "off");
264 +static int jh71xx_pmu_on(struct generic_pm_domain *genpd)
266 + struct jh71xx_pmu_dev *pmd = container_of(genpd,
267 + struct jh71xx_pmu_dev, genpd);
268 + u32 pwr_mask = BIT(pmd->domain_info->bit);
270 + return jh71xx_pmu_set_state(pmd, pwr_mask, true);
273 +static int jh71xx_pmu_off(struct generic_pm_domain *genpd)
275 + struct jh71xx_pmu_dev *pmd = container_of(genpd,
276 + struct jh71xx_pmu_dev, genpd);
277 + u32 pwr_mask = BIT(pmd->domain_info->bit);
279 + return jh71xx_pmu_set_state(pmd, pwr_mask, false);
282 +static void jh71xx_pmu_int_enable(struct jh71xx_pmu *pmu, u32 mask, bool enable)
285 + unsigned long flags;
287 + spin_lock_irqsave(&pmu->lock, flags);
288 + val = readl(pmu->base + JH71XX_PMU_TIMER_INT_MASK);
295 + writel(val, pmu->base + JH71XX_PMU_TIMER_INT_MASK);
296 + spin_unlock_irqrestore(&pmu->lock, flags);
299 +static irqreturn_t jh71xx_pmu_interrupt(int irq, void *data)
301 + struct jh71xx_pmu *pmu = data;
304 + val = readl(pmu->base + JH71XX_PMU_INT_STATUS);
306 + if (val & JH71XX_PMU_INT_SEQ_DONE)
307 + dev_dbg(pmu->dev, "sequence done.\n");
308 + if (val & JH71XX_PMU_INT_HW_REQ)
309 + dev_dbg(pmu->dev, "hardware encourage requestion.\n");
310 + if (val & JH71XX_PMU_INT_SW_FAIL)
311 + dev_err(pmu->dev, "software encourage fail.\n");
312 + if (val & JH71XX_PMU_INT_HW_FAIL)
313 + dev_err(pmu->dev, "hardware encourage fail.\n");
314 + if (val & JH71XX_PMU_INT_PCH_FAIL)
315 + dev_err(pmu->dev, "p-channel fail event.\n");
317 + /* clear interrupts */
318 + writel(val, pmu->base + JH71XX_PMU_INT_STATUS);
319 + writel(val, pmu->base + JH71XX_PMU_EVENT_STATUS);
321 + return IRQ_HANDLED;
324 +static int jh71xx_pmu_init_domain(struct jh71xx_pmu *pmu, int index)
326 + struct jh71xx_pmu_dev *pmd;
329 + bool is_on = false;
331 + pmd = devm_kzalloc(pmu->dev, sizeof(*pmd), GFP_KERNEL);
335 + pmd->domain_info = &pmu->match_data->domain_info[index];
337 + pwr_mask = BIT(pmd->domain_info->bit);
339 + pmd->genpd.name = pmd->domain_info->name;
340 + pmd->genpd.flags = pmd->domain_info->flags;
342 + ret = jh71xx_pmu_get_state(pmd, pwr_mask, &is_on);
344 + dev_warn(pmu->dev, "unable to get current state for %s\n",
347 + pmd->genpd.power_on = jh71xx_pmu_on;
348 + pmd->genpd.power_off = jh71xx_pmu_off;
349 + pm_genpd_init(&pmd->genpd, NULL, !is_on);
351 + pmu->genpd_data.domains[index] = &pmd->genpd;
356 +static int jh71xx_pmu_probe(struct platform_device *pdev)
358 + struct device *dev = &pdev->dev;
359 + struct device_node *np = dev->of_node;
360 + const struct jh71xx_pmu_match_data *match_data;
361 + struct jh71xx_pmu *pmu;
365 + pmu = devm_kzalloc(dev, sizeof(*pmu), GFP_KERNEL);
369 + pmu->base = devm_platform_ioremap_resource(pdev, 0);
370 + if (IS_ERR(pmu->base))
371 + return PTR_ERR(pmu->base);
373 + pmu->irq = platform_get_irq(pdev, 0);
377 + ret = devm_request_irq(dev, pmu->irq, jh71xx_pmu_interrupt,
378 + 0, pdev->name, pmu);
380 + dev_err(dev, "failed to request irq\n");
382 + match_data = of_device_get_match_data(dev);
386 + pmu->genpd = devm_kcalloc(dev, match_data->num_domains,
387 + sizeof(struct generic_pm_domain *),
393 + pmu->match_data = match_data;
394 + pmu->genpd_data.domains = pmu->genpd;
395 + pmu->genpd_data.num_domains = match_data->num_domains;
397 + for (i = 0; i < match_data->num_domains; i++) {
398 + ret = jh71xx_pmu_init_domain(pmu, i);
400 + dev_err(dev, "failed to initialize power domain\n");
405 + spin_lock_init(&pmu->lock);
406 + jh71xx_pmu_int_enable(pmu, JH71XX_PMU_INT_ALL_MASK & ~JH71XX_PMU_INT_PCH_FAIL, true);
408 + ret = of_genpd_add_provider_onecell(np, &pmu->genpd_data);
410 + dev_err(dev, "failed to register genpd driver: %d\n", ret);
414 + dev_dbg(dev, "registered %u power domains\n", i);
419 +static const struct jh71xx_domain_info jh7110_power_domains[] = {
420 + [JH7110_PD_SYSTOP] = {
423 + .flags = GENPD_FLAG_ALWAYS_ON,
425 + [JH7110_PD_CPU] = {
428 + .flags = GENPD_FLAG_ALWAYS_ON,
430 + [JH7110_PD_GPUA] = {
434 + [JH7110_PD_VDEC] = {
438 + [JH7110_PD_VOUT] = {
442 + [JH7110_PD_ISP] = {
446 + [JH7110_PD_VENC] = {
452 +static const struct jh71xx_pmu_match_data jh7110_pmu = {
453 + .num_domains = ARRAY_SIZE(jh7110_power_domains),
454 + .domain_info = jh7110_power_domains,
457 +static const struct of_device_id jh71xx_pmu_of_match[] = {
459 + .compatible = "starfive,jh7110-pmu",
460 + .data = (void *)&jh7110_pmu,
466 +static struct platform_driver jh71xx_pmu_driver = {
467 + .probe = jh71xx_pmu_probe,
469 + .name = "jh71xx-pmu",
470 + .of_match_table = jh71xx_pmu_of_match,
471 + .suppress_bind_attrs = true,
474 +builtin_platform_driver(jh71xx_pmu_driver);
476 +MODULE_AUTHOR("Walker Chen <walker.chen@starfivetech.com>");
477 +MODULE_DESCRIPTION("StarFive JH71XX PMU Driver");
478 +MODULE_LICENSE("GPL");