Merge branch 'pm-opp' (d9fecca2) · Commits · 戴 / test

Documentation/devicetree/bindings/opp/opp.txt

+5 −2

Original line number	Diff line number	Diff line
		@@ -82,7 +82,10 @@ This defines voltage-current-frequency combinations along with other related
		properties.

		Required properties:
		- opp-hz: Frequency in Hz, expressed as a 64-bit big-endian integer.
		- opp-hz: Frequency in Hz, expressed as a 64-bit big-endian integer. This is a
		required property for all device nodes but devices like power domains. The
		power domain nodes must have another (implementation dependent) property which
		uniquely identifies the OPP nodes.

		Optional properties:
		- opp-microvolt: voltage in micro Volts.
		@@ -159,7 +162,7 @@ Optional properties:

		- status: Marks the node enabled/disabled.

		- required-opp: This contains phandle to an OPP node in another device's OPP
		- required-opps: This contains phandle to an OPP node in another device's OPP
		table. It may contain an array of phandles, where each phandle points to an
		OPP of a different device. It should not contain multiple phandles to the OPP
		nodes in the same OPP table. This specifies the minimum required OPP of the

Documentation/devicetree/bindings/power/power_domain.txt

+3 −3

Original line number	Diff line number	Diff line
		@@ -127,7 +127,7 @@ inside a PM domain with index 0 of a power controller represented by a node
		with the label "power".

		Optional properties:
		- required-opp: This contains phandle to an OPP node in another device's OPP
		- required-opps: This contains phandle to an OPP node in another device's OPP
		table. It may contain an array of phandles, where each phandle points to an
		OPP of a different device. It should not contain multiple phandles to the OPP
		nodes in the same OPP table. This specifies the minimum required OPP of the
		@@ -175,14 +175,14 @@ Example:
		compatible = "foo,i-leak-current";
		reg = <0x12350000 0x1000>;
		power-domains = <&power 0>;
		required-opp = <&domain0_opp_0>;
		required-opps = <&domain0_opp_0>;
		};

		leaky-device1@12350000 {
		compatible = "foo,i-leak-current";
		reg = <0x12350000 0x1000>;
		power-domains = <&power 1>;
		required-opp = <&domain1_opp_1>;
		required-opps = <&domain1_opp_1>;
		};

		[1]. Documentation/devicetree/bindings/power/domain-idle-state.txt

drivers/base/power/domain.c

+141 −26

