Unverified Commit 7b6894e9 authored by Stephen Boyd's avatar Stephen Boyd
Browse files

Merge tag 'clk-remove-deprecated-apis-v7.1' of ssh://github.com/masneyb/linux into clk-round 

Pull round_rate refactoring from Brian Masney:

Now that all of the dependencies across the tree have been merged into
Linus's tree, here's a small series with the following changes:

 - Converts clk-composite from round_rate() to determine_rate()
 - Removes the round_rate() clk op
 - Removes the deprecated functions divider_round_rate(),
   divider_round_rate_parent(), and divider_ro_round_rate_parent() since
   these are just wrappers for the corresponding determine_rate variant

* tag 'clk-remove-deprecated-apis-v7.1' of ssh://github.com/masneyb/linux:
  clk: divider: remove divider_round_rate() and divider_round_rate_parent()
  clk: divider: remove divider_ro_round_rate_parent()
  clk: remove round_rate() clk ops
  clk: composite: convert from round_rate() to determine_rate()
  clk: test: remove references to clk_ops.round_rate
parents c3692998 d4851759

Documentation/driver-api/clk.rst

+1 −8
Original line number Diff line number Diff line
@@ -77,9 +77,6 @@ the operations defined in clk-provider.h:: 
		void		(*disable_unused)(struct clk_hw *hw);

		unsigned long	(*recalc_rate)(struct clk_hw *hw,

						unsigned long parent_rate);

		long		(*round_rate)(struct clk_hw *hw,

						unsigned long rate,

						unsigned long *parent_rate);

		int		(*determine_rate)(struct clk_hw *hw,

						  struct clk_rate_request *req);

		int		(*set_parent)(struct clk_hw *hw, u8 index);
@@ -220,9 +217,7 @@ optional or must be evaluated on a case-by-case basis. 
   +----------------+------+-------------+---------------+-------------+------+

   |.recalc_rate    |      | y           |               |             |      |

   +----------------+------+-------------+---------------+-------------+------+

   |.round_rate     |      | y [1]_      |               |             |      |

   +----------------+------+-------------+---------------+-------------+------+

   |.determine_rate |      | y [1]_      |               |             |      |

   |.determine_rate |      | y           |               |             |      |

   +----------------+------+-------------+---------------+-------------+------+

   |.set_rate       |      | y           |               |             |      |

   +----------------+------+-------------+---------------+-------------+------+
@@ -238,8 +233,6 @@ optional or must be evaluated on a case-by-case basis. 
   |.init           |      |             |               |             |      |

   +----------------+------+-------------+---------------+-------------+------+



.. [1] either one of round_rate or determine_rate is required.



Finally, register your clock at run-time with a hardware-specific

registration function.  This function simply populates struct clk_foo's

data and then passes the common struct clk parameters to the framework

drivers/clk/clk-composite.c

+5 −33
Original line number Diff line number Diff line
@@ -47,22 +47,10 @@ static int clk_composite_determine_rate_for_parent(struct clk_hw *rate_hw, 
						   struct clk_hw *parent_hw,

						   const struct clk_ops *rate_ops)

{

	long rate;



	req->best_parent_hw = parent_hw;

	req->best_parent_rate = clk_hw_get_rate(parent_hw);



	if (rate_ops->determine_rate)

	return rate_ops->determine_rate(rate_hw, req);



	rate = rate_ops->round_rate(rate_hw, req->rate,

				    &req->best_parent_rate);

	if (rate < 0)

		return rate;



	req->rate = rate;



	return 0;

}



