]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/clk/nxp/clk-lpc18xx-cgu.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'iio-for-4.10a' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23...
[mirror_ubuntu-bionic-kernel.git] / drivers / clk / nxp / clk-lpc18xx-cgu.c
1 /*
2 * Clk driver for NXP LPC18xx/LPC43xx Clock Generation Unit (CGU)
3 *
4 * Copyright (C) 2015 Joachim Eastwood <manabian@gmail.com>
5 *
6 * This file is licensed under the terms of the GNU General Public
7 * License version 2. This program is licensed "as is" without any
8 * warranty of any kind, whether express or implied.
9 */
10
11 #include <linux/clk-provider.h>
12 #include <linux/delay.h>
13 #include <linux/kernel.h>
14 #include <linux/of.h>
15 #include <linux/of_address.h>
16
17 #include <dt-bindings/clock/lpc18xx-cgu.h>
18
19 /* Clock Generation Unit (CGU) registers */
20 #define LPC18XX_CGU_XTAL_OSC_CTRL 0x018
21 #define LPC18XX_CGU_PLL0USB_STAT 0x01c
22 #define LPC18XX_CGU_PLL0USB_CTRL 0x020
23 #define LPC18XX_CGU_PLL0USB_MDIV 0x024
24 #define LPC18XX_CGU_PLL0USB_NP_DIV 0x028
25 #define LPC18XX_CGU_PLL0AUDIO_STAT 0x02c
26 #define LPC18XX_CGU_PLL0AUDIO_CTRL 0x030
27 #define LPC18XX_CGU_PLL0AUDIO_MDIV 0x034
28 #define LPC18XX_CGU_PLL0AUDIO_NP_DIV 0x038
29 #define LPC18XX_CGU_PLL0AUDIO_FRAC 0x03c
30 #define LPC18XX_CGU_PLL1_STAT 0x040
31 #define LPC18XX_CGU_PLL1_CTRL 0x044
32 #define LPC18XX_PLL1_CTRL_FBSEL BIT(6)
33 #define LPC18XX_PLL1_CTRL_DIRECT BIT(7)
34 #define LPC18XX_CGU_IDIV_CTRL(n) (0x048 + (n) * sizeof(u32))
35 #define LPC18XX_CGU_BASE_CLK(id) (0x05c + (id) * sizeof(u32))
36 #define LPC18XX_CGU_PLL_CTRL_OFFSET 0x4
37
38 /* PLL0 bits common to both audio and USB PLL */
39 #define LPC18XX_PLL0_STAT_LOCK BIT(0)
40 #define LPC18XX_PLL0_CTRL_PD BIT(0)
41 #define LPC18XX_PLL0_CTRL_BYPASS BIT(1)
42 #define LPC18XX_PLL0_CTRL_DIRECTI BIT(2)
43 #define LPC18XX_PLL0_CTRL_DIRECTO BIT(3)
44 #define LPC18XX_PLL0_CTRL_CLKEN BIT(4)
45 #define LPC18XX_PLL0_MDIV_MDEC_MASK 0x1ffff
46 #define LPC18XX_PLL0_MDIV_SELP_SHIFT 17
47 #define LPC18XX_PLL0_MDIV_SELI_SHIFT 22
48 #define LPC18XX_PLL0_MSEL_MAX BIT(15)
49
50 /* Register value that gives PLL0 post/pre dividers equal to 1 */
51 #define LPC18XX_PLL0_NP_DIVS_1 0x00302062
52
53 enum {
54 CLK_SRC_OSC32,
55 CLK_SRC_IRC,
56 CLK_SRC_ENET_RX_CLK,
57 CLK_SRC_ENET_TX_CLK,
58 CLK_SRC_GP_CLKIN,
59 CLK_SRC_RESERVED1,
60 CLK_SRC_OSC,
61 CLK_SRC_PLL0USB,
62 CLK_SRC_PLL0AUDIO,
63 CLK_SRC_PLL1,
64 CLK_SRC_RESERVED2,
65 CLK_SRC_RESERVED3,
66 CLK_SRC_IDIVA,
67 CLK_SRC_IDIVB,
68 CLK_SRC_IDIVC,
69 CLK_SRC_IDIVD,
70 CLK_SRC_IDIVE,
71 CLK_SRC_MAX
72 };
73
74 static const char *clk_src_names[CLK_SRC_MAX] = {
75 [CLK_SRC_OSC32] = "osc32",
76 [CLK_SRC_IRC] = "irc",
77 [CLK_SRC_ENET_RX_CLK] = "enet_rx_clk",
78 [CLK_SRC_ENET_TX_CLK] = "enet_tx_clk",
79 [CLK_SRC_GP_CLKIN] = "gp_clkin",
80 [CLK_SRC_OSC] = "osc",
81 [CLK_SRC_PLL0USB] = "pll0usb",
82 [CLK_SRC_PLL0AUDIO] = "pll0audio",
83 [CLK_SRC_PLL1] = "pll1",
84 [CLK_SRC_IDIVA] = "idiva",
85 [CLK_SRC_IDIVB] = "idivb",
86 [CLK_SRC_IDIVC] = "idivc",
87 [CLK_SRC_IDIVD] = "idivd",
88 [CLK_SRC_IDIVE] = "idive",
89 };
90
91 static const char *clk_base_names[BASE_CLK_MAX] = {
92 [BASE_SAFE_CLK] = "base_safe_clk",
93 [BASE_USB0_CLK] = "base_usb0_clk",
94 [BASE_PERIPH_CLK] = "base_periph_clk",
95 [BASE_USB1_CLK] = "base_usb1_clk",
96 [BASE_CPU_CLK] = "base_cpu_clk",
97 [BASE_SPIFI_CLK] = "base_spifi_clk",
98 [BASE_SPI_CLK] = "base_spi_clk",
99 [BASE_PHY_RX_CLK] = "base_phy_rx_clk",
100 [BASE_PHY_TX_CLK] = "base_phy_tx_clk",
101 [BASE_APB1_CLK] = "base_apb1_clk",
102 [BASE_APB3_CLK] = "base_apb3_clk",
103 [BASE_LCD_CLK] = "base_lcd_clk",
104 [BASE_ADCHS_CLK] = "base_adchs_clk",
105 [BASE_SDIO_CLK] = "base_sdio_clk",
106 [BASE_SSP0_CLK] = "base_ssp0_clk",
107 [BASE_SSP1_CLK] = "base_ssp1_clk",
108 [BASE_UART0_CLK] = "base_uart0_clk",
109 [BASE_UART1_CLK] = "base_uart1_clk",
110 [BASE_UART2_CLK] = "base_uart2_clk",
111 [BASE_UART3_CLK] = "base_uart3_clk",
112 [BASE_OUT_CLK] = "base_out_clk",
113 [BASE_AUDIO_CLK] = "base_audio_clk",
114 [BASE_CGU_OUT0_CLK] = "base_cgu_out0_clk",
115 [BASE_CGU_OUT1_CLK] = "base_cgu_out1_clk",
116 };
117
118 static u32 lpc18xx_cgu_pll0_src_ids[] = {
119 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
120 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
121 CLK_SRC_PLL1, CLK_SRC_IDIVA, CLK_SRC_IDIVB, CLK_SRC_IDIVC,
122 CLK_SRC_IDIVD, CLK_SRC_IDIVE,
123 };
124
125 static u32 lpc18xx_cgu_pll1_src_ids[] = {
126 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
127 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
128 CLK_SRC_PLL0USB, CLK_SRC_PLL0AUDIO, CLK_SRC_IDIVA,
129 CLK_SRC_IDIVB, CLK_SRC_IDIVC, CLK_SRC_IDIVD, CLK_SRC_IDIVE,
130 };
131
132 static u32 lpc18xx_cgu_idiva_src_ids[] = {
133 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
134 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
135 CLK_SRC_PLL0USB, CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1
136 };
137
138 static u32 lpc18xx_cgu_idivbcde_src_ids[] = {
139 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
140 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
141 CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1, CLK_SRC_IDIVA,
142 };
143
144 static u32 lpc18xx_cgu_base_irc_src_ids[] = {CLK_SRC_IRC};
145
146 static u32 lpc18xx_cgu_base_usb0_src_ids[] = {CLK_SRC_PLL0USB};
147
148 static u32 lpc18xx_cgu_base_common_src_ids[] = {
149 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
150 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
151 CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1, CLK_SRC_IDIVA,
152 CLK_SRC_IDIVB, CLK_SRC_IDIVC, CLK_SRC_IDIVD, CLK_SRC_IDIVE,
153 };
154
155 static u32 lpc18xx_cgu_base_all_src_ids[] = {
156 CLK_SRC_OSC32, CLK_SRC_IRC, CLK_SRC_ENET_RX_CLK,
157 CLK_SRC_ENET_TX_CLK, CLK_SRC_GP_CLKIN, CLK_SRC_OSC,
158 CLK_SRC_PLL0USB, CLK_SRC_PLL0AUDIO, CLK_SRC_PLL1,
159 CLK_SRC_IDIVA, CLK_SRC_IDIVB, CLK_SRC_IDIVC,
160 CLK_SRC_IDIVD, CLK_SRC_IDIVE,
161 };
162
163 struct lpc18xx_cgu_src_clk_div {
164 u8 clk_id;
165 u8 n_parents;
166 struct clk_divider div;
167 struct clk_mux mux;
168 struct clk_gate gate;
169 };
170
171 #define LPC1XX_CGU_SRC_CLK_DIV(_id, _width, _table) \
172 { \
173 .clk_id = CLK_SRC_ ##_id, \
174 .n_parents = ARRAY_SIZE(lpc18xx_cgu_ ##_table), \
175 .div = { \
176 .shift = 2, \
177 .width = _width, \
178 }, \
179 .mux = { \
180 .mask = 0x1f, \
181 .shift = 24, \
182 .table = lpc18xx_cgu_ ##_table, \
183 }, \
184 .gate = { \
185 .bit_idx = 0, \
186 .flags = CLK_GATE_SET_TO_DISABLE, \
187 }, \
188 }
189
190 static struct lpc18xx_cgu_src_clk_div lpc18xx_cgu_src_clk_divs[] = {
191 LPC1XX_CGU_SRC_CLK_DIV(IDIVA, 2, idiva_src_ids),
192 LPC1XX_CGU_SRC_CLK_DIV(IDIVB, 4, idivbcde_src_ids),
193 LPC1XX_CGU_SRC_CLK_DIV(IDIVC, 4, idivbcde_src_ids),
194 LPC1XX_CGU_SRC_CLK_DIV(IDIVD, 4, idivbcde_src_ids),
195 LPC1XX_CGU_SRC_CLK_DIV(IDIVE, 8, idivbcde_src_ids),
196 };
197
198 struct lpc18xx_cgu_base_clk {
199 u8 clk_id;
200 u8 n_parents;
201 struct clk_mux mux;
202 struct clk_gate gate;
203 };
204
205 #define LPC1XX_CGU_BASE_CLK(_id, _table, _flags) \
206 { \
207 .clk_id = BASE_ ##_id ##_CLK, \
208 .n_parents = ARRAY_SIZE(lpc18xx_cgu_ ##_table), \
209 .mux = { \
210 .mask = 0x1f, \
211 .shift = 24, \
212 .table = lpc18xx_cgu_ ##_table, \
213 .flags = _flags, \
214 }, \
215 .gate = { \
216 .bit_idx = 0, \
217 .flags = CLK_GATE_SET_TO_DISABLE, \
218 }, \
219 }
220
221 static struct lpc18xx_cgu_base_clk lpc18xx_cgu_base_clks[] = {
222 LPC1XX_CGU_BASE_CLK(SAFE, base_irc_src_ids, CLK_MUX_READ_ONLY),
223 LPC1XX_CGU_BASE_CLK(USB0, base_usb0_src_ids, 0),
224 LPC1XX_CGU_BASE_CLK(PERIPH, base_common_src_ids, 0),
225 LPC1XX_CGU_BASE_CLK(USB1, base_all_src_ids, 0),
226 LPC1XX_CGU_BASE_CLK(CPU, base_common_src_ids, 0),
227 LPC1XX_CGU_BASE_CLK(SPIFI, base_common_src_ids, 0),
228 LPC1XX_CGU_BASE_CLK(SPI, base_common_src_ids, 0),
229 LPC1XX_CGU_BASE_CLK(PHY_RX, base_common_src_ids, 0),
230 LPC1XX_CGU_BASE_CLK(PHY_TX, base_common_src_ids, 0),
231 LPC1XX_CGU_BASE_CLK(APB1, base_common_src_ids, 0),
232 LPC1XX_CGU_BASE_CLK(APB3, base_common_src_ids, 0),
233 LPC1XX_CGU_BASE_CLK(LCD, base_common_src_ids, 0),
234 LPC1XX_CGU_BASE_CLK(ADCHS, base_common_src_ids, 0),
235 LPC1XX_CGU_BASE_CLK(SDIO, base_common_src_ids, 0),
236 LPC1XX_CGU_BASE_CLK(SSP0, base_common_src_ids, 0),
237 LPC1XX_CGU_BASE_CLK(SSP1, base_common_src_ids, 0),
238 LPC1XX_CGU_BASE_CLK(UART0, base_common_src_ids, 0),
239 LPC1XX_CGU_BASE_CLK(UART1, base_common_src_ids, 0),
240 LPC1XX_CGU_BASE_CLK(UART2, base_common_src_ids, 0),
241 LPC1XX_CGU_BASE_CLK(UART3, base_common_src_ids, 0),
242 LPC1XX_CGU_BASE_CLK(OUT, base_all_src_ids, 0),
243 { /* 21 reserved */ },
244 { /* 22 reserved */ },
245 { /* 23 reserved */ },
246 { /* 24 reserved */ },
247 LPC1XX_CGU_BASE_CLK(AUDIO, base_common_src_ids, 0),
248 LPC1XX_CGU_BASE_CLK(CGU_OUT0, base_all_src_ids, 0),
249 LPC1XX_CGU_BASE_CLK(CGU_OUT1, base_all_src_ids, 0),
250 };
251
252 struct lpc18xx_pll {
253 struct clk_hw hw;
254 void __iomem *reg;
255 spinlock_t *lock;
256 u8 flags;
257 };
258
259 #define to_lpc_pll(hw) container_of(hw, struct lpc18xx_pll, hw)
260
261 struct lpc18xx_cgu_pll_clk {
262 u8 clk_id;
263 u8 n_parents;
264 u8 reg_offset;
265 struct clk_mux mux;
266 struct clk_gate gate;
267 struct lpc18xx_pll pll;
268 const struct clk_ops *pll_ops;
269 };
270
271 #define LPC1XX_CGU_CLK_PLL(_id, _table, _pll_ops) \
272 { \
273 .clk_id = CLK_SRC_ ##_id, \
274 .n_parents = ARRAY_SIZE(lpc18xx_cgu_ ##_table), \
275 .reg_offset = LPC18XX_CGU_ ##_id ##_STAT, \
276 .mux = { \
277 .mask = 0x1f, \
278 .shift = 24, \
279 .table = lpc18xx_cgu_ ##_table, \
280 }, \
281 .gate = { \
282 .bit_idx = 0, \
283 .flags = CLK_GATE_SET_TO_DISABLE, \
284 }, \
285 .pll_ops = &lpc18xx_ ##_pll_ops, \
286 }
287
288 /*
289 * PLL0 uses a special register value encoding. The compute functions below
290 * are taken or derived from the LPC1850 user manual (section 12.6.3.3).
291 */
292
293 /* Compute PLL0 multiplier from decoded version */
294 static u32 lpc18xx_pll0_mdec2msel(u32 x)
295 {
296 int i;
297
298 switch (x) {
299 case 0x18003: return 1;
300 case 0x10003: return 2;
301 default:
302 for (i = LPC18XX_PLL0_MSEL_MAX + 1; x != 0x4000 && i > 0; i--)
303 x = ((x ^ x >> 14) & 1) | (x << 1 & 0x7fff);
304 return i;
305 }
306 }
307 /* Compute PLL0 decoded multiplier from binary version */
308 static u32 lpc18xx_pll0_msel2mdec(u32 msel)
309 {
310 u32 i, x = 0x4000;
311
312 switch (msel) {
313 case 0: return 0;
314 case 1: return 0x18003;
315 case 2: return 0x10003;
316 default:
317 for (i = msel; i <= LPC18XX_PLL0_MSEL_MAX; i++)
318 x = ((x ^ x >> 1) & 1) << 14 | (x >> 1 & 0xffff);
319 return x;
320 }
321 }
322
323 /* Compute PLL0 bandwidth SELI reg from multiplier */
324 static u32 lpc18xx_pll0_msel2seli(u32 msel)
325 {
326 u32 tmp;
327
328 if (msel > 16384) return 1;
329 if (msel > 8192) return 2;
330 if (msel > 2048) return 4;
331 if (msel >= 501) return 8;
332 if (msel >= 60) {
333 tmp = 1024 / (msel + 9);
334 return ((1024 == (tmp * (msel + 9))) == 0) ? tmp * 4 : (tmp + 1) * 4;
335 }
336
337 return (msel & 0x3c) + 4;
338 }
339
340 /* Compute PLL0 bandwidth SELP reg from multiplier */
341 static u32 lpc18xx_pll0_msel2selp(u32 msel)
342 {
343 if (msel < 60)
344 return (msel >> 1) + 1;
345
346 return 31;
347 }
348
349 static unsigned long lpc18xx_pll0_recalc_rate(struct clk_hw *hw,
350 unsigned long parent_rate)
351 {
352 struct lpc18xx_pll *pll = to_lpc_pll(hw);
353 u32 ctrl, mdiv, msel, npdiv;
354
355 ctrl = clk_readl(pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
356 mdiv = clk_readl(pll->reg + LPC18XX_CGU_PLL0USB_MDIV);
357 npdiv = clk_readl(pll->reg + LPC18XX_CGU_PLL0USB_NP_DIV);
358
359 if (ctrl & LPC18XX_PLL0_CTRL_BYPASS)
360 return parent_rate;
361
362 if (npdiv != LPC18XX_PLL0_NP_DIVS_1) {
363 pr_warn("%s: pre/post dividers not supported\n", __func__);
364 return 0;
365 }
366
367 msel = lpc18xx_pll0_mdec2msel(mdiv & LPC18XX_PLL0_MDIV_MDEC_MASK);
368 if (msel)
369 return 2 * msel * parent_rate;
370
371 pr_warn("%s: unable to calculate rate\n", __func__);
372
373 return 0;
374 }
375
376 static long lpc18xx_pll0_round_rate(struct clk_hw *hw, unsigned long rate,
377 unsigned long *prate)
378 {
379 unsigned long m;
380
381 if (*prate < rate) {
382 pr_warn("%s: pll dividers not supported\n", __func__);
383 return -EINVAL;
384 }
385
386 m = DIV_ROUND_UP_ULL(*prate, rate * 2);
387 if (m <= 0 && m > LPC18XX_PLL0_MSEL_MAX) {
388 pr_warn("%s: unable to support rate %lu\n", __func__, rate);
389 return -EINVAL;
390 }
391
392 return 2 * *prate * m;
393 }
394
395 static int lpc18xx_pll0_set_rate(struct clk_hw *hw, unsigned long rate,
396 unsigned long parent_rate)
397 {
398 struct lpc18xx_pll *pll = to_lpc_pll(hw);
399 u32 ctrl, stat, m;
400 int retry = 3;
401
402 if (parent_rate < rate) {
403 pr_warn("%s: pll dividers not supported\n", __func__);
404 return -EINVAL;
405 }
406
407 m = DIV_ROUND_UP_ULL(parent_rate, rate * 2);
408 if (m <= 0 && m > LPC18XX_PLL0_MSEL_MAX) {
409 pr_warn("%s: unable to support rate %lu\n", __func__, rate);
410 return -EINVAL;
411 }
412
413 m = lpc18xx_pll0_msel2mdec(m);
414 m |= lpc18xx_pll0_msel2selp(m) << LPC18XX_PLL0_MDIV_SELP_SHIFT;
415 m |= lpc18xx_pll0_msel2seli(m) << LPC18XX_PLL0_MDIV_SELI_SHIFT;
416
417 /* Power down PLL, disable clk output and dividers */
418 ctrl = clk_readl(pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
419 ctrl |= LPC18XX_PLL0_CTRL_PD;
420 ctrl &= ~(LPC18XX_PLL0_CTRL_BYPASS | LPC18XX_PLL0_CTRL_DIRECTI |
421 LPC18XX_PLL0_CTRL_DIRECTO | LPC18XX_PLL0_CTRL_CLKEN);
422 clk_writel(ctrl, pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
423
424 /* Configure new PLL settings */
425 clk_writel(m, pll->reg + LPC18XX_CGU_PLL0USB_MDIV);
426 clk_writel(LPC18XX_PLL0_NP_DIVS_1, pll->reg + LPC18XX_CGU_PLL0USB_NP_DIV);
427
428 /* Power up PLL and wait for lock */
429 ctrl &= ~LPC18XX_PLL0_CTRL_PD;
430 clk_writel(ctrl, pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
431 do {
432 udelay(10);
433 stat = clk_readl(pll->reg + LPC18XX_CGU_PLL0USB_STAT);
434 if (stat & LPC18XX_PLL0_STAT_LOCK) {
435 ctrl |= LPC18XX_PLL0_CTRL_CLKEN;
436 clk_writel(ctrl, pll->reg + LPC18XX_CGU_PLL0USB_CTRL);
437
438 return 0;
439 }
440 } while (retry--);
441
442 pr_warn("%s: unable to lock pll\n", __func__);
443
444 return -EINVAL;
445 }
446
447 static const struct clk_ops lpc18xx_pll0_ops = {
448 .recalc_rate = lpc18xx_pll0_recalc_rate,
449 .round_rate = lpc18xx_pll0_round_rate,
450 .set_rate = lpc18xx_pll0_set_rate,
451 };
452
453 static unsigned long lpc18xx_pll1_recalc_rate(struct clk_hw *hw,
454 unsigned long parent_rate)
455 {
456 struct lpc18xx_pll *pll = to_lpc_pll(hw);
457 u16 msel, nsel, psel;
458 bool direct, fbsel;
459 u32 stat, ctrl;
460
461 stat = clk_readl(pll->reg + LPC18XX_CGU_PLL1_STAT);
462 ctrl = clk_readl(pll->reg + LPC18XX_CGU_PLL1_CTRL);
463
464 direct = (ctrl & LPC18XX_PLL1_CTRL_DIRECT) ? true : false;
465 fbsel = (ctrl & LPC18XX_PLL1_CTRL_FBSEL) ? true : false;
466
467 msel = ((ctrl >> 16) & 0xff) + 1;
468 nsel = ((ctrl >> 12) & 0x3) + 1;
469
470 if (direct || fbsel)
471 return msel * (parent_rate / nsel);
472
473 psel = (ctrl >> 8) & 0x3;
474 psel = 1 << psel;
475
476 return (msel / (2 * psel)) * (parent_rate / nsel);
477 }
478
479 static const struct clk_ops lpc18xx_pll1_ops = {
480 .recalc_rate = lpc18xx_pll1_recalc_rate,
481 };
482
483 static int lpc18xx_cgu_gate_enable(struct clk_hw *hw)
484 {
485 return clk_gate_ops.enable(hw);
486 }
487
488 static void lpc18xx_cgu_gate_disable(struct clk_hw *hw)
489 {
490 clk_gate_ops.disable(hw);
491 }
492
493 static int lpc18xx_cgu_gate_is_enabled(struct clk_hw *hw)
494 {
495 const struct clk_hw *parent;
496
497 /*
498 * The consumer of base clocks needs know if the
499 * base clock is really enabled before it can be
500 * accessed. It is therefore necessary to verify
501 * this all the way up.
502 */
503 parent = clk_hw_get_parent(hw);
504 if (!parent)
505 return 0;
506
507 if (!clk_hw_is_enabled(parent))
508 return 0;
509
510 return clk_gate_ops.is_enabled(hw);
511 }
512
513 static const struct clk_ops lpc18xx_gate_ops = {
514 .enable = lpc18xx_cgu_gate_enable,
515 .disable = lpc18xx_cgu_gate_disable,
516 .is_enabled = lpc18xx_cgu_gate_is_enabled,
517 };
518
519 static struct lpc18xx_cgu_pll_clk lpc18xx_cgu_src_clk_plls[] = {
520 LPC1XX_CGU_CLK_PLL(PLL0USB, pll0_src_ids, pll0_ops),
521 LPC1XX_CGU_CLK_PLL(PLL0AUDIO, pll0_src_ids, pll0_ops),
522 LPC1XX_CGU_CLK_PLL(PLL1, pll1_src_ids, pll1_ops),
523 };
524
525 static void lpc18xx_fill_parent_names(const char **parent, u32 *id, int size)
526 {
527 int i;
528
529 for (i = 0; i < size; i++)
530 parent[i] = clk_src_names[id[i]];
531 }
532
533 static struct clk *lpc18xx_cgu_register_div(struct lpc18xx_cgu_src_clk_div *clk,
534 void __iomem *base, int n)
535 {
536 void __iomem *reg = base + LPC18XX_CGU_IDIV_CTRL(n);
537 const char *name = clk_src_names[clk->clk_id];
538 const char *parents[CLK_SRC_MAX];
539
540 clk->div.reg = reg;
541 clk->mux.reg = reg;
542 clk->gate.reg = reg;
543
544 lpc18xx_fill_parent_names(parents, clk->mux.table, clk->n_parents);
545
546 return clk_register_composite(NULL, name, parents, clk->n_parents,
547 &clk->mux.hw, &clk_mux_ops,
548 &clk->div.hw, &clk_divider_ops,
549 &clk->gate.hw, &lpc18xx_gate_ops, 0);
550 }
551
552
553 static struct clk *lpc18xx_register_base_clk(struct lpc18xx_cgu_base_clk *clk,
554 void __iomem *reg_base, int n)
555 {
556 void __iomem *reg = reg_base + LPC18XX_CGU_BASE_CLK(n);
557 const char *name = clk_base_names[clk->clk_id];
558 const char *parents[CLK_SRC_MAX];
559
560 if (clk->n_parents == 0)
561 return ERR_PTR(-ENOENT);
562
563 clk->mux.reg = reg;
564 clk->gate.reg = reg;
565
566 lpc18xx_fill_parent_names(parents, clk->mux.table, clk->n_parents);
567
568 /* SAFE_CLK can not be turned off */
569 if (n == BASE_SAFE_CLK)
570 return clk_register_composite(NULL, name, parents, clk->n_parents,
571 &clk->mux.hw, &clk_mux_ops,
572 NULL, NULL, NULL, NULL, 0);
573
574 return clk_register_composite(NULL, name, parents, clk->n_parents,
575 &clk->mux.hw, &clk_mux_ops,
576 NULL, NULL,
577 &clk->gate.hw, &lpc18xx_gate_ops, 0);
578 }
579
580
581 static struct clk *lpc18xx_cgu_register_pll(struct lpc18xx_cgu_pll_clk *clk,
582 void __iomem *base)
583 {
584 const char *name = clk_src_names[clk->clk_id];
585 const char *parents[CLK_SRC_MAX];
586
587 clk->pll.reg = base;
588 clk->mux.reg = base + clk->reg_offset + LPC18XX_CGU_PLL_CTRL_OFFSET;
589 clk->gate.reg = base + clk->reg_offset + LPC18XX_CGU_PLL_CTRL_OFFSET;
590
591 lpc18xx_fill_parent_names(parents, clk->mux.table, clk->n_parents);
592
593 return clk_register_composite(NULL, name, parents, clk->n_parents,
594 &clk->mux.hw, &clk_mux_ops,
595 &clk->pll.hw, clk->pll_ops,
596 &clk->gate.hw, &lpc18xx_gate_ops, 0);
597 }
598
599 static void __init lpc18xx_cgu_register_source_clks(struct device_node *np,
600 void __iomem *base)
601 {
602 const char *parents[CLK_SRC_MAX];
603 struct clk *clk;
604 int i;
605
606 /* Register the internal 12 MHz RC oscillator (IRC) */
607 clk = clk_register_fixed_rate(NULL, clk_src_names[CLK_SRC_IRC],
608 NULL, 0, 12000000);
609 if (IS_ERR(clk))
610 pr_warn("%s: failed to register irc clk\n", __func__);
611
612 /* Register crystal oscillator controlller */
613 parents[0] = of_clk_get_parent_name(np, 0);
614 clk = clk_register_gate(NULL, clk_src_names[CLK_SRC_OSC], parents[0],
615 0, base + LPC18XX_CGU_XTAL_OSC_CTRL,
616 0, CLK_GATE_SET_TO_DISABLE, NULL);
617 if (IS_ERR(clk))
618 pr_warn("%s: failed to register osc clk\n", __func__);
619
620 /* Register all PLLs */
621 for (i = 0; i < ARRAY_SIZE(lpc18xx_cgu_src_clk_plls); i++) {
622 clk = lpc18xx_cgu_register_pll(&lpc18xx_cgu_src_clk_plls[i],
623 base);
624 if (IS_ERR(clk))
625 pr_warn("%s: failed to register pll (%d)\n", __func__, i);
626 }
627
628 /* Register all clock dividers A-E */
629 for (i = 0; i < ARRAY_SIZE(lpc18xx_cgu_src_clk_divs); i++) {
630 clk = lpc18xx_cgu_register_div(&lpc18xx_cgu_src_clk_divs[i],
631 base, i);
632 if (IS_ERR(clk))
633 pr_warn("%s: failed to register div %d\n", __func__, i);
634 }
635 }
636
637 static struct clk *clk_base[BASE_CLK_MAX];
638 static struct clk_onecell_data clk_base_data = {
639 .clks = clk_base,
640 .clk_num = BASE_CLK_MAX,
641 };
642
643 static void __init lpc18xx_cgu_register_base_clks(void __iomem *reg_base)
644 {
645 int i;
646
647 for (i = BASE_SAFE_CLK; i < BASE_CLK_MAX; i++) {
648 clk_base[i] = lpc18xx_register_base_clk(&lpc18xx_cgu_base_clks[i],
649 reg_base, i);
650 if (IS_ERR(clk_base[i]) && PTR_ERR(clk_base[i]) != -ENOENT)
651 pr_warn("%s: register base clk %d failed\n", __func__, i);
652 }
653 }
654
655 static void __init lpc18xx_cgu_init(struct device_node *np)
656 {
657 void __iomem *reg_base;
658
659 reg_base = of_iomap(np, 0);
660 if (!reg_base) {
661 pr_warn("%s: failed to map address range\n", __func__);
662 return;
663 }
664
665 lpc18xx_cgu_register_source_clks(np, reg_base);
666 lpc18xx_cgu_register_base_clks(reg_base);
667
668 of_clk_add_provider(np, of_clk_src_onecell_get, &clk_base_data);
669 }
670 CLK_OF_DECLARE(lpc18xx_cgu, "nxp,lpc1850-cgu", lpc18xx_cgu_init);
ubuntu-bionic-kernel mirror