Original line number	Diff line number	Diff line
		@@ -10,6 +10,7 @@
		#include <linux/kernel.h>
		#include <linux/io.h>
		#include <linux/platform_device.h>
		#include <linux/pm_opp.h>
		#include <linux/pm_runtime.h>
		#include <linux/pm_domain.h>
		#include <linux/pm_qos.h>
		@@ -1315,7 +1316,6 @@ EXPORT_SYMBOL_GPL(pm_genpd_syscore_poweron);
		#endif /* CONFIG_PM_SLEEP */

		static struct generic_pm_domain_data genpd_alloc_dev_data(struct device dev,
		struct generic_pm_domain *genpd,
		struct gpd_timing_data *td)
		{
		struct generic_pm_domain_data *gpd_data;
		@@ -1384,7 +1384,7 @@ static int genpd_add_device(struct generic_pm_domain genpd, struct device dev,
		if (IS_ERR_OR_NULL(genpd) \|\| IS_ERR_OR_NULL(dev))
		return -EINVAL;

		gpd_data = genpd_alloc_dev_data(dev, genpd, td);
		gpd_data = genpd_alloc_dev_data(dev, td);
		if (IS_ERR(gpd_data))
		return PTR_ERR(gpd_data);

		@@ -1413,23 +1413,21 @@ static int genpd_add_device(struct generic_pm_domain genpd, struct device dev,
		}

		/**
		* __pm_genpd_add_device - Add a device to an I/O PM domain.
		* pm_genpd_add_device - Add a device to an I/O PM domain.
		* @genpd: PM domain to add the device to.
		* @dev: Device to be added.
		* @td: Set of PM QoS timing parameters to attach to the device.
		*/
		int __pm_genpd_add_device(struct generic_pm_domain genpd, struct device dev,
		struct gpd_timing_data *td)
		int pm_genpd_add_device(struct generic_pm_domain genpd, struct device dev)
		{
		int ret;

		mutex_lock(&gpd_list_lock);
		ret = genpd_add_device(genpd, dev, td);
		ret = genpd_add_device(genpd, dev, NULL);
		mutex_unlock(&gpd_list_lock);

		return ret;
		}
		EXPORT_SYMBOL_GPL(__pm_genpd_add_device);
		EXPORT_SYMBOL_GPL(pm_genpd_add_device);

		static int genpd_remove_device(struct generic_pm_domain *genpd,
		struct device *dev)
		@@ -1476,13 +1474,13 @@ static int genpd_remove_device(struct generic_pm_domain *genpd,

		/**
		* pm_genpd_remove_device - Remove a device from an I/O PM domain.
		* @genpd: PM domain to remove the device from.
		* @dev: Device to be removed.
		*/
		int pm_genpd_remove_device(struct generic_pm_domain *genpd,
		struct device *dev)
		int pm_genpd_remove_device(struct device *dev)
		{
		if (!genpd \|\| genpd != genpd_lookup_dev(dev))
		struct generic_pm_domain *genpd = genpd_lookup_dev(dev);

		if (!genpd)
		return -EINVAL;

		return genpd_remove_device(genpd, dev);
		@@ -1691,6 +1689,9 @@ int pm_genpd_init(struct generic_pm_domain *genpd,
		return ret;
		}

		device_initialize(&genpd->dev);
		dev_set_name(&genpd->dev, "%s", genpd->name);

		mutex_lock(&gpd_list_lock);
		list_add(&genpd->gpd_list_node, &gpd_list);
		mutex_unlock(&gpd_list_lock);
		@@ -1887,14 +1888,33 @@ int of_genpd_add_provider_simple(struct device_node *np,

		mutex_lock(&gpd_list_lock);

		if (genpd_present(genpd)) {
		if (!genpd_present(genpd))
		goto unlock;

		genpd->dev.of_node = np;

		/* Parse genpd OPP table */
		if (genpd->set_performance_state) {
		ret = dev_pm_opp_of_add_table(&genpd->dev);
		if (ret) {
		dev_err(&genpd->dev, "Failed to add OPP table: %d\n",
		ret);
		goto unlock;
		}
		}

		ret = genpd_add_provider(np, genpd_xlate_simple, genpd);
		if (!ret) {
		if (ret) {
		if (genpd->set_performance_state)
		dev_pm_opp_of_remove_table(&genpd->dev);

		goto unlock;
		}

		genpd->provider = &np->fwnode;
		genpd->has_provider = true;
		}
		}

		unlock:
		mutex_unlock(&gpd_list_lock);

		return ret;
		@@ -1909,6 +1929,7 @@ EXPORT_SYMBOL_GPL(of_genpd_add_provider_simple);
		int of_genpd_add_provider_onecell(struct device_node *np,
		struct genpd_onecell_data *data)
		{
		struct generic_pm_domain *genpd;
		unsigned int i;
		int ret = -EINVAL;

		@@ -1921,13 +1942,27 @@ int of_genpd_add_provider_onecell(struct device_node *np,
		data->xlate = genpd_xlate_onecell;

		for (i = 0; i < data->num_domains; i++) {
		if (!data->domains[i])
		genpd = data->domains[i];

		if (!genpd)
		continue;
		if (!genpd_present(data->domains[i]))
		if (!genpd_present(genpd))
		goto error;

		genpd->dev.of_node = np;

		/* Parse genpd OPP table */
		if (genpd->set_performance_state) {
		ret = dev_pm_opp_of_add_table_indexed(&genpd->dev, i);
		if (ret) {
		dev_err(&genpd->dev, "Failed to add OPP table for index %d: %d\n",
		i, ret);
		goto error;
		}
		}

		data->domains[i]->provider = &np->fwnode;
		data->domains[i]->has_provider = true;
		genpd->provider = &np->fwnode;
		genpd->has_provider = true;
		}

		ret = genpd_add_provider(np, data->xlate, data);
		@@ -1940,10 +1975,16 @@ int of_genpd_add_provider_onecell(struct device_node *np,

		error:
		while (i--) {
		if (!data->domains[i])
		genpd = data->domains[i];

		if (!genpd)
		continue;
		data->domains[i]->provider = NULL;
		data->domains[i]->has_provider = false;

		genpd->provider = NULL;
		genpd->has_provider = false;

		if (genpd->set_performance_state)
		dev_pm_opp_of_remove_table(&genpd->dev);
		}

		mutex_unlock(&gpd_list_lock);
		@@ -1970,10 +2011,17 @@ void of_genpd_del_provider(struct device_node *np)
		* provider, set the 'has_provider' to false
		* so that the PM domain can be safely removed.
		*/
		list_for_each_entry(gpd, &gpd_list, gpd_list_node)
		if (gpd->provider == &np->fwnode)
		list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
		if (gpd->provider == &np->fwnode) {
		gpd->has_provider = false;

		if (!gpd->set_performance_state)
		continue;

		dev_pm_opp_of_remove_table(&gpd->dev);
		}
		}

		list_del(&cp->link);
		of_node_put(cp->node);
		kfree(cp);
		@@ -2346,6 +2394,55 @@ int of_genpd_parse_idle_states(struct device_node *dn,
		}
		EXPORT_SYMBOL_GPL(of_genpd_parse_idle_states);

		/**
		* of_genpd_opp_to_performance_state- Gets performance state of device's
		* power domain corresponding to a DT node's "required-opps" property.
		*
		* @dev: Device for which the performance-state needs to be found.
		* @opp_node: DT node where the "required-opps" property is present. This can be
		* the device node itself (if it doesn't have an OPP table) or a node
		* within the OPP table of a device (if device has an OPP table).
		* @state: Pointer to return performance state.
		*
		* Returns performance state corresponding to the "required-opps" property of
		* a DT node. This calls platform specific genpd->opp_to_performance_state()
		* callback to translate power domain OPP to performance state.
		*
		* Returns performance state on success and 0 on failure.
		*/
		unsigned int of_genpd_opp_to_performance_state(struct device *dev,
		struct device_node *opp_node)
		{
		struct generic_pm_domain *genpd;
		struct dev_pm_opp *opp;
		int state = 0;

		genpd = dev_to_genpd(dev);
		if (IS_ERR(genpd))
		return 0;

		if (unlikely(!genpd->set_performance_state))
		return 0;

		genpd_lock(genpd);

		opp = of_dev_pm_opp_find_required_opp(&genpd->dev, opp_node);
		if (IS_ERR(opp)) {
		dev_err(dev, "Failed to find required OPP: %ld\n",
		PTR_ERR(opp));
		goto unlock;
		}

		state = genpd->opp_to_performance_state(genpd, opp);
		dev_pm_opp_put(opp);

		unlock:
		genpd_unlock(genpd);

		return state;
		}
		EXPORT_SYMBOL_GPL(of_genpd_opp_to_performance_state);

		#endif /* CONFIG_PM_GENERIC_DOMAINS_OF */


		@@ -2613,6 +2710,19 @@ static int genpd_devices_show(struct seq_file s, void data)
		return ret;
		}

		static int genpd_perf_state_show(struct seq_file s, void data)
		{
		struct generic_pm_domain *genpd = s->private;

		if (genpd_lock_interruptible(genpd))
		return -ERESTARTSYS;

		seq_printf(s, "%u\n", genpd->performance_state);

		genpd_unlock(genpd);
		return 0;
		}

		#define define_genpd_open_function(name) \
		static int genpd_##name##_open(struct inode inode, struct file file) \
		{ \
		@@ -2626,6 +2736,7 @@ define_genpd_open_function(idle_states);
		define_genpd_open_function(active_time);
		define_genpd_open_function(total_idle_time);
		define_genpd_open_function(devices);
		define_genpd_open_function(perf_state);

		#define define_genpd_debugfs_fops(name) \
		static const struct file_operations genpd_##name##_fops = { \
		@@ -2642,6 +2753,7 @@ define_genpd_debugfs_fops(idle_states);
		define_genpd_debugfs_fops(active_time);
		define_genpd_debugfs_fops(total_idle_time);
		define_genpd_debugfs_fops(devices);
		define_genpd_debugfs_fops(perf_state);

		static int __init genpd_debug_init(void)
		{
		@@ -2675,6 +2787,9 @@ static int __init genpd_debug_init(void)
		d, genpd, &genpd_total_idle_time_fops);
		debugfs_create_file("devices", 0444,
		d, genpd, &genpd_devices_fops);
		if (genpd->set_performance_state)
		debugfs_create_file("perf_state", 0444,
		d, genpd, &genpd_perf_state_fops);
		}

		return 0;

drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -513,7 +513,7 @@ static int acp_hw_fini(void *handle)
		if (adev->acp.acp_genpd) {
		for (i = 0; i < ACP_DEVS ; i++) {
		dev = get_mfd_cell_dev(adev->acp.acp_cell[i].name, i);
		ret = pm_genpd_remove_device(&adev->acp.acp_genpd->gpd, dev);
		ret = pm_genpd_remove_device(dev);
		/* If removal fails, dont giveup and try rest */
		if (ret)
		dev_err(dev, "remove dev from genpd failed\n");

drivers/opp/core.c

+79 −188

Original line number	Diff line number	Diff line
		@@ -33,8 +33,6 @@ LIST_HEAD(opp_tables);
		/* Lock to allow exclusive modification to the device and opp lists */
		DEFINE_MUTEX(opp_table_lock);

		static void dev_pm_opp_get(struct dev_pm_opp *opp);

		static struct opp_device _find_opp_dev(const struct device dev,
		struct opp_table *opp_table)
		{
		@@ -281,6 +279,23 @@ unsigned long dev_pm_opp_get_suspend_opp_freq(struct device *dev)
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp_freq);

		int _get_opp_count(struct opp_table *opp_table)
		{
		struct dev_pm_opp *opp;
		int count = 0;

		mutex_lock(&opp_table->lock);

		list_for_each_entry(opp, &opp_table->opp_list, node) {
		if (opp->available)
		count++;
		}

		mutex_unlock(&opp_table->lock);

		return count;
		}

		/**
		* dev_pm_opp_get_opp_count() - Get number of opps available in the opp table
		* @dev: device for which we do this operation
		@@ -291,25 +306,17 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_get_suspend_opp_freq);
		int dev_pm_opp_get_opp_count(struct device *dev)
		{
		struct opp_table *opp_table;
		struct dev_pm_opp *temp_opp;
		int count = 0;
		int count;

		opp_table = _find_opp_table(dev);
		if (IS_ERR(opp_table)) {
		count = PTR_ERR(opp_table);
		dev_dbg(dev, "%s: OPP table not found (%d)\n",
		__func__, count);
		return count;
		}

		mutex_lock(&opp_table->lock);

		list_for_each_entry(temp_opp, &opp_table->opp_list, node) {
		if (temp_opp->available)
		count++;
		return 0;
		}

		mutex_unlock(&opp_table->lock);
		count = _get_opp_count(opp_table);
		dev_pm_opp_put_opp_table(opp_table);

		return count;
		@@ -892,7 +899,7 @@ static void _opp_kref_release(struct kref *kref)
		dev_pm_opp_put_opp_table(opp_table);
		}

		static void dev_pm_opp_get(struct dev_pm_opp *opp)
		void dev_pm_opp_get(struct dev_pm_opp *opp)
		{
		kref_get(&opp->kref);
		}
		@@ -985,22 +992,11 @@ static bool _opp_supported_by_regulators(struct dev_pm_opp *opp,
		return true;
		}

		/*
		* Returns:
		* 0: On success. And appropriate error message for duplicate OPPs.
		* -EBUSY: For OPP with same freq/volt and is available. The callers of
		* _opp_add() must return 0 if they receive -EBUSY from it. This is to make
		* sure we don't print error messages unnecessarily if different parts of
		* kernel try to initialize the OPP table.
		* -EEXIST: For OPP with same freq but different volt or is unavailable. This
		* should be considered an error by the callers of _opp_add().
		*/
		int _opp_add(struct device dev, struct dev_pm_opp new_opp,
		struct opp_table *opp_table)
		static int _opp_is_duplicate(struct device dev, struct dev_pm_opp new_opp,
		struct opp_table *opp_table,
		struct list_head **head)
		{
		struct dev_pm_opp *opp;
		struct list_head *head;
		int ret;

		/*
		* Insert new OPP in order of increasing frequency and discard if
		@@ -1010,17 +1006,14 @@ int _opp_add(struct device dev, struct dev_pm_opp new_opp,
		* loop, don't replace it with head otherwise it will become an infinite
		* loop.
		*/
		mutex_lock(&opp_table->lock);
		head = &opp_table->opp_list;

		list_for_each_entry(opp, &opp_table->opp_list, node) {
		if (new_opp->rate > opp->rate) {
		head = &opp->node;
		*head = &opp->node;
		continue;
		}

		if (new_opp->rate < opp->rate)
		break;
		return 0;

		/* Duplicate OPPs */
		dev_warn(dev, "%s: duplicate OPPs detected. Existing: freq: %lu, volt: %lu, enabled: %d. New: freq: %lu, volt: %lu, enabled: %d\n",
		@@ -1029,15 +1022,39 @@ int _opp_add(struct device dev, struct dev_pm_opp new_opp,
		new_opp->supplies[0].u_volt, new_opp->available);

		/* Should we compare voltages for all regulators here ? */
		ret = opp->available &&
		return opp->available &&
		new_opp->supplies[0].u_volt == opp->supplies[0].u_volt ? -EBUSY : -EEXIST;
		}

		return 0;
		}

		/*
		* Returns:
		* 0: On success. And appropriate error message for duplicate OPPs.
		* -EBUSY: For OPP with same freq/volt and is available. The callers of
		* _opp_add() must return 0 if they receive -EBUSY from it. This is to make
		* sure we don't print error messages unnecessarily if different parts of
		* kernel try to initialize the OPP table.
		* -EEXIST: For OPP with same freq but different volt or is unavailable. This
		* should be considered an error by the callers of _opp_add().
		*/
		int _opp_add(struct device dev, struct dev_pm_opp new_opp,
		struct opp_table *opp_table, bool rate_not_available)
		{
		struct list_head *head;
		int ret;

		mutex_lock(&opp_table->lock);
		head = &opp_table->opp_list;

		if (likely(!rate_not_available)) {
		ret = _opp_is_duplicate(dev, new_opp, opp_table, &head);
		if (ret) {
		mutex_unlock(&opp_table->lock);
		return ret;
		}

		if (opp_table->get_pstate)
		new_opp->pstate = opp_table->get_pstate(dev, new_opp->rate);
		}

		list_add(&new_opp->node, head);
		mutex_unlock(&opp_table->lock);
		@@ -1104,7 +1121,7 @@ int _opp_add_v1(struct opp_table opp_table, struct device dev,
		new_opp->available = true;
		new_opp->dynamic = dynamic;

		ret = _opp_add(dev, new_opp, opp_table);
		ret = _opp_add(dev, new_opp, opp_table, false);
		if (ret) {
		/* Don't return error for duplicate OPPs */
		if (ret == -EBUSY)
		@@ -1140,7 +1157,6 @@ struct opp_table dev_pm_opp_set_supported_hw(struct device dev,
		const u32 *versions, unsigned int count)
		{
		struct opp_table *opp_table;
		int ret;

		opp_table = dev_pm_opp_get_opp_table(dev);
		if (!opp_table)
		@@ -1149,29 +1165,20 @@ struct opp_table dev_pm_opp_set_supported_hw(struct device dev,
		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));

		/* Do we already have a version hierarchy associated with opp_table? */
		if (opp_table->supported_hw) {
		dev_err(dev, "%s: Already have supported hardware list\n",
		__func__);
		ret = -EBUSY;
		goto err;
		}
		/* Another CPU that shares the OPP table has set the property ? */
		if (opp_table->supported_hw)
		return opp_table;

		opp_table->supported_hw = kmemdup(versions, count * sizeof(*versions),
		GFP_KERNEL);
		if (!opp_table->supported_hw) {
		ret = -ENOMEM;
		goto err;
		dev_pm_opp_put_opp_table(opp_table);
		return ERR_PTR(-ENOMEM);
		}

		opp_table->supported_hw_count = count;

		return opp_table;

		err:
		dev_pm_opp_put_opp_table(opp_table);

		return ERR_PTR(ret);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_set_supported_hw);

		@@ -1188,12 +1195,6 @@ void dev_pm_opp_put_supported_hw(struct opp_table *opp_table)
		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));

		if (!opp_table->supported_hw) {
		pr_err("%s: Doesn't have supported hardware list\n",
		__func__);
		return;
		}

		kfree(opp_table->supported_hw);
		opp_table->supported_hw = NULL;
		opp_table->supported_hw_count = 0;
		@@ -1215,7 +1216,6 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_put_supported_hw);
		struct opp_table dev_pm_opp_set_prop_name(struct device dev, const char *name)
		{
		struct opp_table *opp_table;
		int ret;

		opp_table = dev_pm_opp_get_opp_table(dev);
		if (!opp_table)
		@@ -1224,26 +1224,17 @@ struct opp_table dev_pm_opp_set_prop_name(struct device dev, const char *name)
		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));

		/* Do we already have a prop-name associated with opp_table? */
		if (opp_table->prop_name) {
		dev_err(dev, "%s: Already have prop-name %s\n", __func__,
		opp_table->prop_name);
		ret = -EBUSY;
		goto err;
		}
		/* Another CPU that shares the OPP table has set the property ? */
		if (opp_table->prop_name)
		return opp_table;

		opp_table->prop_name = kstrdup(name, GFP_KERNEL);
		if (!opp_table->prop_name) {
		ret = -ENOMEM;
		goto err;
		dev_pm_opp_put_opp_table(opp_table);
		return ERR_PTR(-ENOMEM);
		}

		return opp_table;

		err:
		dev_pm_opp_put_opp_table(opp_table);

		return ERR_PTR(ret);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_set_prop_name);

		@@ -1260,11 +1251,6 @@ void dev_pm_opp_put_prop_name(struct opp_table *opp_table)
		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));

		if (!opp_table->prop_name) {
		pr_err("%s: Doesn't have a prop-name\n", __func__);
		return;
		}

		kfree(opp_table->prop_name);
		opp_table->prop_name = NULL;

		@@ -1334,11 +1320,9 @@ struct opp_table dev_pm_opp_set_regulators(struct device dev,
		goto err;
		}

		/* Already have regulators set */
		if (opp_table->regulators) {
		ret = -EBUSY;
		goto err;
		}
		/* Another CPU that shares the OPP table has set the regulators ? */
		if (opp_table->regulators)
		return opp_table;

		opp_table->regulators = kmalloc_array(count,
		sizeof(*opp_table->regulators),
		@@ -1392,10 +1376,8 @@ void dev_pm_opp_put_regulators(struct opp_table *opp_table)
		{
		int i;

		if (!opp_table->regulators) {
		pr_err("%s: Doesn't have regulators set\n", __func__);
		return;
		}
		if (!opp_table->regulators)
		goto put_opp_table;

		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));
		@@ -1409,6 +1391,7 @@ void dev_pm_opp_put_regulators(struct opp_table *opp_table)
		opp_table->regulators = NULL;
		opp_table->regulator_count = 0;

		put_opp_table:
		dev_pm_opp_put_opp_table(opp_table);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_put_regulators);
		@@ -1494,7 +1477,6 @@ struct opp_table dev_pm_opp_register_set_opp_helper(struct device dev,
		int (set_opp)(struct dev_pm_set_opp_data data))
		{
		struct opp_table *opp_table;
		int ret;

		if (!set_opp)
		return ERR_PTR(-EINVAL);
		@@ -1505,24 +1487,15 @@ struct opp_table dev_pm_opp_register_set_opp_helper(struct device dev,

		/* This should be called before OPPs are initialized */
		if (WARN_ON(!list_empty(&opp_table->opp_list))) {
		ret = -EBUSY;
		goto err;
		}

		/* Already have custom set_opp helper */
		if (WARN_ON(opp_table->set_opp)) {
		ret = -EBUSY;
		goto err;
		dev_pm_opp_put_opp_table(opp_table);
		return ERR_PTR(-EBUSY);
		}

		/* Another CPU that shares the OPP table has set the helper ? */
		if (!opp_table->set_opp)
		opp_table->set_opp = set_opp;

		return opp_table;

		err:
		dev_pm_opp_put_opp_table(opp_table);

		return ERR_PTR(ret);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_register_set_opp_helper);

		@@ -1535,96 +1508,14 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_register_set_opp_helper);
		*/
		void dev_pm_opp_unregister_set_opp_helper(struct opp_table *opp_table)
		{
		if (!opp_table->set_opp) {
		pr_err("%s: Doesn't have custom set_opp helper set\n",
		__func__);
		return;
		}

		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));

		opp_table->set_opp = NULL;

		dev_pm_opp_put_opp_table(opp_table);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_unregister_set_opp_helper);

		/**
		* dev_pm_opp_register_get_pstate_helper() - Register get_pstate() helper.
		* @dev: Device for which the helper is getting registered.
		* @get_pstate: Helper.
		*
		* TODO: Remove this callback after the same information is available via Device
		* Tree.
		*
		* This allows a platform to initialize the performance states of individual
		* OPPs for its devices, until we get similar information directly from DT.
		*
		* This must be called before the OPPs are initialized for the device.
		*/
		struct opp_table dev_pm_opp_register_get_pstate_helper(struct device dev,
		int (get_pstate)(struct device dev, unsigned long rate))
		{
		struct opp_table *opp_table;
		int ret;

		if (!get_pstate)
		return ERR_PTR(-EINVAL);

		opp_table = dev_pm_opp_get_opp_table(dev);
		if (!opp_table)
		return ERR_PTR(-ENOMEM);

		/* This should be called before OPPs are initialized */
		if (WARN_ON(!list_empty(&opp_table->opp_list))) {
		ret = -EBUSY;
		goto err;
		}

		/* Already have genpd_performance_state set */
		if (WARN_ON(opp_table->genpd_performance_state)) {
		ret = -EBUSY;
		goto err;
		}

		opp_table->genpd_performance_state = true;
		opp_table->get_pstate = get_pstate;

		return opp_table;

		err:
		dev_pm_opp_put_opp_table(opp_table);

		return ERR_PTR(ret);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_register_get_pstate_helper);

		/**
		* dev_pm_opp_unregister_get_pstate_helper() - Releases resources blocked for
		* get_pstate() helper
		* @opp_table: OPP table returned from dev_pm_opp_register_get_pstate_helper().
		*
		* Release resources blocked for platform specific get_pstate() helper.
		*/
		void dev_pm_opp_unregister_get_pstate_helper(struct opp_table *opp_table)
		{
		if (!opp_table->genpd_performance_state) {
		pr_err("%s: Doesn't have performance states set\n",
		__func__);
		return;
		}

		/* Make sure there are no concurrent readers while updating opp_table */
		WARN_ON(!list_empty(&opp_table->opp_list));

		opp_table->genpd_performance_state = false;
		opp_table->get_pstate = NULL;

		dev_pm_opp_put_opp_table(opp_table);
		}
		EXPORT_SYMBOL_GPL(dev_pm_opp_unregister_get_pstate_helper);

		/**
		* dev_pm_opp_add() - Add an OPP table from a table definitions
		* @dev: device for which we do this operation

Admin message