[v2,06/14] PM / cpu_domains: Setup PM domains for CPUs/clusters

Commit Message

Lina Iyer July 29, 2016, 9:56 p.m. UTC

Define and add Generic PM domains (genpd) for CPU clusters. Many new
SoCs group CPUs as clusters. Clusters share common resources like power
rails, caches, VFP, Coresight etc. When all CPUs in the cluster are
idle, these shared resources may also be put in their idle state.

CPUs may be associated with their domain providers in DT. The domains in
turn may be associated with their providers. This is clean way to model
the cluster hierarchy like that of ARM's big.little architecture. The
current patch expects OF support to initialize and setup CPU PM domains.

For each CPU in the DT, we identify the domain provider; initialize and
register the PM domain if isn't already registered and attach all the
CPU devices to the domain. Usually, when there are multiple clusters of
CPUs, there is a top level coherency domain that is dependent on these
individual domains. All domains thus created are marked IRQ safe
automatically and therefore may be powered down when the CPUs in the
domain are powered down by cpuidle.

Reading DT, initializing Generic PM domains, attaching CPUs to it
domains are common functionalities across ARM SoCs. Provide a common set
of APIs to setup PM domains for CPU clusters and its parents. The
platform drivers may just call of_setup_cpu_pd() to do a single step
setup of CPU domains.

Cc: Ulf Hansson <[e-mail]>
Cc: Daniel Lezcano <[e-mail]>
Cc: Lorenzo Pieralisi <[e-mail]>
Suggested-by: Kevin Hilman <[e-mail]>
Signed-off-by: Lina Iyer <[e-mail]>
---
 drivers/base/power/Makefile      |   1 +
 drivers/base/power/cpu_domains.c | 310 +++++++++++++++++++++++++++++++++++++++
 include/linux/cpu_domains.h      |  39 +++++
 3 files changed, 350 insertions(+)
 create mode 100644 drivers/base/power/cpu_domains.c
 create mode 100644 include/linux/cpu_domains.h

Comments

Brendan Jackman Aug. 4, 2016, 10:15 a.m. UTC | #1

Hi Lina,

On Fri, Jul 29, 2016 at 03:56:17PM -0600, Lina Iyer wrote:
> +static struct generic_pm_domain *of_get_cpu_domain(struct device_node *dn,
> +		const struct cpu_pd_ops *ops, int cpu)
> +{
> +	struct of_phandle_args args;
> +	struct generic_pm_domain *genpd, *parent;
> +	struct cpu_pm_domain *cpu_pd, *parent_cpu_pd;
> +	int ret;
> +
> +	/* Do we have this domain? If not, create the domain */
> +	args.np = dn;
> +	args.args_count = 0;
> +
> +	genpd = of_genpd_get_from_provider(&args);
> +	if (!IS_ERR(genpd))
> +		return genpd;
> +
> +	genpd = of_init_cpu_pm_domain(dn, ops);
> +	if (IS_ERR(genpd))
> +		return genpd;
> +
> +	/* Is there a domain provider for this domain? */
> +	ret = of_parse_phandle_with_args(dn, "power-domains",
> +			"#power-domain-cells", 0, &args);
> +	if (ret < 0)
> +		goto skip_parent;
> +
> +	/* Find its parent and attach this domain to it, recursively */
> +	parent = of_get_cpu_domain(args.np, ops, cpu);
> +	if (IS_ERR(parent))
> +		goto skip_parent;
> +
> +	ret = pm_genpd_add_subdomain(genpd, parent);

Looks like the arguments are the wrong way around here, it should be:

	ret = pm_genpd_add_subdomain(parent, genpd);

> +	if (ret) {
> +		pr_err("%s: Unable to add sub-domain (%s)\n err: %d",
> +				__func__, genpd->name, ret);
> +		return ERR_PTR(ret);
> +	}
> +
> +	/*
> +	 * Reference parent domain for easy access.
> +	 * Note: We could be attached to a domain that is not a
> +	 * CPU PM domain in that case don't reference the parent.
> +	 */
> +	cpu_pd = to_cpu_pd(genpd);
> +	parent_cpu_pd = to_cpu_pd(parent);
> +
> +	if (cpu_pd && parent_cpu_pd)
> +		cpu_pd->parent = parent_cpu_pd;
> +
> +skip_parent:
> +	of_node_put(dn);
> +	return genpd;
> +}

