Merge branch 'opp/linux-next' of git://git.kernel.org/pub/scm/linux/kernel/git/vireshk/pm (bcbeef5f) · Commits · 戴 / test

drivers/base/power/domain.c

+148 −54

Original line number	Diff line number	Diff line
		@@ -239,6 +239,127 @@ static void genpd_update_accounting(struct generic_pm_domain *genpd)
		static inline void genpd_update_accounting(struct generic_pm_domain *genpd) {}
		#endif

		static int _genpd_reeval_performance_state(struct generic_pm_domain *genpd,
		unsigned int state)
		{
		struct generic_pm_domain_data *pd_data;
		struct pm_domain_data *pdd;
		struct gpd_link *link;

		/* New requested state is same as Max requested state */
		if (state == genpd->performance_state)
		return state;

		/* New requested state is higher than Max requested state */
		if (state > genpd->performance_state)
		return state;

		/* Traverse all devices within the domain */
		list_for_each_entry(pdd, &genpd->dev_list, list_node) {
		pd_data = to_gpd_data(pdd);

		if (pd_data->performance_state > state)
		state = pd_data->performance_state;
		}

		/*
		* Traverse all sub-domains within the domain. This can be
		* done without any additional locking as the link->performance_state
		* field is protected by the master genpd->lock, which is already taken.
		*
		* Also note that link->performance_state (subdomain's performance state
		* requirement to master domain) is different from
		* link->slave->performance_state (current performance state requirement
		* of the devices/sub-domains of the subdomain) and so can have a
		* different value.
		*
		* Note that we also take vote from powered-off sub-domains into account
		* as the same is done for devices right now.
		*/
		list_for_each_entry(link, &genpd->master_links, master_node) {
		if (link->performance_state > state)
		state = link->performance_state;
		}

		return state;
		}

		static int _genpd_set_performance_state(struct generic_pm_domain *genpd,
		unsigned int state, int depth)
		{
		struct generic_pm_domain *master;
		struct gpd_link *link;
		int master_state, ret;

		if (state == genpd->performance_state)
		return 0;

		/* Propagate to masters of genpd */
		list_for_each_entry(link, &genpd->slave_links, slave_node) {
		master = link->master;

		if (!master->set_performance_state)
		continue;

		/* Find master's performance state */
		ret = dev_pm_opp_xlate_performance_state(genpd->opp_table,
		master->opp_table,
		state);
		if (unlikely(ret < 0))
		goto err;

		master_state = ret;

		genpd_lock_nested(master, depth + 1);

		link->prev_performance_state = link->performance_state;
		link->performance_state = master_state;
		master_state = _genpd_reeval_performance_state(master,
		master_state);
		ret = _genpd_set_performance_state(master, master_state, depth + 1);
		if (ret)
		link->performance_state = link->prev_performance_state;

		genpd_unlock(master);

		if (ret)
		goto err;
		}

		ret = genpd->set_performance_state(genpd, state);
		if (ret)
		goto err;

		genpd->performance_state = state;
		return 0;

		err:
		/* Encountered an error, lets rollback */
		list_for_each_entry_continue_reverse(link, &genpd->slave_links,
		slave_node) {
		master = link->master;

		if (!master->set_performance_state)
		continue;

		genpd_lock_nested(master, depth + 1);

		master_state = link->prev_performance_state;
		link->performance_state = master_state;

		master_state = _genpd_reeval_performance_state(master,
		master_state);
		if (_genpd_set_performance_state(master, master_state, depth + 1)) {
		pr_err("%s: Failed to roll back to %d performance state\n",
		master->name, master_state);
		}

		genpd_unlock(master);
		}

		return ret;
		}

		/**
		* dev_pm_genpd_set_performance_state- Set performance state of device's power
		* domain.
		@@ -257,10 +378,9 @@ static inline void genpd_update_accounting(struct generic_pm_domain *genpd) {}
		int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state)
		{
		struct generic_pm_domain *genpd;
		struct generic_pm_domain_data gpd_data, pd_data;
		struct pm_domain_data *pdd;
		struct generic_pm_domain_data *gpd_data;
		unsigned int prev;
		int ret = 0;
		int ret;

		genpd = dev_to_genpd(dev);
		if (IS_ERR(genpd))
		@@ -281,47 +401,11 @@ int dev_pm_genpd_set_performance_state(struct device *dev, unsigned int state)
		prev = gpd_data->performance_state;
		gpd_data->performance_state = state;

		/* New requested state is same as Max requested state */
		if (state == genpd->performance_state)
		goto unlock;

		/* New requested state is higher than Max requested state */
		if (state > genpd->performance_state)
		goto update_state;

		/* Traverse all devices within the domain */
		list_for_each_entry(pdd, &genpd->dev_list, list_node) {
		pd_data = to_gpd_data(pdd);

		if (pd_data->performance_state > state)
		state = pd_data->performance_state;
		}

		if (state == genpd->performance_state)
		goto unlock;

		/*
		* We aren't propagating performance state changes of a subdomain to its
		* masters as we don't have hardware that needs it. Over that, the
		* performance states of subdomain and its masters may not have
		* one-to-one mapping and would require additional information. We can
		* get back to this once we have hardware that needs it. For that
		* reason, we don't have to consider performance state of the subdomains
		* of genpd here.
		*/

		update_state:
		if (genpd_status_on(genpd)) {
		ret = genpd->set_performance_state(genpd, state);
		if (ret) {
		state = _genpd_reeval_performance_state(genpd, state);
		ret = _genpd_set_performance_state(genpd, state, 0);
		if (ret)
		gpd_data->performance_state = prev;
		goto unlock;
		}
		}

		genpd->performance_state = state;

		unlock:
		genpd_unlock(genpd);

		return ret;
		@@ -347,15 +431,6 @@ static int _genpd_power_on(struct generic_pm_domain *genpd, bool timed)
		return ret;

		elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));

		if (unlikely(genpd->set_performance_state)) {
		ret = genpd->set_performance_state(genpd, genpd->performance_state);
		if (ret) {
		pr_warn("%s: Failed to set performance state %d (%d)\n",
		genpd->name, genpd->performance_state, ret);
		}
		}

		if (elapsed_ns <= genpd->states[state_idx].power_on_latency_ns)
		return ret;

		@@ -1907,12 +1982,21 @@ int of_genpd_add_provider_simple(struct device_node *np,
		ret);
		goto unlock;
		}

		/*
		* Save table for faster processing while setting performance
		* state.
		*/
		genpd->opp_table = dev_pm_opp_get_opp_table(&genpd->dev);
		WARN_ON(!genpd->opp_table);
		}

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

		goto unlock;
		}
		@@ -1965,6 +2049,13 @@ int of_genpd_add_provider_onecell(struct device_node *np,
		i, ret);
		goto error;
		}

		/*
		* Save table for faster processing while setting
		* performance state.
		*/
		genpd->opp_table = dev_pm_opp_get_opp_table_indexed(&genpd->dev, i);
		WARN_ON(!genpd->opp_table);
		}

		genpd->provider = &np->fwnode;
		@@ -1989,9 +2080,11 @@ error:
		genpd->provider = NULL;
		genpd->has_provider = false;

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

		mutex_unlock(&gpd_list_lock);

		@@ -2024,6 +2117,7 @@ void of_genpd_del_provider(struct device_node *np)
		if (!gpd->set_performance_state)
		continue;

		dev_pm_opp_put_opp_table(gpd->opp_table);
		dev_pm_opp_of_remove_table(&gpd->dev);
		}
		}

