Skip to content

Commit

Permalink
clk: Add support for runtime PM
Browse files Browse the repository at this point in the history 
Registers for some clocks might be located in the SOC area, which are under the
power domain. To enable access to those registers respective domain has to be
turned on. Additionally, registers for such clocks will usually loose its
contents when power domain is turned off, so additional saving and restoring of
them might be needed in the clock controller driver.

This patch adds basic infrastructure in the clocks core to allow implementing
driver for such clocks under power domains. Clock provider can supply a
struct device pointer, which is the used by clock core for tracking and managing
clock's controller runtime pm state. Each clk_prepare() operation
will first call pm_runtime_get_sync() on the supplied device, while
clk_unprepare() will do pm_runtime_put_sync() at the end.

Additional calls to pm_runtime_get/put functions are required to ensure that any
register access (like calculating/changing clock rates and unpreparing/disabling
unused clocks on boot) will be done with clock controller in runtime resumend
state.

When one wants to register clock controller, which make use of this feature, he
has to:
1. Provide a struct device to the core when registering the provider.
2. Ensure to enable runtime PM for that device before registering clocks.
3. Make sure that the runtime PM status of the controller device reflects
   the HW state.

Signed-off-by: Marek Szyprowski <[email protected]>
Reviewed-by: Ulf Hansson <[email protected]>
Acked-by: Krzysztof Kozlowski <[email protected]>
Signed-off-by: Michael Turquette <[email protected]>
Link: lkml.kernel.org/r/[email protected]
  • Loading branch information
@mszyprow @mturquette
mszyprow authored and mturquette committed Sep 7, 2017
1 parent 5771a8c commit 9a34b45
Showing 1 changed file with 112 additions and 14 deletions.
126 changes: 112 additions & 14 deletions drivers/clk/clk.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@
#include <linux/of.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/pm_runtime.h>
#include <linux/sched.h>
#include <linux/clkdev.h>

Expand All @@ -46,6 +47,7 @@ struct clk_core {
const struct clk_ops *ops;
struct clk_hw *hw;
struct module *owner;
struct device *dev;
struct clk_core *parent;
const char **parent_names;
struct clk_core **parents;
Expand Down Expand Up @@ -87,6 +89,26 @@ struct clk {
struct hlist_node clks_node;
};

/*** runtime pm ***/
static int clk_pm_runtime_get(struct clk_core *core)
{
int ret = 0;

if (!core->dev)
return 0;

ret = pm_runtime_get_sync(core->dev);
return ret < 0 ? ret : 0;
}

static void clk_pm_runtime_put(struct clk_core *core)
{
if (!core->dev)
return;

pm_runtime_put_sync(core->dev);
}

/*** locking ***/
static void clk_prepare_lock(void)
{
Expand Down Expand Up @@ -150,26 +172,57 @@ static void clk_enable_unlock(unsigned long flags)

static bool clk_core_is_prepared(struct clk_core *core)
{
bool ret = false;

/*
* .is_prepared is optional for clocks that can prepare
* fall back to software usage counter if it is missing
*/
if (!core->ops->is_prepared)
return core->prepare_count;

return core->ops->is_prepared(core->hw);
if (!clk_pm_runtime_get(core)) {
ret = core->ops->is_prepared(core->hw);
clk_pm_runtime_put(core);
}

return ret;
}

static bool clk_core_is_enabled(struct clk_core *core)
{
bool ret = false;

/*
* .is_enabled is only mandatory for clocks that gate
* fall back to software usage counter if .is_enabled is missing
*/
if (!core->ops->is_enabled)
return core->enable_count;

return core->ops->is_enabled(core->hw);
/*
* Check if clock controller's device is runtime active before
* calling .is_enabled callback. If not, assume that clock is
* disabled, because we might be called from atomic context, from
* which pm_runtime_get() is not allowed.
* This function is called mainly from clk_disable_unused_subtree,
* which ensures proper runtime pm activation of controller before
* taking enable spinlock, but the below check is needed if one tries
* to call it from other places.
*/
if (core->dev) {
pm_runtime_get_noresume(core->dev);
if (!pm_runtime_active(core->dev)) {
ret = false;
goto done;
}
}

ret = core->ops->is_enabled(core->hw);
done:
clk_pm_runtime_put(core);

return ret;
}

/*** helper functions ***/
Expand Down Expand Up @@ -489,6 +542,8 @@ static void clk_core_unprepare(struct clk_core *core)
if (core->ops->unprepare)
core->ops->unprepare(core->hw);

clk_pm_runtime_put(core);

trace_clk_unprepare_complete(core);
clk_core_unprepare(core->parent);
}
Expand Down Expand Up @@ -530,26 +585,33 @@ static int clk_core_prepare(struct clk_core *core)
return 0;

if (core->prepare_count == 0) {
ret = clk_core_prepare(core->parent);
ret = clk_pm_runtime_get(core);
if (ret)
return ret;

ret = clk_core_prepare(core->parent);
if (ret)
goto runtime_put;

trace_clk_prepare(core);

if (core->ops->prepare)
ret = core->ops->prepare(core->hw);

trace_clk_prepare_complete(core);

if (ret) {
clk_core_unprepare(core->parent);
return ret;
}
if (ret)
goto unprepare;
}

core->prepare_count++;

return 0;
unprepare:
clk_core_unprepare(core->parent);
runtime_put:
clk_pm_runtime_put(core);
return ret;
}