Cheers,
Brendan

Lina Iyer Aug. 4, 2016, 3:06 p.m. UTC | #2

On Thu, Aug 04 2016 at 04:15 -0600, Brendan Jackman wrote:
>Hi Lina,
>
>On Fri, Jul 29, 2016 at 03:56:17PM -0600, Lina Iyer wrote:
>> +static struct generic_pm_domain *of_get_cpu_domain(struct device_node *dn,
>> +		const struct cpu_pd_ops *ops, int cpu)
>> +{
>> +	struct of_phandle_args args;
>> +	struct generic_pm_domain *genpd, *parent;
>> +	struct cpu_pm_domain *cpu_pd, *parent_cpu_pd;
>> +	int ret;
>> +
>> +	/* Do we have this domain? If not, create the domain */
>> +	args.np = dn;
>> +	args.args_count = 0;
>> +
>> +	genpd = of_genpd_get_from_provider(&args);
>> +	if (!IS_ERR(genpd))
>> +		return genpd;
>> +
>> +	genpd = of_init_cpu_pm_domain(dn, ops);
>> +	if (IS_ERR(genpd))
>> +		return genpd;
>> +
>> +	/* Is there a domain provider for this domain? */
>> +	ret = of_parse_phandle_with_args(dn, "power-domains",
>> +			"#power-domain-cells", 0, &args);
>> +	if (ret < 0)
>> +		goto skip_parent;
>> +
>> +	/* Find its parent and attach this domain to it, recursively */
>> +	parent = of_get_cpu_domain(args.np, ops, cpu);
>> +	if (IS_ERR(parent))
>> +		goto skip_parent;
>> +
>> +	ret = pm_genpd_add_subdomain(genpd, parent);
>
>Looks like the arguments are the wrong way around here, it should be:
>
>	ret = pm_genpd_add_subdomain(parent, genpd);
>
Right. Thanks, will fix.

Thanks,
Lina

>> +	if (ret) {
>> +		pr_err("%s: Unable to add sub-domain (%s)\n err: %d",
>> +				__func__, genpd->name, ret);
>> +		return ERR_PTR(ret);
>> +	}
>> +
>> +	/*
>> +	 * Reference parent domain for easy access.
>> +	 * Note: We could be attached to a domain that is not a
>> +	 * CPU PM domain in that case don't reference the parent.
>> +	 */
>> +	cpu_pd = to_cpu_pd(genpd);
>> +	parent_cpu_pd = to_cpu_pd(parent);
>> +
>> +	if (cpu_pd && parent_cpu_pd)
>> +		cpu_pd->parent = parent_cpu_pd;
>> +
>> +skip_parent:
>> +	of_node_put(dn);
>> +	return genpd;
>> +}
>
>Cheers,
>Brendan

Brendan Jackman Aug. 4, 2016, 3:59 p.m. UTC | #3

Hi Lina,

I spotted a couple more nits..