drivers/opp/core.c

+79 −7

Original line number	Diff line number	Diff line
		@@ -196,12 +196,12 @@ unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev)
		if (IS_ERR(opp_table))
		return 0;

		count = opp_table->regulator_count;

		/* Regulator may not be required for the device */
		if (!count)
		if (!opp_table->regulators)
		goto put_opp_table;

		count = opp_table->regulator_count;

		uV = kmalloc_array(count, sizeof(*uV), GFP_KERNEL);
		if (!uV)
		goto put_opp_table;
		@@ -843,6 +843,9 @@ static struct opp_table _allocate_opp_table(struct device dev, int index)
		mutex_init(&opp_table->genpd_virt_dev_lock);
		INIT_LIST_HEAD(&opp_table->dev_list);

		/* Mark regulator count uninitialized */
		opp_table->regulator_count = -1;

		opp_dev = _add_opp_dev(dev, opp_table);
		if (!opp_dev) {
		kfree(opp_table);
		@@ -1063,7 +1066,7 @@ struct dev_pm_opp _opp_allocate(struct opp_table table)
		int count, supply_size;

		/* Allocate space for at least one supply */
		count = table->regulator_count ? table->regulator_count : 1;
		count = table->regulator_count > 0 ? table->regulator_count : 1;
		supply_size = sizeof(opp->supplies) count;

		/* allocate new OPP node and supplies structures */
		@@ -1084,6 +1087,9 @@ static bool _opp_supported_by_regulators(struct dev_pm_opp *opp,
		struct regulator *reg;
		int i;

		if (!opp_table->regulators)
		return true;

		for (i = 0; i < opp_table->regulator_count; i++) {
		reg = opp_table->regulators[i];

		@@ -1368,7 +1374,7 @@ static int _allocate_set_opp_data(struct opp_table *opp_table)
		struct dev_pm_set_opp_data *data;
		int len, count = opp_table->regulator_count;

		if (WARN_ON(!count))
		if (WARN_ON(!opp_table->regulators))
		return -EINVAL;

		/* space for set_opp_data */
		@@ -1465,7 +1471,7 @@ free_regulators:

		kfree(opp_table->regulators);
		opp_table->regulators = NULL;
		opp_table->regulator_count = 0;
		opp_table->regulator_count = -1;
		err:
		dev_pm_opp_put_opp_table(opp_table);

		@@ -1494,7 +1500,7 @@ void dev_pm_opp_put_regulators(struct opp_table *opp_table)

		kfree(opp_table->regulators);
		opp_table->regulators = NULL;
		opp_table->regulator_count = 0;
		opp_table->regulator_count = -1;

		put_opp_table:
		dev_pm_opp_put_opp_table(opp_table);
		@@ -1707,6 +1713,69 @@ void dev_pm_opp_put_genpd_virt_dev(struct opp_table *opp_table,
		dev_err(virt_dev, "Failed to find required device entry\n");
		}

		/**
		* dev_pm_opp_xlate_performance_state() - Find required OPP's pstate for src_table.
		* @src_table: OPP table which has dst_table as one of its required OPP table.
		* @dst_table: Required OPP table of the src_table.
		* @pstate: Current performance state of the src_table.
		*
		* This Returns pstate of the OPP (present in @dst_table) pointed out by the
		* "required-opps" property of the OPP (present in @src_table) which has
		* performance state set to @pstate.
		*
		* Return: Zero or positive performance state on success, otherwise negative
		* value on errors.
		*/
		int dev_pm_opp_xlate_performance_state(struct opp_table *src_table,
		struct opp_table *dst_table,
		unsigned int pstate)
		{
		struct dev_pm_opp *opp;
		int dest_pstate = -EINVAL;
		int i;

		if (!pstate)
		return 0;

		/*
		* Normally the src_table will have the "required_opps" property set to
		* point to one of the OPPs in the dst_table, but in some cases the
		* genpd and its master have one to one mapping of performance states
		* and so none of them have the "required-opps" property set. Return the
		* pstate of the src_table as it is in such cases.
		*/
		if (!src_table->required_opp_count)
		return pstate;

		for (i = 0; i < src_table->required_opp_count; i++) {
		if (src_table->required_opp_tables[i]->np == dst_table->np)
		break;
		}

		if (unlikely(i == src_table->required_opp_count)) {
		pr_err("%s: Couldn't find matching OPP table (%p: %p)\n",
		__func__, src_table, dst_table);
		return -EINVAL;
		}

		mutex_lock(&src_table->lock);

		list_for_each_entry(opp, &src_table->opp_list, node) {
		if (opp->pstate == pstate) {
		dest_pstate = opp->required_opps[i]->pstate;
		goto unlock;
		}
		}

		pr_err("%s: Couldn't find matching OPP (%p: %p)\n", __func__, src_table,
		dst_table);

		unlock:
		mutex_unlock(&src_table->lock);

		return dest_pstate;
		}

		/**
		* dev_pm_opp_add() - Add an OPP table from a table definitions
		* @dev: device for which we do this operation
		@@ -1733,6 +1802,9 @@ int dev_pm_opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
		if (!opp_table)
		return -ENOMEM;

		/* Fix regulator count for dynamic OPPs */
		opp_table->regulator_count = 1;

		ret = _opp_add_v1(opp_table, dev, freq, u_volt, true);
		if (ret)
		dev_pm_opp_put_opp_table(opp_table);

drivers/opp/of.c

+31 −13

Original line number	Diff line number	Diff line
		@@ -114,19 +114,25 @@ static struct device_node of_parse_required_opp(struct device_node np,
		static struct opp_table _find_table_of_opp_np(struct device_node opp_np)
		{
		struct opp_table *opp_table;
		struct dev_pm_opp *opp;
		struct device_node *opp_table_np;

		lockdep_assert_held(&opp_table_lock);

		opp_table_np = of_get_parent(opp_np);
		if (!opp_table_np)
		goto err;

		/* It is safe to put the node now as all we need now is its address */
		of_node_put(opp_table_np);

		list_for_each_entry(opp_table, &opp_tables, node) {
		opp = _find_opp_of_np(opp_table, opp_np);
		if (opp) {
		dev_pm_opp_put(opp);
		if (opp_table_np == opp_table->np) {
		_get_opp_table_kref(opp_table);
		return opp_table;
		}
		}

		err:
		return ERR_PTR(-ENODEV);
		}

		@@ -385,12 +391,10 @@ static int opp_parse_supplies(struct dev_pm_opp opp, struct device dev,
		struct opp_table *opp_table)
		{
		u32 microvolt, microamp = NULL;
		int supplies, vcount, icount, ret, i, j;
		int supplies = opp_table->regulator_count, vcount, icount, ret, i, j;
		struct property *prop = NULL;
		char name[NAME_MAX];

		supplies = opp_table->regulator_count ? opp_table->regulator_count : 1;

		/* Search for "opp-microvolt-<name>" */
		if (opp_table->prop_name) {
		snprintf(name, sizeof(name), "opp-microvolt-%s",
		@@ -405,7 +409,13 @@ static int opp_parse_supplies(struct dev_pm_opp opp, struct device dev,

		/* Missing property isn't a problem, but an invalid entry is */
		if (!prop) {
		if (!opp_table->regulator_count)
		if (unlikely(supplies == -1)) {
		/* Initialize regulator_count */
		opp_table->regulator_count = 0;
		return 0;
		}

		if (!supplies)
		return 0;

		dev_err(dev, "%s: opp-microvolt missing although OPP managing regulators\n",
		@@ -414,6 +424,14 @@ static int opp_parse_supplies(struct dev_pm_opp opp, struct device dev,
		}
		}

		if (unlikely(supplies == -1)) {
		/* Initialize regulator_count */
		supplies = opp_table->regulator_count = 1;
		} else if (unlikely(!supplies)) {
		dev_err(dev, "%s: opp-microvolt wasn't expected\n", __func__);
		return -EINVAL;
		}

		vcount = of_property_count_u32_elems(opp->np, name);
		if (vcount < 0) {
		dev_err(dev, "%s: Invalid %s property (%d)\n",
		@@ -975,19 +993,19 @@ EXPORT_SYMBOL_GPL(dev_pm_opp_of_get_sharing_cpus);
		* Returns the performance state of the OPP pointed out by the "required-opps"
		* property at @index in @np.
		*
		* Return: Positive performance state on success, otherwise 0 on errors.
		* Return: Zero or positive performance state on success, otherwise negative
		* value on errors.
		*/
		unsigned int of_get_required_opp_performance_state(struct device_node *np,
		int index)
		int of_get_required_opp_performance_state(struct device_node *np, int index)
		{
		struct dev_pm_opp *opp;
		struct device_node *required_np;
		struct opp_table *opp_table;
		unsigned int pstate = 0;
		int pstate = -EINVAL;

		required_np = of_parse_required_opp(np, index);
		if (!required_np)
		return 0;
		return -EINVAL;

		opp_table = _find_table_of_opp_np(required_np);
		if (IS_ERR(opp_table)) {

drivers/opp/opp.h

+4 −2

Original line number	Diff line number	Diff line
		@@ -145,7 +145,9 @@ enum opp_table_access {
		* @prop_name: A name to postfix to many DT properties, while parsing them.
		* @clk: Device's clock handle
		* @regulators: Supply regulators
		* @regulator_count: Number of power supply regulators
		* @regulator_count: Number of power supply regulators. Its value can be -1
		* (uninitialized), 0 (no opp-microvolt property) or > 0 (has opp-microvolt
		* property).
		* @genpd_performance_state: Device's power domain support performance state.
		* @is_genpd: Marks if the OPP table belongs to a genpd.
		* @set_opp: Platform specific set_opp callback
		@@ -189,7 +191,7 @@ struct opp_table {
		const char *prop_name;
		struct clk *clk;
		struct regulator **regulators;
		unsigned int regulator_count;
		int regulator_count;
		bool genpd_performance_state;
		bool is_genpd;

include/linux/pm_domain.h

+6 −0

Original line number	Diff line number	Diff line
		@@ -73,6 +73,7 @@ struct genpd_power_state {

		struct genpd_lock_ops;
		struct dev_pm_opp;
		struct opp_table;

		struct generic_pm_domain {
		struct device dev;
		@@ -94,6 +95,7 @@ struct generic_pm_domain {
		unsigned int performance_state; /* Aggregated max performance state */
		int (power_off)(struct generic_pm_domain domain);
		int (power_on)(struct generic_pm_domain domain);
		struct opp_table opp_table; / OPP table of the genpd */
		unsigned int (opp_to_performance_state)(struct generic_pm_domain genpd,
		struct dev_pm_opp *opp);
		int (set_performance_state)(struct generic_pm_domain genpd,
		@@ -134,6 +136,10 @@ struct gpd_link {
		struct list_head master_node;
		struct generic_pm_domain *slave;
		struct list_head slave_node;

		/* Sub-domain's per-master domain performance state */
		unsigned int performance_state;
		unsigned int prev_performance_state;
		};

		struct gpd_timing_data {

Admin message