Revert "block: don't call into the driver for BLKROSET"

[platform/kernel/linux-rpi.git] / drivers / pwm / pwm-sifive.c

diff --git a/drivers/pwm/pwm-sifive.c b/drivers/pwm/pwm-sifive.c
index 420edc4..58347fc 100644 (file)
--- a/drivers/pwm/pwm-sifive.c
+++ b/drivers/pwm/pwm-sifive.c
@@ -23,7 +23,7 @@
 #define PWM_SIFIVE_PWMCFG              0x0
 #define PWM_SIFIVE_PWMCOUNT            0x8
 #define PWM_SIFIVE_PWMS                        0x10
-#define PWM_SIFIVE_PWMCMP0             0x20
+#define PWM_SIFIVE_PWMCMP(i)           (0x20 + 4 * (i))
 
 /* PWMCFG fields */
 #define PWM_SIFIVE_PWMCFG_SCALE                GENMASK(3, 0)
@@ -36,8 +36,6 @@
 #define PWM_SIFIVE_PWMCFG_GANG         BIT(24)
 #define PWM_SIFIVE_PWMCFG_IP           BIT(28)
 
-/* PWM_SIFIVE_SIZE_PWMCMP is used to calculate offset for pwmcmpX registers */
-#define PWM_SIFIVE_SIZE_PWMCMP         4
 #define PWM_SIFIVE_CMPWIDTH            16
 #define PWM_SIFIVE_DEFAULT_PERIOD      10000000
 
@@ -112,8 +110,7 @@ static void pwm_sifive_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
        struct pwm_sifive_ddata *ddata = pwm_sifive_chip_to_ddata(chip);
        u32 duty, val;
 
-       duty = readl(ddata->regs + PWM_SIFIVE_PWMCMP0 +
-                    pwm->hwpwm * PWM_SIFIVE_SIZE_PWMCMP);
+       duty = readl(ddata->regs + PWM_SIFIVE_PWMCMP(pwm->hwpwm));
 
        state->enabled = duty > 0;
 
@@ -194,8 +191,7 @@ static int pwm_sifive_apply(struct pwm_chip *chip, struct pwm_device *pwm,
                pwm_sifive_update_clock(ddata, clk_get_rate(ddata->clk));
        }
 
-       writel(frac, ddata->regs + PWM_SIFIVE_PWMCMP0 +
-              pwm->hwpwm * PWM_SIFIVE_SIZE_PWMCMP);
+       writel(frac, ddata->regs + PWM_SIFIVE_PWMCMP(pwm->hwpwm));
 
        if (state->enabled != enabled)
                pwm_sifive_enable(chip, state->enabled);
@@ -233,6 +229,8 @@ static int pwm_sifive_probe(struct platform_device *pdev)
        struct pwm_sifive_ddata *ddata;
        struct pwm_chip *chip;
        int ret;
+       u32 val;
+       unsigned int enabled_pwms = 0, enabled_clks = 1;
 
        ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
        if (!ddata)
@@ -259,6 +257,33 @@ static int pwm_sifive_probe(struct platform_device *pdev)
                return ret;
        }
 
+       val = readl(ddata->regs + PWM_SIFIVE_PWMCFG);
+       if (val & PWM_SIFIVE_PWMCFG_EN_ALWAYS) {
+               unsigned int i;
+
+               for (i = 0; i < chip->npwm; ++i) {
+                       val = readl(ddata->regs + PWM_SIFIVE_PWMCMP(i));
+                       if (val > 0)
+                               ++enabled_pwms;
+               }
+       }
+
+       /* The clk should be on once for each running PWM. */
+       if (enabled_pwms) {
+               while (enabled_clks < enabled_pwms) {
+                       /* This is not expected to fail as the clk is already on */
+                       ret = clk_enable(ddata->clk);
+                       if (unlikely(ret)) {
+                               dev_err_probe(dev, ret, "Failed to enable clk\n");
+                               goto disable_clk;
+                       }
+                       ++enabled_clks;
+               }
+       } else {
+               clk_disable(ddata->clk);
+               enabled_clks = 0;
+       }
+
        /* Watch for changes to underlying clock frequency */
        ddata->notifier.notifier_call = pwm_sifive_clock_notifier;
        ret = clk_notifier_register(ddata->clk, &ddata->notifier);
@@ -281,7 +306,11 @@ static int pwm_sifive_probe(struct platform_device *pdev)
 unregister_clk:
        clk_notifier_unregister(ddata->clk, &ddata->notifier);
 disable_clk:
-       clk_disable_unprepare(ddata->clk);
+       while (enabled_clks) {
+               clk_disable(ddata->clk);
+               --enabled_clks;
+       }
+       clk_unprepare(ddata->clk);
 
        return ret;
 }
@@ -289,25 +318,21 @@ disable_clk:
 static int pwm_sifive_remove(struct platform_device *dev)
 {
        struct pwm_sifive_ddata *ddata = platform_get_drvdata(dev);
-       bool is_enabled = false;
        struct pwm_device *pwm;
-       int ret, ch;
+       int ch;
+
+       pwmchip_remove(&ddata->chip);
+       clk_notifier_unregister(ddata->clk, &ddata->notifier);
 
        for (ch = 0; ch < ddata->chip.npwm; ch++) {
                pwm = &ddata->chip.pwms[ch];
-               if (pwm->state.enabled) {
-                       is_enabled = true;
-                       break;
-               }
+               if (pwm->state.enabled)
+                       clk_disable(ddata->clk);
        }
-       if (is_enabled)
-               clk_disable(ddata->clk);
 
-       clk_disable_unprepare(ddata->clk);
-       ret = pwmchip_remove(&ddata->chip);
-       clk_notifier_unregister(ddata->clk, &ddata->notifier);
+       clk_unprepare(ddata->clk);
 
-       return ret;
+       return 0;
 }
 
 static const struct of_device_id pwm_sifive_of_match[] = {