> +static struct generic_pm_domain *of_init_cpu_pm_domain(struct device_node *dn,
> +				const struct cpu_pd_ops *ops)
> +{
> +	struct cpu_pm_domain *pd = NULL;
> +	struct generic_pm_domain *genpd = NULL;
> +	int ret = -ENOMEM;
> +
> +	if (!of_device_is_available(dn))
> +		return ERR_PTR(-ENODEV);
> +
> +	genpd = kzalloc(sizeof(*genpd), GFP_KERNEL);
> +	if (!genpd)
> +		goto fail;
> +
> +	genpd->name = kstrndup(dn->full_name, CPU_PD_NAME_MAX, GFP_KERNEL);
> +	if (!genpd->name)
> +		goto fail;
> +
> +	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
> +	if (!pd)
> +		goto fail;
> +
> +	if (!zalloc_cpumask_var(&pd->cpus, GFP_KERNEL))
> +		goto fail;
> +
> +	genpd->power_off = cpu_pd_power_off;
> +	genpd->power_on = cpu_pd_power_on;
> +	genpd->flags |= GENPD_FLAG_IRQ_SAFE;
> +	genpd->of_node = dn;
> +	pd->genpd = genpd;
> +	pd->ops.power_on = ops->power_on;
> +	pd->ops.power_off = ops->power_off;
> +
> +	INIT_LIST_HEAD_RCU(&pd->link);
> +	mutex_lock(&cpu_pd_list_lock);
> +	list_add_rcu(&pd->link, &of_cpu_pd_list);
> +	mutex_unlock(&cpu_pd_list_lock);
> +
> +	/* Populate platform specific states from DT */
> +	if (ops->populate_state_data) {
> +		struct device_node *np;
> +		int i;
> +
> +		/* Initialize the arm,idle-state properties */
> +		ret = pm_genpd_of_parse_power_states(genpd);
> +		if (ret) {
> +			pr_warn("%s domain states not initialized (%d)\n",
> +					dn->full_name, ret);
> +			goto fail;
> +		}
> +		for (i = 0; i < genpd->state_count; i++) {
> +			np = of_parse_phandle(dn, "domain-idle-states", i);
> +			ret = ops->populate_state_data(np,
> +					&genpd->states[i].param);
> +			of_node_put(np);
> +			if (ret)
> +				goto fail;
> +		}
> +	}

It seems a bit unfortunate to do of_parse_phandle for "domain-idle-states"
again, when pm_genpd_of_parse_power_states has just done that. Maybe we could
could add an `of_node` member to `struct genpd_power_state` and have
pm_genpd_of_parse_power_states populate that?

> +
> +	/* Register the CPU genpd */
> +	pr_debug("adding %s as CPU PM domain\n", pd->genpd->name);
> +	ret = pm_genpd_init(pd->genpd, &simple_qos_governor, false);
> +	if (ret) {
> +		pr_err("Unable to initialize domain %s\n", dn->full_name);
> +		goto fail;
> +	}
> +
> +	ret = of_genpd_add_provider_simple(dn, pd->genpd);
> +	if (ret)
> +		pr_warn("Unable to add genpd %s as provider\n",
> +				pd->genpd->name);
> +
> +	return pd->genpd;
> +fail:
> +
> +	kfree(genpd->name);
> +	kfree(genpd);
> +	if (pd)
> +		kfree(pd->cpus);
> +	kfree(pd);
> +	return ERR_PTR(ret);
> +}
> +


> +int of_setup_cpu_pd_single(int cpu, const struct cpu_pd_ops *ops)
> +{
> +
> +	struct device_node *dn;
> +	struct generic_pm_domain *genpd;
> +	struct cpu_pm_domain *cpu_pd;
> +
> +	dn = of_get_cpu_node(cpu, NULL);
> +	if (!dn)
> +		return -ENODEV;

of_get_cpu_node increments the refcount so we need an of_node_put at some point.

There are loads of instances around the kernel of of_get_cpu_node without
corresponding of_node_put, though, I could be misunderstanding...

> +
> +	dn = of_parse_phandle(dn, "power-domains", 0);
> +	if (!dn)
> +		return -ENODEV;
> +
> +	/* Find the genpd for this CPU, create if not found */
> +	genpd = of_get_cpu_domain(dn, ops, cpu);
> +	if (IS_ERR(genpd))
> +		return PTR_ERR(genpd);
> +
> +	of_node_put(dn);
> +	cpu_pd = to_cpu_pd(genpd);
> +	if (!cpu_pd) {
> +		pr_err("%s: Genpd was created outside CPU PM domains\n",
> +				__func__);
> +		return -ENOENT;
> +	}
> +
> +	return cpu_pd_attach_cpu(cpu_pd, cpu);
> +}

Cheers,
Brendan

Lina Iyer Aug. 4, 2016, 4:32 p.m. UTC | #4

