clk: sunxi-ng: clk parent rewrite part 1
Subsystems (2)
Chen-Yu Tsai
maintainerPATCH v2 4/25 clk: Add CLK_HW_INIT_PARENT_DATA macro using .parent_data
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, struct clk_init_data was expanded to include .parent_data, for clk drivers that have parents referenced using a combination of device tree clock-names, clock indices, and/or struct clk_hw pointers.
Add a new macro that can take a list of struct clk_parent_data for drivers to use.
--- include/linux/clk-provider.h | 9 +++++++++ 1 file changed, 9 insertions(+)
include/linux/clk-provider.h +9 -0
@@ -956,6 +956,15 @@ extern struct of_device_id __clk_of_table; .ops = _ops, \ }) +#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, \ + }) +#define CLK_HW_INIT_NO_PARENT (_name, _ops, _flags) \ (&(struct clk_init_data) { \ .flags = _flags, \
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 2/25 clk: Add CLK_HW_INIT_* macros using .parent_hws
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, struct clk_init_data was expanded to include .parent_hws, for clk drivers to directly list parents by pointing to their respective struct clk_hw's.
Add macros that can take either one single struct clk_hw *, or an array of them, for drivers to use.
A special CLK_HW_INIT_HWS macro is included, which takes an array of struct clk_hw *, but sets .num_parents to 1. This variant is to allow the reuse of the array, instead of having a compound literal allocated for each clk sharing the same parent.
--- include/linux/clk-provider.h | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+)
include/linux/clk-provider.h +32 -0
@@ -904,6 +904,29 @@ extern struct of_device_id __clk_of_table; .ops = _ops, \ }) +#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, \ + }) +#define CLK_HW_INIT_PARENTS (_name, _parents, _ops, _flags) \ (&(struct clk_init_data) { \ .flags = _flags, \
@@ -913,6 +936,15 @@ extern struct of_device_id __clk_of_table; .ops = _ops, \ }) +#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, \ + }) +#define CLK_HW_INIT_NO_PARENT (_name, _ops, _flags) \ (&(struct clk_init_data) { \ .flags = _flags, \
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 8/25 clk: sunxi-ng: switch to of_clk_hw_register() for registering clks
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
Commit 89a5ddcc799d ("clk: Add of_clk_hw_register() API for early clk drivers") introduces a new API for registering clks, which allows the user to directly specify a device node, even if there is no struct device attached to it. The device node is used for local DT clock-names matching.
Switch to of_clk_hw_register() so that local DT clock-names matching works.
--- drivers/clk/sunxi-ng/ccu_common.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/clk/sunxi-ng/ccu_common.c +1 -1
@@ -110,7 +110,7 @@ int sunxi_ccu_probe(struct device_node *node, void __iomem *reg,if (!hw)continue ; - ret =clk_hw_register (NULL , hw); + ret =of_clk_hw_register (node, hw);if (ret) {pr_err ("Couldn't register clock %d - %s\n" , i,clk_hw_get_name (hw));
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 1/25 clk: Fix debugfs clk_possible_parents for clks without parent string names
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
Following the commit fc0c209c147f ("clk: Allow parents to be specified without string names"), the parent name string is not always populated.
Instead, fetch the parents clk_core struct using the appropriate helper, and read its name directly. If that fails, go through the possible sources of parent names. The order in which they are used is different from how parents are looked up, with the global name having precedence over local fw_name and indices. This makes more sense as a) the parent_maps structure does not differentiate between legacy global names and fallback global names, and b) global names likely provide more information than local fw_names.
--- drivers/clk/clk.c | 44 +++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 3 deletions(-)
drivers/clk/clk.c +41 -3
@@ -3000,12 +3000,50 @@ DEFINE_SHOW_ATTRIBUTE(clk_flags);static int possible_parents_show (struct seq_file *s,void *data) {struct clk_core *core = s->private; +struct clk_core *parent;int i; -for (i =0 ; i < core->num_parents -1 ; i++) -seq_printf (s,"%s " , core->parents[i].name); +/* +* Go through the following options to fetch a parent's name. +* +* 1. Fetch the registered parent clock and use its name +* 2. Use the global (fallback) name if specified +* 3. Use the local fw_name if provided +* 4. Fetch parent clock's clock-output-name if DT index was set +* +* This may still fail in some cases, such as when the parent is +* specified directly via a struct clk_hw pointer, but it isn't +* registered (yet). +*/ +for (i =0 ; i < core->num_parents -1 ; i++) { + parent =clk_core_get_parent_by_index (core, i); +if (parent) +seq_printf (s,"%s " , parent->name); +else if (core->parents[i].name) +seq_printf (s,"%s " , core->parents[i].name); +else if (core->parents[i].fw_name) +seq_printf (s,"<%s>(fw) " , core->parents[i].fw_name); +else if (core->parents[i].index >=0 ) +seq_printf (s,"%s " , +of_clk_get_parent_name (core->of_node, + core->parents[i].index)); +else +seq_puts (s,"(missing) " ); + } -seq_printf (s,"%s\n" , core->parents[i].name); + parent =clk_core_get_parent_by_index (core, i); +if (parent) +seq_printf (s,"%s" , parent->name); +else if (core->parents[i].name) +seq_printf (s,"%s" , core->parents[i].name); +else if (core->parents[i].fw_name) +seq_printf (s,"<%s>(fw)" , core->parents[i].fw_name); +else if (core->parents[i].index >=0 ) +seq_printf (s,"%s" , +of_clk_get_parent_name (core->of_node, + core->parents[i].index)); +else +seq_puts (s,"(missing)" );return 0 ; }
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 16/25 clk: sunxi-ng: r40: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun8i-r40.c | 46 ++++++++++++++++++---------- 1 file changed, 29 insertions(+), 17 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-r40.c +29 -17
@@ -952,25 +952,37 @@ static struct ccu_common *sun8i_r40_ccu_clks[] = { };/* Fixed Factor clocks */ -static CLK_FIXED_FACTOR(osc12M_clk, "osc12M", "osc24M", 2, 1, 0); +static CLK_FIXED_FACTOR_FW_NAME(osc12M_clk, "osc12M", "hosc", 2, 1, 0); + +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +};/* We hardcode the divider to 4 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 4, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph0_2x_clk, "pll-periph0-2x", - "pll-periph0", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_periph1_2x_clk, "pll-periph1-2x", - "pll-periph1", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_video0_2x_clk, "pll-video0-2x", - "pll-video0", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_video1_2x_clk, "pll-video1-2x", - "pll-video1", 1, 2, 0); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 4, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph0_2x_clk, "pll-periph0-2x", + &pll_periph0_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_periph1_2x_clk, "pll-periph1-2x", + &pll_periph1_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_video0_2x_clk, "pll-video0-2x", + &pll_video0_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_video1_2x_clk, "pll-video1-2x", + &pll_video1_clk.common.hw, + 1, 2, 0);static struct clk_hw_onecell_data sun8i_r40_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 23/25 clk: sunxi-ng: gate: Add macros for referencing local clock parents
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, clk_init_data was expanded to include .parent_hws, for clk drivers to directly reference parents by clk_hw, and .parent_data, for clk drivers to specify parents using a combination of device tree clock-names, pointers to struct clk_hw, device tree clocks, and/or fallback global clock names.
Add four new macros:
- SUNXI_CCU_GATE_HW, that can take a struct clk_hw pointer, instead of a string, as its parent.
- SUNXI_CCU_GATE_FW that takes a string to match a clock-names entry in the device tree to specify the clock parent.
- SUNXI_CCU_GATE_HWS that takes an array of struct clk_hw * as its parent. This allows the array to be shared with other clk declarations.
- SUNXI_CCU_GATE_DATA that takes an array of struct clk_parent_data * as its parent. This allows the array to be shared with other clk declarations.
--- drivers/clk/sunxi-ng/ccu_gate.h | 53 +++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+)
drivers/clk/sunxi-ng/ccu_gate.h +53 -0
@@ -36,6 +36,59 @@ struct ccu_gate { } \ } +#define SUNXI_CCU_GATE_HW (_struct, _name, _parent, _reg, _gate, _flags) \ + struct ccu_gate _struct = { \ + .enable = _gate, \ + .common = { \ + .reg = _reg, \ + .hw.init = CLK_HW_INIT_HW(_name, \ + _parent, \ + &ccu_gate_ops, \ + _flags), \ + } \ + } + +#define SUNXI_CCU_GATE_FW (_struct, _name, _parent, _reg, _gate, _flags) \ + struct ccu_gate _struct = { \ + .enable = _gate, \ + .common = { \ + .reg = _reg, \ + .hw.init = CLK_HW_INIT_FW_NAME(_name, \ + _parent, \ + &ccu_gate_ops, \ + _flags), \ + } \ + } + +/* +* The following two macros allow the re-use of the data structure +* holding the parent info. +*/ +#define SUNXI_CCU_GATE_HWS (_struct, _name, _parent, _reg, _gate, _flags) \ + struct ccu_gate _struct = { \ + .enable = _gate, \ + .common = { \ + .reg = _reg, \ + .hw.init = CLK_HW_INIT_HWS(_name, \ + _parent, \ + &ccu_gate_ops, \ + _flags), \ + } \ + } + +#define SUNXI_CCU_GATE_DATA (_struct, _name, _data, _reg, _gate, _flags) \ + struct ccu_gate _struct = { \ + .enable = _gate, \ + .common = { \ + .reg = _reg, \ + .hw.init = \ + CLK_HW_INIT_PARENTS_DATA(_name, \ + _data, \ + &ccu_gate_ops, \ + _flags), \ + } \ + } +static inline struct ccu_gate *hw_to_ccu_gate (struct clk_hw *hw) {struct ccu_common *common =hw_to_ccu_common (hw);
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 7/25 clk: fixed-factor: Add CLK_FIXED_FACTOR_FW_NAME for DT clock-names parent
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, clk_init_data was expanded to include .parent_data, for clk drivers to specify parents using a combination of device tree clock-names, pointers to struct clk_hw, device tree clocks, and/or fallback global clock names.
Add a new macro, CLK_FIXED_FACTOR_FW_NAME, that takes a string to match a clock-names entry in the device tree to specify the clock parent.
--- include/linux/clk-provider.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
include/linux/clk-provider.h +11 -0
@@ -1011,6 +1011,17 @@ extern struct of_device_id __clk_of_table; _flags), \ } +#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), \ + } +#ifdef CONFIG_OF int of_clk_add_provider(struct device_node *np, struct clk *(*clk_src_get)(struct of_phandle_args *args,
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 18/25 clk: sunxi-ng: sun8i-r: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun8i-r.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/clk/sunxi-ng/ccu-sun8i-r.c +1 -1
@@ -57,7 +57,7 @@ static struct ccu_div ar100_clk = { }, }; -static CLK_FIXED_FACTOR(ahb0_clk, "ahb0", "ar100", 1, 1, 0); +static CLK_FIXED_FACTOR_HW(ahb0_clk, "ahb0", &ar100_clk.common.hw, 1, 1, 0);static struct ccu_div apb0_clk = { .div =_SUNXI_CCU_DIV_FLAGS (0 ,2 ,CLK_DIVIDER_POWER_OF_TWO ),
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 11/25 clk: sunxi-ng: sun5i: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun5i.c | 34 +++++++++++++++++++++----------- 1 file changed, 22 insertions(+), 12 deletions(-)
drivers/clk/sunxi-ng/ccu-sun5i.c +22 -12
@@ -611,19 +611,29 @@ static struct ccu_common *sun5i_a10s_ccu_clks[] = { &iep_clk.common, }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* We hardcode the divider to 1 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_video0_2x_clk, "pll-video0-2x", - "pll-video0", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_video1_2x_clk, "pll-video1-2x", - "pll-video1", 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video0_2x_clk, "pll-video0-2x", + &pll_video0_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video1_2x_clk, "pll-video1-2x", + &pll_video1_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT);static struct clk_hw_onecell_data sun5i_a10s_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 21/25 clk: sunxi-ng: h6: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
A forward declaration for struct clk_fixed_factor pll_periph0_4x_clk is added as the definitions of the fixed factor clocks appear much later in the file. The position of fixed factor clock definitions will be moved for all drivers at a later time, before the conversion of all other clock types.
--- drivers/clk/sunxi-ng/ccu-sun50i-h6.c | 69 ++++++++++++++++++---------- 1 file changed, 44 insertions(+), 25 deletions(-)
drivers/clk/sunxi-ng/ccu-sun50i-h6.c +44 -25
@@ -622,8 +622,9 @@ static SUNXI_CCU_GATE(bus_xhci_clk, "bus-xhci", "ahb3", 0xa8c, BIT(5), 0); static SUNXI_CCU_GATE(bus_ehci3_clk, "bus-ehci3", "ahb3", 0xa8c, BIT(7), 0); staticSUNXI_CCU_GATE (bus_otg_clk,"bus-otg" ,"ahb3" ,0xa8c ,BIT (8 ),0 ); -static CLK_FIXED_FACTOR(pcie_ref_100m_clk, "pcie-ref-100M", - "pll-periph0-4x", 24, 1, 0); +static struct clk_fixed_factor pll_periph0_4x_clk; +static CLK_FIXED_FACTOR_HW(pcie_ref_100m_clk, "pcie-ref-100M", + &pll_periph0_4x_clk.hw, 24, 1, 0); static SUNXI_CCU_GATE(pcie_ref_clk, "pcie-ref", "pcie-ref-100M", 0xab0, BIT(31), 0); static SUNXI_CCU_GATE(pcie_ref_out_clk, "pcie-ref-out", "pcie-ref",
@@ -745,34 +746,52 @@ static SUNXI_CCU_M_WITH_MUX_GATE(hdcp_clk, "hdcp", hdcp_parents, 0xc40, static SUNXI_CCU_GATE(bus_hdcp_clk, "bus-hdcp", "ahb3", 0xc4c, BIT(0), 0);/* Fixed factor clocks */ -static CLK_FIXED_FACTOR(osc12M_clk, "osc12M", "osc24M", 2, 1, 0); +static CLK_FIXED_FACTOR_FW_NAME(osc12M_clk, "osc12M", "hosc", 2, 1, 0); + +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +};/* * The divider of pll-audio is fixed to 8 now, as pll-audio-4x has a * fixed post-divider 2. */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 8, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 4, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); - -static CLK_FIXED_FACTOR(pll_periph0_4x_clk, "pll-periph0-4x", - "pll-periph0", 1, 4, 0); -static CLK_FIXED_FACTOR(pll_periph0_2x_clk, "pll-periph0-2x", - "pll-periph0", 1, 2, 0); - -static CLK_FIXED_FACTOR(pll_periph1_4x_clk, "pll-periph1-4x", - "pll-periph1", 1, 4, 0); -static CLK_FIXED_FACTOR(pll_periph1_2x_clk, "pll-periph1-2x", - "pll-periph1", 1, 2, 0); - -static CLK_FIXED_FACTOR(pll_video0_4x_clk, "pll-video0-4x", - "pll-video0", 1, 4, CLK_SET_RATE_PARENT); - -static CLK_FIXED_FACTOR(pll_video1_4x_clk, "pll-video1-4x", - "pll-video1", 1, 4, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 8, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 4, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); + +static const struct clk_hw pll_periph0_parents[] = { + &pll_periph0_clk.common.hw +}; +static CLK_FIXED_FACTOR_HWS(pll_periph0_4x_clk, "pll-periph0-4x", + pll_periph0_parents, + 1, 4, 0); +static CLK_FIXED_FACTOR_HWS(pll_periph0_2x_clk, "pll-periph0-2x", + pll_periph0_parents, + 1, 2, 0); + +static const struct clk_hw pll_periph1_parents[] = { + &pll_periph1_clk.common.hw +}; +static CLK_FIXED_FACTOR_HWS(pll_periph1_4x_clk, "pll-periph1-4x", + pll_periph1_parents, + 1, 4, 0); +static CLK_FIXED_FACTOR_HWS(pll_periph1_2x_clk, "pll-periph1-2x", + pll_periph1_parents, + 1, 2, 0); + +static CLK_FIXED_FACTOR_HW(pll_video0_4x_clk, "pll-video0-4x", + &pll_video0_clk.common.hw, + 1, 4, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video1_4x_clk, "pll-video1-4x", + &pll_video1_clk.common.hw, + 1, 4, CLK_SET_RATE_PARENT);static struct ccu_common *sun50i_h6_ccu_clks[] = { &pll_cpux_clk.common,
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 24/25 clk: sunxi-ng: a80-usb: Use local parent references for SUNXI_CCU_GATE
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and SUNXI_CCU_GATE macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing SUNXI_CCU_GATE definitions to SUNXI_CCU_GATE_DATA to specify the parent clock.
--- drivers/clk/sunxi-ng/ccu-sun9i-a80-usb.c | 32 +++++++++++++++--------- 1 file changed, 20 insertions(+), 12 deletions(-)
drivers/clk/sunxi-ng/ccu-sun9i-a80-usb.c +20 -12
@@ -22,18 +22,26 @@#include "ccu-sun9i-a80-usb.h" -static SUNXI_CCU_GATE(bus_hci0_clk, "bus-hci0", "bus-usb", 0x0, BIT(1), 0); -static SUNXI_CCU_GATE(usb_ohci0_clk, "usb-ohci0", "osc24M", 0x0, BIT(2), 0); -static SUNXI_CCU_GATE(bus_hci1_clk, "bus-hci1", "bus-usb", 0x0, BIT(3), 0); -static SUNXI_CCU_GATE(bus_hci2_clk, "bus-hci2", "bus-usb", 0x0, BIT(5), 0); -static SUNXI_CCU_GATE(usb_ohci2_clk, "usb-ohci2", "osc24M", 0x0, BIT(6), 0); - -static SUNXI_CCU_GATE(usb0_phy_clk, "usb0-phy", "osc24M", 0x4, BIT(1), 0); -static SUNXI_CCU_GATE(usb1_hsic_clk, "usb1-hsic", "osc24M", 0x4, BIT(2), 0); -static SUNXI_CCU_GATE(usb1_phy_clk, "usb1-phy", "osc24M", 0x4, BIT(3), 0); -static SUNXI_CCU_GATE(usb2_hsic_clk, "usb2-hsic", "osc24M", 0x4, BIT(4), 0); -static SUNXI_CCU_GATE(usb2_phy_clk, "usb2-phy", "osc24M", 0x4, BIT(5), 0); -static SUNXI_CCU_GATE(usb_hsic_clk, "usb-hsic", "osc24M", 0x4, BIT(10), 0); +static const struct clk_parent_data clk_parent_hosc[] = { + { .fw_name ="hosc" }, +}; + +static const struct clk_parent_data clk_parent_bus[] = { + { .fw_name ="bus" }, +}; + +static SUNXI_CCU_GATE_DATA(bus_hci0_clk, "bus-hci0", clk_parent_bus, 0x0, BIT(1), 0); +static SUNXI_CCU_GATE_DATA(usb_ohci0_clk, "usb-ohci0", clk_parent_hosc, 0x0, BIT(2), 0); +staticSUNXI_CCU_GATE_DATA (bus_hci1_clk,"bus-hci1" , clk_parent_bus,0x0 ,BIT (3 ),0 ); +static SUNXI_CCU_GATE_DATA(bus_hci2_clk, "bus-hci2", clk_parent_bus, 0x0, BIT(5), 0); +staticSUNXI_CCU_GATE_DATA (usb_ohci2_clk,"usb-ohci2" , clk_parent_hosc,0x0 ,BIT (6 ),0 ); + +static SUNXI_CCU_GATE_DATA(usb0_phy_clk, "usb0-phy", clk_parent_hosc, 0x4, BIT(1), 0); +static SUNXI_CCU_GATE_DATA(usb1_hsic_clk, "usb1-hsic", clk_parent_hosc, 0x4, BIT(2), 0); +staticSUNXI_CCU_GATE_DATA (usb1_phy_clk,"usb1-phy" , clk_parent_hosc,0x4 ,BIT (3 ),0 ); +static SUNXI_CCU_GATE_DATA(usb2_hsic_clk, "usb2-hsic", clk_parent_hosc, 0x4, BIT(4), 0); +staticSUNXI_CCU_GATE_DATA (usb2_phy_clk,"usb2-phy" , clk_parent_hosc,0x4 ,BIT (5 ),0 ); +static SUNXI_CCU_GATE_DATA(usb_hsic_clk, "usb-hsic", clk_parent_hosc, 0x4, BIT(10), 0); static struct ccu_common *sun9i_a80_usb_clks[] = { &bus_hci0_clk.common,
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 20/25 clk: sunxi-ng: a64: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun50i-a64.c | 41 +++++++++++++++++---------- 1 file changed, 26 insertions(+), 15 deletions(-)
drivers/clk/sunxi-ng/ccu-sun50i-a64.c +26 -15
@@ -605,23 +605,34 @@ static SUNXI_CCU_M_WITH_GATE(gpu_clk, "gpu", "pll-gpu", 0x1a0, 0, 3, BIT(31), CLK_SET_RATE_PARENT);/* Fixed Factor clocks */ -static CLK_FIXED_FACTOR(osc12M_clk, "osc12M", "osc24M", 2, 1, 0); +static CLK_FIXED_FACTOR_FW_NAME(osc12M_clk, "osc12M", "hosc", 2, 1, 0); + +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +};/* We hardcode the divider to 1 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph0_2x_clk, "pll-periph0-2x", - "pll-periph0", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_periph1_2x_clk, "pll-periph1-2x", - "pll-periph1", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_video0_2x_clk, "pll-video0-2x", - "pll-video0", 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph0_2x_clk, "pll-periph0-2x", + &pll_periph0_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_periph1_2x_clk, "pll-periph1-2x", + &pll_periph1_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_video0_2x_clk, "pll-video0-2x", + &pll_video0_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT);static struct ccu_common *sun50i_a64_ccu_clks[] = { &pll_cpux_clk.common,
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 22/25 clk: sunxi-ng: h6-r: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun50i-h6-r.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/clk/sunxi-ng/ccu-sun50i-h6-r.c +1 -1
@@ -49,7 +49,7 @@ static struct ccu_div ar100_clk = { }, }; -static CLK_FIXED_FACTOR(r_ahb_clk, "r-ahb", "ar100", 1, 1, 0); +static CLK_FIXED_FACTOR_HW(r_ahb_clk, "r-ahb", &ar100_clk.common.hw, 1, 1, 0);static struct ccu_div r_apb1_clk = { .div =_SUNXI_CCU_DIV (0 ,2 ),
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 25/25 clk: sunxi-ng: sun8i-r: Use local parent references for SUNXI_CCU_GATE
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and SUNXI_CCU_GATE macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing SUNXI_CCU_GATE definitions to SUNXI_CCU_GATE_HWS as the parent clock is internal to this clock unit.
To avoid duplication of clock definitions, we fix up the parent reference for A83T in the A83T init function.
--- drivers/clk/sunxi-ng/ccu-sun8i-r.c | 37 +++++++++++++++++++----------- 1 file changed, 23 insertions(+), 14 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-r.c +23 -14
@@ -73,20 +73,26 @@ static struct ccu_div apb0_clk = { static SUNXI_CCU_M(a83t_apb0_clk, "apb0", "ahb0", 0x0c, 0, 2, 0); -static SUNXI_CCU_GATE(apb0_pio_clk, "apb0-pio", "apb0", - 0x28, BIT(0), 0); -static SUNXI_CCU_GATE(apb0_ir_clk, "apb0-ir", "apb0", - 0x28, BIT(1), 0); -static SUNXI_CCU_GATE(apb0_timer_clk, "apb0-timer", "apb0", - 0x28, BIT(2), 0); -static SUNXI_CCU_GATE(apb0_rsb_clk, "apb0-rsb", "apb0", - 0x28, BIT(3), 0); -static SUNXI_CCU_GATE(apb0_uart_clk, "apb0-uart", "apb0", - 0x28, BIT(4), 0); -static SUNXI_CCU_GATE(apb0_i2c_clk, "apb0-i2c", "apb0", - 0x28, BIT(6), 0); -static SUNXI_CCU_GATE(apb0_twd_clk, "apb0-twd", "apb0", - 0x28, BIT(7), 0); +/* +* Define the parent as an array that can be reused to save space +* instead of having compound literals for each gate. Also have it +* non-const so we can change it on the A83T. +*/ +static const struct clk_hw *apb0_gate_parent[] = { &apb0_clk.common.hw }; +static SUNXI_CCU_GATE_HWS(apb0_pio_clk, "apb0-pio", + apb0_gate_parent, 0x28, BIT(0), 0); +static SUNXI_CCU_GATE_HWS(apb0_ir_clk, "apb0-ir", + apb0_gate_parent, 0x28, BIT(1), 0); +static SUNXI_CCU_GATE_HWS(apb0_timer_clk, "apb0-timer", + apb0_gate_parent, 0x28, BIT(2), 0); +static SUNXI_CCU_GATE_HWS(apb0_rsb_clk, "apb0-rsb", + apb0_gate_parent, 0x28, BIT(3), 0); +static SUNXI_CCU_GATE_HWS(apb0_uart_clk, "apb0-uart", + apb0_gate_parent, 0x28, BIT(4), 0); +static SUNXI_CCU_GATE_HWS(apb0_i2c_clk, "apb0-i2c", + apb0_gate_parent, 0x28, BIT(6), 0); +static SUNXI_CCU_GATE_HWS(apb0_twd_clk, "apb0-twd", + apb0_gate_parent, 0x28, BIT(7), 0);static const char *const r_mod0_default_parents[] = {"osc32k" ,"osc24M" }; static SUNXI_CCU_MP_WITH_MUX_GATE(ir_clk, "ir",
@@ -284,6 +290,9 @@ static void __init sunxi_r_ccu_init(struct device_node *node,static void __init sun8i_a83t_r_ccu_setup (struct device_node *node) { +/* Fix apb0 bus gate parents here */ + apb0_gate_parent[0 ] = &a83t_apb0_clk.common.hw; +sunxi_r_ccu_init (node, &sun8i_a83t_r_ccu_desc); } CLK_OF_DECLARE(sun8i_a83t_r_ccu, "allwinner,sun8i-a83t-r-ccu",
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 19/25 clk: sunxi-ng: f1c100s: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-suniv-f1c100s.c | 29 ++++++++++++++++-------- 1 file changed, 19 insertions(+), 10 deletions(-)
drivers/clk/sunxi-ng/ccu-suniv-f1c100s.c +19 -10
@@ -374,16 +374,25 @@ static struct ccu_common *suniv_ccu_clks[] = { &avs_clk.common, }; -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 4, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_video_2x_clk, "pll-video-2x", - "pll-video", 1, 2, 0); +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; + +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio + 4, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video0_2x_clk, "pll-video0-2x", + &pll_video0_clk.common.hw, + 1, 2, 0);static struct clk_hw_onecell_data suniv_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 3/25 clk: Add CLK_HW_INIT_FW_NAME macro using .fw_name in .parent_data
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, clk_init_data was expanded to include .parent_data, for clk drivers that have parents referenced using a combination of device tree clock-names, clock indices, and/or clk_hw pointers.
Add a CLK_HW_INIT macro for specifying a single parent from the device tree using .fw_name in struct clk_parent_data.
--- include/linux/clk-provider.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
include/linux/clk-provider.h +11 -0
@@ -927,6 +927,17 @@ extern struct of_device_id __clk_of_table; .ops = _ops, \ }) +#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, \ + }) +#define CLK_HW_INIT_PARENTS (_name, _parents, _ops, _flags) \ (&(struct clk_init_data) { \ .flags = _flags, \
Signature · 7 lines
2.20.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Chen-Yu Tsai
maintainerPATCH v2 15/25 clk: sunxi-ng: h3: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun8i-h3.c | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-h3.c +19 -10
@@ -725,17 +725,26 @@ static struct ccu_common *sun50i_h5_ccu_clks[] = { &gpu_clk.common, }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* We hardcode the divider to 1 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph0_2x_clk, "pll-periph0-2x", - "pll-periph0", 1, 2, 0); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph0_2x_clk, "pll-periph0-2x", + &pll_periph0_clk.common.hw, + 1, 2, 0);static struct clk_hw_onecell_data sun8i_h3_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 17/25 clk: sunxi-ng: v3s: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun8i-v3s.c | 29 ++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-v3s.c +19 -10
@@ -437,17 +437,26 @@ static struct ccu_common *sun8i_v3s_ccu_clks[] = { &mipi_csi_clk.common, }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* We hardcode the divider to 4 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 4, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph0_2x_clk, "pll-periph0-2x", - "pll-periph0", 1, 2, 0); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 4, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph0_2x_clk, "pll-periph0-2x", + &pll_periph0_clk.common.hw, + 1, 2, 0);static struct clk_hw_onecell_data sun8i_v3s_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 10/25 clk: sunxi-ng: a10: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun4i-a10.c | 39 ++++++++++++++++++---------- 1 file changed, 25 insertions(+), 14 deletions(-)
drivers/clk/sunxi-ng/ccu-sun4i-a10.c +25 -14
@@ -168,8 +168,9 @@ static struct ccu_nk pll_periph_base_clk = { }, }; -static CLK_FIXED_FACTOR(pll_periph_clk, "pll-periph", "pll-periph-base", - 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph_clk, "pll-periph", + &pll_periph_base_clk.common.hw, + 2, 1, CLK_SET_RATE_PARENT);/* Not documented on A10 */ static struct ccu_div pll_periph_sata_clk = {
@@ -1036,19 +1037,29 @@ static struct ccu_common *sun4i_sun7i_ccu_clks[] = { &out_b_clk.common }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* Post-divider for pll-audio is hardcoded to 1 */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_video0_2x_clk, "pll-video0-2x", - "pll-video0", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_video1_2x_clk, "pll-video1-2x", - "pll-video1", 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video0_2x_clk, "pll-video0-2x", + &pll_video0_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video1_2x_clk, "pll-video1-2x", + &pll_video1_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT); static struct clk_hw_onecell_data sun4i_a10_hw_clks = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 9/25 clk: sunxi-ng: sun8i-r: Use local parent references for CLK_HW_INIT_*
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_HW_INIT_* macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_HW_INIT_* definitions to describe parents using either struct clk_hw pointers or clock-names from the device tree binding.
For the AR100, this also allows us to merge the generic AR100 and the A83T specific one, which only differed in the global clock names for their parent clocks. The device tree bindings used the same name specifiers.
--- drivers/clk/sunxi-ng/ccu-sun8i-r.c | 65 ++++++++++++------------------ 1 file changed, 25 insertions(+), 40 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-r.c +25 -40
@@ -25,10 +25,13 @@#include "ccu-sun8i-r.h" -static const char *const ar100_parents[] = {"osc32k" ,"osc24M" , -"pll-periph0" ,"iosc" }; -static const char *const a83t_ar100_parents[] = {"osc16M-d512" ,"osc24M" , -"pll-periph0" ,"iosc" }; +static const struct clk_parent_data ar100_parents[] = { + { .fw_name ="losc" }, + { .fw_name ="hosc" }, + { .fw_name ="pll-periph" }, + { .fw_name ="iosc" }, +}; +static const struct ccu_mux_var_prediv ar100_predivs[] = { { .index =2 , .shift =8 , .width =5 }, };
@@ -47,31 +50,10 @@ static struct ccu_div ar100_clk = { .common = { .reg = 0x00, .features = CCU_FEATURE_VARIABLE_PREDIV, - .hw.init =CLK_HW_INIT_PARENTS ("ar100" , - ar100_parents, - &ccu_div_ops, - 0), - }, -}; - -static struct ccu_div a83t_ar100_clk = { - .div =_SUNXI_CCU_DIV_FLAGS (4 ,2 ,CLK_DIVIDER_POWER_OF_TWO ), - - .mux = { - .shift =16 , - .width =2 , - - .var_predivs = ar100_predivs, - .n_var_predivs =ARRAY_SIZE (ar100_predivs), - }, - - .common = { - .reg =0x00 , - .features =CCU_FEATURE_VARIABLE_PREDIV , - .hw.init =CLK_HW_INIT_PARENTS ("ar100" , - a83t_ar100_parents, - &ccu_div_ops, -0 ), + .hw.init =CLK_HW_INIT_PARENTS_DATA ("ar100" , + ar100_parents, + &ccu_div_ops, + 0), }, };
@@ -82,10 +64,10 @@ static struct ccu_div apb0_clk = { .common = { .reg = 0x0c, - .hw.init =CLK_HW_INIT ("apb0" , -"ahb0" , - &ccu_div_ops, - 0), + .hw.init =CLK_HW_INIT_HW ("apb0" , + &ahb0_clk.hw, + &ccu_div_ops, + 0), }, };
@@ -115,7 +97,10 @@ static SUNXI_CCU_MP_WITH_MUX_GATE(ir_clk, "ir",BIT (31 ),/* gate */ 0); -static const char *const a83t_r_mod0_parents[] = {"osc16M" ,"osc24M" }; +static const struct clk_parent_data a83t_r_mod0_parents[] = { + { .fw_name ="iosc" }, + { .fw_name ="hosc" }, +};static const struct ccu_mux_fixed_prediv a83t_ir_predivs[] = { { .index =0 , .div =16 }, };
@@ -135,15 +120,15 @@ static struct ccu_mp a83t_ir_clk = { .common = { .reg = 0x54, .features = CCU_FEATURE_VARIABLE_PREDIV, - .hw.init =CLK_HW_INIT_PARENTS ("ir" , - a83t_r_mod0_parents, - &ccu_mp_ops, - 0), + .hw.init =CLK_HW_INIT_PARENTS_DATA ("ir" , + a83t_r_mod0_parents, + &ccu_mp_ops, + 0), }, };static struct ccu_common *sun8i_a83t_r_ccu_clks[] = { - &a83t_ar100_clk.common, + &ar100_clk.common, &a83t_apb0_clk.common, &apb0_pio_clk.common, &apb0_ir_clk.common,
@@ -182,7 +167,7 @@ static struct ccu_common *sun50i_a64_r_ccu_clks[] = {static struct clk_hw_onecell_data sun8i_a83t_r_hw_clks = { .hws = { - [CLK_AR100 ] = &a83t_ar100_clk.common.hw, + [CLK_AR100 ] = &ar100_clk.common.hw, [CLK_AHB0 ] = &ahb0_clk.hw, [CLK_APB0 ] = &a83t_apb0_clk.common.hw, [CLK_APB0_PIO ] = &apb0_pio_clk.common.hw,
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 12/25 clk: sunxi-ng: a31: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun6i-a31.c | 39 ++++++++++++++++++---------- 1 file changed, 25 insertions(+), 14 deletions(-)
drivers/clk/sunxi-ng/ccu-sun6i-a31.c +25 -14
@@ -963,21 +963,32 @@ static struct ccu_common *sun6i_a31_ccu_clks[] = { &out_c_clk.common, }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* We hardcode the divider to 1 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph_2x_clk, "pll-periph-2x", - "pll-periph", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_video0_2x_clk, "pll-video0-2x", - "pll-video0", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_video1_2x_clk, "pll-video1-2x", - "pll-video1", 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph_2x_clk, "pll-periph-2x", + &pll_periph_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_video0_2x_clk, "pll-video0-2x", + &pll_video0_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_video1_2x_clk, "pll-video1-2x", + &pll_video1_clk.common.hw, + 1, 2, CLK_SET_RATE_PARENT);static struct clk_hw_onecell_data sun6i_a31_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 13/25 clk: sunxi-ng: a23: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun8i-a23.c | 34 ++++++++++++++++++---------- 1 file changed, 22 insertions(+), 12 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-a23.c +22 -12
@@ -551,19 +551,29 @@ static struct ccu_common *sun8i_a23_ccu_clks[] = { &ats_clk.common, }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* We hardcode the divider to 1 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph_2x_clk, "pll-periph-2x", - "pll-periph", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_video_2x_clk, "pll-video-2x", - "pll-video", 1, 2, 0); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph_2x_clk, "pll-periph-2x", + &pll_periph_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_video_2x_clk, "pll-video-2x", + &pll_video_clk.common.hw, + 1, 2, 0);static struct clk_hw_onecell_data sun8i_a23_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 6/25 clk: fixed-factor: Add CLK_FIXED_FACTOR_HWS which takes list of struct clk_hw *
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, clk_init_data was expanded to include .parent_hws, for clk drivers to directly reference parents by clk_hw.
Add a new macro, CLK_FIXED_FACTOR_HWS, that can take an array of pointers to struct clk_hw, instead of a string, as its parent. Taking an array instead of a direct pointer allows the reuse of the array for multiple clks, rather than having one compound literal with the same contents allocated for each clk declaration.
--- include/linux/clk-provider.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+)
include/linux/clk-provider.h +15 -0
@@ -996,6 +996,21 @@ extern struct of_device_id __clk_of_table; _flags), \ } +/* +* 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), \ + } +#ifdef CONFIG_OF int of_clk_add_provider(struct device_node *np, struct clk *(*clk_src_get)(struct of_phandle_args *args,
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerPATCH v2 14/25 clk: sunxi-ng: a33: Use local parent references for CLK_FIXED_FACTOR
In reply to Chen-Yu TsaiFrom: Chen-Yu Tsai <[email protected]>
With the new clk parenting code and CLK_FIXED_FACTOR_{HW,FW_NAME} macros, we can reference parents locally via pointers to struct clk_hw or DT clock-names.
Convert existing CLK_FIXED_FACTOR definitions to either the _HW or _FW_NAME variant based on whether the parent clock is internal or external to the CCU.
--- drivers/clk/sunxi-ng/ccu-sun8i-a33.c | 34 ++++++++++++++++++---------- 1 file changed, 22 insertions(+), 12 deletions(-)
drivers/clk/sunxi-ng/ccu-sun8i-a33.c +22 -12
@@ -588,19 +588,29 @@ static struct ccu_common *sun8i_a33_ccu_clks[] = { &ats_clk.common, }; +static const struct clk_hw *clk_parent_pll_audio[] = { + &pll_audio_base_clk.common.hw +}; +/* We hardcode the divider to 1 for now */ -static CLK_FIXED_FACTOR(pll_audio_clk, "pll-audio", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_2x_clk, "pll-audio-2x", - "pll-audio-base", 2, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_4x_clk, "pll-audio-4x", - "pll-audio-base", 1, 1, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_audio_8x_clk, "pll-audio-8x", - "pll-audio-base", 1, 2, CLK_SET_RATE_PARENT); -static CLK_FIXED_FACTOR(pll_periph_2x_clk, "pll-periph-2x", - "pll-periph", 1, 2, 0); -static CLK_FIXED_FACTOR(pll_video_2x_clk, "pll-video-2x", - "pll-video", 1, 2, 0); +static CLK_FIXED_FACTOR_HWS(pll_audio_clk, "pll-audio", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_2x_clk, "pll-audio-2x", + clk_parent_pll_audio, + 2, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_4x_clk, "pll-audio-4x", + clk_parent_pll_audio, + 1, 1, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HWS(pll_audio_8x_clk, "pll-audio-8x", + clk_parent_pll_audio, + 1, 2, CLK_SET_RATE_PARENT); +static CLK_FIXED_FACTOR_HW(pll_periph_2x_clk, "pll-periph-2x", + &pll_periph_clk.common.hw, + 1, 2, 0); +static CLK_FIXED_FACTOR_HW(pll_video_2x_clk, "pll-video-2x", + &pll_video_clk.common.hw, + 1, 2, 0);static struct clk_hw_onecell_data sun8i_a33_hw_clks = { .hws = {
Signature · 1 line
2.20.1
Chen-Yu Tsai
maintainerv2 cover clk: sunxi-ng: clk parent rewrite part 1
From: Chen-Yu Tsai <[email protected]>
Hi everyone,
This is v2 of the sunxi-ng clk parent rewrite part 1.
Changes since v1:
- Collected Maxime's Acked-by for sunxi patches
- Expanded possible_parents_show() to cover most cases
- Added comment to CLK_HW_INIT_HWS detailing usage for sharing compound literal
As mentioned in my reply to the cover letter of v1, I can merge all the patches through the sunxi tree and send a combined (with other sunxi stuff) PR, or as an independent branch, whichever is preferred.
Excerpt from original cover letter follows:
This is series is the first part of a large series (I haven't done the rest) of patches to rewrite the clk parent relationship handling within the sunxi-ng clk driver. This is based on Stephen's recent work allowing clk drivers to specify clk parents using struct clk_hw * or parsing DT phandles in the clk node.
This series can be split into a few major parts:
1) The first patch is a small fix for clk debugfs representation. This was done before commit 1a079560b145 ("clk: Cache core in clk_fetch_parent_index() without names") was posted, so it might or might not be needed. Found this when checking my work using clk_possible_parents.
2) A bunch of CLK_HW_INIT_* helper macros are added. These cover the situations I encountered, or assume I will encounter, such as single internal (struct clk_hw *) parent, single DT (struct clk_parent_data .fw_name), multiple internal parents, and multiple mixed (internal + DT) parents. A special variant for just an internal single parent is added, CLK_HW_INIT_HWS, which lets the driver share the singular list, instead of having the compiler create a compound literal every time. It might even make sense to only keep this variant.
3) A bunch of CLK_FIXED_FACTOR_* helper macros are added. The rationale is the same as the single parent CLK_HW_INIT_* helpers.
4) Bulk conversion of CLK_FIXED_FACTOR to use local parent references, either struct clk_hw * or DT .fw_name types, whichever the hardware requires.
5) The beginning of SUNXI_CCU_GATE conversion to local parent references. This part is not done. They are included as justification and examples for the shared list of clk parents case.
Thanks
ChenYu
Chen-Yu Tsai (25):
clk: Fix debugfs clk_possible_parents for clks without parent string
names
clk: Add CLK_HW_INIT_* macros using .parent_hws
clk: Add CLK_HW_INIT_FW_NAME macro using .fw_name in .parent_data
clk: Add CLK_HW_INIT_PARENT_DATA macro using .parent_data
clk: fixed-factor: Add CLK_FIXED_FACTOR_HW which takes clk_hw pointer
as parent
clk: fixed-factor: Add CLK_FIXED_FACTOR_HWS which takes list of struct
clk_hw *
clk: fixed-factor: Add CLK_FIXED_FACTOR_FW_NAME for DT clock-names
parent
clk: sunxi-ng: switch to of_clk_hw_register() for registering clks
clk: sunxi-ng: sun8i-r: Use local parent references for CLK_HW_INIT_*
clk: sunxi-ng: a10: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: sun5i: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: a31: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: a23: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: a33: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: h3: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: r40: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: v3s: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: sun8i-r: Use local parent references for
CLK_FIXED_FACTOR
clk: sunxi-ng: f1c100s: Use local parent references for
CLK_FIXED_FACTOR
clk: sunxi-ng: a64: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: h6: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: h6-r: Use local parent references for CLK_FIXED_FACTOR
clk: sunxi-ng: gate: Add macros for referencing local clock parents
clk: sunxi-ng: a80-usb: Use local parent references for SUNXI_CCU_GATE
clk: sunxi-ng: sun8i-r: Use local parent references for SUNXI_CCU_GATE
drivers/clk/clk.c | 44 +++++++++- drivers/clk/sunxi-ng/ccu-sun4i-a10.c | 39 ++++++--- drivers/clk/sunxi-ng/ccu-sun50i-a64.c | 41 +++++---- drivers/clk/sunxi-ng/ccu-sun50i-h6-r.c | 2 +- drivers/clk/sunxi-ng/ccu-sun50i-h6.c | 69 +++++++++------ drivers/clk/sunxi-ng/ccu-sun5i.c | 34 +++++--- drivers/clk/sunxi-ng/ccu-sun6i-a31.c | 39 ++++++--- drivers/clk/sunxi-ng/ccu-sun8i-a23.c | 34 +++++--- drivers/clk/sunxi-ng/ccu-sun8i-a33.c | 34 +++++--- drivers/clk/sunxi-ng/ccu-sun8i-h3.c | 29 ++++--- drivers/clk/sunxi-ng/ccu-sun8i-r.c | 104 +++++++++++------------ drivers/clk/sunxi-ng/ccu-sun8i-r40.c | 46 ++++++---- drivers/clk/sunxi-ng/ccu-sun8i-v3s.c | 29 ++++--- drivers/clk/sunxi-ng/ccu-sun9i-a80-usb.c | 32 ++++--- drivers/clk/sunxi-ng/ccu-suniv-f1c100s.c | 29 ++++--- drivers/clk/sunxi-ng/ccu_common.c | 2 +- drivers/clk/sunxi-ng/ccu_gate.h | 53 ++++++++++++ include/linux/clk-provider.h | 89 +++++++++++++++++++ 18 files changed, 526 insertions(+), 223 deletions(-)
Signature · 7 lines
2.20.1 _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Chen-Yu Tsai
maintainerPATCH v2 5/25 clk: fixed-factor: Add CLK_FIXED_FACTOR_HW which takes clk_hw pointer as parent
From: Chen-Yu Tsai <[email protected]>
With the new clk parenting code, clk_init_data was expanded to include .parent_hws, for clk drivers to directly reference parents by clk_hw.
Add a new macro, CLK_FIXED_FACTOR_HW, that can take a struct clk_hw pointer, instead of a string, as its parent.
--- include/linux/clk-provider.h | 11 +++++++++++ 1 file changed, 11 insertions(+)
include/linux/clk-provider.h +11 -0
@@ -985,6 +985,17 @@ extern struct of_device_id __clk_of_table; _flags), \ } +#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), \ + } +#ifdef CONFIG_OF int of_clk_add_provider(struct device_node *np, struct clk *(*clk_src_get)(struct of_phandle_args *args,
Signature · 1 line
2.20.1