static int clk_composite_determine_rate(struct clk_hw *hw,
@@ -79,8 +67,7 @@ static int clk_composite_determine_rate(struct clk_hw *hw, 
	unsigned long best_rate = 0;

	int i, ret;



	if (rate_hw && rate_ops &&

	    (rate_ops->determine_rate || rate_ops->round_rate) &&

	if (rate_hw && rate_ops && rate_ops->determine_rate &&

	    mux_hw && mux_ops && mux_ops->set_parent) {

		req->best_parent_hw = NULL;
@@ -150,18 +137,6 @@ static int clk_composite_determine_rate(struct clk_hw *hw, 
	}

}



static long clk_composite_round_rate(struct clk_hw *hw, unsigned long rate,

				  unsigned long *prate)

{

	struct clk_composite *composite = to_clk_composite(hw);

	const struct clk_ops *rate_ops = composite->rate_ops;

	struct clk_hw *rate_hw = composite->rate_hw;



	__clk_hw_set_clk(rate_hw, hw);



	return rate_ops->round_rate(rate_hw, rate, prate);

}



static int clk_composite_set_rate(struct clk_hw *hw, unsigned long rate,

			       unsigned long parent_rate)

{
@@ -288,17 +263,14 @@ static struct clk_hw *__clk_hw_register_composite(struct device *dev, 
		if (rate_ops->determine_rate)

			clk_composite_ops->determine_rate =

				clk_composite_determine_rate;

		else if (rate_ops->round_rate)

			clk_composite_ops->round_rate =

				clk_composite_round_rate;



		/* .set_rate requires either .round_rate or .determine_rate */

		/* .set_rate requires .determine_rate */

		if (rate_ops->set_rate) {

			if (rate_ops->determine_rate || rate_ops->round_rate)

			if (rate_ops->determine_rate)

				clk_composite_ops->set_rate =

						clk_composite_set_rate;

			else

				WARN(1, "%s: missing round_rate op is required\n",

				WARN(1, "%s: missing determine_rate op is required\n",

						__func__);

		}

drivers/clk/clk-divider.c

+0 −44
Original line number Diff line number Diff line
@@ -387,50 +387,6 @@ int divider_ro_determine_rate(struct clk_hw *hw, struct clk_rate_request *req, 
}

EXPORT_SYMBOL_GPL(divider_ro_determine_rate);



long divider_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent,

			       unsigned long rate, unsigned long *prate,

			       const struct clk_div_table *table,

			       u8 width, unsigned long flags)

{

	struct clk_rate_request req;

	int ret;



	clk_hw_init_rate_request(hw, &req, rate);

	req.best_parent_rate = *prate;

	req.best_parent_hw = parent;



	ret = divider_determine_rate(hw, &req, table, width, flags);

	if (ret)

		return ret;



	*prate = req.best_parent_rate;



	return req.rate;

}

EXPORT_SYMBOL_GPL(divider_round_rate_parent);



long divider_ro_round_rate_parent(struct clk_hw *hw, struct clk_hw *parent,

				  unsigned long rate, unsigned long *prate,

				  const struct clk_div_table *table, u8 width,

				  unsigned long flags, unsigned int val)

{

	struct clk_rate_request req;

	int ret;



	clk_hw_init_rate_request(hw, &req, rate);

	req.best_parent_rate = *prate;

	req.best_parent_hw = parent;



	ret = divider_ro_determine_rate(hw, &req, table, width, flags, val);

	if (ret)

		return ret;



	*prate = req.best_parent_rate;



	return req.rate;

}

EXPORT_SYMBOL_GPL(divider_ro_round_rate_parent);



static int clk_divider_determine_rate(struct clk_hw *hw,

				      struct clk_rate_request *req)

{

drivers/clk/clk.c

+14 −25
Original line number Diff line number Diff line
@@ -1560,8 +1560,6 @@ late_initcall_sync(clk_disable_unused); 
static int clk_core_determine_round_nolock(struct clk_core *core,

					   struct clk_rate_request *req)

{

	long rate;



	lockdep_assert_held(&prepare_lock);



	if (!core)
@@ -1591,13 +1589,6 @@ static int clk_core_determine_round_nolock(struct clk_core *core, 
		req->rate = core->rate;

	} else if (core->ops->determine_rate) {

		return core->ops->determine_rate(core->hw, req);

	} else if (core->ops->round_rate) {

		rate = core->ops->round_rate(core->hw, req->rate,

					     &req->best_parent_rate);

		if (rate < 0)

			return rate;



		req->rate = rate;

	} else {

		return -EINVAL;

	}
@@ -1682,7 +1673,7 @@ EXPORT_SYMBOL_GPL(clk_hw_forward_rate_request); 


static bool clk_core_can_round(struct clk_core * const core)

{

	return core->ops->determine_rate || core->ops->round_rate;

	return core->ops->determine_rate;

}



static int clk_core_round_rate_nolock(struct clk_core *core,
@@ -1750,11 +1741,11 @@ EXPORT_SYMBOL_GPL(__clk_determine_rate); 
 * use.

 *

 * Context: prepare_lock must be held.

 *          For clk providers to call from within clk_ops such as .round_rate,

 *          For clk providers to call from within clk_ops such as

 *          .determine_rate.

 *

 * Return: returns rounded rate of hw clk if clk supports round_rate operation

 *         else returns the parent rate.

 * Return: returns rounded rate of hw clk if clk supports determine_rate

 *         operation; else returns the parent rate.

 */

unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate)

{
@@ -2569,12 +2560,13 @@ static int clk_core_set_rate_nolock(struct clk_core *core, 
 *

 * Setting the CLK_SET_RATE_PARENT flag allows the rate change operation to

 * propagate up to clk's parent; whether or not this happens depends on the

 * outcome of clk's .round_rate implementation.  If *parent_rate is unchanged

 * after calling .round_rate then upstream parent propagation is ignored.  If

 * *parent_rate comes back with a new rate for clk's parent then we propagate

 * up to clk's parent and set its rate.  Upward propagation will continue

 * until either a clk does not support the CLK_SET_RATE_PARENT flag or

 * .round_rate stops requesting changes to clk's parent_rate.

 * outcome of clk's .determine_rate implementation. If req->best_parent_rate

 * is unchanged after calling .determine_rate then upstream parent propagation

 * is ignored.  If req->best_parent_rate comes back with a new rate for clk's

 * parent then we propagate up to clk's parent and set its rate. Upward

 * propagation will continue until either a clk does not support the

 * CLK_SET_RATE_PARENT flag or .determine_rate stops requesting changes to

 * clk's parent_rate.

 *

 * Rate changes are accomplished via tree traversal that also recalculates the

 * rates for the clocks and fires off POST_RATE_CHANGE notifiers.
@@ -2703,8 +2695,6 @@ static int clk_set_rate_range_nolock(struct clk *clk, 
	 * FIXME:

	 * There is a catch. It may fail for the usual reason (clock

	 * broken, clock protected, etc) but also because:

	 * - round_rate() was not favorable and fell on the wrong

	 *   side of the boundary

	 * - the determine_rate() callback does not really check for

	 *   this corner case when determining the rate

	 */
@@ -3915,10 +3905,9 @@ static int __clk_core_init(struct clk_core *core) 
	}



	/* check that clk_ops are sane.  See Documentation/driver-api/clk.rst */

	if (core->ops->set_rate &&

	    !((core->ops->round_rate || core->ops->determine_rate) &&

	      core->ops->recalc_rate)) {

		pr_err("%s: %s must implement .round_rate or .determine_rate in addition to .recalc_rate\n",

	if (core->ops->set_rate && !core->ops->determine_rate &&

	      core->ops->recalc_rate) {

		pr_err("%s: %s must implement .determine_rate in addition to .recalc_rate\n",

		       __func__, core->name);

		ret = -EINVAL;

		goto out;

drivers/clk/clk_test.c

+8 −8
Original line number Diff line number Diff line
@@ -241,8 +241,8 @@ static void clk_test_get_rate(struct kunit *test) 
 * Test that, after a call to clk_set_rate(), the rate returned by

 * clk_get_rate() matches.

 *

 * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't

 * modify the requested rate, which is our case in clk_dummy_rate_ops.

 * This assumes that clk_ops.determine_rate won't modify the requested rate,

 * which is our case in clk_dummy_rate_ops.

 */

static void clk_test_set_get_rate(struct kunit *test)

{
@@ -266,8 +266,8 @@ static void clk_test_set_get_rate(struct kunit *test) 
 * Test that, after several calls to clk_set_rate(), the rate returned

 * by clk_get_rate() matches the last one.

 *

 * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't

 * modify the requested rate, which is our case in clk_dummy_rate_ops.

 * This assumes that clk_ops.determine_rate won't modify the requested rate,

 * which is our case in clk_dummy_rate_ops.

 */

static void clk_test_set_set_get_rate(struct kunit *test)

{
@@ -1675,8 +1675,8 @@ static void clk_range_test_set_range_set_round_rate_consistent_higher(struct kun 
 * call to clk_set_rate_range(), the rate will be raised to match the

 * new minimum.

 *

 * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't

 * modify the requested rate, which is our case in clk_dummy_rate_ops.

 * This assumes that clk_ops.determine_rate won't modify the requested rate,

 * which is our case in clk_dummy_rate_ops.

 */

static void clk_range_test_set_range_get_rate_raised(struct kunit *test)

{
@@ -1707,8 +1707,8 @@ static void clk_range_test_set_range_get_rate_raised(struct kunit *test) 
 * call to clk_set_rate_range(), the rate will be lowered to match the

 * new maximum.

 *

 * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't

 * modify the requested rate, which is our case in clk_dummy_rate_ops.

 * This assumes that clk_ops.determine_rate won't modify the requested rate,

 * which is our case in clk_dummy_rate_ops.

 */

static void clk_range_test_set_range_get_rate_lowered(struct kunit *test)

{