On Thu, Aug 04 2016 at 09:59 -0600, Brendan Jackman wrote:
>Hi Lina,
>
>I spotted a couple more nits..
>
>> +static struct generic_pm_domain *of_init_cpu_pm_domain(struct device_node *dn,
>> +				const struct cpu_pd_ops *ops)
>> +{
>> +	struct cpu_pm_domain *pd = NULL;
>> +	struct generic_pm_domain *genpd = NULL;
>> +	int ret = -ENOMEM;
>> +
>> +	if (!of_device_is_available(dn))
>> +		return ERR_PTR(-ENODEV);
>> +
>> +	genpd = kzalloc(sizeof(*genpd), GFP_KERNEL);
>> +	if (!genpd)
>> +		goto fail;
>> +
>> +	genpd->name = kstrndup(dn->full_name, CPU_PD_NAME_MAX, GFP_KERNEL);
>> +	if (!genpd->name)
>> +		goto fail;
>> +
>> +	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
>> +	if (!pd)
>> +		goto fail;
>> +
>> +	if (!zalloc_cpumask_var(&pd->cpus, GFP_KERNEL))
>> +		goto fail;
>> +
>> +	genpd->power_off = cpu_pd_power_off;
>> +	genpd->power_on = cpu_pd_power_on;
>> +	genpd->flags |= GENPD_FLAG_IRQ_SAFE;
>> +	genpd->of_node = dn;
>> +	pd->genpd = genpd;
>> +	pd->ops.power_on = ops->power_on;
>> +	pd->ops.power_off = ops->power_off;
>> +
>> +	INIT_LIST_HEAD_RCU(&pd->link);
>> +	mutex_lock(&cpu_pd_list_lock);
>> +	list_add_rcu(&pd->link, &of_cpu_pd_list);
>> +	mutex_unlock(&cpu_pd_list_lock);
>> +
>> +	/* Populate platform specific states from DT */
>> +	if (ops->populate_state_data) {
>> +		struct device_node *np;
>> +		int i;
>> +
>> +		/* Initialize the arm,idle-state properties */
>> +		ret = pm_genpd_of_parse_power_states(genpd);
>> +		if (ret) {
>> +			pr_warn("%s domain states not initialized (%d)\n",
>> +					dn->full_name, ret);
>> +			goto fail;
>> +		}
>> +		for (i = 0; i < genpd->state_count; i++) {
>> +			np = of_parse_phandle(dn, "domain-idle-states", i);
>> +			ret = ops->populate_state_data(np,
>> +					&genpd->states[i].param);
>> +			of_node_put(np);
>> +			if (ret)
>> +				goto fail;
>> +		}
>> +	}
>
>It seems a bit unfortunate to do of_parse_phandle for "domain-idle-states"
>again, when pm_genpd_of_parse_power_states has just done that. Maybe we could
>could add an `of_node` member to `struct genpd_power_state` and have
>pm_genpd_of_parse_power_states populate that?
>
Hmm.. that could be done.

>> +
>> +	/* Register the CPU genpd */
>> +	pr_debug("adding %s as CPU PM domain\n", pd->genpd->name);
>> +	ret = pm_genpd_init(pd->genpd, &simple_qos_governor, false);
>> +	if (ret) {
>> +		pr_err("Unable to initialize domain %s\n", dn->full_name);
>> +		goto fail;
>> +	}
>> +
>> +	ret = of_genpd_add_provider_simple(dn, pd->genpd);
>> +	if (ret)
>> +		pr_warn("Unable to add genpd %s as provider\n",
>> +				pd->genpd->name);
>> +
>> +	return pd->genpd;
>> +fail:
>> +
>> +	kfree(genpd->name);
>> +	kfree(genpd);
>> +	if (pd)
>> +		kfree(pd->cpus);
>> +	kfree(pd);
>> +	return ERR_PTR(ret);
>> +}
>> +
>
>
>> +int of_setup_cpu_pd_single(int cpu, const struct cpu_pd_ops *ops)
>> +{
>> +
>> +	struct device_node *dn;
>> +	struct generic_pm_domain *genpd;
>> +	struct cpu_pm_domain *cpu_pd;
>> +
>> +	dn = of_get_cpu_node(cpu, NULL);
>> +	if (!dn)
>> +		return -ENODEV;
>
>of_get_cpu_node increments the refcount so we need an of_node_put at some point.
>
>There are loads of instances around the kernel of of_get_cpu_node without
>corresponding of_node_put, though, I could be misunderstanding...
>
It should be done. An easily missed statementr, I suppose.

Thanks for all the nits. This is the best time for that.

Thanks,
Lina

>> +
>> +	dn = of_parse_phandle(dn, "power-domains", 0);
>> +	if (!dn)
>> +		return -ENODEV;
>> +
>> +	/* Find the genpd for this CPU, create if not found */
>> +	genpd = of_get_cpu_domain(dn, ops, cpu);
>> +	if (IS_ERR(genpd))
>> +		return PTR_ERR(genpd);
>> +
>> +	of_node_put(dn);
>> +	cpu_pd = to_cpu_pd(genpd);
>> +	if (!cpu_pd) {
>> +		pr_err("%s: Genpd was created outside CPU PM domains\n",
>> +				__func__);
>> +		return -ENOENT;
>> +	}
>> +
>> +	return cpu_pd_attach_cpu(cpu_pd, cpu);
>> +}
>
>Cheers,
>Brendan

