2018-12-12 01:43:03 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2012-03-16 14:11:19 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2010-2011 Jeremy Kerr <jeremy.kerr@canonical.com>
|
|
|
|
* Copyright (C) 2011-2012 Linaro Ltd <mturquette@linaro.org>
|
|
|
|
*/
|
|
|
|
#ifndef __LINUX_CLK_PROVIDER_H
|
|
|
|
#define __LINUX_CLK_PROVIDER_H
|
|
|
|
|
2014-08-31 03:18:00 +08:00
|
|
|
#include <linux/of.h>
|
2018-04-18 22:50:01 +08:00
|
|
|
#include <linux/of_clk.h>
|
2012-03-16 14:11:19 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* flags used across common struct clk. these flags should only affect the
|
|
|
|
* top-level framework. custom flags for dealing with hardware specifics
|
|
|
|
* belong in struct clk_foo
|
2018-01-03 19:06:16 +08:00
|
|
|
*
|
|
|
|
* Please update clk_flags[] in drivers/clk/clk.c when making changes here!
|
2012-03-16 14:11:19 +08:00
|
|
|
*/
|
|
|
|
#define CLK_SET_RATE_GATE BIT(0) /* must be gated across rate change */
|
|
|
|
#define CLK_SET_PARENT_GATE BIT(1) /* must be gated across re-parent */
|
|
|
|
#define CLK_SET_RATE_PARENT BIT(2) /* propagate rate change up one level */
|
|
|
|
#define CLK_IGNORE_UNUSED BIT(3) /* do not gate even if unused */
|
2016-06-02 05:56:57 +08:00
|
|
|
/* unused */
|
2019-04-26 01:57:37 +08:00
|
|
|
/* unused */
|
2012-08-31 20:21:28 +08:00
|
|
|
#define CLK_GET_RATE_NOCACHE BIT(6) /* do not use the cached clk rate */
|
2013-07-29 19:25:01 +08:00
|
|
|
#define CLK_SET_RATE_NO_REPARENT BIT(7) /* don't re-parent on rate change */
|
2013-12-21 17:34:47 +08:00
|
|
|
#define CLK_GET_ACCURACY_NOCACHE BIT(8) /* do not use the cached clk accuracy */
|
2015-04-04 00:43:44 +08:00
|
|
|
#define CLK_RECALC_NEW_RATES BIT(9) /* recalc rates after notifications */
|
2015-12-23 05:27:58 +08:00
|
|
|
#define CLK_SET_RATE_UNGATE BIT(10) /* clock needs to run to set rate */
|
2016-02-12 05:19:09 +08:00
|
|
|
#define CLK_IS_CRITICAL BIT(11) /* do not gate, ever */
|
clk: core: support clocks which requires parents enable (part 1)
On Freescale i.MX7D platform, all clocks operations, including
enable/disable, rate change and re-parent, requires its parent
clock enable. Current clock core can not support it well.
This patch introduce a new flag CLK_OPS_PARENT_ENABLE to handle this
special case in clock core that enable its parent clock firstly for
each operation and disable it later after operation complete.
The patch part 1 fixes the possible disabling clocks while its parent
is off during kernel booting phase in clk_disable_unused_subtree().
Before the completion of kernel booting, clock tree is still not built
completely, there may be a case that the child clock is on but its
parent is off which could be caused by either HW initial reset state
or bootloader initialization.
Taking bootloader as an example, we may enable all clocks in HW by default.
And during kernel booting time, the parent clock could be disabled in its
driver probe due to calling clk_prepare_enable and clk_disable_unprepare.
Because it's child clock is only enabled in HW while its SW usecount
in clock tree is still 0, so clk_disable of parent clock will gate
the parent clock in both HW and SW usecount ultimately. Then there will
be a child clock is still on in HW but its parent is already off.
Later in clk_disable_unused(), this clock disable accessing while its
parent off will cause system hang due to the limitation of HW which
must require its parent on.
This patch simply enables the parent clock first before disabling
if flag CLK_OPS_PARENT_ENABLE is set in clk_disable_unused_subtree().
This is a simple solution and only affects booting time.
After kernel booting up the clock tree is already created, there will
be no case that child is off but its parent is off.
So no need do this checking for normal clk_disable() later.
Cc: Michael Turquette <mturquette@baylibre.com>
Cc: Stephen Boyd <sboyd@codeaurora.org>
Cc: Shawn Guo <shawnguo@kernel.org>
Signed-off-by: Dong Aisheng <aisheng.dong@nxp.com>
Signed-off-by: Stephen Boyd <sboyd@codeaurora.org>
2016-06-30 17:31:13 +08:00
|
|
|
/* parents need enable during gate/ungate, set rate and re-parent */
|
|
|
|
#define CLK_OPS_PARENT_ENABLE BIT(12)
|
clk: add duty cycle support
Add the possibility to apply and query the clock signal duty cycle ratio.
This is useful when the duty cycle of the clock signal depends on some
other parameters controlled by the clock framework.
For example, the duty cycle of a divider may depends on the raw divider
setting (ratio = N / div) , which is controlled by the CCF. In such case,
going through the pwm framework to control the duty cycle ratio of this
clock would be a burden.
A clock provider is not required to implement the operation to set and get
the duty cycle. If it does not implement .get_duty_cycle(), the ratio is
assumed to be 50%.
This change also adds a new flag, CLK_DUTY_CYCLE_PARENT. This flag should
be used to indicate that a clock, such as gates and muxes, may inherit
the duty cycle ratio of its parent clock. If a clock does not provide a
get_duty_cycle() callback and has CLK_DUTY_CYCLE_PARENT, then the call
will be directly forwarded to its parent clock, if any. For
set_duty_cycle(), the clock should also have CLK_SET_RATE_PARENT for the
call to be forwarded
Signed-off-by: Jerome Brunet <jbrunet@baylibre.com>
Signed-off-by: Michael Turquette <mturquette@baylibre.com>
Link: lkml.kernel.org/r/20180619144141.8506-1-jbrunet@baylibre.com
2018-06-19 22:41:41 +08:00
|
|
|
/* duty cycle call may be forwarded to the parent clock */
|
|
|
|
#define CLK_DUTY_CYCLE_PARENT BIT(13)
|
2012-03-16 14:11:19 +08:00
|
|
|
|
2015-06-23 08:13:49 +08:00
|
|
|
struct clk;
|
2012-04-26 13:58:56 +08:00
|
|
|
struct clk_hw;
|
2015-01-23 19:03:30 +08:00
|
|
|
struct clk_core;
|
2014-03-21 19:43:56 +08:00
|
|
|
struct dentry;
|
2012-04-26 13:58:56 +08:00
|
|
|
|
2015-07-08 02:48:08 +08:00
|
|
|
/**
|
|
|
|
* struct clk_rate_request - Structure encoding the clk constraints that
|
|
|
|
* a clock user might require.
|
|
|
|
*
|
|
|
|
* @rate: Requested clock rate. This field will be adjusted by
|
|
|
|
* clock drivers according to hardware capabilities.
|
|
|
|
* @min_rate: Minimum rate imposed by clk users.
|
2015-11-05 17:02:34 +08:00
|
|
|
* @max_rate: Maximum rate imposed by clk users.
|
2015-07-08 02:48:08 +08:00
|
|
|
* @best_parent_rate: The best parent rate a parent can provide to fulfill the
|
|
|
|
* requested constraints.
|
|
|
|
* @best_parent_hw: The most appropriate parent clock that fulfills the
|
|
|
|
* requested constraints.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct clk_rate_request {
|
|
|
|
unsigned long rate;
|
|
|
|
unsigned long min_rate;
|
|
|
|
unsigned long max_rate;
|
|
|
|
unsigned long best_parent_rate;
|
|
|
|
struct clk_hw *best_parent_hw;
|
|
|
|
};
|
|
|
|
|
clk: add duty cycle support
Add the possibility to apply and query the clock signal duty cycle ratio.
This is useful when the duty cycle of the clock signal depends on some
other parameters controlled by the clock framework.
For example, the duty cycle of a divider may depends on the raw divider
setting (ratio = N / div) , which is controlled by the CCF. In such case,
going through the pwm framework to control the duty cycle ratio of this
clock would be a burden.
A clock provider is not required to implement the operation to set and get
the duty cycle. If it does not implement .get_duty_cycle(), the ratio is
assumed to be 50%.
This change also adds a new flag, CLK_DUTY_CYCLE_PARENT. This flag should
be used to indicate that a clock, such as gates and muxes, may inherit
the duty cycle ratio of its parent clock. If a clock does not provide a
get_duty_cycle() callback and has CLK_DUTY_CYCLE_PARENT, then the call
will be directly forwarded to its parent clock, if any. For
set_duty_cycle(), the clock should also have CLK_SET_RATE_PARENT for the
call to be forwarded
Signed-off-by: Jerome Brunet <jbrunet@baylibre.com>
Signed-off-by: Michael Turquette <mturquette@baylibre.com>
Link: lkml.kernel.org/r/20180619144141.8506-1-jbrunet@baylibre.com
2018-06-19 22:41:41 +08:00
|
|
|
/**
|
|
|
|
* struct clk_duty - Struture encoding the duty cycle ratio of a clock
|
|
|
|
*
|
|
|
|
* @num: Numerator of the duty cycle ratio
|
|
|
|
* @den: Denominator of the duty cycle ratio
|
|
|
|
*/
|
|
|
|
struct clk_duty {
|
|
|
|
unsigned int num;
|
|
|
|
unsigned int den;
|
|
|
|
};
|
|
|
|
|
2012-03-16 14:11:19 +08:00
|
|
|
/**
|
|
|
|
* struct clk_ops - Callback operations for hardware clocks; these are to
|
|
|
|
* be provided by the clock implementation, and will be called by drivers
|
|
|
|
* through the clk_* api.
|
|
|
|
*
|
|
|
|
* @prepare: Prepare the clock for enabling. This must not return until
|
2014-04-22 21:11:41 +08:00
|
|
|
* the clock is fully prepared, and it's safe to call clk_enable.
|
|
|
|
* This callback is intended to allow clock implementations to
|
|
|
|
* do any initialisation that may sleep. Called with
|
|
|
|
* prepare_lock held.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
|
|
|
* @unprepare: Release the clock from its prepared state. This will typically
|
2014-04-22 21:11:41 +08:00
|
|
|
* undo any work done in the @prepare callback. Called with
|
|
|
|
* prepare_lock held.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
2013-03-13 03:26:02 +08:00
|
|
|
* @is_prepared: Queries the hardware to determine if the clock is prepared.
|
|
|
|
* This function is allowed to sleep. Optional, if this op is not
|
|
|
|
* set then the prepare count will be used.
|
|
|
|
*
|
2013-03-13 03:26:04 +08:00
|
|
|
* @unprepare_unused: Unprepare the clock atomically. Only called from
|
|
|
|
* clk_disable_unused for prepare clocks with special needs.
|
|
|
|
* Called with prepare mutex held. This function may sleep.
|
|
|
|
*
|
2012-03-16 14:11:19 +08:00
|
|
|
* @enable: Enable the clock atomically. This must not return until the
|
2014-04-22 21:11:41 +08:00
|
|
|
* clock is generating a valid clock signal, usable by consumer
|
|
|
|
* devices. Called with enable_lock held. This function must not
|
|
|
|
* sleep.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
|
|
|
* @disable: Disable the clock atomically. Called with enable_lock held.
|
2014-04-22 21:11:41 +08:00
|
|
|
* This function must not sleep.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
2012-10-04 14:38:53 +08:00
|
|
|
* @is_enabled: Queries the hardware to determine if the clock is enabled.
|
2014-04-22 21:11:41 +08:00
|
|
|
* This function must not sleep. Optional, if this op is not
|
|
|
|
* set then the enable count will be used.
|
2012-10-04 14:38:53 +08:00
|
|
|
*
|
2012-12-05 03:00:35 +08:00
|
|
|
* @disable_unused: Disable the clock atomically. Only called from
|
|
|
|
* clk_disable_unused for gate clocks with special needs.
|
|
|
|
* Called with enable_lock held. This function must not
|
|
|
|
* sleep.
|
|
|
|
*
|
2018-09-04 14:49:35 +08:00
|
|
|
* @save_context: Save the context of the clock in prepration for poweroff.
|
|
|
|
*
|
|
|
|
* @restore_context: Restore the context of the clock after a restoration
|
|
|
|
* of power.
|
|
|
|
*
|
2012-10-04 14:38:54 +08:00
|
|
|
* @recalc_rate Recalculate the rate of this clock, by querying hardware. The
|
2014-04-22 21:11:41 +08:00
|
|
|
* parent rate is an input parameter. It is up to the caller to
|
|
|
|
* ensure that the prepare_mutex is held across this call.
|
|
|
|
* Returns the calculated rate. Optional, but recommended - if
|
|
|
|
* this op is not set then clock rate will be initialized to 0.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
|
|
|
* @round_rate: Given a target rate as input, returns the closest rate actually
|
2014-04-22 21:11:42 +08:00
|
|
|
* supported by the clock. The parent rate is an input/output
|
|
|
|
* parameter.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
2013-07-29 19:25:00 +08:00
|
|
|
* @determine_rate: Given a target rate as input, returns the closest rate
|
|
|
|
* actually supported by the clock, and optionally the parent clock
|
|
|
|
* that should be used to provide the clock rate.
|
|
|
|
*
|
2012-03-16 14:11:19 +08:00
|
|
|
* @set_parent: Change the input source of this clock; for clocks with multiple
|
2014-04-22 21:11:42 +08:00
|
|
|
* possible parents specify a new parent by passing in the index
|
|
|
|
* as a u8 corresponding to the parent in either the .parent_names
|
|
|
|
* or .parents arrays. This function in affect translates an
|
|
|
|
* array index into the value programmed into the hardware.
|
|
|
|
* Returns 0 on success, -EERROR otherwise.
|
|
|
|
*
|
2012-03-16 14:11:19 +08:00
|
|
|
* @get_parent: Queries the hardware to determine the parent of a clock. The
|
2014-04-22 21:11:41 +08:00
|
|
|
* return value is a u8 which specifies the index corresponding to
|
|
|
|
* the parent clock. This index can be applied to either the
|
|
|
|
* .parent_names or .parents arrays. In short, this function
|
|
|
|
* translates the parent value read from hardware into an array
|
|
|
|
* index. Currently only called when the clock is initialized by
|
|
|
|
* __clk_init. This callback is mandatory for clocks with
|
|
|
|
* multiple parents. It is optional (and unnecessary) for clocks
|
|
|
|
* with 0 or 1 parents.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
2012-04-12 20:50:18 +08:00
|
|
|
* @set_rate: Change the rate of this clock. The requested rate is specified
|
|
|
|
* by the second argument, which should typically be the return
|
|
|
|
* of .round_rate call. The third argument gives the parent rate
|
|
|
|
* which is likely helpful for most .set_rate implementation.
|
|
|
|
* Returns 0 on success, -EERROR otherwise.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
2014-01-16 02:47:22 +08:00
|
|
|
* @set_rate_and_parent: Change the rate and the parent of this clock. The
|
|
|
|
* requested rate is specified by the second argument, which
|
|
|
|
* should typically be the return of .round_rate call. The
|
|
|
|
* third argument gives the parent rate which is likely helpful
|
|
|
|
* for most .set_rate_and_parent implementation. The fourth
|
|
|
|
* argument gives the parent index. This callback is optional (and
|
|
|
|
* unnecessary) for clocks with 0 or 1 parents as well as
|
|
|
|
* for clocks that can tolerate switching the rate and the parent
|
|
|
|
* separately via calls to .set_parent and .set_rate.
|
|
|
|
* Returns 0 on success, -EERROR otherwise.
|
|
|
|
*
|
2014-04-22 21:11:42 +08:00
|
|
|
* @recalc_accuracy: Recalculate the accuracy of this clock. The clock accuracy
|
|
|
|
* is expressed in ppb (parts per billion). The parent accuracy is
|
|
|
|
* an input parameter.
|
|
|
|
* Returns the calculated accuracy. Optional - if this op is not
|
|
|
|
* set then clock accuracy will be initialized to parent accuracy
|
|
|
|
* or 0 (perfect clock) if clock has no parent.
|
|
|
|
*
|
2014-07-14 19:53:27 +08:00
|
|
|
* @get_phase: Queries the hardware to get the current phase of a clock.
|
|
|
|
* Returned values are 0-359 degrees on success, negative
|
|
|
|
* error codes on failure.
|
|
|
|
*
|
2014-02-19 13:21:25 +08:00
|
|
|
* @set_phase: Shift the phase this clock signal in degrees specified
|
|
|
|
* by the second argument. Valid values for degrees are
|
|
|
|
* 0-359. Return 0 on success, otherwise -EERROR.
|
|
|
|
*
|
clk: add duty cycle support
Add the possibility to apply and query the clock signal duty cycle ratio.
This is useful when the duty cycle of the clock signal depends on some
other parameters controlled by the clock framework.
For example, the duty cycle of a divider may depends on the raw divider
setting (ratio = N / div) , which is controlled by the CCF. In such case,
going through the pwm framework to control the duty cycle ratio of this
clock would be a burden.
A clock provider is not required to implement the operation to set and get
the duty cycle. If it does not implement .get_duty_cycle(), the ratio is
assumed to be 50%.
This change also adds a new flag, CLK_DUTY_CYCLE_PARENT. This flag should
be used to indicate that a clock, such as gates and muxes, may inherit
the duty cycle ratio of its parent clock. If a clock does not provide a
get_duty_cycle() callback and has CLK_DUTY_CYCLE_PARENT, then the call
will be directly forwarded to its parent clock, if any. For
set_duty_cycle(), the clock should also have CLK_SET_RATE_PARENT for the
call to be forwarded
Signed-off-by: Jerome Brunet <jbrunet@baylibre.com>
Signed-off-by: Michael Turquette <mturquette@baylibre.com>
Link: lkml.kernel.org/r/20180619144141.8506-1-jbrunet@baylibre.com
2018-06-19 22:41:41 +08:00
|
|
|
* @get_duty_cycle: Queries the hardware to get the current duty cycle ratio
|
|
|
|
* of a clock. Returned values denominator cannot be 0 and must be
|
|
|
|
* superior or equal to the numerator.
|
|
|
|
*
|
|
|
|
* @set_duty_cycle: Apply the duty cycle ratio to this clock signal specified by
|
|
|
|
* the numerator (2nd argurment) and denominator (3rd argument).
|
|
|
|
* Argument must be a valid ratio (denominator > 0
|
|
|
|
* and >= numerator) Return 0 on success, otherwise -EERROR.
|
|
|
|
*
|
2014-04-22 21:11:42 +08:00
|
|
|
* @init: Perform platform-specific initialization magic.
|
2020-07-19 08:28:30 +08:00
|
|
|
* This is not used by any of the basic clock types.
|
2019-09-24 20:39:53 +08:00
|
|
|
* This callback exist for HW which needs to perform some
|
|
|
|
* initialisation magic for CCF to get an accurate view of the
|
|
|
|
* clock. It may also be used dynamic resource allocation is
|
|
|
|
* required. It shall not used to deal with clock parameters,
|
|
|
|
* such as rate or parents.
|
|
|
|
* Returns 0 on success, -EERROR otherwise.
|
2014-04-22 21:11:42 +08:00
|
|
|
*
|
2019-09-24 20:39:54 +08:00
|
|
|
* @terminate: Free any resource allocated by init.
|
|
|
|
*
|
2014-03-21 19:43:56 +08:00
|
|
|
* @debug_init: Set up type-specific debugfs entries for this clock. This
|
|
|
|
* is called once, after the debugfs directory entry for this
|
|
|
|
* clock has been created. The dentry pointer representing that
|
|
|
|
* directory is provided as an argument. Called with
|
|
|
|
* prepare_lock held. Returns 0 on success, -EERROR otherwise.
|
|
|
|
*
|
2014-01-16 02:47:22 +08:00
|
|
|
*
|
2012-03-16 14:11:19 +08:00
|
|
|
* The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow
|
|
|
|
* implementations to split any work between atomic (enable) and sleepable
|
|
|
|
* (prepare) contexts. If enabling a clock requires code that might sleep,
|
|
|
|
* this must be done in clk_prepare. Clock enable code that will never be
|
2012-10-04 14:38:54 +08:00
|
|
|
* called in a sleepable context may be implemented in clk_enable.
|
2012-03-16 14:11:19 +08:00
|
|
|
*
|
|
|
|
* Typically, drivers will call clk_prepare when a clock may be needed later
|
|
|
|
* (eg. when a device is opened), and clk_enable when the clock is actually
|
|
|
|
* required (eg. from an interrupt). Note that clk_prepare MUST have been
|
|
|
|
* called before clk_enable.
|
|
|
|
*/
|
|
|
|
struct clk_ops {
|
|
|
|
int (*prepare)(struct clk_hw *hw);
|
|
|
|
void (*unprepare)(struct clk_hw *hw);
|
2013-03-13 03:26:02 +08:00
|
|
|
int (*is_prepared)(struct clk_hw *hw);
|
2013-03-13 03:26:04 +08:00
|
|
|
void (*unprepare_unused)(struct clk_hw *hw);
|
2012-03-16 14:11:19 +08:00
|
|
|
int (*enable)(struct clk_hw *hw);
|
|
|
|
void (*disable)(struct clk_hw *hw);
|
|
|
|
int (*is_enabled)(struct clk_hw *hw);
|
2012-12-05 03:00:35 +08:00
|
|
|
void (*disable_unused)(struct clk_hw *hw);
|
2018-09-04 14:49:35 +08:00
|
|
|
int (*save_context)(struct clk_hw *hw);
|
|
|
|
void (*restore_context)(struct clk_hw *hw);
|
2012-03-16 14:11:19 +08:00
|
|
|
unsigned long (*recalc_rate)(struct clk_hw *hw,
|
|
|
|
unsigned long parent_rate);
|
2014-04-22 21:11:42 +08:00
|
|
|
long (*round_rate)(struct clk_hw *hw, unsigned long rate,
|
|
|
|
unsigned long *parent_rate);
|
2015-07-08 02:48:08 +08:00
|
|
|
int (*determine_rate)(struct clk_hw *hw,
|
|
|
|
struct clk_rate_request *req);
|
2012-03-16 14:11:19 +08:00
|
|
|
int (*set_parent)(struct clk_hw *hw, u8 index);
|
|
|
|
u8 (*get_parent)(struct clk_hw *hw);
|
2014-04-22 21:11:42 +08:00
|
|
|
int (*set_rate)(struct clk_hw *hw, unsigned long rate,
|
|
|
|
unsigned long parent_rate);
|
2014-01-16 02:47:22 +08:00
|
|
|
int (*set_rate_and_parent)(struct clk_hw *hw,
|
|
|
|
unsigned long rate,
|
|
|
|
unsigned long parent_rate, u8 index);
|
2013-12-21 17:34:47 +08:00
|
|
|
unsigned long (*recalc_accuracy)(struct clk_hw *hw,
|
|
|
|
unsigned long parent_accuracy);
|
2014-07-14 19:53:27 +08:00
|
|
|
int (*get_phase)(struct clk_hw *hw);
|
2014-02-19 13:21:25 +08:00
|
|
|
int (*set_phase)(struct clk_hw *hw, int degrees);
|
clk: add duty cycle support
Add the possibility to apply and query the clock signal duty cycle ratio.
This is useful when the duty cycle of the clock signal depends on some
other parameters controlled by the clock framework.
For example, the duty cycle of a divider may depends on the raw divider
setting (ratio = N / div) , which is controlled by the CCF. In such case,
going through the pwm framework to control the duty cycle ratio of this
clock would be a burden.
A clock provider is not required to implement the operation to set and get
the duty cycle. If it does not implement .get_duty_cycle(), the ratio is
assumed to be 50%.
This change also adds a new flag, CLK_DUTY_CYCLE_PARENT. This flag should
be used to indicate that a clock, such as gates and muxes, may inherit
the duty cycle ratio of its parent clock. If a clock does not provide a
get_duty_cycle() callback and has CLK_DUTY_CYCLE_PARENT, then the call
will be directly forwarded to its parent clock, if any. For
set_duty_cycle(), the clock should also have CLK_SET_RATE_PARENT for the
call to be forwarded
Signed-off-by: Jerome Brunet <jbrunet@baylibre.com>
Signed-off-by: Michael Turquette <mturquette@baylibre.com>
Link: lkml.kernel.org/r/20180619144141.8506-1-jbrunet@baylibre.com
2018-06-19 22:41:41 +08:00
|
|
|
int (*get_duty_cycle)(struct clk_hw *hw,
|
|
|
|
struct clk_duty *duty);
|
|
|
|
int (*set_duty_cycle)(struct clk_hw *hw,
|
|
|
|
struct clk_duty *duty);
|
2019-09-24 20:39:53 +08:00
|
|
|
int (*init)(struct clk_hw *hw);
|
2019-09-24 20:39:54 +08:00
|
|
|
void (*terminate)(struct clk_hw *hw);
|
2018-06-02 12:42:07 +08:00
|
|
|
void (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
|
2012-03-16 14:11:19 +08:00
|
|
|
};
|
|
|
|
|
2019-04-13 02:31:47 +08:00
|
|
|
/**
|
|
|
|
* struct clk_parent_data - clk parent information
|
|
|
|
* @hw: parent clk_hw pointer (used for clk providers with internal clks)
|
|
|
|
* @fw_name: parent name local to provider registering clk
|
|
|
|
* @name: globally unique parent name (used as a fallback)
|
2019-04-13 02:31:49 +08:00
|
|
|
* @index: parent index local to provider registering clk (if @fw_name absent)
|
2019-04-13 02:31:47 +08:00
|
|
|
*/
|
|
|
|
struct clk_parent_data {
|
|
|
|
const struct clk_hw *hw;
|
|
|
|
const char *fw_name;
|
|
|
|
const char *name;
|
2019-04-13 02:31:49 +08:00
|
|
|
int index;
|
2019-04-13 02:31:47 +08:00
|
|
|
};
|
|
|
|
|
2012-04-26 13:58:56 +08:00
|
|
|
/**
|
|
|
|
* struct clk_init_data - holds init data that's common to all clocks and is
|
|
|
|
* shared between the clock provider and the common clock framework.
|
|
|
|
*
|
|
|
|
* @name: clock name
|
|
|
|
* @ops: operations this clock supports
|
|
|
|
* @parent_names: array of string names for all possible parents
|
2019-04-13 02:31:47 +08:00
|
|
|
* @parent_data: array of parent data for all possible parents (when some
|
|
|
|
* parents are external to the clk controller)
|
|
|
|
* @parent_hws: array of pointers to all possible parents (when all parents
|
|
|
|
* are internal to the clk controller)
|
2012-04-26 13:58:56 +08:00
|
|
|
* @num_parents: number of possible parents
|
|
|
|
* @flags: framework-level hints and quirks
|
|
|
|
*/
|
|
|
|
struct clk_init_data {
|
|
|
|
const char *name;
|
|
|
|
const struct clk_ops *ops;
|
2019-04-13 02:31:47 +08:00
|
|
|
/* Only one of the following three should be assigned */
|
2015-04-01 02:16:52 +08:00
|
|
|
const char * const *parent_names;
|
2019-04-13 02:31:47 +08:00
|
|
|
const struct clk_parent_data *parent_data;
|
|
|
|
const struct clk_hw **parent_hws;
|
2012-04-26 13:58:56 +08:00
|
|
|
u8 num_parents;
|
|
|
|
unsigned long flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct clk_hw - handle for traversing from a struct clk to its corresponding
|
|
|
|
* hardware-specific structure. struct clk_hw should be declared within struct
|
|
|
|
* clk_foo and then referenced by the struct clk instance that uses struct
|
|
|
|
* clk_foo's clk_ops
|
|
|
|
*
|
2015-01-23 19:03:30 +08:00
|
|
|
* @core: pointer to the struct clk_core instance that points back to this
|
|
|
|
* struct clk_hw instance
|
|
|
|
*
|
|
|
|
* @clk: pointer to the per-user struct clk instance that can be used to call
|
|
|
|
* into the clk API
|
2012-04-26 13:58:56 +08:00
|
|
|
*
|
|
|
|
* @init: pointer to struct clk_init_data that contains the init data shared
|
2019-08-01 03:35:17 +08:00
|
|
|
* with the common clock framework. This pointer will be set to NULL once
|
|
|
|
* a clk_register() variant is called on this clk_hw pointer.
|
2012-04-26 13:58:56 +08:00
|
|
|
*/
|
|
|
|
struct clk_hw {
|
2015-01-23 19:03:30 +08:00
|
|
|
struct clk_core *core;
|
2012-04-26 13:58:56 +08:00
|
|
|
struct clk *clk;
|
2012-05-14 22:12:42 +08:00
|
|
|
const struct clk_init_data *init;
|
2012-04-26 13:58:56 +08:00
|
|
|
};
|
|
|
|
|
2012-03-16 14:11:20 +08:00
|
|
|
/*
|
|
|
|
* DOC: Basic clock implementations common to many platforms
|
|
|
|
*
|
|
|
|
* Each basic clock hardware type is comprised of a structure describing the
|
|
|
|
* clock hardware, implementations of the relevant callbacks in struct clk_ops,
|
|
|
|
* unique flags for that hardware type, a registration function and an
|
|
|
|
* alternative macro for static initialization
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct clk_fixed_rate - fixed-rate clock
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @fixed_rate: constant frequency of clock
|
2019-08-30 23:09:16 +08:00
|
|
|
* @fixed_accuracy: constant accuracy of clock in ppb (parts per billion)
|
2019-08-30 23:09:17 +08:00
|
|
|
* @flags: hardware specific flags
|
2019-08-30 23:09:18 +08:00
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* * CLK_FIXED_RATE_PARENT_ACCURACY - Use the accuracy of the parent clk
|
|
|
|
* instead of what's set in @fixed_accuracy.
|
2012-03-16 14:11:20 +08:00
|
|
|
*/
|
|
|
|
struct clk_fixed_rate {
|
|
|
|
struct clk_hw hw;
|
|
|
|
unsigned long fixed_rate;
|
2013-12-21 17:34:48 +08:00
|
|
|
unsigned long fixed_accuracy;
|
2019-08-30 23:09:17 +08:00
|
|
|
unsigned long flags;
|
2012-03-16 14:11:20 +08:00
|
|
|
};
|
|
|
|
|
2019-08-30 23:09:18 +08:00
|
|
|
#define CLK_FIXED_RATE_PARENT_ACCURACY BIT(0)
|
2016-01-08 23:51:46 +08:00
|
|
|
|
2012-03-27 15:23:23 +08:00
|
|
|
extern const struct clk_ops clk_fixed_rate_ops;
|
2019-08-30 23:09:17 +08:00
|
|
|
struct clk_hw *__clk_hw_register_fixed_rate(struct device *dev,
|
|
|
|
struct device_node *np, const char *name,
|
|
|
|
const char *parent_name, const struct clk_hw *parent_hw,
|
|
|
|
const struct clk_parent_data *parent_data, unsigned long flags,
|
|
|
|
unsigned long fixed_rate, unsigned long fixed_accuracy,
|
|
|
|
unsigned long clk_fixed_flags);
|
2012-03-16 14:11:20 +08:00
|
|
|
struct clk *clk_register_fixed_rate(struct device *dev, const char *name,
|
|
|
|
const char *parent_name, unsigned long flags,
|
|
|
|
unsigned long fixed_rate);
|
2019-08-30 23:09:17 +08:00
|
|
|
/**
|
|
|
|
* clk_hw_register_fixed_rate - register fixed-rate clock with the clock
|
|
|
|
* framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @fixed_rate: non-adjustable clock rate
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_fixed_rate(dev, name, parent_name, flags, fixed_rate) \
|
|
|
|
__clk_hw_register_fixed_rate((dev), NULL, (name), (parent_name), NULL, \
|
|
|
|
NULL, (flags), (fixed_rate), 0, 0)
|
|
|
|
/**
|
|
|
|
* clk_hw_register_fixed_rate_parent_hw - register fixed-rate clock with
|
|
|
|
* the clock framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_hw: pointer to parent clk
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @fixed_rate: non-adjustable clock rate
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_fixed_rate_parent_hw(dev, name, parent_hw, flags, \
|
|
|
|
fixed_rate) \
|
|
|
|
__clk_hw_register_fixed_rate((dev), NULL, (name), NULL, (parent_hw), \
|
|
|
|
NULL, (flags), (fixed_rate), 0, 0)
|
|
|
|
/**
|
|
|
|
* clk_hw_register_fixed_rate_parent_data - register fixed-rate clock with
|
|
|
|
* the clock framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_data: parent clk data
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @fixed_rate: non-adjustable clock rate
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_fixed_rate_parent_data(dev, name, parent_hw, flags, \
|
|
|
|
fixed_rate) \
|
|
|
|
__clk_hw_register_fixed_rate((dev), NULL, (name), NULL, NULL, \
|
|
|
|
(parent_data), (flags), (fixed_rate), 0, \
|
|
|
|
0)
|
|
|
|
/**
|
|
|
|
* clk_hw_register_fixed_rate_with_accuracy - register fixed-rate clock with
|
|
|
|
* the clock framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @fixed_rate: non-adjustable clock rate
|
2019-08-30 23:09:19 +08:00
|
|
|
* @fixed_accuracy: non-adjustable clock accuracy
|
2019-08-30 23:09:17 +08:00
|
|
|
*/
|
|
|
|
#define clk_hw_register_fixed_rate_with_accuracy(dev, name, parent_name, \
|
|
|
|
flags, fixed_rate, \
|
|
|
|
fixed_accuracy) \
|
|
|
|
__clk_hw_register_fixed_rate((dev), NULL, (name), (parent_name), \
|
|
|
|
NULL, NULL, (flags), (fixed_rate), \
|
|
|
|
(fixed_accuracy), 0)
|
|
|
|
/**
|
|
|
|
* clk_hw_register_fixed_rate_with_accuracy_parent_hw - register fixed-rate
|
|
|
|
* clock with the clock framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_hw: pointer to parent clk
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @fixed_rate: non-adjustable clock rate
|
|
|
|
* @fixed_accuracy: non-adjustable clock accuracy
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_fixed_rate_with_accuracy_parent_hw(dev, name, \
|
|
|
|
parent_hw, flags, fixed_rate, fixed_accuracy) \
|
|
|
|
__clk_hw_register_fixed_rate((dev), NULL, (name), NULL, (parent_hw) \
|
|
|
|
NULL, NULL, (flags), (fixed_rate), \
|
|
|
|
(fixed_accuracy), 0)
|
|
|
|
/**
|
|
|
|
* clk_hw_register_fixed_rate_with_accuracy_parent_data - register fixed-rate
|
|
|
|
* clock with the clock framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @fixed_rate: non-adjustable clock rate
|
|
|
|
* @fixed_accuracy: non-adjustable clock accuracy
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_fixed_rate_with_accuracy_parent_data(dev, name, \
|
|
|
|
parent_data, flags, fixed_rate, fixed_accuracy) \
|
|
|
|
__clk_hw_register_fixed_rate((dev), NULL, (name), NULL, NULL, \
|
|
|
|
(parent_data), NULL, (flags), \
|
|
|
|
(fixed_rate), (fixed_accuracy), 0)
|
|
|
|
|
2016-01-06 12:25:10 +08:00
|
|
|
void clk_unregister_fixed_rate(struct clk *clk);
|
2016-05-22 13:33:35 +08:00
|
|
|
void clk_hw_unregister_fixed_rate(struct clk_hw *hw);
|
2016-02-07 16:34:13 +08:00
|
|
|
|
2012-04-08 10:39:39 +08:00
|
|
|
void of_fixed_clk_setup(struct device_node *np);
|
|
|
|
|
2012-03-16 14:11:20 +08:00
|
|
|
/**
|
|
|
|
* struct clk_gate - gating clock
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @reg: register controlling gate
|
|
|
|
* @bit_idx: single bit controlling gate
|
|
|
|
* @flags: hardware-specific flags
|
|
|
|
* @lock: register lock
|
|
|
|
*
|
|
|
|
* Clock which can gate its output. Implements .enable & .disable
|
|
|
|
*
|
|
|
|
* Flags:
|
2012-04-17 19:15:35 +08:00
|
|
|
* CLK_GATE_SET_TO_DISABLE - by default this clock sets the bit at bit_idx to
|
2014-04-22 21:11:41 +08:00
|
|
|
* enable the clock. Setting this flag does the opposite: setting the bit
|
|
|
|
* disable the clock and clearing it enables the clock
|
2013-06-08 22:47:19 +08:00
|
|
|
* CLK_GATE_HIWORD_MASK - The gate settings are only in lower 16-bit
|
2014-04-22 21:11:41 +08:00
|
|
|
* of this register, and mask of gate bits are in higher 16-bit of this
|
|
|
|
* register. While setting the gate bits, higher 16-bit should also be
|
|
|
|
* updated to indicate changing gate bits.
|
2019-04-18 19:12:06 +08:00
|
|
|
* CLK_GATE_BIG_ENDIAN - by default little endian register accesses are used for
|
|
|
|
* the gate register. Setting this flag makes the register accesses big
|
|
|
|
* endian.
|
2012-03-16 14:11:20 +08:00
|
|
|
*/
|
|
|
|
struct clk_gate {
|
|
|
|
struct clk_hw hw;
|
|
|
|
void __iomem *reg;
|
|
|
|
u8 bit_idx;
|
|
|
|
u8 flags;
|
|
|
|
spinlock_t *lock;
|
|
|
|
};
|
|
|
|
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_gate(_hw) container_of(_hw, struct clk_gate, hw)
|
|
|
|
|
2012-03-16 14:11:20 +08:00
|
|
|
#define CLK_GATE_SET_TO_DISABLE BIT(0)
|
2013-06-08 22:47:19 +08:00
|
|
|
#define CLK_GATE_HIWORD_MASK BIT(1)
|
2019-04-18 19:12:06 +08:00
|
|
|
#define CLK_GATE_BIG_ENDIAN BIT(2)
|
2012-03-16 14:11:20 +08:00
|
|
|
|
2012-03-27 15:23:23 +08:00
|
|
|
extern const struct clk_ops clk_gate_ops;
|
2019-08-30 23:09:22 +08:00
|
|
|
struct clk_hw *__clk_hw_register_gate(struct device *dev,
|
|
|
|
struct device_node *np, const char *name,
|
|
|
|
const char *parent_name, const struct clk_hw *parent_hw,
|
|
|
|
const struct clk_parent_data *parent_data,
|
|
|
|
unsigned long flags,
|
2012-03-16 14:11:20 +08:00
|
|
|
void __iomem *reg, u8 bit_idx,
|
|
|
|
u8 clk_gate_flags, spinlock_t *lock);
|
2019-08-30 23:09:22 +08:00
|
|
|
struct clk *clk_register_gate(struct device *dev, const char *name,
|
2016-02-07 15:54:45 +08:00
|
|
|
const char *parent_name, unsigned long flags,
|
|
|
|
void __iomem *reg, u8 bit_idx,
|
|
|
|
u8 clk_gate_flags, spinlock_t *lock);
|
2019-08-30 23:09:22 +08:00
|
|
|
/**
|
|
|
|
* clk_hw_register_gate - register a gate clock with the clock framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of this clock's parent
|
|
|
|
* @flags: framework-specific flags for this clock
|
|
|
|
* @reg: register address to control gating of this clock
|
|
|
|
* @bit_idx: which bit in the register controls gating of this clock
|
|
|
|
* @clk_gate_flags: gate-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_gate(dev, name, parent_name, flags, reg, bit_idx, \
|
|
|
|
clk_gate_flags, lock) \
|
|
|
|
__clk_hw_register_gate((dev), NULL, (name), (parent_name), NULL, \
|
|
|
|
NULL, (flags), (reg), (bit_idx), \
|
|
|
|
(clk_gate_flags), (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_gate_parent_hw - register a gate clock with the clock
|
|
|
|
* framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_hw: pointer to parent clk
|
|
|
|
* @flags: framework-specific flags for this clock
|
|
|
|
* @reg: register address to control gating of this clock
|
|
|
|
* @bit_idx: which bit in the register controls gating of this clock
|
|
|
|
* @clk_gate_flags: gate-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
2020-03-25 10:22:57 +08:00
|
|
|
#define clk_hw_register_gate_parent_hw(dev, name, parent_hw, flags, reg, \
|
2019-08-30 23:09:22 +08:00
|
|
|
bit_idx, clk_gate_flags, lock) \
|
2020-03-25 10:22:57 +08:00
|
|
|
__clk_hw_register_gate((dev), NULL, (name), NULL, (parent_hw), \
|
2019-08-30 23:09:22 +08:00
|
|
|
NULL, (flags), (reg), (bit_idx), \
|
|
|
|
(clk_gate_flags), (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_gate_parent_data - register a gate clock with the clock
|
|
|
|
* framework
|
|
|
|
* @dev: device that is registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_data: parent clk data
|
|
|
|
* @flags: framework-specific flags for this clock
|
|
|
|
* @reg: register address to control gating of this clock
|
|
|
|
* @bit_idx: which bit in the register controls gating of this clock
|
|
|
|
* @clk_gate_flags: gate-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
2020-03-25 10:22:57 +08:00
|
|
|
#define clk_hw_register_gate_parent_data(dev, name, parent_data, flags, reg, \
|
2019-08-30 23:09:22 +08:00
|
|
|
bit_idx, clk_gate_flags, lock) \
|
2020-03-25 10:22:57 +08:00
|
|
|
__clk_hw_register_gate((dev), NULL, (name), NULL, NULL, (parent_data), \
|
|
|
|
(flags), (reg), (bit_idx), \
|
2019-08-30 23:09:22 +08:00
|
|
|
(clk_gate_flags), (lock))
|
2015-01-05 17:52:40 +08:00
|
|
|
void clk_unregister_gate(struct clk *clk);
|
2016-02-07 15:54:45 +08:00
|
|
|
void clk_hw_unregister_gate(struct clk_hw *hw);
|
2017-08-21 19:59:01 +08:00
|
|
|
int clk_gate_is_enabled(struct clk_hw *hw);
|
2012-03-16 14:11:20 +08:00
|
|
|
|
2012-06-29 21:36:32 +08:00
|
|
|
struct clk_div_table {
|
|
|
|
unsigned int val;
|
|
|
|
unsigned int div;
|
|
|
|
};
|
|
|
|
|
2012-03-16 14:11:20 +08:00
|
|
|
/**
|
|
|
|
* struct clk_divider - adjustable divider clock
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @reg: register containing the divider
|
|
|
|
* @shift: shift to the divider bit field
|
|
|
|
* @width: width of the divider bit field
|
2012-06-29 21:36:32 +08:00
|
|
|
* @table: array of value/divider pairs, last entry should have div = 0
|
2012-03-16 14:11:20 +08:00
|
|
|
* @lock: register lock
|
|
|
|
*
|
|
|
|
* Clock with an adjustable divider affecting its output frequency. Implements
|
|
|
|
* .recalc_rate, .set_rate and .round_rate
|
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* CLK_DIVIDER_ONE_BASED - by default the divisor is the value read from the
|
2014-04-22 21:11:41 +08:00
|
|
|
* register plus one. If CLK_DIVIDER_ONE_BASED is set then the divider is
|
|
|
|
* the raw value read from the register, with the value of zero considered
|
2013-04-03 06:36:56 +08:00
|
|
|
* invalid, unless CLK_DIVIDER_ALLOW_ZERO is set.
|
2012-03-16 14:11:20 +08:00
|
|
|
* CLK_DIVIDER_POWER_OF_TWO - clock divisor is 2 raised to the value read from
|
2014-04-22 21:11:41 +08:00
|
|
|
* the hardware register
|
2013-04-03 06:36:56 +08:00
|
|
|
* CLK_DIVIDER_ALLOW_ZERO - Allow zero divisors. For dividers which have
|
|
|
|
* CLK_DIVIDER_ONE_BASED set, it is possible to end up with a zero divisor.
|
|
|
|
* Some hardware implementations gracefully handle this case and allow a
|
|
|
|
* zero divisor by not modifying their input clock
|
|
|
|
* (divide by one / bypass).
|
2013-06-08 22:47:18 +08:00
|
|
|
* CLK_DIVIDER_HIWORD_MASK - The divider settings are only in lower 16-bit
|
2014-04-22 21:11:41 +08:00
|
|
|
* of this register, and mask of divider bits are in higher 16-bit of this
|
|
|
|
* register. While setting the divider bits, higher 16-bit should also be
|
|
|
|
* updated to indicate changing divider bits.
|
2014-01-30 00:24:07 +08:00
|
|
|
* CLK_DIVIDER_ROUND_CLOSEST - Makes the best calculated divider to be rounded
|
|
|
|
* to the closest integer instead of the up one.
|
2014-05-23 21:02:15 +08:00
|
|
|
* CLK_DIVIDER_READ_ONLY - The divider settings are preconfigured and should
|
|
|
|
* not be changed by the clock framework.
|
2015-05-16 03:45:47 +08:00
|
|
|
* CLK_DIVIDER_MAX_AT_ZERO - For dividers which are like CLK_DIVIDER_ONE_BASED
|
|
|
|
* except when the value read from the register is zero, the divisor is
|
|
|
|
* 2^width of the field.
|
2019-04-18 19:12:04 +08:00
|
|
|
* CLK_DIVIDER_BIG_ENDIAN - By default little endian register accesses are used
|
|
|
|
* for the divider register. Setting this flag makes the register accesses
|
|
|
|
* big endian.
|
2012-03-16 14:11:20 +08:00
|
|
|
*/
|
|
|
|
struct clk_divider {
|
|
|
|
struct clk_hw hw;
|
|
|
|
void __iomem *reg;
|
|
|
|
u8 shift;
|
|
|
|
u8 width;
|
|
|
|
u8 flags;
|
2012-06-29 21:36:32 +08:00
|
|
|
const struct clk_div_table *table;
|
2012-03-16 14:11:20 +08:00
|
|
|
spinlock_t *lock;
|
|
|
|
};
|
|
|
|
|
2018-02-14 21:43:33 +08:00
|
|
|
#define clk_div_mask(width) ((1 << (width)) - 1)
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_divider(_hw) container_of(_hw, struct clk_divider, hw)
|
|
|
|
|
2012-03-16 14:11:20 +08:00
|
|
|
#define CLK_DIVIDER_ONE_BASED BIT(0)
|
|
|
|
#define CLK_DIVIDER_POWER_OF_TWO BIT(1)
|
2013-04-03 06:36:56 +08:00
|
|
|
#define CLK_DIVIDER_ALLOW_ZERO BIT(2)
|
2013-06-08 22:47:18 +08:00
|
|
|
#define CLK_DIVIDER_HIWORD_MASK BIT(3)
|
2014-01-30 00:24:07 +08:00
|
|
|
#define CLK_DIVIDER_ROUND_CLOSEST BIT(4)
|
2014-05-23 21:02:15 +08:00
|
|
|
#define CLK_DIVIDER_READ_ONLY BIT(5)
|
2015-05-16 03:45:47 +08:00
|
|
|
#define CLK_DIVIDER_MAX_AT_ZERO BIT(6)
|
2019-04-18 19:12:04 +08:00
|
|
|
#define CLK_DIVIDER_BIG_ENDIAN BIT(7)
|
2012-03-16 14:11:20 +08:00
|
|
|
|
2012-03-27 15:23:23 +08:00
|
|
|
extern const struct clk_ops clk_divider_ops;
|
2016-01-22 04:53:09 +08:00
|
|
|
extern const struct clk_ops clk_divider_ro_ops;
|
2015-01-20 10:05:29 +08:00
|
|
|
|
|
|
|
unsigned long divider_recalc_rate(struct clk_hw *hw, unsigned long parent_rate,
|
|
|
|
unsigned int val, const struct clk_div_table *table,
|
2017-12-22 00:30:54 +08:00
|
|
|
unsigned long flags, unsigned long width);
|
2017-05-17 15:40:30 +08:00
|
|
|
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);
|
2018-02-14 21:43:39 +08:00
|
|
|
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);
|
2015-01-20 10:05:29 +08:00
|
|
|
int divider_get_val(unsigned long rate, unsigned long parent_rate,
|
|
|
|
const struct clk_div_table *table, u8 width,
|
|
|
|
unsigned long flags);
|
|
|
|
|
2019-08-30 23:09:23 +08:00
|
|
|
struct clk_hw *__clk_hw_register_divider(struct device *dev,
|
|
|
|
struct device_node *np, const char *name,
|
|
|
|
const char *parent_name, const struct clk_hw *parent_hw,
|
|
|
|
const struct clk_parent_data *parent_data, unsigned long flags,
|
|
|
|
void __iomem *reg, u8 shift, u8 width, u8 clk_divider_flags,
|
|
|
|
const struct clk_div_table *table, spinlock_t *lock);
|
2020-11-09 02:51:09 +08:00
|
|
|
struct clk_hw *__devm_clk_hw_register_divider(struct device *dev,
|
|
|
|
struct device_node *np, const char *name,
|
|
|
|
const char *parent_name, const struct clk_hw *parent_hw,
|
|
|
|
const struct clk_parent_data *parent_data, unsigned long flags,
|
|
|
|
void __iomem *reg, u8 shift, u8 width, u8 clk_divider_flags,
|
|
|
|
const struct clk_div_table *table, spinlock_t *lock);
|
2012-06-29 21:36:32 +08:00
|
|
|
struct clk *clk_register_divider_table(struct device *dev, const char *name,
|
|
|
|
const char *parent_name, unsigned long flags,
|
|
|
|
void __iomem *reg, u8 shift, u8 width,
|
|
|
|
u8 clk_divider_flags, const struct clk_div_table *table,
|
|
|
|
spinlock_t *lock);
|
2019-08-30 23:09:23 +08:00
|
|
|
/**
|
|
|
|
* clk_register_divider - register a divider clock with the clock framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_register_divider(dev, name, parent_name, flags, reg, shift, width, \
|
|
|
|
clk_divider_flags, lock) \
|
|
|
|
clk_register_divider_table((dev), (name), (parent_name), (flags), \
|
|
|
|
(reg), (shift), (width), \
|
|
|
|
(clk_divider_flags), NULL, (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_divider - register a divider clock with the clock framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_divider(dev, name, parent_name, flags, reg, shift, \
|
|
|
|
width, clk_divider_flags, lock) \
|
|
|
|
__clk_hw_register_divider((dev), NULL, (name), (parent_name), NULL, \
|
|
|
|
NULL, (flags), (reg), (shift), (width), \
|
|
|
|
(clk_divider_flags), NULL, (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_divider_parent_hw - register a divider clock with the clock
|
|
|
|
* framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_hw: pointer to parent clk
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_divider_parent_hw(dev, name, parent_hw, flags, reg, \
|
|
|
|
shift, width, clk_divider_flags, \
|
|
|
|
lock) \
|
|
|
|
__clk_hw_register_divider((dev), NULL, (name), NULL, (parent_hw), \
|
|
|
|
NULL, (flags), (reg), (shift), (width), \
|
|
|
|
(clk_divider_flags), NULL, (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_divider_parent_data - register a divider clock with the clock
|
|
|
|
* framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_data: parent clk data
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_divider_parent_data(dev, name, parent_data, flags, \
|
|
|
|
reg, shift, width, \
|
|
|
|
clk_divider_flags, lock) \
|
|
|
|
__clk_hw_register_divider((dev), NULL, (name), NULL, NULL, \
|
|
|
|
(parent_data), (flags), (reg), (shift), \
|
|
|
|
(width), (clk_divider_flags), NULL, (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_divider_table - register a table based divider clock with
|
|
|
|
* the clock framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @table: array of divider/value pairs ending with a div set to 0
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_divider_table(dev, name, parent_name, flags, reg, \
|
|
|
|
shift, width, clk_divider_flags, table, \
|
|
|
|
lock) \
|
|
|
|
__clk_hw_register_divider((dev), NULL, (name), (parent_name), NULL, \
|
|
|
|
NULL, (flags), (reg), (shift), (width), \
|
|
|
|
(clk_divider_flags), (table), (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_divider_table_parent_hw - register a table based divider
|
|
|
|
* clock with the clock framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_hw: pointer to parent clk
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @table: array of divider/value pairs ending with a div set to 0
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_divider_table_parent_hw(dev, name, parent_hw, flags, \
|
|
|
|
reg, shift, width, \
|
|
|
|
clk_divider_flags, table, \
|
|
|
|
lock) \
|
|
|
|
__clk_hw_register_divider((dev), NULL, (name), NULL, (parent_hw), \
|
|
|
|
NULL, (flags), (reg), (shift), (width), \
|
|
|
|
(clk_divider_flags), (table), (lock))
|
|
|
|
/**
|
|
|
|
* clk_hw_register_divider_table_parent_data - register a table based divider
|
|
|
|
* clock with the clock framework
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_data: parent clk data
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @table: array of divider/value pairs ending with a div set to 0
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define clk_hw_register_divider_table_parent_data(dev, name, parent_data, \
|
|
|
|
flags, reg, shift, width, \
|
|
|
|
clk_divider_flags, table, \
|
|
|
|
lock) \
|
|
|
|
__clk_hw_register_divider((dev), NULL, (name), NULL, NULL, \
|
|
|
|
(parent_data), (flags), (reg), (shift), \
|
|
|
|
(width), (clk_divider_flags), (table), \
|
|
|
|
(lock))
|
2020-11-09 02:51:09 +08:00
|
|
|
/**
|
|
|
|
* devm_clk_hw_register_divider_table - register a table based divider clock
|
|
|
|
* with the clock framework (devres variant)
|
|
|
|
* @dev: device registering this clock
|
|
|
|
* @name: name of this clock
|
|
|
|
* @parent_name: name of clock's parent
|
|
|
|
* @flags: framework-specific flags
|
|
|
|
* @reg: register address to adjust divider
|
|
|
|
* @shift: number of bits to shift the bitfield
|
|
|
|
* @width: width of the bitfield
|
|
|
|
* @clk_divider_flags: divider-specific flags for this clock
|
|
|
|
* @table: array of divider/value pairs ending with a div set to 0
|
|
|
|
* @lock: shared register lock for this clock
|
|
|
|
*/
|
|
|
|
#define devm_clk_hw_register_divider_table(dev, name, parent_name, flags, \
|
|
|
|
reg, shift, width, \
|
|
|
|
clk_divider_flags, table, lock) \
|
|
|
|
__devm_clk_hw_register_divider((dev), NULL, (name), (parent_name), \
|
|
|
|
NULL, NULL, (flags), (reg), (shift), \
|
|
|
|
(width), (clk_divider_flags), (table), \
|
|
|
|
(lock))
|
2019-08-30 23:09:23 +08:00
|
|
|
|
2015-01-05 17:52:40 +08:00
|
|
|
void clk_unregister_divider(struct clk *clk);
|
2016-02-07 15:26:37 +08:00
|
|
|
void clk_hw_unregister_divider(struct clk_hw *hw);
|
2012-03-16 14:11:20 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* struct clk_mux - multiplexer clock
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @reg: register controlling multiplexer
|
2018-02-14 21:43:38 +08:00
|
|
|
* @table: array of register values corresponding to the parent index
|
2012-03-16 14:11:20 +08:00
|
|
|
* @shift: shift to multiplexer bit field
|
2018-02-14 21:43:38 +08:00
|
|
|
* @mask: mask of mutliplexer bit field
|
2013-03-25 22:35:07 +08:00
|
|
|
* @flags: hardware-specific flags
|
2012-03-16 14:11:20 +08:00
|
|
|
* @lock: register lock
|
|
|
|
*
|
|
|
|
* Clock with multiple selectable parents. Implements .get_parent, .set_parent
|
|
|
|
* and .recalc_rate
|
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* CLK_MUX_INDEX_ONE - register index starts at 1, not 0
|
2012-04-17 19:15:35 +08:00
|
|
|
* CLK_MUX_INDEX_BIT - register index is a single bit (power of two)
|
2013-06-08 22:47:17 +08:00
|
|
|
* CLK_MUX_HIWORD_MASK - The mux settings are only in lower 16-bit of this
|
2014-04-22 21:11:41 +08:00
|
|
|
* register, and mask of mux bits are in higher 16-bit of this register.
|
|
|
|
* While setting the mux bits, higher 16-bit should also be updated to
|
|
|
|
* indicate changing mux bits.
|
2018-12-12 02:58:33 +08:00
|
|
|
* CLK_MUX_READ_ONLY - The mux registers can't be written, only read in the
|
|
|
|
* .get_parent clk_op.
|
2015-01-20 10:05:28 +08:00
|
|
|
* CLK_MUX_ROUND_CLOSEST - Use the parent rate that is closest to the desired
|
|
|
|
* frequency.
|
2019-04-18 19:12:08 +08:00
|
|
|
* CLK_MUX_BIG_ENDIAN - By default little endian register accesses are used for
|
|
|
|
* the mux register. Setting this flag makes the register accesses big
|
|
|
|
* endian.
|
2012-03-16 14:11:20 +08:00
|
|
|
*/
|
|
|
|
struct clk_mux {
|
|
|
|
struct clk_hw hw;
|
|
|
|
void __iomem *reg;
|
2013-03-22 20:07:53 +08:00
|
|
|
u32 *table;
|
|
|
|
u32 mask;
|
2012-03-16 14:11:20 +08:00
|
|
|
u8 shift;
|
|
|
|
u8 flags;
|
|
|
|
spinlock_t *lock;
|
|
|
|
};
|
|
|
|
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_mux(_hw) container_of(_hw, struct clk_mux, hw)
|
|
|
|
|
2012-03-16 14:11:20 +08:00
|
|
|
#define CLK_MUX_INDEX_ONE BIT(0)
|
|
|
|
#define CLK_MUX_INDEX_BIT BIT(1)
|
2013-06-08 22:47:17 +08:00
|
|
|
#define CLK_MUX_HIWORD_MASK BIT(2)
|
2015-01-20 10:05:28 +08:00
|
|
|
#define CLK_MUX_READ_ONLY BIT(3) /* mux can't be changed */
|
|
|
|
#define CLK_MUX_ROUND_CLOSEST BIT(4)
|
2019-04-18 19:12:08 +08:00
|
|
|
#define CLK_MUX_BIG_ENDIAN BIT(5)
|
2012-03-16 14:11:20 +08:00
|
|
|
|
2012-03-27 15:23:23 +08:00
|
|
|
extern const struct clk_ops clk_mux_ops;
|
2013-07-23 07:49:18 +08:00
|
|
|
extern const struct clk_ops clk_mux_ro_ops;
|
2013-03-22 20:07:53 +08:00
|
|
|
|
2019-08-30 23:09:21 +08:00
|
|
|
struct clk_hw *__clk_hw_register_mux(struct device *dev, struct device_node *np,
|
|
|
|
const char *name, u8 num_parents,
|
|
|
|
const char * const *parent_names,
|
|
|
|
const struct clk_hw **parent_hws,
|
|
|
|
const struct clk_parent_data *parent_data,
|
|
|
|
unsigned long flags, void __iomem *reg, u8 shift, u32 mask,
|
2013-03-22 20:07:53 +08:00
|
|
|
u8 clk_mux_flags, u32 *table, spinlock_t *lock);
|
2019-08-30 23:09:21 +08:00
|
|
|
struct clk *clk_register_mux_table(struct device *dev, const char *name,
|
2016-02-07 16:05:48 +08:00
|
|
|
const char * const *parent_names, u8 num_parents,
|
2019-08-30 23:09:21 +08:00
|
|
|
unsigned long flags, void __iomem *reg, u8 shift, u32 mask,
|
2016-02-07 16:05:48 +08:00
|
|
|
u8 clk_mux_flags, u32 *table, spinlock_t *lock);
|
2013-03-22 20:07:53 +08:00
|
|
|
|
2019-08-30 23:09:21 +08:00
|
|
|
#define clk_register_mux(dev, name, parent_names, num_parents, flags, reg, \
|
|
|
|
shift, width, clk_mux_flags, lock) \
|
|
|
|
clk_register_mux_table((dev), (name), (parent_names), (num_parents), \
|
|
|
|
(flags), (reg), (shift), BIT((width)) - 1, \
|
|
|
|
(clk_mux_flags), NULL, (lock))
|
|
|
|
#define clk_hw_register_mux_table(dev, name, parent_names, num_parents, \
|
|
|
|
flags, reg, shift, mask, clk_mux_flags, \
|
|
|
|
table, lock) \
|
|
|
|
__clk_hw_register_mux((dev), NULL, (name), (num_parents), \
|
|
|
|
(parent_names), NULL, NULL, (flags), (reg), \
|
|
|
|
(shift), (mask), (clk_mux_flags), (table), \
|
|
|
|
(lock))
|
|
|
|
#define clk_hw_register_mux(dev, name, parent_names, num_parents, flags, reg, \
|
|
|
|
shift, width, clk_mux_flags, lock) \
|
|
|
|
__clk_hw_register_mux((dev), NULL, (name), (num_parents), \
|
|
|
|
(parent_names), NULL, NULL, (flags), (reg), \
|
|
|
|
(shift), BIT((width)) - 1, (clk_mux_flags), \
|
|
|
|
NULL, (lock))
|
|
|
|
#define clk_hw_register_mux_hws(dev, name, parent_hws, num_parents, flags, \
|
|
|
|
reg, shift, width, clk_mux_flags, lock) \
|
|
|
|
__clk_hw_register_mux((dev), NULL, (name), (num_parents), NULL, \
|
|
|
|
(parent_hws), NULL, (flags), (reg), (shift), \
|
|
|
|
BIT((width)) - 1, (clk_mux_flags), NULL, (lock))
|
|
|
|
#define clk_hw_register_mux_parent_data(dev, name, parent_data, num_parents, \
|
|
|
|
flags, reg, shift, width, \
|
|
|
|
clk_mux_flags, lock) \
|
|
|
|
__clk_hw_register_mux((dev), NULL, (name), (num_parents), NULL, NULL, \
|
|
|
|
(parent_data), (flags), (reg), (shift), \
|
|
|
|
BIT((width)) - 1, (clk_mux_flags), NULL, (lock))
|
|
|
|
|
2018-02-14 21:43:34 +08:00
|
|
|
int clk_mux_val_to_index(struct clk_hw *hw, u32 *table, unsigned int flags,
|
|
|
|
unsigned int val);
|
|
|
|
unsigned int clk_mux_index_to_val(u32 *table, unsigned int flags, u8 index);
|
|
|
|
|
2015-01-05 17:52:40 +08:00
|
|
|
void clk_unregister_mux(struct clk *clk);
|
2016-02-07 16:05:48 +08:00
|
|
|
void clk_hw_unregister_mux(struct clk_hw *hw);
|
2015-01-05 17:52:40 +08:00
|
|
|
|
2013-04-12 19:57:44 +08:00
|
|
|
void of_fixed_factor_clk_setup(struct device_node *node);
|
|
|
|
|
2012-05-03 18:06:14 +08:00
|
|
|
/**
|
|
|
|
* struct clk_fixed_factor - fixed multiplier and divider clock
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @mult: multiplier
|
|
|
|
* @div: divider
|
|
|
|
*
|
|
|
|
* Clock with a fixed multiplier and divider. The output frequency is the
|
|
|
|
* parent clock rate divided by div and multiplied by mult.
|
|
|
|
* Implements .recalc_rate, .set_rate and .round_rate
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct clk_fixed_factor {
|
|
|
|
struct clk_hw hw;
|
|
|
|
unsigned int mult;
|
|
|
|
unsigned int div;
|
|
|
|
};
|
|
|
|
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_fixed_factor(_hw) container_of(_hw, struct clk_fixed_factor, hw)
|
|
|
|
|
2015-06-11 04:04:54 +08:00
|
|
|
extern const struct clk_ops clk_fixed_factor_ops;
|
2012-05-03 18:06:14 +08:00
|
|
|
struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
|
|
|
|
const char *parent_name, unsigned long flags,
|
|
|
|
unsigned int mult, unsigned int div);
|
2016-01-06 12:25:09 +08:00
|
|
|
void clk_unregister_fixed_factor(struct clk *clk);
|
2016-02-07 16:11:06 +08:00
|
|
|
struct clk_hw *clk_hw_register_fixed_factor(struct device *dev,
|
|
|
|
const char *name, const char *parent_name, unsigned long flags,
|
|
|
|
unsigned int mult, unsigned int div);
|
|
|
|
void clk_hw_unregister_fixed_factor(struct clk_hw *hw);
|
2021-02-11 13:22:02 +08:00
|
|
|
struct clk_hw *devm_clk_hw_register_fixed_factor(struct device *dev,
|
|
|
|
const char *name, const char *parent_name, unsigned long flags,
|
|
|
|
unsigned int mult, unsigned int div);
|
2014-05-15 21:40:25 +08:00
|
|
|
/**
|
|
|
|
* struct clk_fractional_divider - adjustable fractional divider clock
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @reg: register containing the divider
|
|
|
|
* @mshift: shift to the numerator bit field
|
|
|
|
* @mwidth: width of the numerator bit field
|
|
|
|
* @nshift: shift to the denominator bit field
|
|
|
|
* @nwidth: width of the denominator bit field
|
|
|
|
* @lock: register lock
|
|
|
|
*
|
|
|
|
* Clock with adjustable fractional divider affecting its output frequency.
|
2018-11-14 21:01:39 +08:00
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* CLK_FRAC_DIVIDER_ZERO_BASED - by default the numerator and denominator
|
|
|
|
* is the value read from the register. If CLK_FRAC_DIVIDER_ZERO_BASED
|
|
|
|
* is set then the numerator and denominator are both the value read
|
|
|
|
* plus one.
|
2019-04-18 19:12:05 +08:00
|
|
|
* CLK_FRAC_DIVIDER_BIG_ENDIAN - By default little endian register accesses are
|
|
|
|
* used for the divider register. Setting this flag makes the register
|
|
|
|
* accesses big endian.
|
2014-05-15 21:40:25 +08:00
|
|
|
*/
|
|
|
|
struct clk_fractional_divider {
|
|
|
|
struct clk_hw hw;
|
|
|
|
void __iomem *reg;
|
|
|
|
u8 mshift;
|
2015-09-22 23:54:09 +08:00
|
|
|
u8 mwidth;
|
2014-05-15 21:40:25 +08:00
|
|
|
u32 mmask;
|
|
|
|
u8 nshift;
|
2015-09-22 23:54:09 +08:00
|
|
|
u8 nwidth;
|
2014-05-15 21:40:25 +08:00
|
|
|
u32 nmask;
|
|
|
|
u8 flags;
|
2017-08-02 00:21:22 +08:00
|
|
|
void (*approximation)(struct clk_hw *hw,
|
|
|
|
unsigned long rate, unsigned long *parent_rate,
|
|
|
|
unsigned long *m, unsigned long *n);
|
2014-05-15 21:40:25 +08:00
|
|
|
spinlock_t *lock;
|
|
|
|
};
|
|
|
|
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_fd(_hw) container_of(_hw, struct clk_fractional_divider, hw)
|
|
|
|
|
2018-11-14 21:01:39 +08:00
|
|
|
#define CLK_FRAC_DIVIDER_ZERO_BASED BIT(0)
|
2019-04-18 19:12:05 +08:00
|
|
|
#define CLK_FRAC_DIVIDER_BIG_ENDIAN BIT(1)
|
2018-11-14 21:01:39 +08:00
|
|
|
|
2014-05-15 21:40:25 +08:00
|
|
|
extern const struct clk_ops clk_fractional_divider_ops;
|
|
|
|
struct clk *clk_register_fractional_divider(struct device *dev,
|
|
|
|
const char *name, const char *parent_name, unsigned long flags,
|
|
|
|
void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
|
|
|
|
u8 clk_divider_flags, spinlock_t *lock);
|
2016-02-07 16:15:09 +08:00
|
|
|
struct clk_hw *clk_hw_register_fractional_divider(struct device *dev,
|
|
|
|
const char *name, const char *parent_name, unsigned long flags,
|
|
|
|
void __iomem *reg, u8 mshift, u8 mwidth, u8 nshift, u8 nwidth,
|
|
|
|
u8 clk_divider_flags, spinlock_t *lock);
|
|
|
|
void clk_hw_unregister_fractional_divider(struct clk_hw *hw);
|
2014-05-15 21:40:25 +08:00
|
|
|
|
2015-05-20 04:19:33 +08:00
|
|
|
/**
|
|
|
|
* struct clk_multiplier - adjustable multiplier clock
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
|
|
|
* @reg: register containing the multiplier
|
|
|
|
* @shift: shift to the multiplier bit field
|
|
|
|
* @width: width of the multiplier bit field
|
|
|
|
* @lock: register lock
|
|
|
|
*
|
|
|
|
* Clock with an adjustable multiplier affecting its output frequency.
|
|
|
|
* Implements .recalc_rate, .set_rate and .round_rate
|
|
|
|
*
|
|
|
|
* Flags:
|
|
|
|
* CLK_MULTIPLIER_ZERO_BYPASS - By default, the multiplier is the value read
|
|
|
|
* from the register, with 0 being a valid value effectively
|
|
|
|
* zeroing the output clock rate. If CLK_MULTIPLIER_ZERO_BYPASS is
|
|
|
|
* set, then a null multiplier will be considered as a bypass,
|
|
|
|
* leaving the parent rate unmodified.
|
|
|
|
* CLK_MULTIPLIER_ROUND_CLOSEST - Makes the best calculated divider to be
|
|
|
|
* rounded to the closest integer instead of the down one.
|
2019-04-18 19:12:07 +08:00
|
|
|
* CLK_MULTIPLIER_BIG_ENDIAN - By default little endian register accesses are
|
|
|
|
* used for the multiplier register. Setting this flag makes the register
|
|
|
|
* accesses big endian.
|
2015-05-20 04:19:33 +08:00
|
|
|
*/
|
|
|
|
struct clk_multiplier {
|
|
|
|
struct clk_hw hw;
|
|
|
|
void __iomem *reg;
|
|
|
|
u8 shift;
|
|
|
|
u8 width;
|
|
|
|
u8 flags;
|
|
|
|
spinlock_t *lock;
|
|
|
|
};
|
|
|
|
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_multiplier(_hw) container_of(_hw, struct clk_multiplier, hw)
|
|
|
|
|
2015-05-20 04:19:33 +08:00
|
|
|
#define CLK_MULTIPLIER_ZERO_BYPASS BIT(0)
|
|
|
|
#define CLK_MULTIPLIER_ROUND_CLOSEST BIT(1)
|
2019-04-18 19:12:07 +08:00
|
|
|
#define CLK_MULTIPLIER_BIG_ENDIAN BIT(2)
|
2015-05-20 04:19:33 +08:00
|
|
|
|
|
|
|
extern const struct clk_ops clk_multiplier_ops;
|
|
|
|
|
2013-03-20 20:00:34 +08:00
|
|
|
/***
|
|
|
|
* struct clk_composite - aggregate clock of mux, divider and gate clocks
|
|
|
|
*
|
|
|
|
* @hw: handle between common and hardware-specific interfaces
|
2013-04-12 02:31:36 +08:00
|
|
|
* @mux_hw: handle between composite and hardware-specific mux clock
|
|
|
|
* @rate_hw: handle between composite and hardware-specific rate clock
|
|
|
|
* @gate_hw: handle between composite and hardware-specific gate clock
|
2013-03-20 20:00:34 +08:00
|
|
|
* @mux_ops: clock ops for mux
|
2013-04-12 02:31:36 +08:00
|
|
|
* @rate_ops: clock ops for rate
|
2013-03-20 20:00:34 +08:00
|
|
|
* @gate_ops: clock ops for gate
|
|
|
|
*/
|
|
|
|
struct clk_composite {
|
|
|
|
struct clk_hw hw;
|
|
|
|
struct clk_ops ops;
|
|
|
|
|
|
|
|
struct clk_hw *mux_hw;
|
2013-04-12 02:31:36 +08:00
|
|
|
struct clk_hw *rate_hw;
|
2013-03-20 20:00:34 +08:00
|
|
|
struct clk_hw *gate_hw;
|
|
|
|
|
|
|
|
const struct clk_ops *mux_ops;
|
2013-04-12 02:31:36 +08:00
|
|
|
const struct clk_ops *rate_ops;
|
2013-03-20 20:00:34 +08:00
|
|
|
const struct clk_ops *gate_ops;
|
|
|
|
};
|
|
|
|
|
2016-01-08 23:51:46 +08:00
|
|
|
#define to_clk_composite(_hw) container_of(_hw, struct clk_composite, hw)
|
|
|
|
|
2013-03-20 20:00:34 +08:00
|
|
|
struct clk *clk_register_composite(struct device *dev, const char *name,
|
2015-04-01 02:16:52 +08:00
|
|
|
const char * const *parent_names, int num_parents,
|
2013-03-20 20:00:34 +08:00
|
|
|
struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
|
2013-04-12 02:31:36 +08:00
|
|
|
struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
|
2013-03-20 20:00:34 +08:00
|
|
|
struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
|
|
|
|
unsigned long flags);
|
2020-01-03 07:10:59 +08:00
|
|
|
struct clk *clk_register_composite_pdata(struct device *dev, const char *name,
|
|
|
|
const struct clk_parent_data *parent_data, int num_parents,
|
|
|
|
struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
|
|
|
|
struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
|
|
|
|
struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
|
|
|
|
unsigned long flags);
|
2016-03-24 00:38:24 +08:00
|
|
|
void clk_unregister_composite(struct clk *clk);
|
2016-02-07 16:20:31 +08:00
|
|
|
struct clk_hw *clk_hw_register_composite(struct device *dev, const char *name,
|
|
|
|
const char * const *parent_names, int num_parents,
|
|
|
|
struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
|
|
|
|
struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
|
|
|
|
struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
|
|
|
|
unsigned long flags);
|
2020-01-03 07:10:59 +08:00
|
|
|
struct clk_hw *clk_hw_register_composite_pdata(struct device *dev,
|
|
|
|
const char *name,
|
|
|
|
const struct clk_parent_data *parent_data, int num_parents,
|
2016-02-07 16:20:31 +08:00
|
|
|
struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
|
|
|
|
struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
|
|
|
|
struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
|
|
|
|
unsigned long flags);
|
2020-11-06 03:27:45 +08:00
|
|
|
struct clk_hw *devm_clk_hw_register_composite_pdata(struct device *dev,
|
|
|
|
const char *name, const struct clk_parent_data *parent_data,
|
|
|
|
int num_parents,
|
|
|
|
struct clk_hw *mux_hw, const struct clk_ops *mux_ops,
|
|
|
|
struct clk_hw *rate_hw, const struct clk_ops *rate_ops,
|
2016-02-07 16:20:31 +08:00
|
|
|
struct clk_hw *gate_hw, const struct clk_ops *gate_ops,
|
|
|
|
unsigned long flags);
|
|
|
|
void clk_hw_unregister_composite(struct clk_hw *hw);
|
2013-03-20 20:00:34 +08:00
|
|
|
|
2012-04-26 13:58:56 +08:00
|
|
|
struct clk *clk_register(struct device *dev, struct clk_hw *hw);
|
2012-09-25 04:38:04 +08:00
|
|
|
struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw);
|
2012-03-16 14:11:19 +08:00
|
|
|
|
2016-02-06 09:02:52 +08:00
|
|
|
int __must_check clk_hw_register(struct device *dev, struct clk_hw *hw);
|
|
|
|
int __must_check devm_clk_hw_register(struct device *dev, struct clk_hw *hw);
|
2019-04-13 02:31:46 +08:00
|
|
|
int __must_check of_clk_hw_register(struct device_node *node, struct clk_hw *hw);
|
2016-02-06 09:02:52 +08:00
|
|
|
|
2012-04-18 16:07:12 +08:00
|
|
|
void clk_unregister(struct clk *clk);
|
2012-09-25 04:38:04 +08:00
|
|
|
void devm_clk_unregister(struct device *dev, struct clk *clk);
|
2012-04-18 16:07:12 +08:00
|
|
|
|
2016-02-06 09:02:52 +08:00
|
|
|
void clk_hw_unregister(struct clk_hw *hw);
|
|
|
|
void devm_clk_hw_unregister(struct device *dev, struct clk_hw *hw);
|
|
|
|
|
2012-03-16 14:11:19 +08:00
|
|
|
/* helper functions */
|
2015-10-16 20:35:21 +08:00
|
|
|
const char *__clk_get_name(const struct clk *clk);
|
2015-08-13 04:04:56 +08:00
|
|
|
const char *clk_hw_get_name(const struct clk_hw *hw);
|
2019-07-02 10:03:50 +08:00
|
|
|
#ifdef CONFIG_COMMON_CLK
|
2012-03-16 14:11:19 +08:00
|
|
|
struct clk_hw *__clk_get_hw(struct clk *clk);
|
2019-07-02 10:03:50 +08:00
|
|
|
#else
|
|
|
|
static inline struct clk_hw *__clk_get_hw(struct clk *clk)
|
|
|
|
{
|
|
|
|
return (struct clk_hw *)clk;
|
|
|
|
}
|
|
|
|
#endif
|
2020-10-22 00:21:46 +08:00
|
|
|
|
|
|
|
struct clk *clk_hw_get_clk(struct clk_hw *hw, const char *con_id);
|
|
|
|
struct clk *devm_clk_hw_get_clk(struct device *dev, struct clk_hw *hw,
|
|
|
|
const char *con_id);
|
|
|
|
|
2015-08-13 04:04:56 +08:00
|
|
|
unsigned int clk_hw_get_num_parents(const struct clk_hw *hw);
|
|
|
|
struct clk_hw *clk_hw_get_parent(const struct clk_hw *hw);
|
|
|
|
struct clk_hw *clk_hw_get_parent_by_index(const struct clk_hw *hw,
|
2015-06-26 06:55:14 +08:00
|
|
|
unsigned int index);
|
2019-08-17 03:41:52 +08:00
|
|
|
int clk_hw_get_parent_index(struct clk_hw *hw);
|
2019-07-31 16:40:16 +08:00
|
|
|
int clk_hw_set_parent(struct clk_hw *hw, struct clk_hw *new_parent);
|
2012-12-12 03:25:08 +08:00
|
|
|
unsigned int __clk_get_enable_count(struct clk *clk);
|
2015-08-13 04:04:56 +08:00
|
|
|
unsigned long clk_hw_get_rate(const struct clk_hw *hw);
|
|
|
|
unsigned long clk_hw_get_flags(const struct clk_hw *hw);
|
clk: fractional-divider: check parent rate only if flag is set
Custom approximation of fractional-divider may not need parent clock
rate checking. For example Rockchip SoCs work fine using grand parent
clock rate even if target rate is greater than parent.
This patch checks parent clock rate only if CLK_SET_RATE_PARENT flag
is set.
For detailed example, clock tree of Rockchip I2S audio hardware.
- Clock rate of CPLL is 1.2GHz, GPLL is 491.52MHz.
- i2s1_div is integer divider can divide N (N is 1~128).
Input clock is CPLL or GPLL. Initial divider value is N = 1.
Ex) PLL = CPLL, N = 10, i2s1_div output rate is
CPLL / 10 = 1.2GHz / 10 = 120MHz
- i2s1_frac is fractional divider can divide input to x/y, x and
y are 16bit integer.
CPLL --> | selector | ---> i2s1_div -+--> | selector | --> I2S1 MCLK
GPLL --> | | ,--------------' | |
`--> i2s1_frac ---> | |
Clock mux system try to choose suitable one from i2s1_div and
i2s1_frac for master clock (MCLK) of I2S1.
Bad scenario as follows:
- Try to set MCLK to 8.192MHz (32kHz audio replay)
Candidate setting is
- i2s1_div: GPLL / 60 = 8.192MHz
i2s1_div candidate is exactly same as target clock rate, so mux
choose this clock source. i2s1_div output rate is changed
491.52MHz -> 8.192MHz
- After that try to set to 11.2896MHz (44.1kHz audio replay)
Candidate settings are
- i2s1_div : CPLL / 107 = 11.214945MHz
- i2s1_frac: i2s1_div = 8.192MHz
This is because clk_fd_round_rate() thinks target rate
(11.2896MHz) is higher than parent rate (i2s1_div = 8.192MHz)
and returns parent clock rate.
Above is current upstreamed behavior. Clock mux system choose
i2s1_div, but this clock rate is not acceptable for I2S driver, so
users cannot replay audio.
Expected behavior is:
- Try to set master clock to 11.2896MHz (44.1kHz audio replay)
Candidate settings are
- i2s1_div : CPLL / 107 = 11.214945MHz
- i2s1_frac: i2s1_div * 147/6400 = 11.2896MHz
Change i2s1_div to GPLL / 1 = 491.52MHz at same
time.
If apply this commit, clk_fd_round_rate() calls custom approximate
function of Rockchip even if target rate is higher than parent.
Custom function changes both grand parent (i2s1_div) and parent
(i2s_frac) settings at same time. Clock mux system can choose
i2s1_frac and audio works fine.
Signed-off-by: Katsuhiro Suzuki <katsuhiro@katsuster.net>
Reviewed-by: Heiko Stuebner <heiko@sntech.de>
[sboyd@kernel.org: Make function into a macro instead]
Signed-off-by: Stephen Boyd <sboyd@kernel.org>
2019-02-10 23:38:06 +08:00
|
|
|
#define clk_hw_can_set_rate_parent(hw) \
|
|
|
|
(clk_hw_get_flags((hw)) & CLK_SET_RATE_PARENT)
|
|
|
|
|
2015-08-13 04:04:56 +08:00
|
|
|
bool clk_hw_is_prepared(const struct clk_hw *hw);
|
2017-12-02 05:51:56 +08:00
|
|
|
bool clk_hw_rate_is_protected(const struct clk_hw *hw);
|
2015-10-25 00:55:22 +08:00
|
|
|
bool clk_hw_is_enabled(const struct clk_hw *hw);
|
2012-10-04 14:38:55 +08:00
|
|
|
bool __clk_is_enabled(struct clk *clk);
|
2012-03-16 14:11:19 +08:00
|
|
|
struct clk *__clk_lookup(const char *name);
|
2015-07-08 02:48:08 +08:00
|
|
|
int __clk_mux_determine_rate(struct clk_hw *hw,
|
|
|
|
struct clk_rate_request *req);
|
|
|
|
int __clk_determine_rate(struct clk_hw *core, struct clk_rate_request *req);
|
|
|
|
int __clk_mux_determine_rate_closest(struct clk_hw *hw,
|
|
|
|
struct clk_rate_request *req);
|
2018-04-09 21:59:20 +08:00
|
|
|
int clk_mux_determine_rate_flags(struct clk_hw *hw,
|
|
|
|
struct clk_rate_request *req,
|
|
|
|
unsigned long flags);
|
2015-03-11 18:34:25 +08:00
|
|
|
void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent);
|
2015-07-17 03:50:27 +08:00
|
|
|
void clk_hw_set_rate_range(struct clk_hw *hw, unsigned long min_rate,
|
|
|
|
unsigned long max_rate);
|
2012-03-16 14:11:19 +08:00
|
|
|
|
2015-02-12 21:58:29 +08:00
|
|
|
static inline void __clk_hw_set_clk(struct clk_hw *dst, struct clk_hw *src)
|
|
|
|
{
|
|
|
|
dst->clk = src->clk;
|
|
|
|
dst->core = src->core;
|
|
|
|
}
|
|
|
|
|
2017-05-17 15:40:30 +08:00
|
|
|
static inline long divider_round_rate(struct clk_hw *hw, unsigned long rate,
|
|
|
|
unsigned long *prate,
|
|
|
|
const struct clk_div_table *table,
|
|
|
|
u8 width, unsigned long flags)
|
|
|
|
{
|
|
|
|
return divider_round_rate_parent(hw, clk_hw_get_parent(hw),
|
|
|
|
rate, prate, table, width, flags);
|
|
|
|
}
|
|
|
|
|
2018-02-14 21:43:39 +08:00
|
|
|
static inline long divider_ro_round_rate(struct clk_hw *hw, unsigned long rate,
|
|
|
|
unsigned long *prate,
|
|
|
|
const struct clk_div_table *table,
|
|
|
|
u8 width, unsigned long flags,
|
|
|
|
unsigned int val)
|
|
|
|
{
|
|
|
|
return divider_ro_round_rate_parent(hw, clk_hw_get_parent(hw),
|
|
|
|
rate, prate, table, width, flags,
|
|
|
|
val);
|
|
|
|
}
|
|
|
|
|
2012-03-16 14:11:19 +08:00
|
|
|
/*
|
|
|
|
* FIXME clock api without lock protection
|
|
|
|
*/
|
2015-06-26 06:55:14 +08:00
|
|
|
unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate);
|
2012-03-16 14:11:19 +08:00
|
|
|
|
2013-05-01 08:58:28 +08:00
|
|
|
struct clk_onecell_data {
|
|
|
|
struct clk **clks;
|
|
|
|
unsigned int clk_num;
|
|
|
|
};
|
|
|
|
|
2016-02-06 09:38:26 +08:00
|
|
|
struct clk_hw_onecell_data {
|
2016-09-23 20:29:36 +08:00
|
|
|
unsigned int num;
|
2016-02-06 09:38:26 +08:00
|
|
|
struct clk_hw *hws[];
|
|
|
|
};
|
|
|
|
|
2014-05-09 05:09:24 +08:00
|
|
|
#define CLK_OF_DECLARE(name, compat, fn) OF_DECLARE_1(clk, name, compat, fn)
|
2013-05-01 08:58:28 +08:00
|
|
|
|
2016-07-06 00:23:25 +08:00
|
|
|
/*
|
|
|
|
* Use this macro when you have a driver that requires two initialization
|
|
|
|
* routines, one at of_clk_init(), and one at platform device probe
|
|
|
|
*/
|
|
|
|
#define CLK_OF_DECLARE_DRIVER(name, compat, fn) \
|
2016-10-08 16:59:38 +08:00
|
|
|
static void __init name##_of_clk_init_driver(struct device_node *np) \
|
2016-07-06 00:23:25 +08:00
|
|
|
{ \
|
|
|
|
of_node_clear_flag(np, OF_POPULATED); \
|
|
|
|
fn(np); \
|
|
|
|
} \
|
|
|
|
OF_DECLARE_1(clk, name, compat, name##_of_clk_init_driver)
|
|
|
|
|
2017-12-07 20:57:04 +08:00
|
|
|
#define CLK_HW_INIT(_name, _parent, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_names = (const char *[]) { _parent }, \
|
|
|
|
.num_parents = 1, \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
2019-04-22 07:15:05 +08:00
|
|
|
#define CLK_HW_INIT_HW(_name, _parent, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_hws = (const struct clk_hw*[]) { _parent }, \
|
|
|
|
.num_parents = 1, \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This macro is intended for drivers to be able to share the otherwise
|
|
|
|
* individual struct clk_hw[] compound literals created by the compiler
|
|
|
|
* when using CLK_HW_INIT_HW. It does NOT support multiple parents.
|
|
|
|
*/
|
|
|
|
#define CLK_HW_INIT_HWS(_name, _parent, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_hws = _parent, \
|
|
|
|
.num_parents = 1, \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
2019-05-03 11:49:03 +08:00
|
|
|
#define CLK_HW_INIT_FW_NAME(_name, _parent, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_data = (const struct clk_parent_data[]) { \
|
|
|
|
{ .fw_name = _parent }, \
|
|
|
|
}, \
|
|
|
|
.num_parents = 1, \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
2017-12-07 20:57:04 +08:00
|
|
|
#define CLK_HW_INIT_PARENTS(_name, _parents, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_names = _parents, \
|
|
|
|
.num_parents = ARRAY_SIZE(_parents), \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
2019-04-22 07:15:05 +08:00
|
|
|
#define CLK_HW_INIT_PARENTS_HW(_name, _parents, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_hws = _parents, \
|
|
|
|
.num_parents = ARRAY_SIZE(_parents), \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
2019-04-22 07:17:50 +08:00
|
|
|
#define CLK_HW_INIT_PARENTS_DATA(_name, _parents, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_data = _parents, \
|
|
|
|
.num_parents = ARRAY_SIZE(_parents), \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
2017-12-07 20:57:04 +08:00
|
|
|
#define CLK_HW_INIT_NO_PARENT(_name, _ops, _flags) \
|
|
|
|
(&(struct clk_init_data) { \
|
|
|
|
.flags = _flags, \
|
|
|
|
.name = _name, \
|
|
|
|
.parent_names = NULL, \
|
|
|
|
.num_parents = 0, \
|
|
|
|
.ops = _ops, \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define CLK_FIXED_FACTOR(_struct, _name, _parent, \
|
|
|
|
_div, _mult, _flags) \
|
|
|
|
struct clk_fixed_factor _struct = { \
|
|
|
|
.div = _div, \
|
|
|
|
.mult = _mult, \
|
|
|
|
.hw.init = CLK_HW_INIT(_name, \
|
|
|
|
_parent, \
|
|
|
|
&clk_fixed_factor_ops, \
|
|
|
|
_flags), \
|
|
|
|
}
|
|
|
|
|
2019-04-22 07:19:46 +08:00
|
|
|
#define CLK_FIXED_FACTOR_HW(_struct, _name, _parent, \
|
|
|
|
_div, _mult, _flags) \
|
|
|
|
struct clk_fixed_factor _struct = { \
|
|
|
|
.div = _div, \
|
|
|
|
.mult = _mult, \
|
|
|
|
.hw.init = CLK_HW_INIT_HW(_name, \
|
|
|
|
_parent, \
|
|
|
|
&clk_fixed_factor_ops, \
|
|
|
|
_flags), \
|
|
|
|
}
|
|
|
|
|
2019-05-06 10:43:16 +08:00
|
|
|
/*
|
|
|
|
* This macro allows the driver to reuse the _parent array for multiple
|
|
|
|
* fixed factor clk declarations.
|
|
|
|
*/
|
|
|
|
#define CLK_FIXED_FACTOR_HWS(_struct, _name, _parent, \
|
|
|
|
_div, _mult, _flags) \
|
|
|
|
struct clk_fixed_factor _struct = { \
|
|
|
|
.div = _div, \
|
|
|
|
.mult = _mult, \
|
|
|
|
.hw.init = CLK_HW_INIT_HWS(_name, \
|
|
|
|
_parent, \
|
|
|
|
&clk_fixed_factor_ops, \
|
|
|
|
_flags), \
|
|
|
|
}
|
|
|
|
|
2019-05-03 11:58:20 +08:00
|
|
|
#define CLK_FIXED_FACTOR_FW_NAME(_struct, _name, _parent, \
|
|
|
|
_div, _mult, _flags) \
|
|
|
|
struct clk_fixed_factor _struct = { \
|
|
|
|
.div = _div, \
|
|
|
|
.mult = _mult, \
|
|
|
|
.hw.init = CLK_HW_INIT_FW_NAME(_name, \
|
|
|
|
_parent, \
|
|
|
|
&clk_fixed_factor_ops, \
|
|
|
|
_flags), \
|
|
|
|
}
|
|
|
|
|
2013-05-01 08:58:28 +08:00
|
|
|
#ifdef CONFIG_OF
|
2012-04-10 03:50:06 +08:00
|
|
|
int of_clk_add_provider(struct device_node *np,
|
|
|
|
struct clk *(*clk_src_get)(struct of_phandle_args *args,
|
|
|
|
void *data),
|
|
|
|
void *data);
|
2016-02-06 09:38:26 +08:00
|
|
|
int of_clk_add_hw_provider(struct device_node *np,
|
|
|
|
struct clk_hw *(*get)(struct of_phandle_args *clkspec,
|
|
|
|
void *data),
|
|
|
|
void *data);
|
2017-09-02 07:16:40 +08:00
|
|
|
int devm_of_clk_add_hw_provider(struct device *dev,
|
|
|
|
struct clk_hw *(*get)(struct of_phandle_args *clkspec,
|
|
|
|
void *data),
|
|
|
|
void *data);
|
2012-04-10 03:50:06 +08:00
|
|
|
void of_clk_del_provider(struct device_node *np);
|
2017-09-02 07:16:40 +08:00
|
|
|
void devm_of_clk_del_provider(struct device *dev);
|
2012-04-10 03:50:06 +08:00
|
|
|
struct clk *of_clk_src_simple_get(struct of_phandle_args *clkspec,
|
|
|
|
void *data);
|
2016-02-06 09:38:26 +08:00
|
|
|
struct clk_hw *of_clk_hw_simple_get(struct of_phandle_args *clkspec,
|
|
|
|
void *data);
|
2012-08-22 21:36:27 +08:00
|
|
|
struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
|
2016-02-06 09:38:26 +08:00
|
|
|
struct clk_hw *of_clk_hw_onecell_get(struct of_phandle_args *clkspec,
|
|
|
|
void *data);
|
2015-06-06 00:26:13 +08:00
|
|
|
int of_clk_parent_fill(struct device_node *np, const char **parents,
|
|
|
|
unsigned int size);
|
2016-02-12 05:19:11 +08:00
|
|
|
int of_clk_detect_critical(struct device_node *np, int index,
|
|
|
|
unsigned long *flags);
|
2012-04-10 03:50:06 +08:00
|
|
|
|
2013-05-01 08:58:28 +08:00
|
|
|
#else /* !CONFIG_OF */
|
2013-01-04 15:00:52 +08:00
|
|
|
|
2013-05-01 08:58:28 +08:00
|
|
|
static inline int of_clk_add_provider(struct device_node *np,
|
|
|
|
struct clk *(*clk_src_get)(struct of_phandle_args *args,
|
|
|
|
void *data),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-06 09:38:26 +08:00
|
|
|
static inline int of_clk_add_hw_provider(struct device_node *np,
|
|
|
|
struct clk_hw *(*get)(struct of_phandle_args *clkspec,
|
|
|
|
void *data),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2017-09-02 07:16:40 +08:00
|
|
|
static inline int devm_of_clk_add_hw_provider(struct device *dev,
|
|
|
|
struct clk_hw *(*get)(struct of_phandle_args *clkspec,
|
|
|
|
void *data),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2015-10-30 05:12:56 +08:00
|
|
|
static inline void of_clk_del_provider(struct device_node *np) {}
|
2017-09-02 07:16:40 +08:00
|
|
|
static inline void devm_of_clk_del_provider(struct device *dev) {}
|
2013-05-01 08:58:28 +08:00
|
|
|
static inline struct clk *of_clk_src_simple_get(
|
|
|
|
struct of_phandle_args *clkspec, void *data)
|
|
|
|
{
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
}
|
2016-02-06 09:38:26 +08:00
|
|
|
static inline struct clk_hw *
|
|
|
|
of_clk_hw_simple_get(struct of_phandle_args *clkspec, void *data)
|
|
|
|
{
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
}
|
2013-05-01 08:58:28 +08:00
|
|
|
static inline struct clk *of_clk_src_onecell_get(
|
|
|
|
struct of_phandle_args *clkspec, void *data)
|
|
|
|
{
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
}
|
2016-02-06 09:38:26 +08:00
|
|
|
static inline struct clk_hw *
|
|
|
|
of_clk_hw_onecell_get(struct of_phandle_args *clkspec, void *data)
|
|
|
|
{
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
}
|
2015-10-27 02:55:34 +08:00
|
|
|
static inline int of_clk_parent_fill(struct device_node *np,
|
|
|
|
const char **parents, unsigned int size)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2016-02-12 05:19:11 +08:00
|
|
|
static inline int of_clk_detect_critical(struct device_node *np, int index,
|
|
|
|
unsigned long *flags)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2013-05-01 08:58:28 +08:00
|
|
|
#endif /* CONFIG_OF */
|
2013-07-22 20:14:40 +08:00
|
|
|
|
2018-09-04 14:49:36 +08:00
|
|
|
void clk_gate_restore_context(struct clk_hw *hw);
|
|
|
|
|
2012-03-16 14:11:19 +08:00
|
|
|
#endif /* CLK_PROVIDER_H */
|