Merge tag 'perf-tools-for-v5.14-2021-07-10' of git://git.kernel.org/pub/scm/linux...

[linux-2.6-microblaze.git] / drivers / soc / tegra / pmc.c

diff --git a/drivers/soc/tegra/pmc.c b/drivers/soc/tegra/pmc.c
index 4a582ea..ea62f84 100644 (file)
--- a/drivers/soc/tegra/pmc.c
+++ b/drivers/soc/tegra/pmc.c
@@ -38,6 +38,7 @@
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/platform_device.h>
 #include <linux/pm_domain.h>
+#include <linux/pm_opp.h>
 #include <linux/reboot.h>
 #include <linux/regmap.h>
 #include <linux/reset.h>
@@ -428,6 +429,9 @@ struct tegra_pmc {
        struct irq_chip irq;
 
        struct notifier_block clk_nb;
+
+       bool core_domain_state_synced;
+       bool core_domain_registered;
 };
 
 static struct tegra_pmc *pmc = &(struct tegra_pmc) {
@@ -1297,12 +1301,107 @@ free_mem:
        return err;
 }
 
+bool tegra_pmc_core_domain_state_synced(void)
+{
+       return pmc->core_domain_state_synced;
+}
+
+static int
+tegra_pmc_core_pd_set_performance_state(struct generic_pm_domain *genpd,
+                                       unsigned int level)
+{
+       struct dev_pm_opp *opp;
+       int err;
+
+       opp = dev_pm_opp_find_level_ceil(&genpd->dev, &level);
+       if (IS_ERR(opp)) {
+               dev_err(&genpd->dev, "failed to find OPP for level %u: %pe\n",
+                       level, opp);
+               return PTR_ERR(opp);
+       }
+
+       mutex_lock(&pmc->powergates_lock);
+       err = dev_pm_opp_set_opp(pmc->dev, opp);
+       mutex_unlock(&pmc->powergates_lock);
+
+       dev_pm_opp_put(opp);
+
+       if (err) {
+               dev_err(&genpd->dev, "failed to set voltage to %duV: %d\n",
+                       level, err);
+               return err;
+       }
+
+       return 0;
+}
+
+static unsigned int
+tegra_pmc_core_pd_opp_to_performance_state(struct generic_pm_domain *genpd,
+                                          struct dev_pm_opp *opp)
+{
+       return dev_pm_opp_get_level(opp);
+}
+
+static int tegra_pmc_core_pd_add(struct tegra_pmc *pmc, struct device_node *np)
+{
+       struct generic_pm_domain *genpd;
+       const char *rname = "core";
+       int err;
+
+       genpd = devm_kzalloc(pmc->dev, sizeof(*genpd), GFP_KERNEL);
+       if (!genpd)
+               return -ENOMEM;
+
+       genpd->name = np->name;
+       genpd->set_performance_state = tegra_pmc_core_pd_set_performance_state;
+       genpd->opp_to_performance_state = tegra_pmc_core_pd_opp_to_performance_state;
+
+       err = devm_pm_opp_set_regulators(pmc->dev, &rname, 1);
+       if (err)
+               return dev_err_probe(pmc->dev, err,
+                                    "failed to set core OPP regulator\n");
+
+       err = pm_genpd_init(genpd, NULL, false);
+       if (err) {
+               dev_err(pmc->dev, "failed to init core genpd: %d\n", err);
+               return err;
+       }
+
+       err = of_genpd_add_provider_simple(np, genpd);
+       if (err) {
+               dev_err(pmc->dev, "failed to add core genpd: %d\n", err);
+               goto remove_genpd;
+       }
+
+       pmc->core_domain_registered = true;
+
+       return 0;
+
+remove_genpd:
+       pm_genpd_remove(genpd);
+
+       return err;
+}
+
 static int tegra_powergate_init(struct tegra_pmc *pmc,
                                struct device_node *parent)
 {
+       struct of_phandle_args child_args, parent_args;
        struct device_node *np, *child;
        int err = 0;
 
+       /*
+        * Core power domain is the parent of powergate domains, hence it
+        * should be registered first.
+        */
+       np = of_get_child_by_name(parent, "core-domain");
+       if (np) {
+               err = tegra_pmc_core_pd_add(pmc, np);
+               of_node_put(np);
+               if (err)
+                       return err;
+       }
+
        np = of_get_child_by_name(parent, "powergates");
        if (!np)
                return 0;
@@ -1313,6 +1412,21 @@ static int tegra_powergate_init(struct tegra_pmc *pmc,
                        of_node_put(child);
                        break;
                }
+
+               if (of_parse_phandle_with_args(child, "power-domains",
+                                              "#power-domain-cells",
+                                              0, &parent_args))
+                       continue;
+
+               child_args.np = child;
+               child_args.args_count = 0;
+
+               err = of_genpd_add_subdomain(&parent_args, &child_args);
+               of_node_put(parent_args.np);
+               if (err) {
+                       of_node_put(child);
+                       break;
+               }
        }
 
        of_node_put(np);
@@ -1356,6 +1470,12 @@ static void tegra_powergate_remove_all(struct device_node *parent)
        }
 
        of_node_put(np);
+
+       np = of_get_child_by_name(parent, "core-domain");
+       if (np) {
+               of_genpd_del_provider(np);
+               of_genpd_remove_last(np);
+       }
 }
 
 static const struct tegra_io_pad_soc *
@@ -3667,6 +3787,29 @@ static const struct of_device_id tegra_pmc_match[] = {
        { }
 };
 
+static void tegra_pmc_sync_state(struct device *dev)
+{
+       int err;
+
+       /*
+        * Older device-trees don't have core PD, and thus, there are
+        * no dependencies that will block the state syncing. We shouldn't
+        * mark the domain as synced in this case.
+        */
+       if (!pmc->core_domain_registered)
+               return;
+
+       pmc->core_domain_state_synced = true;
+
+       /* this is a no-op if core regulator isn't used */
+       mutex_lock(&pmc->powergates_lock);
+       err = dev_pm_opp_sync_regulators(dev);
+       mutex_unlock(&pmc->powergates_lock);
+
+       if (err)
+               dev_err(dev, "failed to sync regulators: %d\n", err);
+}
+
 static struct platform_driver tegra_pmc_driver = {
        .driver = {
                .name = "tegra-pmc",
@@ -3675,6 +3818,7 @@ static struct platform_driver tegra_pmc_driver = {
 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_ARM)
                .pm = &tegra_pmc_pm_ops,
 #endif
+               .sync_state = tegra_pmc_sync_state,
        },
        .probe = tegra_pmc_probe,
 };