Patch

diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 5998c53..9883e89 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -3,6 +3,7 @@  obj-$(CONFIG_PM_SLEEP)	+= main.o wakeup.o
 obj-$(CONFIG_PM_TRACE_RTC)	+= trace.o
 obj-$(CONFIG_PM_OPP)	+= opp/
 obj-$(CONFIG_PM_GENERIC_DOMAINS)	+=  domain.o domain_governor.o
+obj-$(CONFIG_PM_GENERIC_DOMAINS_OF)	+= cpu_domains.o
 obj-$(CONFIG_HAVE_CLK)	+= clock_ops.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
diff --git a/drivers/base/power/cpu_domains.c b/drivers/base/power/cpu_domains.c
new file mode 100644
index 0000000..f80b308
--- /dev/null
+++ b/drivers/base/power/cpu_domains.c
@@ -0,0 +1,310 @@ 
+/*
+ * drivers/base/power/cpu_domains.c - Helper functions to create CPU PM domains.
+ *
+ * Copyright (C) 2016 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/cpu.h>
+#include <linux/cpumask.h>
+#include <linux/cpu_domains.h>
+#include <linux/cpu_pm.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/of.h>
+#include <linux/pm_domain.h>
+#include <linux/rculist.h>
+#include <linux/rcupdate.h>
+#include <linux/slab.h>
+
+#define CPU_PD_NAME_MAX 36
+
+struct cpu_pm_domain {
+	struct list_head link;
+	struct cpu_pd_ops ops;
+	struct generic_pm_domain *genpd;
+	struct cpu_pm_domain *parent;
+	cpumask_var_t cpus;
+};
+
+/* List of CPU PM domains we care about */
+static LIST_HEAD(of_cpu_pd_list);
+static DEFINE_MUTEX(cpu_pd_list_lock);
+
+static inline
+struct cpu_pm_domain *to_cpu_pd(struct generic_pm_domain *d)
+{
+	struct cpu_pm_domain *pd;
+	struct cpu_pm_domain *res = NULL;
+
+	rcu_read_lock();
+	list_for_each_entry_rcu(pd, &of_cpu_pd_list, link)
+		if (pd->genpd == d) {
+			res = pd;
+			break;
+		}
+	rcu_read_unlock();
+
+	return res;
+}
+
+static int cpu_pd_attach_cpu(struct cpu_pm_domain *cpu_pd, int cpu)
+{
+	int ret;
+	struct device *cpu_dev;
+
+	cpu_dev = get_cpu_device(cpu);
+	if (!cpu_dev) {
+		pr_warn("%s: Unable to get device for CPU%d\n",
+				__func__, cpu);
+		return -ENODEV;
+	}
+
+	ret = genpd_dev_pm_attach(cpu_dev);
+	if (ret)
+		dev_warn(cpu_dev,
+			"%s: Unable to attach to power-domain: %d\n",
+			__func__, ret);
+	else
+		dev_dbg(cpu_dev, "Attached to domain\n");
+
+	while (!ret && cpu_pd) {
+		cpumask_set_cpu(cpu, cpu_pd->cpus);
+		cpu_pd = cpu_pd->parent;
+	};
+
+	return ret;
+}
+
+static int cpu_pd_power_on(struct generic_pm_domain *genpd)
+{
+	struct cpu_pm_domain *pd = to_cpu_pd(genpd);
+
+	return pd->ops.power_on ? pd->ops.power_on() : 0;
+}
+
+static int cpu_pd_power_off(struct generic_pm_domain *genpd)
+{
+	struct cpu_pm_domain *pd = to_cpu_pd(genpd);
+
+	return pd->ops.power_off ? pd->ops.power_off(genpd->state_idx,
+					genpd->states[genpd->state_idx].param,
+					pd->cpus) : 0;
+}
+
+/**
+ * of_init_cpu_pm_domain() - Initialize a CPU PM domain from a device node
+ *
+ * @dn: The domain provider's device node
+ * @ops: The power_on/_off callbacks for the domain
+ *
+ * Returns the generic_pm_domain (genpd) pointer to the domain on success
+ */
+static struct generic_pm_domain *of_init_cpu_pm_domain(struct device_node *dn,
+				const struct cpu_pd_ops *ops)
+{
+	struct cpu_pm_domain *pd = NULL;
+	struct generic_pm_domain *genpd = NULL;
+	int ret = -ENOMEM;
+
+	if (!of_device_is_available(dn))
+		return ERR_PTR(-ENODEV);
+
+	genpd = kzalloc(sizeof(*genpd), GFP_KERNEL);
+	if (!genpd)
+		goto fail;
+
+	genpd->name = kstrndup(dn->full_name, CPU_PD_NAME_MAX, GFP_KERNEL);
+	if (!genpd->name)
+		goto fail;
+
+	pd = kzalloc(sizeof(*pd), GFP_KERNEL);
+	if (!pd)
+		goto fail;
+
+	if (!zalloc_cpumask_var(&pd->cpus, GFP_KERNEL))
+		goto fail;
+
+	genpd->power_off = cpu_pd_power_off;
+	genpd->power_on = cpu_pd_power_on;
+	genpd->flags |= GENPD_FLAG_IRQ_SAFE;
+	genpd->of_node = dn;
+	pd->genpd = genpd;
+	pd->ops.power_on = ops->power_on;
+	pd->ops.power_off = ops->power_off;
+
+	INIT_LIST_HEAD_RCU(&pd->link);
+	mutex_lock(&cpu_pd_list_lock);
+	list_add_rcu(&pd->link, &of_cpu_pd_list);
+	mutex_unlock(&cpu_pd_list_lock);
+
+	/* Populate platform specific states from DT */
+	if (ops->populate_state_data) {
+		struct device_node *np;
+		int i;
+
+		/* Initialize the arm,idle-state properties */
+		ret = pm_genpd_of_parse_power_states(genpd);
+		if (ret) {
+			pr_warn("%s domain states not initialized (%d)\n",
+					dn->full_name, ret);
+			goto fail;
+		}
+		for (i = 0; i < genpd->state_count; i++) {
+			np = of_parse_phandle(dn, "domain-idle-states", i);
+			ret = ops->populate_state_data(np,
+					&genpd->states[i].param);
+			of_node_put(np);
+			if (ret)
+				goto fail;
+		}
+	}
+
+	/* Register the CPU genpd */
+	pr_debug("adding %s as CPU PM domain\n", pd->genpd->name);
+	ret = pm_genpd_init(pd->genpd, &simple_qos_governor, false);
+	if (ret) {
+		pr_err("Unable to initialize domain %s\n", dn->full_name);
+		goto fail;
+	}
+
+	ret = of_genpd_add_provider_simple(dn, pd->genpd);
+	if (ret)
+		pr_warn("Unable to add genpd %s as provider\n",
+				pd->genpd->name);
+
+	return pd->genpd;
+fail:
+
+	kfree(genpd->name);
+	kfree(genpd);
+	if (pd)
+		kfree(pd->cpus);
+	kfree(pd);
+	return ERR_PTR(ret);
+}
+
+static struct generic_pm_domain *of_get_cpu_domain(struct device_node *dn,
+		const struct cpu_pd_ops *ops, int cpu)
+{
+	struct of_phandle_args args;
+	struct generic_pm_domain *genpd, *parent;
+	struct cpu_pm_domain *cpu_pd, *parent_cpu_pd;
+	int ret;
+
+	/* Do we have this domain? If not, create the domain */
+	args.np = dn;
+	args.args_count = 0;
+
+	genpd = of_genpd_get_from_provider(&args);
+	if (!IS_ERR(genpd))
+		return genpd;
+
+	genpd = of_init_cpu_pm_domain(dn, ops);
+	if (IS_ERR(genpd))
+		return genpd;
+
+	/* Is there a domain provider for this domain? */
+	ret = of_parse_phandle_with_args(dn, "power-domains",
+			"#power-domain-cells", 0, &args);
+	if (ret < 0)
+		goto skip_parent;
+
+	/* Find its parent and attach this domain to it, recursively */
+	parent = of_get_cpu_domain(args.np, ops, cpu);
+	if (IS_ERR(parent))
+		goto skip_parent;
+
+	ret = pm_genpd_add_subdomain(genpd, parent);
+	if (ret) {
+		pr_err("%s: Unable to add sub-domain (%s)\n err: %d",
+				__func__, genpd->name, ret);
+		return ERR_PTR(ret);
+	}
+
+	/*
+	 * Reference parent domain for easy access.
+	 * Note: We could be attached to a domain that is not a
+	 * CPU PM domain in that case don't reference the parent.
+	 */
+	cpu_pd = to_cpu_pd(genpd);
+	parent_cpu_pd = to_cpu_pd(parent);
+
+	if (cpu_pd && parent_cpu_pd)
+		cpu_pd->parent = parent_cpu_pd;
+
+skip_parent:
+	of_node_put(dn);
+	return genpd;
+}
+
+/**
+ * of_setup_cpu_pd_single() - Setup the PM domains for a CPU
+ *
+ * @cpu: The CPU for which the PM domain is to be set up.
+ * @ops: The PM domain suspend/resume ops for the CPU's domain
+ *
+ * If the CPU PM domain exists already, then the CPU is attached to
+ * that CPU PD. If it doesn't, the domain is created, the @ops are
+ * set for power_on/power_off callbacks and then the CPU is attached
+ * to that domain. If the domain was created outside this framework,
+ * then we do not attach the CPU to the domain.
+ */
+int of_setup_cpu_pd_single(int cpu, const struct cpu_pd_ops *ops)
+{
+
+	struct device_node *dn;
+	struct generic_pm_domain *genpd;
+	struct cpu_pm_domain *cpu_pd;
+
+	dn = of_get_cpu_node(cpu, NULL);
+	if (!dn)
+		return -ENODEV;
+
+	dn = of_parse_phandle(dn, "power-domains", 0);
+	if (!dn)
+		return -ENODEV;
+
+	/* Find the genpd for this CPU, create if not found */
+	genpd = of_get_cpu_domain(dn, ops, cpu);
+	if (IS_ERR(genpd))
+		return PTR_ERR(genpd);
+
+	of_node_put(dn);
+	cpu_pd = to_cpu_pd(genpd);
+	if (!cpu_pd) {
+		pr_err("%s: Genpd was created outside CPU PM domains\n",
+				__func__);
+		return -ENOENT;
+	}
+
+	return cpu_pd_attach_cpu(cpu_pd, cpu);
+}
+EXPORT_SYMBOL(of_setup_cpu_pd_single);
+
+/**
+ * of_setup_cpu_pd() - Setup the PM domains for all CPUs
+ *
+ * @ops: The PM domain suspend/resume ops for all the domains
+ *
+ * Setup the CPU PM domain and attach all possible CPUs to their respective
+ * domains. The domains are created if not already and then attached.
+ */
+int of_setup_cpu_pd(const struct cpu_pd_ops *ops)
+{
+	int cpu;
+	int ret;
+
+	for_each_possible_cpu(cpu) {
+		ret = of_setup_cpu_pd_single(cpu, ops);
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+EXPORT_SYMBOL(of_setup_cpu_pd);
diff --git a/include/linux/cpu_domains.h b/include/linux/cpu_domains.h
new file mode 100644
index 0000000..de17f80
--- /dev/null
+++ b/include/linux/cpu_domains.h
@@ -0,0 +1,39 @@ 
+/*
+ * include/linux/cpu_domains.h
+ *
+ * Copyright (C) 2016 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __CPU_DOMAINS_H__
+#define __CPU_DOMAINS_H__
+
+#include <linux/types.h>
+
+struct cpumask;
+struct device_node;
+
+struct cpu_pd_ops {
+	int (*populate_state_data)(struct device_node *n, u32 *param);
+	int (*power_off)(u32 state_idx, u32 param, const struct cpumask *mask);
+	int (*power_on)(void);
+};
+
+#ifdef CONFIG_PM_GENERIC_DOMAINS_OF
+int of_setup_cpu_pd_single(int cpu, const struct cpu_pd_ops *ops);
+int of_setup_cpu_pd(const struct cpu_pd_ops *ops);
+#else
+static inline int of_setup_cpu_pd_single(int cpu, const struct cpu_pd_ops *ops)
+{
+	return -ENODEV;
+}
+static inline int of_setup_cpu_pd(const struct cpu_pd_ops *ops)
+{
+	return -ENODEV;
+}
+#endif /* CONFIG_PM_GENERIC_DOMAINS_OF */
+
+#endif /* __CPU_DOMAINS_H__ */