target/linux/jh71x0/patches-6.1/0072-soc-starfive-Extract-JH7110-pmu-private-operations.patch

   1 From 52e2ade50f3ec212468e284b1236aaa521ba5913 Mon Sep 17 00:00:00 2001
   2 From: Changhuang Liang <changhuang.liang@starfivetech.com>
   3 Date: Thu, 18 May 2023 23:02:01 -0700
   4 Subject: [PATCH 072/122] soc: starfive: Extract JH7110 pmu private operations
   5
   6 Move JH7110 private operation into private data of compatible. Convenient
   7 to add AON PMU which would not have interrupts property.
   8
   9 Signed-off-by: Changhuang Liang <changhuang.liang@starfivetech.com>
  10 Reviewed-by: Walker Chen <walker.chen@starfivetech.com>
  11 ---
  12  drivers/soc/starfive/jh71xx_pmu.c | 89 +++++++++++++++++++++----------
  13  1 file changed, 62 insertions(+), 27 deletions(-)
  14
  15 diff --git a/drivers/soc/starfive/jh71xx_pmu.c b/drivers/soc/starfive/jh71xx_pmu.c
  16 index 7d5f50d71c0d..0dbdcc0d2c91 100644
  17 --- a/drivers/soc/starfive/jh71xx_pmu.c
  18 +++ b/drivers/soc/starfive/jh71xx_pmu.c
  19 @@ -51,9 +51,17 @@ struct jh71xx_domain_info {
  20         u8 bit;
  21  };
  22
  23 +struct jh71xx_pmu;
  24 +struct jh71xx_pmu_dev;
  25 +
  26  struct jh71xx_pmu_match_data {
  27         const struct jh71xx_domain_info *domain_info;
  28         int num_domains;
  29 +       unsigned int pmu_status;
  30 +       int (*pmu_parse_irq)(struct platform_device *pdev,
  31 +                            struct jh71xx_pmu *pmu);
  32 +       int (*pmu_set_state)(struct jh71xx_pmu_dev *pmd,
  33 +                            u32 mask, bool on);
  34  };
  35
  36  struct jh71xx_pmu {
  37 @@ -79,12 +87,12 @@ static int jh71xx_pmu_get_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool *is_o
  38         if (!mask)
  39                 return -EINVAL;
  40
  41 -       *is_on = readl(pmu->base + JH71XX_PMU_CURR_POWER_MODE) & mask;
  42 +       *is_on = readl(pmu->base + pmu->match_data->pmu_status) & mask;
  43
  44         return 0;
  45  }
  46
  47 -static int jh71xx_pmu_set_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool on)
  48 +static int jh7110_pmu_set_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool on)
  49  {
  50         struct jh71xx_pmu *pmu = pmd->pmu;
  51         unsigned long flags;
  52 @@ -92,22 +100,8 @@ static int jh71xx_pmu_set_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool on)
  53         u32 mode;
  54         u32 encourage_lo;
  55         u32 encourage_hi;
  56 -       bool is_on;
  57         int ret;
  58
  59 -       ret = jh71xx_pmu_get_state(pmd, mask, &is_on);
  60 -       if (ret) {
  61 -               dev_dbg(pmu->dev, "unable to get current state for %s\n",
  62 -                       pmd->genpd.name);
  63 -               return ret;
  64 -       }
  65 -
  66 -       if (is_on == on) {
  67 -               dev_dbg(pmu->dev, "pm domain [%s] is already %sable status.\n",
  68 -                       pmd->genpd.name, on ? "en" : "dis");
  69 -               return 0;
  70 -       }
  71 -
  72         spin_lock_irqsave(&pmu->lock, flags);
  73
  74         /*
  75 @@ -166,6 +160,29 @@ static int jh71xx_pmu_set_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool on)
  76         return 0;
  77  }
  78
  79 +static int jh71xx_pmu_set_state(struct jh71xx_pmu_dev *pmd, u32 mask, bool on)
  80 +{
  81 +       struct jh71xx_pmu *pmu = pmd->pmu;
  82 +       const struct jh71xx_pmu_match_data *match_data = pmu->match_data;
  83 +       bool is_on;
  84 +       int ret;
  85 +
  86 +       ret = jh71xx_pmu_get_state(pmd, mask, &is_on);
  87 +       if (ret) {
  88 +               dev_dbg(pmu->dev, "unable to get current state for %s\n",
  89 +                       pmd->genpd.name);
  90 +               return ret;
  91 +       }
  92 +
  93 +       if (is_on == on) {
  94 +               dev_dbg(pmu->dev, "pm domain [%s] is already %sable status.\n",
  95 +                       pmd->genpd.name, on ? "en" : "dis");
  96 +               return 0;
  97 +       }
  98 +
  99 +       return match_data->pmu_set_state(pmd, mask, on);
 100 +}
 101 +
 102  static int jh71xx_pmu_on(struct generic_pm_domain *genpd)
 103  {
 104         struct jh71xx_pmu_dev *pmd = container_of(genpd,
 105 @@ -226,6 +243,25 @@ static irqreturn_t jh71xx_pmu_interrupt(int irq, void *data)
 106         return IRQ_HANDLED;
 107  }
 108
 109 +static int jh7110_pmu_parse_irq(struct platform_device *pdev, struct jh71xx_pmu *pmu)
 110 +{
 111 +       struct device *dev = &pdev->dev;
 112 +       int ret;
 113 +
 114 +       pmu->irq = platform_get_irq(pdev, 0);
 115 +       if (pmu->irq < 0)
 116 +               return pmu->irq;
 117 +
 118 +       ret = devm_request_irq(dev, pmu->irq, jh71xx_pmu_interrupt,
 119 +                              0, pdev->name, pmu);
 120 +       if (ret)
 121 +               dev_err(dev, "failed to request irq\n");
 122 +
 123 +       jh71xx_pmu_int_enable(pmu, JH71XX_PMU_INT_ALL_MASK & ~JH71XX_PMU_INT_PCH_FAIL, true);
 124 +
 125 +       return 0;
 126 +}
 127 +
 128  static int jh71xx_pmu_init_domain(struct jh71xx_pmu *pmu, int index)
 129  {
 130         struct jh71xx_pmu_dev *pmd;
 131 @@ -275,19 +311,18 @@ static int jh71xx_pmu_probe(struct platform_device *pdev)
 132         if (IS_ERR(pmu->base))
 133                 return PTR_ERR(pmu->base);
 134
 135 -       pmu->irq = platform_get_irq(pdev, 0);
 136 -       if (pmu->irq < 0)
 137 -               return pmu->irq;
 138 -
 139 -       ret = devm_request_irq(dev, pmu->irq, jh71xx_pmu_interrupt,
 140 -                              0, pdev->name, pmu);
 141 -       if (ret)
 142 -               dev_err(dev, "failed to request irq\n");
 143 +       spin_lock_init(&pmu->lock);
 144
 145         match_data = of_device_get_match_data(dev);
 146         if (!match_data)
 147                 return -EINVAL;
 148
 149 +       ret = match_data->pmu_parse_irq(pdev, pmu);
 150 +       if (ret) {
 151 +               dev_err(dev, "failed to parse irq\n");
 152 +               return ret;
 153 +       }
 154 +
 155         pmu->genpd = devm_kcalloc(dev, match_data->num_domains,
 156                                   sizeof(struct generic_pm_domain *),
 157                                   GFP_KERNEL);
 158 @@ -307,9 +342,6 @@ static int jh71xx_pmu_probe(struct platform_device *pdev)
 159                 }
 160         }
 161
 162 -       spin_lock_init(&pmu->lock);
 163 -       jh71xx_pmu_int_enable(pmu, JH71XX_PMU_INT_ALL_MASK & ~JH71XX_PMU_INT_PCH_FAIL, true);
 164 -
 165         ret = of_genpd_add_provider_onecell(np, &pmu->genpd_data);
 166         if (ret) {
 167                 dev_err(dev, "failed to register genpd driver: %d\n", ret);
 168 @@ -357,6 +389,9 @@ static const struct jh71xx_domain_info jh7110_power_domains[] = {
 169  static const struct jh71xx_pmu_match_data jh7110_pmu = {
 170         .num_domains = ARRAY_SIZE(jh7110_power_domains),
 171         .domain_info = jh7110_power_domains,
 172 +       .pmu_status = JH71XX_PMU_CURR_POWER_MODE,
 173 +       .pmu_parse_irq = jh7110_pmu_parse_irq,
 174 +       .pmu_set_state = jh7110_pmu_set_state,
 175  };
 176
 177  static const struct of_device_id jh71xx_pmu_of_match[] = {
 178 --
 179 2.20.1
 180