2 * Copyright 2013 Freescale Semiconductor, Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
8 * clock driver for Freescale PowerPC corenet SoCs.
10 #include <linux/clk-provider.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/of_address.h>
15 #include <linux/of_platform.h>
17 #include <linux/slab.h>
22 unsigned int clk_per_pll
;
26 #define PLL_KILL BIT(31)
27 #define CLKSEL_SHIFT 27
28 #define CLKSEL_ADJUST BIT(0)
29 #define to_cmux_clk(p) container_of(p, struct cmux_clk, hw)
31 static int cmux_set_parent(struct clk_hw
*hw
, u8 idx
)
33 struct cmux_clk
*clk
= to_cmux_clk(hw
);
36 clksel
= ((idx
/ clk
->clk_per_pll
) << 2) + idx
% clk
->clk_per_pll
;
37 if (clk
->flags
& CLKSEL_ADJUST
)
39 clksel
= (clksel
& 0xf) << CLKSEL_SHIFT
;
40 iowrite32be(clksel
, clk
->reg
);
45 static u8
cmux_get_parent(struct clk_hw
*hw
)
47 struct cmux_clk
*clk
= to_cmux_clk(hw
);
50 clksel
= ioread32be(clk
->reg
);
51 clksel
= (clksel
>> CLKSEL_SHIFT
) & 0xf;
52 if (clk
->flags
& CLKSEL_ADJUST
)
54 clksel
= (clksel
>> 2) * clk
->clk_per_pll
+ clksel
% 4;
59 const struct clk_ops cmux_ops
= {
60 .get_parent
= cmux_get_parent
,
61 .set_parent
= cmux_set_parent
,
64 static void __init
core_mux_init(struct device_node
*np
)
67 struct clk_init_data init
;
68 struct cmux_clk
*cmux_clk
;
69 struct device_node
*node
;
73 const char **parent_names
;
74 struct of_phandle_args clkspec
;
76 rc
= of_property_read_u32(np
, "reg", &offset
);
78 pr_err("%s: could not get reg property\n", np
->name
);
82 /* get the input clock source count */
83 count
= of_property_count_strings(np
, "clock-names");
85 pr_err("%s: get clock count error\n", np
->name
);
88 parent_names
= kzalloc((sizeof(char *) * count
), GFP_KERNEL
);
90 pr_err("%s: could not allocate parent_names\n", __func__
);
94 for (i
= 0; i
< count
; i
++)
95 parent_names
[i
] = of_clk_get_parent_name(np
, i
);
97 cmux_clk
= kzalloc(sizeof(struct cmux_clk
), GFP_KERNEL
);
99 pr_err("%s: could not allocate cmux_clk\n", __func__
);
102 cmux_clk
->reg
= of_iomap(np
, 0);
103 if (!cmux_clk
->reg
) {
104 pr_err("%s: could not map register\n", __func__
);
108 rc
= of_parse_phandle_with_args(np
, "clocks", "#clock-cells", 0,
111 pr_err("%s: parse clock node error\n", __func__
);
115 cmux_clk
->clk_per_pll
= of_property_count_strings(clkspec
.np
,
116 "clock-output-names");
117 of_node_put(clkspec
.np
);
119 node
= of_find_compatible_node(NULL
, NULL
, "fsl,p4080-clockgen");
120 if (node
&& (offset
>= 0x80))
121 cmux_clk
->flags
= CLKSEL_ADJUST
;
123 rc
= of_property_read_string_index(np
, "clock-output-names",
126 pr_err("%s: read clock names error\n", np
->name
);
130 init
.name
= clk_name
;
131 init
.ops
= &cmux_ops
;
132 init
.parent_names
= parent_names
;
133 init
.num_parents
= count
;
135 cmux_clk
->hw
.init
= &init
;
137 clk
= clk_register(NULL
, &cmux_clk
->hw
);
139 pr_err("%s: could not register clock\n", clk_name
);
143 rc
= of_clk_add_provider(np
, of_clk_src_simple_get
, clk
);
145 pr_err("Could not register clock provider for node:%s\n",
154 /* free *_names because they are reallocated when registered */
158 static void __init
core_pll_init(struct device_node
*np
)
162 const char *clk_name
, *parent_name
;
163 struct clk_onecell_data
*onecell_data
;
164 struct clk
**subclks
;
167 base
= of_iomap(np
, 0);
169 pr_err("clk-ppc: iomap error\n");
173 /* get the multiple of PLL */
174 mult
= ioread32be(base
);
176 /* check if this PLL is disabled */
177 if (mult
& PLL_KILL
) {
178 pr_debug("PLL:%s is disabled\n", np
->name
);
181 mult
= (mult
>> 1) & 0x3f;
183 parent_name
= of_clk_get_parent_name(np
, 0);
185 pr_err("PLL: %s must have a parent\n", np
->name
);
189 count
= of_property_count_strings(np
, "clock-output-names");
190 if (count
< 0 || count
> 4) {
191 pr_err("%s: clock is not supported\n", np
->name
);
195 subclks
= kzalloc(sizeof(struct clk
*) * count
, GFP_KERNEL
);
197 pr_err("%s: could not allocate subclks\n", __func__
);
201 onecell_data
= kzalloc(sizeof(struct clk_onecell_data
), GFP_KERNEL
);
203 pr_err("%s: could not allocate onecell_data\n", __func__
);
207 for (i
= 0; i
< count
; i
++) {
208 rc
= of_property_read_string_index(np
, "clock-output-names",
211 pr_err("%s: could not get clock names\n", np
->name
);
216 * when count == 4, there are 4 output clocks:
217 * /1, /2, /3, /4 respectively
218 * when count < 4, there are at least 2 output clocks:
219 * /1, /2, (/4, if count == 3) respectively.
222 subclks
[i
] = clk_register_fixed_factor(NULL
, clk_name
,
223 parent_name
, 0, mult
, 1 + i
);
226 subclks
[i
] = clk_register_fixed_factor(NULL
, clk_name
,
227 parent_name
, 0, mult
, 1 << i
);
229 if (IS_ERR(subclks
[i
])) {
230 pr_err("%s: could not register clock\n", clk_name
);
235 onecell_data
->clks
= subclks
;
236 onecell_data
->clk_num
= count
;
238 rc
= of_clk_add_provider(np
, of_clk_src_onecell_get
, onecell_data
);
240 pr_err("Could not register clk provider for node:%s\n",
255 static void __init
sysclk_init(struct device_node
*node
)
258 const char *clk_name
= node
->name
;
259 struct device_node
*np
= of_get_parent(node
);
263 pr_err("ppc-clk: could not get parent node\n");
267 if (of_property_read_u32(np
, "clock-frequency", &rate
)) {
272 of_property_read_string(np
, "clock-output-names", &clk_name
);
274 clk
= clk_register_fixed_rate(NULL
, clk_name
, NULL
, CLK_IS_ROOT
, rate
);
276 of_clk_add_provider(np
, of_clk_src_simple_get
, clk
);
278 CLK_OF_DECLARE(qoriq_sysclk_1
, "fsl,qoriq-sysclk-1.0", sysclk_init
);
279 CLK_OF_DECLARE(qoriq_sysclk_2
, "fsl,qoriq-sysclk-2.0", sysclk_init
);
280 CLK_OF_DECLARE(qoriq_core_pll_1
, "fsl,qoriq-core-pll-1.0", core_pll_init
);
281 CLK_OF_DECLARE(qoriq_core_pll_2
, "fsl,qoriq-core-pll-2.0", core_pll_init
);
282 CLK_OF_DECLARE(qoriq_core_mux_1
, "fsl,qoriq-core-mux-1.0", core_mux_init
);
283 CLK_OF_DECLARE(qoriq_core_mux_2
, "fsl,qoriq-core-mux-2.0", core_mux_init
);