static int clk_core_prepare_lock(struct clk_core *core)
Expand Down Expand Up @@ -745,6 +807,9 @@ static void clk_unprepare_unused_subtree(struct clk_core *core)
if (core->flags & CLK_IGNORE_UNUSED)
return;

if (clk_pm_runtime_get(core))
return;

if (clk_core_is_prepared(core)) {
trace_clk_unprepare(core);
if (core->ops->unprepare_unused)
Expand All @@ -753,6 +818,8 @@ static void clk_unprepare_unused_subtree(struct clk_core *core)
core->ops->unprepare(core->hw);
trace_clk_unprepare_complete(core);
}

clk_pm_runtime_put(core);
}

static void clk_disable_unused_subtree(struct clk_core *core)
Expand All @@ -768,6 +835,9 @@ static void clk_disable_unused_subtree(struct clk_core *core)
if (core->flags & CLK_OPS_PARENT_ENABLE)
clk_core_prepare_enable(core->parent);

if (clk_pm_runtime_get(core))
goto unprepare_out;

flags = clk_enable_lock();

if (core->enable_count)
Expand All @@ -792,6 +862,8 @@ static void clk_disable_unused_subtree(struct clk_core *core)

unlock_out:
clk_enable_unlock(flags);
clk_pm_runtime_put(core);
unprepare_out:
if (core->flags & CLK_OPS_PARENT_ENABLE)
clk_core_disable_unprepare(core->parent);
}
Expand Down Expand Up @@ -1038,9 +1110,13 @@ EXPORT_SYMBOL_GPL(clk_get_accuracy);
static unsigned long clk_recalc(struct clk_core *core,
unsigned long parent_rate)
{
if (core->ops->recalc_rate)
return core->ops->recalc_rate(core->hw, parent_rate);
return parent_rate;
unsigned long rate = parent_rate;

if (core->ops->recalc_rate && !clk_pm_runtime_get(core)) {
rate = core->ops->recalc_rate(core->hw, parent_rate);
clk_pm_runtime_put(core);
}
return rate;
}

/**
Expand Down Expand Up @@ -1565,6 +1641,7 @@ static int clk_core_set_rate_nolock(struct clk_core *core,
{
struct clk_core *top, *fail_clk;
unsigned long rate = req_rate;
int ret = 0;

if (!core)
return 0;
Expand All @@ -1581,21 +1658,28 @@ static int clk_core_set_rate_nolock(struct clk_core *core,
if (!top)
return -EINVAL;

ret = clk_pm_runtime_get(core);
if (ret)
return ret;

/* notify that we are about to change rates */
fail_clk = clk_propagate_rate_change(top, PRE_RATE_CHANGE);
if (fail_clk) {
pr_debug("%s: failed to set %s rate\n", __func__,
fail_clk->name);
clk_propagate_rate_change(top, ABORT_RATE_CHANGE);
return -EBUSY;
ret = -EBUSY;
goto err;
}

/* change the rates */
clk_change_rate(top);

core->req_rate = req_rate;
err:
clk_pm_runtime_put(core);

return 0;
return ret;
}

/**
Expand Down Expand Up @@ -1826,12 +1910,16 @@ static int clk_core_set_parent(struct clk_core *core, struct clk_core *parent)
p_rate = parent->rate;
}

ret = clk_pm_runtime_get(core);
if (ret)
goto out;

/* propagate PRE_RATE_CHANGE notifications */
ret = __clk_speculate_rates(core, p_rate);

/* abort if a driver objects */
if (ret & NOTIFY_STOP_MASK)
goto out;
goto runtime_put;

/* do the re-parent */
ret = __clk_set_parent(core, parent, p_index);
Expand All @@ -1844,6 +1932,8 @@ static int clk_core_set_parent(struct clk_core *core, struct clk_core *parent)
__clk_recalc_accuracies(core);
}

runtime_put:
clk_pm_runtime_put(core);
out:
clk_prepare_unlock();

Expand Down Expand Up @@ -2350,7 +2440,7 @@ static inline void clk_debug_unregister(struct clk_core *core)
*/
static int __clk_core_init(struct clk_core *core)
{
int i, ret = 0;
int i, ret;
struct clk_core *orphan;
struct hlist_node *tmp2;
unsigned long rate;
Expand All @@ -2360,6 +2450,10 @@ static int __clk_core_init(struct clk_core *core)

clk_prepare_lock();

ret = clk_pm_runtime_get(core);
if (ret)
goto unlock;

/* check to see if a clock with this name is already registered */
if (clk_core_lookup(core->name)) {
pr_debug("%s: clk %s already initialized\n",
Expand Down Expand Up @@ -2512,6 +2606,8 @@ static int __clk_core_init(struct clk_core *core)

kref_init(&core->ref);
out:
clk_pm_runtime_put(core);
unlock:
clk_prepare_unlock();

if (!ret)
Expand Down Expand Up @@ -2583,6 +2679,8 @@ struct clk *clk_register(struct device *dev, struct clk_hw *hw)
goto fail_name;
}
core->ops = hw->init->ops;
if (dev && pm_runtime_enabled(dev))
core->dev = dev;
if (dev && dev->driver)
core->owner = dev->driver->owner;
core->hw = hw;
Expand Down

0 comments on commit 9a34b45

Please sign in to comment.