This source file includes following definitions.
- clk_busy_wait
- to_clk_busy_divider
- clk_busy_divider_recalc_rate
- clk_busy_divider_round_rate
- clk_busy_divider_set_rate
- imx_clk_hw_busy_divider
- to_clk_busy_mux
- clk_busy_mux_get_parent
- clk_busy_mux_set_parent
- imx_clk_hw_busy_mux
1
2
3
4
5
6
7 #include <linux/clk.h>
8 #include <linux/clk-provider.h>
9 #include <linux/io.h>
10 #include <linux/slab.h>
11 #include <linux/jiffies.h>
12 #include <linux/err.h>
13 #include "clk.h"
14
15 static int clk_busy_wait(void __iomem *reg, u8 shift)
16 {
17 unsigned long timeout = jiffies + msecs_to_jiffies(10);
18
19 while (readl_relaxed(reg) & (1 << shift))
20 if (time_after(jiffies, timeout))
21 return -ETIMEDOUT;
22
23 return 0;
24 }
25
26 struct clk_busy_divider {
27 struct clk_divider div;
28 const struct clk_ops *div_ops;
29 void __iomem *reg;
30 u8 shift;
31 };
32
33 static inline struct clk_busy_divider *to_clk_busy_divider(struct clk_hw *hw)
34 {
35 struct clk_divider *div = to_clk_divider(hw);
36
37 return container_of(div, struct clk_busy_divider, div);
38 }
39
40 static unsigned long clk_busy_divider_recalc_rate(struct clk_hw *hw,
41 unsigned long parent_rate)
42 {
43 struct clk_busy_divider *busy = to_clk_busy_divider(hw);
44
45 return busy->div_ops->recalc_rate(&busy->div.hw, parent_rate);
46 }
47
48 static long clk_busy_divider_round_rate(struct clk_hw *hw, unsigned long rate,
49 unsigned long *prate)
50 {
51 struct clk_busy_divider *busy = to_clk_busy_divider(hw);
52
53 return busy->div_ops->round_rate(&busy->div.hw, rate, prate);
54 }
55
56 static int clk_busy_divider_set_rate(struct clk_hw *hw, unsigned long rate,
57 unsigned long parent_rate)
58 {
59 struct clk_busy_divider *busy = to_clk_busy_divider(hw);
60 int ret;
61
62 ret = busy->div_ops->set_rate(&busy->div.hw, rate, parent_rate);
63 if (!ret)
64 ret = clk_busy_wait(busy->reg, busy->shift);
65
66 return ret;
67 }
68
69 static const struct clk_ops clk_busy_divider_ops = {
70 .recalc_rate = clk_busy_divider_recalc_rate,
71 .round_rate = clk_busy_divider_round_rate,
72 .set_rate = clk_busy_divider_set_rate,
73 };
74
75 struct clk_hw *imx_clk_hw_busy_divider(const char *name, const char *parent_name,
76 void __iomem *reg, u8 shift, u8 width,
77 void __iomem *busy_reg, u8 busy_shift)
78 {
79 struct clk_busy_divider *busy;
80 struct clk_hw *hw;
81 struct clk_init_data init;
82 int ret;
83
84 busy = kzalloc(sizeof(*busy), GFP_KERNEL);
85 if (!busy)
86 return ERR_PTR(-ENOMEM);
87
88 busy->reg = busy_reg;
89 busy->shift = busy_shift;
90
91 busy->div.reg = reg;
92 busy->div.shift = shift;
93 busy->div.width = width;
94 busy->div.lock = &imx_ccm_lock;
95 busy->div_ops = &clk_divider_ops;
96
97 init.name = name;
98 init.ops = &clk_busy_divider_ops;
99 init.flags = CLK_SET_RATE_PARENT | CLK_IS_CRITICAL;
100 init.parent_names = &parent_name;
101 init.num_parents = 1;
102
103 busy->div.hw.init = &init;
104
105 hw = &busy->div.hw;
106
107 ret = clk_hw_register(NULL, hw);
108 if (ret) {
109 kfree(busy);
110 return ERR_PTR(ret);
111 }
112
113 return hw;
114 }
115
116 struct clk_busy_mux {
117 struct clk_mux mux;
118 const struct clk_ops *mux_ops;
119 void __iomem *reg;
120 u8 shift;
121 };
122
123 static inline struct clk_busy_mux *to_clk_busy_mux(struct clk_hw *hw)
124 {
125 struct clk_mux *mux = to_clk_mux(hw);
126
127 return container_of(mux, struct clk_busy_mux, mux);
128 }
129
130 static u8 clk_busy_mux_get_parent(struct clk_hw *hw)
131 {
132 struct clk_busy_mux *busy = to_clk_busy_mux(hw);
133
134 return busy->mux_ops->get_parent(&busy->mux.hw);
135 }
136
137 static int clk_busy_mux_set_parent(struct clk_hw *hw, u8 index)
138 {
139 struct clk_busy_mux *busy = to_clk_busy_mux(hw);
140 int ret;
141
142 ret = busy->mux_ops->set_parent(&busy->mux.hw, index);
143 if (!ret)
144 ret = clk_busy_wait(busy->reg, busy->shift);
145
146 return ret;
147 }
148
149 static const struct clk_ops clk_busy_mux_ops = {
150 .get_parent = clk_busy_mux_get_parent,
151 .set_parent = clk_busy_mux_set_parent,
152 };
153
154 struct clk_hw *imx_clk_hw_busy_mux(const char *name, void __iomem *reg, u8 shift,
155 u8 width, void __iomem *busy_reg, u8 busy_shift,
156 const char * const *parent_names, int num_parents)
157 {
158 struct clk_busy_mux *busy;
159 struct clk_hw *hw;
160 struct clk_init_data init;
161 int ret;
162
163 busy = kzalloc(sizeof(*busy), GFP_KERNEL);
164 if (!busy)
165 return ERR_PTR(-ENOMEM);
166
167 busy->reg = busy_reg;
168 busy->shift = busy_shift;
169
170 busy->mux.reg = reg;
171 busy->mux.shift = shift;
172 busy->mux.mask = BIT(width) - 1;
173 busy->mux.lock = &imx_ccm_lock;
174 busy->mux_ops = &clk_mux_ops;
175
176 init.name = name;
177 init.ops = &clk_busy_mux_ops;
178 init.flags = CLK_IS_CRITICAL;
179 init.parent_names = parent_names;
180 init.num_parents = num_parents;
181
182 busy->mux.hw.init = &init;
183
184 hw = &busy->mux.hw;
185
186 ret = clk_hw_register(NULL, hw);
187 if (ret) {
188 kfree(busy);
189 return ERR_PTR(ret);
190 }
191
192 return hw;
193 }