blob: 3ebc376cda76b68265e72f4404e92a37cd875ab0 [file] [log] [blame]
Yann Gautier9aea69e2018-07-24 17:13:36 +02001/*
Yann Gautier360e0e92020-09-16 16:40:34 +02002 * Copyright (C) 2018-2021, STMicroelectronics - All Rights Reserved
Yann Gautier9aea69e2018-07-24 17:13:36 +02003 *
4 * SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
5 */
6
Yann Gautier9aea69e2018-07-24 17:13:36 +02007#include <assert.h>
Yann Gautier9aea69e2018-07-24 17:13:36 +02008#include <errno.h>
Yann Gautier9aea69e2018-07-24 17:13:36 +02009#include <stdint.h>
Antonio Nino Diaz00086e32018-08-16 16:46:06 +010010#include <stdio.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000011
12#include <libfdt.h>
13
Yann Gautier57e282b2019-01-07 11:17:24 +010014#include <platform_def.h>
15
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000016#include <arch.h>
17#include <arch_helpers.h>
18#include <common/debug.h>
Andre Przywaracc99f3f2020-03-26 12:51:21 +000019#include <common/fdt_wrappers.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000020#include <drivers/delay_timer.h>
21#include <drivers/generic_delay_timer.h>
Yann Gautier4d429472019-02-14 11:15:20 +010022#include <drivers/st/stm32mp_clkfunc.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000023#include <drivers/st/stm32mp1_clk.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000024#include <drivers/st/stm32mp1_rcc.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000025#include <dt-bindings/clock/stm32mp1-clksrc.h>
26#include <lib/mmio.h>
Yann Gautiere4a3c352019-02-14 10:53:33 +010027#include <lib/spinlock.h>
Antonio Nino Diaze0f90632018-12-14 00:18:21 +000028#include <lib/utils_def.h>
29#include <plat/common/platform.h>
30
Yann Gautier2299d572019-02-14 11:14:39 +010031#define MAX_HSI_HZ 64000000
Yann Gautiere4a3c352019-02-14 10:53:33 +010032#define USB_PHY_48_MHZ 48000000
Yann Gautier9aea69e2018-07-24 17:13:36 +020033
Yann Gautier2299d572019-02-14 11:14:39 +010034#define TIMEOUT_US_200MS U(200000)
35#define TIMEOUT_US_1S U(1000000)
Yann Gautier9aea69e2018-07-24 17:13:36 +020036
Yann Gautier2299d572019-02-14 11:14:39 +010037#define PLLRDY_TIMEOUT TIMEOUT_US_200MS
38#define CLKSRC_TIMEOUT TIMEOUT_US_200MS
39#define CLKDIV_TIMEOUT TIMEOUT_US_200MS
40#define HSIDIV_TIMEOUT TIMEOUT_US_200MS
41#define OSCRDY_TIMEOUT TIMEOUT_US_1S
Yann Gautier9aea69e2018-07-24 17:13:36 +020042
Yann Gautier5f2e8742019-05-17 15:57:56 +020043const char *stm32mp_osc_node_label[NB_OSC] = {
44 [_LSI] = "clk-lsi",
45 [_LSE] = "clk-lse",
46 [_HSI] = "clk-hsi",
47 [_HSE] = "clk-hse",
48 [_CSI] = "clk-csi",
49 [_I2S_CKIN] = "i2s_ckin",
50};
51
Yann Gautier9aea69e2018-07-24 17:13:36 +020052enum stm32mp1_parent_id {
53/* Oscillators are defined in enum stm32mp_osc_id */
54
55/* Other parent source */
56 _HSI_KER = NB_OSC,
57 _HSE_KER,
58 _HSE_KER_DIV2,
Gabriel Fernandez4e3a51a2021-07-27 15:39:16 +020059 _HSE_RTC,
Yann Gautier9aea69e2018-07-24 17:13:36 +020060 _CSI_KER,
61 _PLL1_P,
62 _PLL1_Q,
63 _PLL1_R,
64 _PLL2_P,
65 _PLL2_Q,
66 _PLL2_R,
67 _PLL3_P,
68 _PLL3_Q,
69 _PLL3_R,
70 _PLL4_P,
71 _PLL4_Q,
72 _PLL4_R,
73 _ACLK,
74 _PCLK1,
75 _PCLK2,
76 _PCLK3,
77 _PCLK4,
78 _PCLK5,
79 _HCLK6,
80 _HCLK2,
81 _CK_PER,
82 _CK_MPU,
Yann Gautiered342322019-02-15 17:33:27 +010083 _CK_MCU,
Yann Gautiere4a3c352019-02-14 10:53:33 +010084 _USB_PHY_48,
Yann Gautier9aea69e2018-07-24 17:13:36 +020085 _PARENT_NB,
86 _UNKNOWN_ID = 0xff,
87};
88
Yann Gautiere4a3c352019-02-14 10:53:33 +010089/* Lists only the parent clock we are interested in */
Yann Gautier9aea69e2018-07-24 17:13:36 +020090enum stm32mp1_parent_sel {
Yann Gautiere4a3c352019-02-14 10:53:33 +010091 _I2C12_SEL,
92 _I2C35_SEL,
93 _STGEN_SEL,
Yann Gautier9aea69e2018-07-24 17:13:36 +020094 _I2C46_SEL,
Yann Gautiere4a3c352019-02-14 10:53:33 +010095 _SPI6_SEL,
Yann Gautier9d8bbcd2019-05-07 18:49:33 +020096 _UART1_SEL,
Yann Gautiere4a3c352019-02-14 10:53:33 +010097 _RNG1_SEL,
Yann Gautier9aea69e2018-07-24 17:13:36 +020098 _UART6_SEL,
99 _UART24_SEL,
100 _UART35_SEL,
101 _UART78_SEL,
102 _SDMMC12_SEL,
103 _SDMMC3_SEL,
104 _QSPI_SEL,
105 _FMC_SEL,
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200106 _AXIS_SEL,
107 _MCUS_SEL,
Yann Gautier9aea69e2018-07-24 17:13:36 +0200108 _USBPHY_SEL,
109 _USBO_SEL,
Etienne Carriere04132612019-12-08 08:20:12 +0100110 _MPU_SEL,
Yann Gautierfaa9bcf2021-08-31 18:23:13 +0200111 _CKPER_SEL,
Etienne Carrierebccc7d02019-12-08 08:22:31 +0100112 _RTC_SEL,
Yann Gautier9aea69e2018-07-24 17:13:36 +0200113 _PARENT_SEL_NB,
114 _UNKNOWN_SEL = 0xff,
115};
116
Etienne Carriere04132612019-12-08 08:20:12 +0100117/* State the parent clock ID straight related to a clock */
118static const uint8_t parent_id_clock_id[_PARENT_NB] = {
119 [_HSE] = CK_HSE,
120 [_HSI] = CK_HSI,
121 [_CSI] = CK_CSI,
122 [_LSE] = CK_LSE,
123 [_LSI] = CK_LSI,
124 [_I2S_CKIN] = _UNKNOWN_ID,
125 [_USB_PHY_48] = _UNKNOWN_ID,
126 [_HSI_KER] = CK_HSI,
127 [_HSE_KER] = CK_HSE,
128 [_HSE_KER_DIV2] = CK_HSE_DIV2,
Gabriel Fernandez4e3a51a2021-07-27 15:39:16 +0200129 [_HSE_RTC] = _UNKNOWN_ID,
Etienne Carriere04132612019-12-08 08:20:12 +0100130 [_CSI_KER] = CK_CSI,
131 [_PLL1_P] = PLL1_P,
132 [_PLL1_Q] = PLL1_Q,
133 [_PLL1_R] = PLL1_R,
134 [_PLL2_P] = PLL2_P,
135 [_PLL2_Q] = PLL2_Q,
136 [_PLL2_R] = PLL2_R,
137 [_PLL3_P] = PLL3_P,
138 [_PLL3_Q] = PLL3_Q,
139 [_PLL3_R] = PLL3_R,
140 [_PLL4_P] = PLL4_P,
141 [_PLL4_Q] = PLL4_Q,
142 [_PLL4_R] = PLL4_R,
143 [_ACLK] = CK_AXI,
144 [_PCLK1] = CK_AXI,
145 [_PCLK2] = CK_AXI,
146 [_PCLK3] = CK_AXI,
147 [_PCLK4] = CK_AXI,
148 [_PCLK5] = CK_AXI,
149 [_CK_PER] = CK_PER,
150 [_CK_MPU] = CK_MPU,
151 [_CK_MCU] = CK_MCU,
152};
153
154static unsigned int clock_id2parent_id(unsigned long id)
155{
156 unsigned int n;
157
158 for (n = 0U; n < ARRAY_SIZE(parent_id_clock_id); n++) {
159 if (parent_id_clock_id[n] == id) {
160 return n;
161 }
162 }
163
164 return _UNKNOWN_ID;
165}
166
Yann Gautier9aea69e2018-07-24 17:13:36 +0200167enum stm32mp1_pll_id {
168 _PLL1,
169 _PLL2,
170 _PLL3,
171 _PLL4,
172 _PLL_NB
173};
174
175enum stm32mp1_div_id {
176 _DIV_P,
177 _DIV_Q,
178 _DIV_R,
179 _DIV_NB,
180};
181
182enum stm32mp1_clksrc_id {
183 CLKSRC_MPU,
184 CLKSRC_AXI,
Yann Gautiered342322019-02-15 17:33:27 +0100185 CLKSRC_MCU,
Yann Gautier9aea69e2018-07-24 17:13:36 +0200186 CLKSRC_PLL12,
187 CLKSRC_PLL3,
188 CLKSRC_PLL4,
189 CLKSRC_RTC,
190 CLKSRC_MCO1,
191 CLKSRC_MCO2,
192 CLKSRC_NB
193};
194
195enum stm32mp1_clkdiv_id {
196 CLKDIV_MPU,
197 CLKDIV_AXI,
Yann Gautiered342322019-02-15 17:33:27 +0100198 CLKDIV_MCU,
Yann Gautier9aea69e2018-07-24 17:13:36 +0200199 CLKDIV_APB1,
200 CLKDIV_APB2,
201 CLKDIV_APB3,
202 CLKDIV_APB4,
203 CLKDIV_APB5,
204 CLKDIV_RTC,
205 CLKDIV_MCO1,
206 CLKDIV_MCO2,
207 CLKDIV_NB
208};
209
210enum stm32mp1_pllcfg {
211 PLLCFG_M,
212 PLLCFG_N,
213 PLLCFG_P,
214 PLLCFG_Q,
215 PLLCFG_R,
216 PLLCFG_O,
217 PLLCFG_NB
218};
219
220enum stm32mp1_pllcsg {
221 PLLCSG_MOD_PER,
222 PLLCSG_INC_STEP,
223 PLLCSG_SSCG_MODE,
224 PLLCSG_NB
225};
226
227enum stm32mp1_plltype {
228 PLL_800,
229 PLL_1600,
230 PLL_TYPE_NB
231};
232
233struct stm32mp1_pll {
234 uint8_t refclk_min;
235 uint8_t refclk_max;
236 uint8_t divn_max;
237};
238
239struct stm32mp1_clk_gate {
240 uint16_t offset;
241 uint8_t bit;
242 uint8_t index;
243 uint8_t set_clr;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100244 uint8_t sel; /* Relates to enum stm32mp1_parent_sel */
245 uint8_t fixed; /* Relates to enum stm32mp1_parent_id */
Yann Gautier9aea69e2018-07-24 17:13:36 +0200246};
247
248struct stm32mp1_clk_sel {
249 uint16_t offset;
250 uint8_t src;
251 uint8_t msk;
252 uint8_t nb_parent;
253 const uint8_t *parent;
254};
255
256#define REFCLK_SIZE 4
257struct stm32mp1_clk_pll {
258 enum stm32mp1_plltype plltype;
259 uint16_t rckxselr;
260 uint16_t pllxcfgr1;
261 uint16_t pllxcfgr2;
262 uint16_t pllxfracr;
263 uint16_t pllxcr;
264 uint16_t pllxcsgr;
265 enum stm32mp_osc_id refclk[REFCLK_SIZE];
266};
267
Yann Gautiere4a3c352019-02-14 10:53:33 +0100268/* Clocks with selectable source and non set/clr register access */
269#define _CLK_SELEC(off, b, idx, s) \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200270 { \
271 .offset = (off), \
272 .bit = (b), \
273 .index = (idx), \
274 .set_clr = 0, \
275 .sel = (s), \
276 .fixed = _UNKNOWN_ID, \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200277 }
278
Yann Gautiere4a3c352019-02-14 10:53:33 +0100279/* Clocks with fixed source and non set/clr register access */
280#define _CLK_FIXED(off, b, idx, f) \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200281 { \
282 .offset = (off), \
283 .bit = (b), \
284 .index = (idx), \
285 .set_clr = 0, \
286 .sel = _UNKNOWN_SEL, \
287 .fixed = (f), \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200288 }
289
Yann Gautiere4a3c352019-02-14 10:53:33 +0100290/* Clocks with selectable source and set/clr register access */
291#define _CLK_SC_SELEC(off, b, idx, s) \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200292 { \
293 .offset = (off), \
294 .bit = (b), \
295 .index = (idx), \
296 .set_clr = 1, \
297 .sel = (s), \
298 .fixed = _UNKNOWN_ID, \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200299 }
300
Yann Gautiere4a3c352019-02-14 10:53:33 +0100301/* Clocks with fixed source and set/clr register access */
302#define _CLK_SC_FIXED(off, b, idx, f) \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200303 { \
304 .offset = (off), \
305 .bit = (b), \
306 .index = (idx), \
307 .set_clr = 1, \
308 .sel = _UNKNOWN_SEL, \
309 .fixed = (f), \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200310 }
311
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200312#define _CLK_PARENT_SEL(_label, _rcc_selr, _parents) \
313 [_ ## _label ## _SEL] = { \
314 .offset = _rcc_selr, \
315 .src = _rcc_selr ## _ ## _label ## SRC_SHIFT, \
Etienne Carrierec164ce22019-12-08 08:20:40 +0100316 .msk = (_rcc_selr ## _ ## _label ## SRC_MASK) >> \
317 (_rcc_selr ## _ ## _label ## SRC_SHIFT), \
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200318 .parent = (_parents), \
319 .nb_parent = ARRAY_SIZE(_parents) \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200320 }
321
Yann Gautiere4a3c352019-02-14 10:53:33 +0100322#define _CLK_PLL(idx, type, off1, off2, off3, \
323 off4, off5, off6, \
324 p1, p2, p3, p4) \
Yann Gautier9aea69e2018-07-24 17:13:36 +0200325 [(idx)] = { \
326 .plltype = (type), \
327 .rckxselr = (off1), \
328 .pllxcfgr1 = (off2), \
329 .pllxcfgr2 = (off3), \
330 .pllxfracr = (off4), \
331 .pllxcr = (off5), \
332 .pllxcsgr = (off6), \
333 .refclk[0] = (p1), \
334 .refclk[1] = (p2), \
335 .refclk[2] = (p3), \
336 .refclk[3] = (p4), \
337 }
338
Yann Gautiere4a3c352019-02-14 10:53:33 +0100339#define NB_GATES ARRAY_SIZE(stm32mp1_clk_gate)
340
Yann Gautier9aea69e2018-07-24 17:13:36 +0200341static const struct stm32mp1_clk_gate stm32mp1_clk_gate[] = {
Yann Gautiere4a3c352019-02-14 10:53:33 +0100342 _CLK_FIXED(RCC_DDRITFCR, 0, DDRC1, _ACLK),
343 _CLK_FIXED(RCC_DDRITFCR, 1, DDRC1LP, _ACLK),
344 _CLK_FIXED(RCC_DDRITFCR, 2, DDRC2, _ACLK),
345 _CLK_FIXED(RCC_DDRITFCR, 3, DDRC2LP, _ACLK),
346 _CLK_FIXED(RCC_DDRITFCR, 4, DDRPHYC, _PLL2_R),
347 _CLK_FIXED(RCC_DDRITFCR, 5, DDRPHYCLP, _PLL2_R),
348 _CLK_FIXED(RCC_DDRITFCR, 6, DDRCAPB, _PCLK4),
349 _CLK_FIXED(RCC_DDRITFCR, 7, DDRCAPBLP, _PCLK4),
350 _CLK_FIXED(RCC_DDRITFCR, 8, AXIDCG, _ACLK),
351 _CLK_FIXED(RCC_DDRITFCR, 9, DDRPHYCAPB, _PCLK4),
352 _CLK_FIXED(RCC_DDRITFCR, 10, DDRPHYCAPBLP, _PCLK4),
353
354 _CLK_SC_FIXED(RCC_MP_APB1ENSETR, 6, TIM12_K, _PCLK1),
355 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 14, USART2_K, _UART24_SEL),
356 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 15, USART3_K, _UART35_SEL),
357 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 16, UART4_K, _UART24_SEL),
358 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 17, UART5_K, _UART35_SEL),
359 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 18, UART7_K, _UART78_SEL),
360 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 19, UART8_K, _UART78_SEL),
361 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 21, I2C1_K, _I2C12_SEL),
362 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 22, I2C2_K, _I2C12_SEL),
363 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 23, I2C3_K, _I2C35_SEL),
364 _CLK_SC_SELEC(RCC_MP_APB1ENSETR, 24, I2C5_K, _I2C35_SEL),
365
366 _CLK_SC_FIXED(RCC_MP_APB2ENSETR, 2, TIM15_K, _PCLK2),
367 _CLK_SC_SELEC(RCC_MP_APB2ENSETR, 13, USART6_K, _UART6_SEL),
368
Yann Gautier3edc7c32019-05-20 19:17:08 +0200369 _CLK_SC_FIXED(RCC_MP_APB3ENSETR, 11, SYSCFG, _UNKNOWN_ID),
370
Yann Gautiere4a3c352019-02-14 10:53:33 +0100371 _CLK_SC_SELEC(RCC_MP_APB4ENSETR, 8, DDRPERFM, _UNKNOWN_SEL),
372 _CLK_SC_SELEC(RCC_MP_APB4ENSETR, 15, IWDG2, _UNKNOWN_SEL),
373 _CLK_SC_SELEC(RCC_MP_APB4ENSETR, 16, USBPHY_K, _USBPHY_SEL),
374
375 _CLK_SC_SELEC(RCC_MP_APB5ENSETR, 0, SPI6_K, _SPI6_SEL),
376 _CLK_SC_SELEC(RCC_MP_APB5ENSETR, 2, I2C4_K, _I2C46_SEL),
377 _CLK_SC_SELEC(RCC_MP_APB5ENSETR, 3, I2C6_K, _I2C46_SEL),
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200378 _CLK_SC_SELEC(RCC_MP_APB5ENSETR, 4, USART1_K, _UART1_SEL),
Yann Gautiere4a3c352019-02-14 10:53:33 +0100379 _CLK_SC_FIXED(RCC_MP_APB5ENSETR, 8, RTCAPB, _PCLK5),
380 _CLK_SC_FIXED(RCC_MP_APB5ENSETR, 11, TZC1, _PCLK5),
381 _CLK_SC_FIXED(RCC_MP_APB5ENSETR, 12, TZC2, _PCLK5),
382 _CLK_SC_FIXED(RCC_MP_APB5ENSETR, 13, TZPC, _PCLK5),
383 _CLK_SC_FIXED(RCC_MP_APB5ENSETR, 15, IWDG1, _PCLK5),
384 _CLK_SC_FIXED(RCC_MP_APB5ENSETR, 16, BSEC, _PCLK5),
385 _CLK_SC_SELEC(RCC_MP_APB5ENSETR, 20, STGEN_K, _STGEN_SEL),
386
387 _CLK_SC_SELEC(RCC_MP_AHB2ENSETR, 8, USBO_K, _USBO_SEL),
388 _CLK_SC_SELEC(RCC_MP_AHB2ENSETR, 16, SDMMC3_K, _SDMMC3_SEL),
389
390 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 0, GPIOA, _UNKNOWN_SEL),
391 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 1, GPIOB, _UNKNOWN_SEL),
392 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 2, GPIOC, _UNKNOWN_SEL),
393 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 3, GPIOD, _UNKNOWN_SEL),
394 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 4, GPIOE, _UNKNOWN_SEL),
395 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 5, GPIOF, _UNKNOWN_SEL),
396 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 6, GPIOG, _UNKNOWN_SEL),
397 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 7, GPIOH, _UNKNOWN_SEL),
398 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 8, GPIOI, _UNKNOWN_SEL),
399 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 9, GPIOJ, _UNKNOWN_SEL),
400 _CLK_SC_SELEC(RCC_MP_AHB4ENSETR, 10, GPIOK, _UNKNOWN_SEL),
401
402 _CLK_SC_FIXED(RCC_MP_AHB5ENSETR, 0, GPIOZ, _PCLK5),
403 _CLK_SC_FIXED(RCC_MP_AHB5ENSETR, 4, CRYP1, _PCLK5),
404 _CLK_SC_FIXED(RCC_MP_AHB5ENSETR, 5, HASH1, _PCLK5),
405 _CLK_SC_SELEC(RCC_MP_AHB5ENSETR, 6, RNG1_K, _RNG1_SEL),
406 _CLK_SC_FIXED(RCC_MP_AHB5ENSETR, 8, BKPSRAM, _PCLK5),
407
408 _CLK_SC_SELEC(RCC_MP_AHB6ENSETR, 12, FMC_K, _FMC_SEL),
409 _CLK_SC_SELEC(RCC_MP_AHB6ENSETR, 14, QSPI_K, _QSPI_SEL),
410 _CLK_SC_SELEC(RCC_MP_AHB6ENSETR, 16, SDMMC1_K, _SDMMC12_SEL),
411 _CLK_SC_SELEC(RCC_MP_AHB6ENSETR, 17, SDMMC2_K, _SDMMC12_SEL),
412 _CLK_SC_SELEC(RCC_MP_AHB6ENSETR, 24, USBH, _UNKNOWN_SEL),
413
Etienne Carrierebccc7d02019-12-08 08:22:31 +0100414 _CLK_SELEC(RCC_BDCR, 20, RTC, _RTC_SEL),
Yann Gautiere4a3c352019-02-14 10:53:33 +0100415 _CLK_SELEC(RCC_DBGCFGR, 8, CK_DBG, _UNKNOWN_SEL),
416};
417
418static const uint8_t i2c12_parents[] = {
419 _PCLK1, _PLL4_R, _HSI_KER, _CSI_KER
420};
421
422static const uint8_t i2c35_parents[] = {
423 _PCLK1, _PLL4_R, _HSI_KER, _CSI_KER
424};
425
426static const uint8_t stgen_parents[] = {
427 _HSI_KER, _HSE_KER
428};
429
430static const uint8_t i2c46_parents[] = {
431 _PCLK5, _PLL3_Q, _HSI_KER, _CSI_KER
432};
433
434static const uint8_t spi6_parents[] = {
435 _PCLK5, _PLL4_Q, _HSI_KER, _CSI_KER, _HSE_KER, _PLL3_Q
436};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200437
Yann Gautiere4a3c352019-02-14 10:53:33 +0100438static const uint8_t usart1_parents[] = {
439 _PCLK5, _PLL3_Q, _HSI_KER, _CSI_KER, _PLL4_Q, _HSE_KER
440};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200441
Yann Gautiere4a3c352019-02-14 10:53:33 +0100442static const uint8_t rng1_parents[] = {
443 _CSI, _PLL4_R, _LSE, _LSI
444};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200445
Yann Gautiere4a3c352019-02-14 10:53:33 +0100446static const uint8_t uart6_parents[] = {
447 _PCLK2, _PLL4_Q, _HSI_KER, _CSI_KER, _HSE_KER
448};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200449
Yann Gautiere4a3c352019-02-14 10:53:33 +0100450static const uint8_t uart234578_parents[] = {
451 _PCLK1, _PLL4_Q, _HSI_KER, _CSI_KER, _HSE_KER
452};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200453
Yann Gautiere4a3c352019-02-14 10:53:33 +0100454static const uint8_t sdmmc12_parents[] = {
455 _HCLK6, _PLL3_R, _PLL4_P, _HSI_KER
456};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200457
Yann Gautiere4a3c352019-02-14 10:53:33 +0100458static const uint8_t sdmmc3_parents[] = {
459 _HCLK2, _PLL3_R, _PLL4_P, _HSI_KER
460};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200461
Yann Gautiere4a3c352019-02-14 10:53:33 +0100462static const uint8_t qspi_parents[] = {
463 _ACLK, _PLL3_R, _PLL4_P, _CK_PER
464};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200465
Yann Gautiere4a3c352019-02-14 10:53:33 +0100466static const uint8_t fmc_parents[] = {
467 _ACLK, _PLL3_R, _PLL4_P, _CK_PER
468};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200469
Etienne Carriere40c28e82019-12-19 10:03:23 +0100470static const uint8_t axiss_parents[] = {
471 _HSI, _HSE, _PLL2_P
Yann Gautier9aea69e2018-07-24 17:13:36 +0200472};
473
Etienne Carriere40c28e82019-12-19 10:03:23 +0100474static const uint8_t mcuss_parents[] = {
475 _HSI, _HSE, _CSI, _PLL3_P
Yann Gautiered342322019-02-15 17:33:27 +0100476};
477
Yann Gautiere4a3c352019-02-14 10:53:33 +0100478static const uint8_t usbphy_parents[] = {
479 _HSE_KER, _PLL4_R, _HSE_KER_DIV2
480};
481
482static const uint8_t usbo_parents[] = {
483 _PLL4_R, _USB_PHY_48
484};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200485
Etienne Carriere04132612019-12-08 08:20:12 +0100486static const uint8_t mpu_parents[] = {
487 _HSI, _HSE, _PLL1_P, _PLL1_P /* specific div */
488};
489
490static const uint8_t per_parents[] = {
491 _HSI, _HSE, _CSI,
492};
493
Etienne Carrierebccc7d02019-12-08 08:22:31 +0100494static const uint8_t rtc_parents[] = {
Gabriel Fernandez4e3a51a2021-07-27 15:39:16 +0200495 _UNKNOWN_ID, _LSE, _LSI, _HSE_RTC
Etienne Carrierebccc7d02019-12-08 08:22:31 +0100496};
497
Yann Gautier9aea69e2018-07-24 17:13:36 +0200498static const struct stm32mp1_clk_sel stm32mp1_clk_sel[_PARENT_SEL_NB] = {
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200499 _CLK_PARENT_SEL(I2C12, RCC_I2C12CKSELR, i2c12_parents),
500 _CLK_PARENT_SEL(I2C35, RCC_I2C35CKSELR, i2c35_parents),
501 _CLK_PARENT_SEL(STGEN, RCC_STGENCKSELR, stgen_parents),
502 _CLK_PARENT_SEL(I2C46, RCC_I2C46CKSELR, i2c46_parents),
503 _CLK_PARENT_SEL(SPI6, RCC_SPI6CKSELR, spi6_parents),
504 _CLK_PARENT_SEL(UART1, RCC_UART1CKSELR, usart1_parents),
505 _CLK_PARENT_SEL(RNG1, RCC_RNG1CKSELR, rng1_parents),
Etienne Carriere04132612019-12-08 08:20:12 +0100506 _CLK_PARENT_SEL(MPU, RCC_MPCKSELR, mpu_parents),
Yann Gautierfaa9bcf2021-08-31 18:23:13 +0200507 _CLK_PARENT_SEL(CKPER, RCC_CPERCKSELR, per_parents),
Etienne Carrierebccc7d02019-12-08 08:22:31 +0100508 _CLK_PARENT_SEL(RTC, RCC_BDCR, rtc_parents),
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200509 _CLK_PARENT_SEL(UART6, RCC_UART6CKSELR, uart6_parents),
510 _CLK_PARENT_SEL(UART24, RCC_UART24CKSELR, uart234578_parents),
511 _CLK_PARENT_SEL(UART35, RCC_UART35CKSELR, uart234578_parents),
512 _CLK_PARENT_SEL(UART78, RCC_UART78CKSELR, uart234578_parents),
513 _CLK_PARENT_SEL(SDMMC12, RCC_SDMMC12CKSELR, sdmmc12_parents),
514 _CLK_PARENT_SEL(SDMMC3, RCC_SDMMC3CKSELR, sdmmc3_parents),
515 _CLK_PARENT_SEL(QSPI, RCC_QSPICKSELR, qspi_parents),
516 _CLK_PARENT_SEL(FMC, RCC_FMCCKSELR, fmc_parents),
Etienne Carriere40c28e82019-12-19 10:03:23 +0100517 _CLK_PARENT_SEL(AXIS, RCC_ASSCKSELR, axiss_parents),
518 _CLK_PARENT_SEL(MCUS, RCC_MSSCKSELR, mcuss_parents),
Yann Gautier9d8bbcd2019-05-07 18:49:33 +0200519 _CLK_PARENT_SEL(USBPHY, RCC_USBCKSELR, usbphy_parents),
520 _CLK_PARENT_SEL(USBO, RCC_USBCKSELR, usbo_parents),
Yann Gautier9aea69e2018-07-24 17:13:36 +0200521};
522
523/* Define characteristic of PLL according type */
524#define DIVN_MIN 24
525static const struct stm32mp1_pll stm32mp1_pll[PLL_TYPE_NB] = {
526 [PLL_800] = {
527 .refclk_min = 4,
528 .refclk_max = 16,
529 .divn_max = 99,
530 },
531 [PLL_1600] = {
532 .refclk_min = 8,
533 .refclk_max = 16,
534 .divn_max = 199,
535 },
536};
537
538/* PLLNCFGR2 register divider by output */
539static const uint8_t pllncfgr2[_DIV_NB] = {
540 [_DIV_P] = RCC_PLLNCFGR2_DIVP_SHIFT,
541 [_DIV_Q] = RCC_PLLNCFGR2_DIVQ_SHIFT,
Yann Gautiere4a3c352019-02-14 10:53:33 +0100542 [_DIV_R] = RCC_PLLNCFGR2_DIVR_SHIFT,
Yann Gautier9aea69e2018-07-24 17:13:36 +0200543};
544
545static const struct stm32mp1_clk_pll stm32mp1_clk_pll[_PLL_NB] = {
Yann Gautiere4a3c352019-02-14 10:53:33 +0100546 _CLK_PLL(_PLL1, PLL_1600,
547 RCC_RCK12SELR, RCC_PLL1CFGR1, RCC_PLL1CFGR2,
548 RCC_PLL1FRACR, RCC_PLL1CR, RCC_PLL1CSGR,
549 _HSI, _HSE, _UNKNOWN_OSC_ID, _UNKNOWN_OSC_ID),
550 _CLK_PLL(_PLL2, PLL_1600,
551 RCC_RCK12SELR, RCC_PLL2CFGR1, RCC_PLL2CFGR2,
552 RCC_PLL2FRACR, RCC_PLL2CR, RCC_PLL2CSGR,
553 _HSI, _HSE, _UNKNOWN_OSC_ID, _UNKNOWN_OSC_ID),
554 _CLK_PLL(_PLL3, PLL_800,
555 RCC_RCK3SELR, RCC_PLL3CFGR1, RCC_PLL3CFGR2,
556 RCC_PLL3FRACR, RCC_PLL3CR, RCC_PLL3CSGR,
557 _HSI, _HSE, _CSI, _UNKNOWN_OSC_ID),
558 _CLK_PLL(_PLL4, PLL_800,
559 RCC_RCK4SELR, RCC_PLL4CFGR1, RCC_PLL4CFGR2,
560 RCC_PLL4FRACR, RCC_PLL4CR, RCC_PLL4CSGR,
561 _HSI, _HSE, _CSI, _I2S_CKIN),
Yann Gautier9aea69e2018-07-24 17:13:36 +0200562};
563
564/* Prescaler table lookups for clock computation */
Yann Gautiered342322019-02-15 17:33:27 +0100565/* div = /1 /2 /4 /8 / 16 /64 /128 /512 */
566static const uint8_t stm32mp1_mcu_div[16] = {
567 0, 1, 2, 3, 4, 6, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9
568};
Yann Gautier9aea69e2018-07-24 17:13:36 +0200569
570/* div = /1 /2 /4 /8 /16 : same divider for PMU and APBX */
571#define stm32mp1_mpu_div stm32mp1_mpu_apbx_div
572#define stm32mp1_apbx_div stm32mp1_mpu_apbx_div
573static const uint8_t stm32mp1_mpu_apbx_div[8] = {
574 0, 1, 2, 3, 4, 4, 4, 4
575};
576
577/* div = /1 /2 /3 /4 */
578static const uint8_t stm32mp1_axi_div[8] = {
579 1, 2, 3, 4, 4, 4, 4, 4
580};
581
Etienne Carriere1368ada2020-05-13 11:49:49 +0200582static const char * const stm32mp1_clk_parent_name[_PARENT_NB] __unused = {
583 [_HSI] = "HSI",
584 [_HSE] = "HSE",
585 [_CSI] = "CSI",
586 [_LSI] = "LSI",
587 [_LSE] = "LSE",
588 [_I2S_CKIN] = "I2S_CKIN",
589 [_HSI_KER] = "HSI_KER",
590 [_HSE_KER] = "HSE_KER",
591 [_HSE_KER_DIV2] = "HSE_KER_DIV2",
Gabriel Fernandez4e3a51a2021-07-27 15:39:16 +0200592 [_HSE_RTC] = "HSE_RTC",
Etienne Carriere1368ada2020-05-13 11:49:49 +0200593 [_CSI_KER] = "CSI_KER",
594 [_PLL1_P] = "PLL1_P",
595 [_PLL1_Q] = "PLL1_Q",
596 [_PLL1_R] = "PLL1_R",
597 [_PLL2_P] = "PLL2_P",
598 [_PLL2_Q] = "PLL2_Q",
599 [_PLL2_R] = "PLL2_R",
600 [_PLL3_P] = "PLL3_P",
601 [_PLL3_Q] = "PLL3_Q",
602 [_PLL3_R] = "PLL3_R",
603 [_PLL4_P] = "PLL4_P",
604 [_PLL4_Q] = "PLL4_Q",
605 [_PLL4_R] = "PLL4_R",
606 [_ACLK] = "ACLK",
607 [_PCLK1] = "PCLK1",
608 [_PCLK2] = "PCLK2",
609 [_PCLK3] = "PCLK3",
610 [_PCLK4] = "PCLK4",
611 [_PCLK5] = "PCLK5",
612 [_HCLK6] = "KCLK6",
613 [_HCLK2] = "HCLK2",
614 [_CK_PER] = "CK_PER",
615 [_CK_MPU] = "CK_MPU",
616 [_CK_MCU] = "CK_MCU",
617 [_USB_PHY_48] = "USB_PHY_48",
618};
619
Yann Gautiere4a3c352019-02-14 10:53:33 +0100620/* RCC clock device driver private */
621static unsigned long stm32mp1_osc[NB_OSC];
622static struct spinlock reg_lock;
623static unsigned int gate_refcounts[NB_GATES];
624static struct spinlock refcount_lock;
625
626static const struct stm32mp1_clk_gate *gate_ref(unsigned int idx)
627{
628 return &stm32mp1_clk_gate[idx];
629}
Yann Gautier9aea69e2018-07-24 17:13:36 +0200630
Yann Gautiere4a3c352019-02-14 10:53:33 +0100631static const struct stm32mp1_clk_sel *clk_sel_ref(unsigned int idx)
632{
633 return &stm32mp1_clk_sel[idx];
634}
Yann Gautier9aea69e2018-07-24 17:13:36 +0200635
Yann Gautiere4a3c352019-02-14 10:53:33 +0100636static const struct stm32mp1_clk_pll *pll_ref(unsigned int idx)
637{
638 return &stm32mp1_clk_pll[idx];
639}
640
Yann Gautiere4a3c352019-02-14 10:53:33 +0100641static void stm32mp1_clk_lock(struct spinlock *lock)
642{
Yann Gautierf540a592019-05-22 19:13:51 +0200643 if (stm32mp_lock_available()) {
644 /* Assume interrupts are masked */
645 spin_lock(lock);
Yann Gautiere4a3c352019-02-14 10:53:33 +0100646 }
Yann Gautiere4a3c352019-02-14 10:53:33 +0100647}
648
649static void stm32mp1_clk_unlock(struct spinlock *lock)
650{
Yann Gautierf540a592019-05-22 19:13:51 +0200651 if (stm32mp_lock_available()) {
652 spin_unlock(lock);
Yann Gautiere4a3c352019-02-14 10:53:33 +0100653 }
Yann Gautiere4a3c352019-02-14 10:53:33 +0100654}
655
656bool stm32mp1_rcc_is_secure(void)
657{
658 uintptr_t rcc_base = stm32mp_rcc_base();
Etienne Carriere5e68f6b2020-02-05 10:03:27 +0100659 uint32_t mask = RCC_TZCR_TZEN;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100660
Etienne Carriere5e68f6b2020-02-05 10:03:27 +0100661 return (mmio_read_32(rcc_base + RCC_TZCR) & mask) == mask;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100662}
663
Yann Gautiered342322019-02-15 17:33:27 +0100664bool stm32mp1_rcc_is_mckprot(void)
665{
666 uintptr_t rcc_base = stm32mp_rcc_base();
Etienne Carriere5e68f6b2020-02-05 10:03:27 +0100667 uint32_t mask = RCC_TZCR_TZEN | RCC_TZCR_MCKPROT;
Yann Gautiered342322019-02-15 17:33:27 +0100668
Etienne Carriere5e68f6b2020-02-05 10:03:27 +0100669 return (mmio_read_32(rcc_base + RCC_TZCR) & mask) == mask;
Yann Gautiered342322019-02-15 17:33:27 +0100670}
671
Yann Gautiere4a3c352019-02-14 10:53:33 +0100672void stm32mp1_clk_rcc_regs_lock(void)
673{
674 stm32mp1_clk_lock(&reg_lock);
675}
676
677void stm32mp1_clk_rcc_regs_unlock(void)
678{
679 stm32mp1_clk_unlock(&reg_lock);
680}
681
682static unsigned long stm32mp1_clk_get_fixed(enum stm32mp_osc_id idx)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200683{
684 if (idx >= NB_OSC) {
685 return 0;
686 }
687
Yann Gautiere4a3c352019-02-14 10:53:33 +0100688 return stm32mp1_osc[idx];
Yann Gautier9aea69e2018-07-24 17:13:36 +0200689}
690
Yann Gautiere4a3c352019-02-14 10:53:33 +0100691static int stm32mp1_clk_get_gated_id(unsigned long id)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200692{
Yann Gautiere4a3c352019-02-14 10:53:33 +0100693 unsigned int i;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200694
Yann Gautiere4a3c352019-02-14 10:53:33 +0100695 for (i = 0U; i < NB_GATES; i++) {
696 if (gate_ref(i)->index == id) {
Yann Gautier9aea69e2018-07-24 17:13:36 +0200697 return i;
698 }
699 }
700
701 ERROR("%s: clk id %d not found\n", __func__, (uint32_t)id);
702
703 return -EINVAL;
704}
705
Yann Gautiere4a3c352019-02-14 10:53:33 +0100706static enum stm32mp1_parent_sel stm32mp1_clk_get_sel(int i)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200707{
Yann Gautiere4a3c352019-02-14 10:53:33 +0100708 return (enum stm32mp1_parent_sel)(gate_ref(i)->sel);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200709}
710
Yann Gautiere4a3c352019-02-14 10:53:33 +0100711static enum stm32mp1_parent_id stm32mp1_clk_get_fixed_parent(int i)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200712{
Yann Gautiere4a3c352019-02-14 10:53:33 +0100713 return (enum stm32mp1_parent_id)(gate_ref(i)->fixed);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200714}
715
Yann Gautiere4a3c352019-02-14 10:53:33 +0100716static int stm32mp1_clk_get_parent(unsigned long id)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200717{
Yann Gautiere4a3c352019-02-14 10:53:33 +0100718 const struct stm32mp1_clk_sel *sel;
Etienne Carriere04132612019-12-08 08:20:12 +0100719 uint32_t p_sel;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200720 int i;
721 enum stm32mp1_parent_id p;
722 enum stm32mp1_parent_sel s;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100723 uintptr_t rcc_base = stm32mp_rcc_base();
Yann Gautier9aea69e2018-07-24 17:13:36 +0200724
Etienne Carriere04132612019-12-08 08:20:12 +0100725 /* Few non gateable clock have a static parent ID, find them */
726 i = (int)clock_id2parent_id(id);
727 if (i != _UNKNOWN_ID) {
728 return i;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200729 }
730
Yann Gautiere4a3c352019-02-14 10:53:33 +0100731 i = stm32mp1_clk_get_gated_id(id);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200732 if (i < 0) {
Yann Gautiere4a3c352019-02-14 10:53:33 +0100733 panic();
Yann Gautier9aea69e2018-07-24 17:13:36 +0200734 }
735
Yann Gautiere4a3c352019-02-14 10:53:33 +0100736 p = stm32mp1_clk_get_fixed_parent(i);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200737 if (p < _PARENT_NB) {
738 return (int)p;
739 }
740
Yann Gautiere4a3c352019-02-14 10:53:33 +0100741 s = stm32mp1_clk_get_sel(i);
742 if (s == _UNKNOWN_SEL) {
Yann Gautier9aea69e2018-07-24 17:13:36 +0200743 return -EINVAL;
744 }
Yann Gautiere4a3c352019-02-14 10:53:33 +0100745 if (s >= _PARENT_SEL_NB) {
746 panic();
Yann Gautier9aea69e2018-07-24 17:13:36 +0200747 }
748
Yann Gautiere4a3c352019-02-14 10:53:33 +0100749 sel = clk_sel_ref(s);
Etienne Carrierec164ce22019-12-08 08:20:40 +0100750 p_sel = (mmio_read_32(rcc_base + sel->offset) &
751 (sel->msk << sel->src)) >> sel->src;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100752 if (p_sel < sel->nb_parent) {
753 return (int)sel->parent[p_sel];
754 }
Yann Gautier9aea69e2018-07-24 17:13:36 +0200755
756 return -EINVAL;
757}
758
Yann Gautiere4a3c352019-02-14 10:53:33 +0100759static unsigned long stm32mp1_pll_get_fref(const struct stm32mp1_clk_pll *pll)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200760{
Yann Gautiere4a3c352019-02-14 10:53:33 +0100761 uint32_t selr = mmio_read_32(stm32mp_rcc_base() + pll->rckxselr);
762 uint32_t src = selr & RCC_SELR_REFCLK_SRC_MASK;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200763
Yann Gautiere4a3c352019-02-14 10:53:33 +0100764 return stm32mp1_clk_get_fixed(pll->refclk[src]);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200765}
766
767/*
768 * pll_get_fvco() : return the VCO or (VCO / 2) frequency for the requested PLL
769 * - PLL1 & PLL2 => return VCO / 2 with Fpll_y_ck = FVCO / 2 * (DIVy + 1)
770 * - PLL3 & PLL4 => return VCO with Fpll_y_ck = FVCO / (DIVy + 1)
771 * => in all cases Fpll_y_ck = pll_get_fvco() / (DIVy + 1)
772 */
Yann Gautiere4a3c352019-02-14 10:53:33 +0100773static unsigned long stm32mp1_pll_get_fvco(const struct stm32mp1_clk_pll *pll)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200774{
Yann Gautier9aea69e2018-07-24 17:13:36 +0200775 unsigned long refclk, fvco;
776 uint32_t cfgr1, fracr, divm, divn;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100777 uintptr_t rcc_base = stm32mp_rcc_base();
Yann Gautier9aea69e2018-07-24 17:13:36 +0200778
Yann Gautiere4a3c352019-02-14 10:53:33 +0100779 cfgr1 = mmio_read_32(rcc_base + pll->pllxcfgr1);
780 fracr = mmio_read_32(rcc_base + pll->pllxfracr);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200781
782 divm = (cfgr1 & (RCC_PLLNCFGR1_DIVM_MASK)) >> RCC_PLLNCFGR1_DIVM_SHIFT;
783 divn = cfgr1 & RCC_PLLNCFGR1_DIVN_MASK;
784
Yann Gautiere4a3c352019-02-14 10:53:33 +0100785 refclk = stm32mp1_pll_get_fref(pll);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200786
787 /*
788 * With FRACV :
789 * Fvco = Fck_ref * ((DIVN + 1) + FRACV / 2^13) / (DIVM + 1)
790 * Without FRACV
791 * Fvco = Fck_ref * ((DIVN + 1) / (DIVM + 1)
792 */
793 if ((fracr & RCC_PLLNFRACR_FRACLE) != 0U) {
Yann Gautiere4a3c352019-02-14 10:53:33 +0100794 uint32_t fracv = (fracr & RCC_PLLNFRACR_FRACV_MASK) >>
795 RCC_PLLNFRACR_FRACV_SHIFT;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200796 unsigned long long numerator, denominator;
797
Yann Gautiere4a3c352019-02-14 10:53:33 +0100798 numerator = (((unsigned long long)divn + 1U) << 13) + fracv;
799 numerator = refclk * numerator;
800 denominator = ((unsigned long long)divm + 1U) << 13;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200801 fvco = (unsigned long)(numerator / denominator);
802 } else {
803 fvco = (unsigned long)(refclk * (divn + 1U) / (divm + 1U));
804 }
805
806 return fvco;
807}
808
Yann Gautiere4a3c352019-02-14 10:53:33 +0100809static unsigned long stm32mp1_read_pll_freq(enum stm32mp1_pll_id pll_id,
Yann Gautier9aea69e2018-07-24 17:13:36 +0200810 enum stm32mp1_div_id div_id)
811{
Yann Gautiere4a3c352019-02-14 10:53:33 +0100812 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200813 unsigned long dfout;
814 uint32_t cfgr2, divy;
815
816 if (div_id >= _DIV_NB) {
817 return 0;
818 }
819
Yann Gautiere4a3c352019-02-14 10:53:33 +0100820 cfgr2 = mmio_read_32(stm32mp_rcc_base() + pll->pllxcfgr2);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200821 divy = (cfgr2 >> pllncfgr2[div_id]) & RCC_PLLNCFGR2_DIVX_MASK;
822
Yann Gautiere4a3c352019-02-14 10:53:33 +0100823 dfout = stm32mp1_pll_get_fvco(pll) / (divy + 1U);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200824
825 return dfout;
826}
827
Yann Gautiere4a3c352019-02-14 10:53:33 +0100828static unsigned long get_clock_rate(int p)
Yann Gautier9aea69e2018-07-24 17:13:36 +0200829{
830 uint32_t reg, clkdiv;
831 unsigned long clock = 0;
Yann Gautiere4a3c352019-02-14 10:53:33 +0100832 uintptr_t rcc_base = stm32mp_rcc_base();
Yann Gautier9aea69e2018-07-24 17:13:36 +0200833
834 switch (p) {
835 case _CK_MPU:
836 /* MPU sub system */
Yann Gautiere4a3c352019-02-14 10:53:33 +0100837 reg = mmio_read_32(rcc_base + RCC_MPCKSELR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200838 switch (reg & RCC_SELR_SRC_MASK) {
839 case RCC_MPCKSELR_HSI:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100840 clock = stm32mp1_clk_get_fixed(_HSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200841 break;
842 case RCC_MPCKSELR_HSE:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100843 clock = stm32mp1_clk_get_fixed(_HSE);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200844 break;
845 case RCC_MPCKSELR_PLL:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100846 clock = stm32mp1_read_pll_freq(_PLL1, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200847 break;
848 case RCC_MPCKSELR_PLL_MPUDIV:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100849 clock = stm32mp1_read_pll_freq(_PLL1, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200850
Yann Gautiere4a3c352019-02-14 10:53:33 +0100851 reg = mmio_read_32(rcc_base + RCC_MPCKDIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200852 clkdiv = reg & RCC_MPUDIV_MASK;
Gabriel Fernandez4d198742020-02-28 09:09:06 +0100853 clock >>= stm32mp1_mpu_div[clkdiv];
Yann Gautier9aea69e2018-07-24 17:13:36 +0200854 break;
855 default:
856 break;
857 }
858 break;
859 /* AXI sub system */
860 case _ACLK:
861 case _HCLK2:
862 case _HCLK6:
863 case _PCLK4:
864 case _PCLK5:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100865 reg = mmio_read_32(rcc_base + RCC_ASSCKSELR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200866 switch (reg & RCC_SELR_SRC_MASK) {
867 case RCC_ASSCKSELR_HSI:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100868 clock = stm32mp1_clk_get_fixed(_HSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200869 break;
870 case RCC_ASSCKSELR_HSE:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100871 clock = stm32mp1_clk_get_fixed(_HSE);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200872 break;
873 case RCC_ASSCKSELR_PLL:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100874 clock = stm32mp1_read_pll_freq(_PLL2, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200875 break;
876 default:
877 break;
878 }
879
880 /* System clock divider */
Yann Gautiere4a3c352019-02-14 10:53:33 +0100881 reg = mmio_read_32(rcc_base + RCC_AXIDIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200882 clock /= stm32mp1_axi_div[reg & RCC_AXIDIV_MASK];
883
884 switch (p) {
885 case _PCLK4:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100886 reg = mmio_read_32(rcc_base + RCC_APB4DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200887 clock >>= stm32mp1_apbx_div[reg & RCC_APBXDIV_MASK];
888 break;
889 case _PCLK5:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100890 reg = mmio_read_32(rcc_base + RCC_APB5DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200891 clock >>= stm32mp1_apbx_div[reg & RCC_APBXDIV_MASK];
892 break;
893 default:
894 break;
895 }
896 break;
Yann Gautiered342322019-02-15 17:33:27 +0100897 /* MCU sub system */
898 case _CK_MCU:
899 case _PCLK1:
900 case _PCLK2:
901 case _PCLK3:
902 reg = mmio_read_32(rcc_base + RCC_MSSCKSELR);
903 switch (reg & RCC_SELR_SRC_MASK) {
904 case RCC_MSSCKSELR_HSI:
905 clock = stm32mp1_clk_get_fixed(_HSI);
906 break;
907 case RCC_MSSCKSELR_HSE:
908 clock = stm32mp1_clk_get_fixed(_HSE);
909 break;
910 case RCC_MSSCKSELR_CSI:
911 clock = stm32mp1_clk_get_fixed(_CSI);
912 break;
913 case RCC_MSSCKSELR_PLL:
914 clock = stm32mp1_read_pll_freq(_PLL3, _DIV_P);
915 break;
916 default:
917 break;
918 }
919
920 /* MCU clock divider */
921 reg = mmio_read_32(rcc_base + RCC_MCUDIVR);
922 clock >>= stm32mp1_mcu_div[reg & RCC_MCUDIV_MASK];
923
924 switch (p) {
925 case _PCLK1:
926 reg = mmio_read_32(rcc_base + RCC_APB1DIVR);
927 clock >>= stm32mp1_apbx_div[reg & RCC_APBXDIV_MASK];
928 break;
929 case _PCLK2:
930 reg = mmio_read_32(rcc_base + RCC_APB2DIVR);
931 clock >>= stm32mp1_apbx_div[reg & RCC_APBXDIV_MASK];
932 break;
933 case _PCLK3:
934 reg = mmio_read_32(rcc_base + RCC_APB3DIVR);
935 clock >>= stm32mp1_apbx_div[reg & RCC_APBXDIV_MASK];
936 break;
937 case _CK_MCU:
938 default:
939 break;
940 }
941 break;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200942 case _CK_PER:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100943 reg = mmio_read_32(rcc_base + RCC_CPERCKSELR);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200944 switch (reg & RCC_SELR_SRC_MASK) {
945 case RCC_CPERCKSELR_HSI:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100946 clock = stm32mp1_clk_get_fixed(_HSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200947 break;
948 case RCC_CPERCKSELR_HSE:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100949 clock = stm32mp1_clk_get_fixed(_HSE);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200950 break;
951 case RCC_CPERCKSELR_CSI:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100952 clock = stm32mp1_clk_get_fixed(_CSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200953 break;
954 default:
955 break;
956 }
957 break;
958 case _HSI:
959 case _HSI_KER:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100960 clock = stm32mp1_clk_get_fixed(_HSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200961 break;
962 case _CSI:
963 case _CSI_KER:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100964 clock = stm32mp1_clk_get_fixed(_CSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200965 break;
966 case _HSE:
967 case _HSE_KER:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100968 clock = stm32mp1_clk_get_fixed(_HSE);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200969 break;
970 case _HSE_KER_DIV2:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100971 clock = stm32mp1_clk_get_fixed(_HSE) >> 1;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200972 break;
Gabriel Fernandez4e3a51a2021-07-27 15:39:16 +0200973 case _HSE_RTC:
974 clock = stm32mp1_clk_get_fixed(_HSE);
975 clock /= (mmio_read_32(rcc_base + RCC_RTCDIVR) & RCC_DIVR_DIV_MASK) + 1U;
976 break;
Yann Gautier9aea69e2018-07-24 17:13:36 +0200977 case _LSI:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100978 clock = stm32mp1_clk_get_fixed(_LSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200979 break;
980 case _LSE:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100981 clock = stm32mp1_clk_get_fixed(_LSE);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200982 break;
983 /* PLL */
984 case _PLL1_P:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100985 clock = stm32mp1_read_pll_freq(_PLL1, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200986 break;
987 case _PLL1_Q:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100988 clock = stm32mp1_read_pll_freq(_PLL1, _DIV_Q);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200989 break;
990 case _PLL1_R:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100991 clock = stm32mp1_read_pll_freq(_PLL1, _DIV_R);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200992 break;
993 case _PLL2_P:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100994 clock = stm32mp1_read_pll_freq(_PLL2, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200995 break;
996 case _PLL2_Q:
Yann Gautiere4a3c352019-02-14 10:53:33 +0100997 clock = stm32mp1_read_pll_freq(_PLL2, _DIV_Q);
Yann Gautier9aea69e2018-07-24 17:13:36 +0200998 break;
999 case _PLL2_R:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001000 clock = stm32mp1_read_pll_freq(_PLL2, _DIV_R);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001001 break;
1002 case _PLL3_P:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001003 clock = stm32mp1_read_pll_freq(_PLL3, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001004 break;
1005 case _PLL3_Q:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001006 clock = stm32mp1_read_pll_freq(_PLL3, _DIV_Q);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001007 break;
1008 case _PLL3_R:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001009 clock = stm32mp1_read_pll_freq(_PLL3, _DIV_R);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001010 break;
1011 case _PLL4_P:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001012 clock = stm32mp1_read_pll_freq(_PLL4, _DIV_P);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001013 break;
1014 case _PLL4_Q:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001015 clock = stm32mp1_read_pll_freq(_PLL4, _DIV_Q);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001016 break;
1017 case _PLL4_R:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001018 clock = stm32mp1_read_pll_freq(_PLL4, _DIV_R);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001019 break;
1020 /* Other */
1021 case _USB_PHY_48:
Yann Gautiere4a3c352019-02-14 10:53:33 +01001022 clock = USB_PHY_48_MHZ;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001023 break;
1024 default:
1025 break;
1026 }
1027
1028 return clock;
1029}
1030
Yann Gautiere4a3c352019-02-14 10:53:33 +01001031static void __clk_enable(struct stm32mp1_clk_gate const *gate)
1032{
1033 uintptr_t rcc_base = stm32mp_rcc_base();
1034
Etienne Carriere8a668892019-12-08 08:21:08 +01001035 VERBOSE("Enable clock %u\n", gate->index);
1036
Yann Gautiere4a3c352019-02-14 10:53:33 +01001037 if (gate->set_clr != 0U) {
1038 mmio_write_32(rcc_base + gate->offset, BIT(gate->bit));
1039 } else {
1040 mmio_setbits_32(rcc_base + gate->offset, BIT(gate->bit));
1041 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001042}
1043
1044static void __clk_disable(struct stm32mp1_clk_gate const *gate)
1045{
1046 uintptr_t rcc_base = stm32mp_rcc_base();
1047
Etienne Carriere8a668892019-12-08 08:21:08 +01001048 VERBOSE("Disable clock %u\n", gate->index);
1049
Yann Gautiere4a3c352019-02-14 10:53:33 +01001050 if (gate->set_clr != 0U) {
1051 mmio_write_32(rcc_base + gate->offset + RCC_MP_ENCLRR_OFFSET,
1052 BIT(gate->bit));
1053 } else {
1054 mmio_clrbits_32(rcc_base + gate->offset, BIT(gate->bit));
1055 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001056}
1057
1058static bool __clk_is_enabled(struct stm32mp1_clk_gate const *gate)
1059{
1060 uintptr_t rcc_base = stm32mp_rcc_base();
1061
1062 return mmio_read_32(rcc_base + gate->offset) & BIT(gate->bit);
1063}
1064
1065unsigned int stm32mp1_clk_get_refcount(unsigned long id)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001066{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001067 int i = stm32mp1_clk_get_gated_id(id);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001068
1069 if (i < 0) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001070 panic();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001071 }
1072
Yann Gautiere4a3c352019-02-14 10:53:33 +01001073 return gate_refcounts[i];
Yann Gautier9aea69e2018-07-24 17:13:36 +02001074}
1075
Etienne Carriere481aa002019-12-08 08:21:44 +01001076/* Oscillators and PLLs are not gated at runtime */
1077static bool clock_is_always_on(unsigned long id)
1078{
1079 switch (id) {
1080 case CK_HSE:
1081 case CK_CSI:
1082 case CK_LSI:
1083 case CK_LSE:
1084 case CK_HSI:
1085 case CK_HSE_DIV2:
1086 case PLL1_Q:
1087 case PLL1_R:
1088 case PLL2_P:
1089 case PLL2_Q:
1090 case PLL2_R:
1091 case PLL3_P:
1092 case PLL3_Q:
1093 case PLL3_R:
Yann Gautierb39a1522020-09-16 16:41:55 +02001094 case CK_AXI:
1095 case CK_MPU:
1096 case CK_MCU:
HE Shushanc47c8162021-07-12 23:04:10 +02001097 case RTC:
Etienne Carriere481aa002019-12-08 08:21:44 +01001098 return true;
1099 default:
1100 return false;
1101 }
1102}
1103
Yann Gautiere4a3c352019-02-14 10:53:33 +01001104void __stm32mp1_clk_enable(unsigned long id, bool secure)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001105{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001106 const struct stm32mp1_clk_gate *gate;
Etienne Carriere481aa002019-12-08 08:21:44 +01001107 int i;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001108 unsigned int *refcnt;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001109
Etienne Carriere481aa002019-12-08 08:21:44 +01001110 if (clock_is_always_on(id)) {
1111 return;
1112 }
1113
1114 i = stm32mp1_clk_get_gated_id(id);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001115 if (i < 0) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001116 ERROR("Clock %d can't be enabled\n", (uint32_t)id);
1117 panic();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001118 }
1119
Yann Gautiere4a3c352019-02-14 10:53:33 +01001120 gate = gate_ref(i);
1121 refcnt = &gate_refcounts[i];
1122
1123 stm32mp1_clk_lock(&refcount_lock);
1124
1125 if (stm32mp_incr_shrefcnt(refcnt, secure) != 0) {
1126 __clk_enable(gate);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001127 }
1128
Yann Gautiere4a3c352019-02-14 10:53:33 +01001129 stm32mp1_clk_unlock(&refcount_lock);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001130}
1131
Yann Gautiere4a3c352019-02-14 10:53:33 +01001132void __stm32mp1_clk_disable(unsigned long id, bool secure)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001133{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001134 const struct stm32mp1_clk_gate *gate;
Etienne Carriere481aa002019-12-08 08:21:44 +01001135 int i;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001136 unsigned int *refcnt;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001137
Etienne Carriere481aa002019-12-08 08:21:44 +01001138 if (clock_is_always_on(id)) {
1139 return;
1140 }
1141
1142 i = stm32mp1_clk_get_gated_id(id);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001143 if (i < 0) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001144 ERROR("Clock %d can't be disabled\n", (uint32_t)id);
1145 panic();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001146 }
1147
Yann Gautiere4a3c352019-02-14 10:53:33 +01001148 gate = gate_ref(i);
1149 refcnt = &gate_refcounts[i];
1150
1151 stm32mp1_clk_lock(&refcount_lock);
1152
1153 if (stm32mp_decr_shrefcnt(refcnt, secure) != 0) {
1154 __clk_disable(gate);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001155 }
1156
Yann Gautiere4a3c352019-02-14 10:53:33 +01001157 stm32mp1_clk_unlock(&refcount_lock);
1158}
1159
1160void stm32mp_clk_enable(unsigned long id)
1161{
1162 __stm32mp1_clk_enable(id, true);
1163}
1164
1165void stm32mp_clk_disable(unsigned long id)
1166{
1167 __stm32mp1_clk_disable(id, true);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001168}
1169
Yann Gautiere4a3c352019-02-14 10:53:33 +01001170bool stm32mp_clk_is_enabled(unsigned long id)
1171{
Etienne Carriere481aa002019-12-08 08:21:44 +01001172 int i;
1173
1174 if (clock_is_always_on(id)) {
1175 return true;
1176 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001177
Etienne Carriere481aa002019-12-08 08:21:44 +01001178 i = stm32mp1_clk_get_gated_id(id);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001179 if (i < 0) {
1180 panic();
1181 }
1182
1183 return __clk_is_enabled(gate_ref(i));
1184}
1185
Yann Gautiera2e2a302019-02-14 11:13:39 +01001186unsigned long stm32mp_clk_get_rate(unsigned long id)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001187{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001188 int p = stm32mp1_clk_get_parent(id);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001189
1190 if (p < 0) {
1191 return 0;
1192 }
1193
Yann Gautiere4a3c352019-02-14 10:53:33 +01001194 return get_clock_rate(p);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001195}
1196
Yann Gautiere4a3c352019-02-14 10:53:33 +01001197static void stm32mp1_ls_osc_set(bool enable, uint32_t offset, uint32_t mask_on)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001198{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001199 uintptr_t address = stm32mp_rcc_base() + offset;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001200
Yann Gautiere4a3c352019-02-14 10:53:33 +01001201 if (enable) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001202 mmio_setbits_32(address, mask_on);
1203 } else {
1204 mmio_clrbits_32(address, mask_on);
1205 }
1206}
1207
Yann Gautiere4a3c352019-02-14 10:53:33 +01001208static void stm32mp1_hs_ocs_set(bool enable, uint32_t mask_on)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001209{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001210 uint32_t offset = enable ? RCC_OCENSETR : RCC_OCENCLRR;
1211 uintptr_t address = stm32mp_rcc_base() + offset;
1212
1213 mmio_write_32(address, mask_on);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001214}
1215
Yann Gautiere4a3c352019-02-14 10:53:33 +01001216static int stm32mp1_osc_wait(bool enable, uint32_t offset, uint32_t mask_rdy)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001217{
Yann Gautier2299d572019-02-14 11:14:39 +01001218 uint64_t timeout;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001219 uint32_t mask_test;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001220 uintptr_t address = stm32mp_rcc_base() + offset;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001221
Yann Gautiere4a3c352019-02-14 10:53:33 +01001222 if (enable) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001223 mask_test = mask_rdy;
1224 } else {
1225 mask_test = 0;
1226 }
1227
Yann Gautier2299d572019-02-14 11:14:39 +01001228 timeout = timeout_init_us(OSCRDY_TIMEOUT);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001229 while ((mmio_read_32(address) & mask_rdy) != mask_test) {
Yann Gautier2299d572019-02-14 11:14:39 +01001230 if (timeout_elapsed(timeout)) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001231 ERROR("OSC %x @ %lx timeout for enable=%d : 0x%x\n",
Yann Gautier9aea69e2018-07-24 17:13:36 +02001232 mask_rdy, address, enable, mmio_read_32(address));
1233 return -ETIMEDOUT;
1234 }
1235 }
1236
1237 return 0;
1238}
1239
Yann Gautiere4a3c352019-02-14 10:53:33 +01001240static void stm32mp1_lse_enable(bool bypass, bool digbyp, uint32_t lsedrv)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001241{
1242 uint32_t value;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001243 uintptr_t rcc_base = stm32mp_rcc_base();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001244
Yann Gautiere4a3c352019-02-14 10:53:33 +01001245 if (digbyp) {
1246 mmio_setbits_32(rcc_base + RCC_BDCR, RCC_BDCR_DIGBYP);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001247 }
1248
Yann Gautiere4a3c352019-02-14 10:53:33 +01001249 if (bypass || digbyp) {
1250 mmio_setbits_32(rcc_base + RCC_BDCR, RCC_BDCR_LSEBYP);
1251 }
1252
Yann Gautier9aea69e2018-07-24 17:13:36 +02001253 /*
1254 * Warning: not recommended to switch directly from "high drive"
1255 * to "medium low drive", and vice-versa.
1256 */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001257 value = (mmio_read_32(rcc_base + RCC_BDCR) & RCC_BDCR_LSEDRV_MASK) >>
Yann Gautier9aea69e2018-07-24 17:13:36 +02001258 RCC_BDCR_LSEDRV_SHIFT;
1259
1260 while (value != lsedrv) {
1261 if (value > lsedrv) {
1262 value--;
1263 } else {
1264 value++;
1265 }
1266
Yann Gautiere4a3c352019-02-14 10:53:33 +01001267 mmio_clrsetbits_32(rcc_base + RCC_BDCR,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001268 RCC_BDCR_LSEDRV_MASK,
1269 value << RCC_BDCR_LSEDRV_SHIFT);
1270 }
1271
Yann Gautiere4a3c352019-02-14 10:53:33 +01001272 stm32mp1_ls_osc_set(true, RCC_BDCR, RCC_BDCR_LSEON);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001273}
1274
Yann Gautiere4a3c352019-02-14 10:53:33 +01001275static void stm32mp1_lse_wait(void)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001276{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001277 if (stm32mp1_osc_wait(true, RCC_BDCR, RCC_BDCR_LSERDY) != 0) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001278 VERBOSE("%s: failed\n", __func__);
1279 }
1280}
1281
Yann Gautiere4a3c352019-02-14 10:53:33 +01001282static void stm32mp1_lsi_set(bool enable)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001283{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001284 stm32mp1_ls_osc_set(enable, RCC_RDLSICR, RCC_RDLSICR_LSION);
1285
1286 if (stm32mp1_osc_wait(enable, RCC_RDLSICR, RCC_RDLSICR_LSIRDY) != 0) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001287 VERBOSE("%s: failed\n", __func__);
1288 }
1289}
1290
Yann Gautiere4a3c352019-02-14 10:53:33 +01001291static void stm32mp1_hse_enable(bool bypass, bool digbyp, bool css)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001292{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001293 uintptr_t rcc_base = stm32mp_rcc_base();
1294
1295 if (digbyp) {
1296 mmio_write_32(rcc_base + RCC_OCENSETR, RCC_OCENR_DIGBYP);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001297 }
1298
Yann Gautiere4a3c352019-02-14 10:53:33 +01001299 if (bypass || digbyp) {
1300 mmio_write_32(rcc_base + RCC_OCENSETR, RCC_OCENR_HSEBYP);
1301 }
1302
1303 stm32mp1_hs_ocs_set(true, RCC_OCENR_HSEON);
1304 if (stm32mp1_osc_wait(true, RCC_OCRDYR, RCC_OCRDYR_HSERDY) != 0) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001305 VERBOSE("%s: failed\n", __func__);
1306 }
1307
1308 if (css) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001309 mmio_write_32(rcc_base + RCC_OCENSETR, RCC_OCENR_HSECSSON);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001310 }
1311}
1312
Yann Gautiere4a3c352019-02-14 10:53:33 +01001313static void stm32mp1_csi_set(bool enable)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001314{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001315 stm32mp1_hs_ocs_set(enable, RCC_OCENR_CSION);
1316 if (stm32mp1_osc_wait(enable, RCC_OCRDYR, RCC_OCRDYR_CSIRDY) != 0) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001317 VERBOSE("%s: failed\n", __func__);
1318 }
1319}
1320
Yann Gautiere4a3c352019-02-14 10:53:33 +01001321static void stm32mp1_hsi_set(bool enable)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001322{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001323 stm32mp1_hs_ocs_set(enable, RCC_OCENR_HSION);
1324 if (stm32mp1_osc_wait(enable, RCC_OCRDYR, RCC_OCRDYR_HSIRDY) != 0) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001325 VERBOSE("%s: failed\n", __func__);
1326 }
1327}
1328
Yann Gautiere4a3c352019-02-14 10:53:33 +01001329static int stm32mp1_set_hsidiv(uint8_t hsidiv)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001330{
Yann Gautier2299d572019-02-14 11:14:39 +01001331 uint64_t timeout;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001332 uintptr_t rcc_base = stm32mp_rcc_base();
1333 uintptr_t address = rcc_base + RCC_OCRDYR;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001334
Yann Gautiere4a3c352019-02-14 10:53:33 +01001335 mmio_clrsetbits_32(rcc_base + RCC_HSICFGR,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001336 RCC_HSICFGR_HSIDIV_MASK,
1337 RCC_HSICFGR_HSIDIV_MASK & (uint32_t)hsidiv);
1338
Yann Gautier2299d572019-02-14 11:14:39 +01001339 timeout = timeout_init_us(HSIDIV_TIMEOUT);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001340 while ((mmio_read_32(address) & RCC_OCRDYR_HSIDIVRDY) == 0U) {
Yann Gautier2299d572019-02-14 11:14:39 +01001341 if (timeout_elapsed(timeout)) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001342 ERROR("HSIDIV failed @ 0x%lx: 0x%x\n",
Yann Gautier9aea69e2018-07-24 17:13:36 +02001343 address, mmio_read_32(address));
1344 return -ETIMEDOUT;
1345 }
1346 }
1347
1348 return 0;
1349}
1350
Yann Gautiere4a3c352019-02-14 10:53:33 +01001351static int stm32mp1_hsidiv(unsigned long hsifreq)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001352{
1353 uint8_t hsidiv;
1354 uint32_t hsidivfreq = MAX_HSI_HZ;
1355
1356 for (hsidiv = 0; hsidiv < 4U; hsidiv++) {
1357 if (hsidivfreq == hsifreq) {
1358 break;
1359 }
1360
1361 hsidivfreq /= 2U;
1362 }
1363
1364 if (hsidiv == 4U) {
1365 ERROR("Invalid clk-hsi frequency\n");
1366 return -1;
1367 }
1368
1369 if (hsidiv != 0U) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001370 return stm32mp1_set_hsidiv(hsidiv);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001371 }
1372
1373 return 0;
1374}
1375
Yann Gautiere4a3c352019-02-14 10:53:33 +01001376static bool stm32mp1_check_pll_conf(enum stm32mp1_pll_id pll_id,
1377 unsigned int clksrc,
1378 uint32_t *pllcfg, int plloff)
1379{
1380 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
1381 uintptr_t rcc_base = stm32mp_rcc_base();
1382 uintptr_t pllxcr = rcc_base + pll->pllxcr;
1383 enum stm32mp1_plltype type = pll->plltype;
1384 uintptr_t clksrc_address = rcc_base + (clksrc >> 4);
1385 unsigned long refclk;
1386 uint32_t ifrge = 0U;
Andre Przywara2d5690c2020-03-26 11:50:33 +00001387 uint32_t src, value, fracv = 0;
1388 void *fdt;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001389
1390 /* Check PLL output */
1391 if (mmio_read_32(pllxcr) != RCC_PLLNCR_PLLON) {
1392 return false;
1393 }
1394
1395 /* Check current clksrc */
1396 src = mmio_read_32(clksrc_address) & RCC_SELR_SRC_MASK;
1397 if (src != (clksrc & RCC_SELR_SRC_MASK)) {
1398 return false;
1399 }
1400
1401 /* Check Div */
1402 src = mmio_read_32(rcc_base + pll->rckxselr) & RCC_SELR_REFCLK_SRC_MASK;
1403
1404 refclk = stm32mp1_clk_get_fixed(pll->refclk[src]) /
1405 (pllcfg[PLLCFG_M] + 1U);
1406
1407 if ((refclk < (stm32mp1_pll[type].refclk_min * 1000000U)) ||
1408 (refclk > (stm32mp1_pll[type].refclk_max * 1000000U))) {
1409 return false;
1410 }
1411
1412 if ((type == PLL_800) && (refclk >= 8000000U)) {
1413 ifrge = 1U;
1414 }
1415
1416 value = (pllcfg[PLLCFG_N] << RCC_PLLNCFGR1_DIVN_SHIFT) &
1417 RCC_PLLNCFGR1_DIVN_MASK;
1418 value |= (pllcfg[PLLCFG_M] << RCC_PLLNCFGR1_DIVM_SHIFT) &
1419 RCC_PLLNCFGR1_DIVM_MASK;
1420 value |= (ifrge << RCC_PLLNCFGR1_IFRGE_SHIFT) &
1421 RCC_PLLNCFGR1_IFRGE_MASK;
1422 if (mmio_read_32(rcc_base + pll->pllxcfgr1) != value) {
1423 return false;
1424 }
1425
1426 /* Fractional configuration */
Andre Przywara2d5690c2020-03-26 11:50:33 +00001427 if (fdt_get_address(&fdt) == 1) {
1428 fracv = fdt_read_uint32_default(fdt, plloff, "frac", 0);
1429 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001430
1431 value = fracv << RCC_PLLNFRACR_FRACV_SHIFT;
1432 value |= RCC_PLLNFRACR_FRACLE;
1433 if (mmio_read_32(rcc_base + pll->pllxfracr) != value) {
1434 return false;
1435 }
1436
1437 /* Output config */
1438 value = (pllcfg[PLLCFG_P] << RCC_PLLNCFGR2_DIVP_SHIFT) &
1439 RCC_PLLNCFGR2_DIVP_MASK;
1440 value |= (pllcfg[PLLCFG_Q] << RCC_PLLNCFGR2_DIVQ_SHIFT) &
1441 RCC_PLLNCFGR2_DIVQ_MASK;
1442 value |= (pllcfg[PLLCFG_R] << RCC_PLLNCFGR2_DIVR_SHIFT) &
1443 RCC_PLLNCFGR2_DIVR_MASK;
1444 if (mmio_read_32(rcc_base + pll->pllxcfgr2) != value) {
1445 return false;
1446 }
1447
1448 return true;
1449}
1450
1451static void stm32mp1_pll_start(enum stm32mp1_pll_id pll_id)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001452{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001453 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
1454 uintptr_t pllxcr = stm32mp_rcc_base() + pll->pllxcr;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001455
Yann Gautierd0dcbaa2019-06-04 15:55:37 +02001456 /* Preserve RCC_PLLNCR_SSCG_CTRL value */
1457 mmio_clrsetbits_32(pllxcr,
1458 RCC_PLLNCR_DIVPEN | RCC_PLLNCR_DIVQEN |
1459 RCC_PLLNCR_DIVREN,
1460 RCC_PLLNCR_PLLON);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001461}
1462
Yann Gautiere4a3c352019-02-14 10:53:33 +01001463static int stm32mp1_pll_output(enum stm32mp1_pll_id pll_id, uint32_t output)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001464{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001465 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
1466 uintptr_t pllxcr = stm32mp_rcc_base() + pll->pllxcr;
Yann Gautier2299d572019-02-14 11:14:39 +01001467 uint64_t timeout = timeout_init_us(PLLRDY_TIMEOUT);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001468
Yann Gautier9aea69e2018-07-24 17:13:36 +02001469 /* Wait PLL lock */
1470 while ((mmio_read_32(pllxcr) & RCC_PLLNCR_PLLRDY) == 0U) {
Yann Gautier2299d572019-02-14 11:14:39 +01001471 if (timeout_elapsed(timeout)) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001472 ERROR("PLL%d start failed @ 0x%lx: 0x%x\n",
Yann Gautier9aea69e2018-07-24 17:13:36 +02001473 pll_id, pllxcr, mmio_read_32(pllxcr));
1474 return -ETIMEDOUT;
1475 }
1476 }
1477
1478 /* Start the requested output */
1479 mmio_setbits_32(pllxcr, output << RCC_PLLNCR_DIVEN_SHIFT);
1480
1481 return 0;
1482}
1483
Yann Gautiere4a3c352019-02-14 10:53:33 +01001484static int stm32mp1_pll_stop(enum stm32mp1_pll_id pll_id)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001485{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001486 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
1487 uintptr_t pllxcr = stm32mp_rcc_base() + pll->pllxcr;
Yann Gautier2299d572019-02-14 11:14:39 +01001488 uint64_t timeout;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001489
1490 /* Stop all output */
1491 mmio_clrbits_32(pllxcr, RCC_PLLNCR_DIVPEN | RCC_PLLNCR_DIVQEN |
1492 RCC_PLLNCR_DIVREN);
1493
1494 /* Stop PLL */
1495 mmio_clrbits_32(pllxcr, RCC_PLLNCR_PLLON);
1496
Yann Gautier2299d572019-02-14 11:14:39 +01001497 timeout = timeout_init_us(PLLRDY_TIMEOUT);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001498 /* Wait PLL stopped */
1499 while ((mmio_read_32(pllxcr) & RCC_PLLNCR_PLLRDY) != 0U) {
Yann Gautier2299d572019-02-14 11:14:39 +01001500 if (timeout_elapsed(timeout)) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001501 ERROR("PLL%d stop failed @ 0x%lx: 0x%x\n",
Yann Gautier9aea69e2018-07-24 17:13:36 +02001502 pll_id, pllxcr, mmio_read_32(pllxcr));
1503 return -ETIMEDOUT;
1504 }
1505 }
1506
1507 return 0;
1508}
1509
Yann Gautiere4a3c352019-02-14 10:53:33 +01001510static void stm32mp1_pll_config_output(enum stm32mp1_pll_id pll_id,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001511 uint32_t *pllcfg)
1512{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001513 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
1514 uintptr_t rcc_base = stm32mp_rcc_base();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001515 uint32_t value;
1516
1517 value = (pllcfg[PLLCFG_P] << RCC_PLLNCFGR2_DIVP_SHIFT) &
1518 RCC_PLLNCFGR2_DIVP_MASK;
1519 value |= (pllcfg[PLLCFG_Q] << RCC_PLLNCFGR2_DIVQ_SHIFT) &
1520 RCC_PLLNCFGR2_DIVQ_MASK;
1521 value |= (pllcfg[PLLCFG_R] << RCC_PLLNCFGR2_DIVR_SHIFT) &
1522 RCC_PLLNCFGR2_DIVR_MASK;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001523 mmio_write_32(rcc_base + pll->pllxcfgr2, value);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001524}
1525
Yann Gautiere4a3c352019-02-14 10:53:33 +01001526static int stm32mp1_pll_config(enum stm32mp1_pll_id pll_id,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001527 uint32_t *pllcfg, uint32_t fracv)
1528{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001529 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
1530 uintptr_t rcc_base = stm32mp_rcc_base();
1531 enum stm32mp1_plltype type = pll->plltype;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001532 unsigned long refclk;
1533 uint32_t ifrge = 0;
1534 uint32_t src, value;
1535
Yann Gautiere4a3c352019-02-14 10:53:33 +01001536 src = mmio_read_32(rcc_base + pll->rckxselr) &
Yann Gautier9aea69e2018-07-24 17:13:36 +02001537 RCC_SELR_REFCLK_SRC_MASK;
1538
Yann Gautiere4a3c352019-02-14 10:53:33 +01001539 refclk = stm32mp1_clk_get_fixed(pll->refclk[src]) /
Yann Gautier9aea69e2018-07-24 17:13:36 +02001540 (pllcfg[PLLCFG_M] + 1U);
1541
1542 if ((refclk < (stm32mp1_pll[type].refclk_min * 1000000U)) ||
1543 (refclk > (stm32mp1_pll[type].refclk_max * 1000000U))) {
1544 return -EINVAL;
1545 }
1546
1547 if ((type == PLL_800) && (refclk >= 8000000U)) {
1548 ifrge = 1U;
1549 }
1550
1551 value = (pllcfg[PLLCFG_N] << RCC_PLLNCFGR1_DIVN_SHIFT) &
1552 RCC_PLLNCFGR1_DIVN_MASK;
1553 value |= (pllcfg[PLLCFG_M] << RCC_PLLNCFGR1_DIVM_SHIFT) &
1554 RCC_PLLNCFGR1_DIVM_MASK;
1555 value |= (ifrge << RCC_PLLNCFGR1_IFRGE_SHIFT) &
1556 RCC_PLLNCFGR1_IFRGE_MASK;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001557 mmio_write_32(rcc_base + pll->pllxcfgr1, value);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001558
1559 /* Fractional configuration */
1560 value = 0;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001561 mmio_write_32(rcc_base + pll->pllxfracr, value);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001562
1563 value = fracv << RCC_PLLNFRACR_FRACV_SHIFT;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001564 mmio_write_32(rcc_base + pll->pllxfracr, value);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001565
1566 value |= RCC_PLLNFRACR_FRACLE;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001567 mmio_write_32(rcc_base + pll->pllxfracr, value);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001568
Yann Gautiere4a3c352019-02-14 10:53:33 +01001569 stm32mp1_pll_config_output(pll_id, pllcfg);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001570
1571 return 0;
1572}
1573
Yann Gautiere4a3c352019-02-14 10:53:33 +01001574static void stm32mp1_pll_csg(enum stm32mp1_pll_id pll_id, uint32_t *csg)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001575{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001576 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001577 uint32_t pllxcsg = 0;
1578
1579 pllxcsg |= (csg[PLLCSG_MOD_PER] << RCC_PLLNCSGR_MOD_PER_SHIFT) &
1580 RCC_PLLNCSGR_MOD_PER_MASK;
1581
1582 pllxcsg |= (csg[PLLCSG_INC_STEP] << RCC_PLLNCSGR_INC_STEP_SHIFT) &
1583 RCC_PLLNCSGR_INC_STEP_MASK;
1584
1585 pllxcsg |= (csg[PLLCSG_SSCG_MODE] << RCC_PLLNCSGR_SSCG_MODE_SHIFT) &
1586 RCC_PLLNCSGR_SSCG_MODE_MASK;
1587
Yann Gautiere4a3c352019-02-14 10:53:33 +01001588 mmio_write_32(stm32mp_rcc_base() + pll->pllxcsgr, pllxcsg);
Yann Gautierd0dcbaa2019-06-04 15:55:37 +02001589
1590 mmio_setbits_32(stm32mp_rcc_base() + pll->pllxcr,
1591 RCC_PLLNCR_SSCG_CTRL);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001592}
1593
Yann Gautiere4a3c352019-02-14 10:53:33 +01001594static int stm32mp1_set_clksrc(unsigned int clksrc)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001595{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001596 uintptr_t clksrc_address = stm32mp_rcc_base() + (clksrc >> 4);
Yann Gautier2299d572019-02-14 11:14:39 +01001597 uint64_t timeout;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001598
Yann Gautiere4a3c352019-02-14 10:53:33 +01001599 mmio_clrsetbits_32(clksrc_address, RCC_SELR_SRC_MASK,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001600 clksrc & RCC_SELR_SRC_MASK);
1601
Yann Gautier2299d572019-02-14 11:14:39 +01001602 timeout = timeout_init_us(CLKSRC_TIMEOUT);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001603 while ((mmio_read_32(clksrc_address) & RCC_SELR_SRCRDY) == 0U) {
Yann Gautier2299d572019-02-14 11:14:39 +01001604 if (timeout_elapsed(timeout)) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001605 ERROR("CLKSRC %x start failed @ 0x%lx: 0x%x\n", clksrc,
1606 clksrc_address, mmio_read_32(clksrc_address));
Yann Gautier9aea69e2018-07-24 17:13:36 +02001607 return -ETIMEDOUT;
1608 }
1609 }
1610
1611 return 0;
1612}
1613
Yann Gautiere4a3c352019-02-14 10:53:33 +01001614static int stm32mp1_set_clkdiv(unsigned int clkdiv, uintptr_t address)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001615{
Yann Gautier2299d572019-02-14 11:14:39 +01001616 uint64_t timeout;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001617
1618 mmio_clrsetbits_32(address, RCC_DIVR_DIV_MASK,
1619 clkdiv & RCC_DIVR_DIV_MASK);
1620
Yann Gautier2299d572019-02-14 11:14:39 +01001621 timeout = timeout_init_us(CLKDIV_TIMEOUT);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001622 while ((mmio_read_32(address) & RCC_DIVR_DIVRDY) == 0U) {
Yann Gautier2299d572019-02-14 11:14:39 +01001623 if (timeout_elapsed(timeout)) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001624 ERROR("CLKDIV %x start failed @ 0x%lx: 0x%x\n",
Yann Gautier9aea69e2018-07-24 17:13:36 +02001625 clkdiv, address, mmio_read_32(address));
1626 return -ETIMEDOUT;
1627 }
1628 }
1629
1630 return 0;
1631}
1632
Yann Gautiere4a3c352019-02-14 10:53:33 +01001633static void stm32mp1_mco_csg(uint32_t clksrc, uint32_t clkdiv)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001634{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001635 uintptr_t clksrc_address = stm32mp_rcc_base() + (clksrc >> 4);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001636
1637 /*
1638 * Binding clksrc :
1639 * bit15-4 offset
1640 * bit3: disable
1641 * bit2-0: MCOSEL[2:0]
1642 */
1643 if ((clksrc & 0x8U) != 0U) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001644 mmio_clrbits_32(clksrc_address, RCC_MCOCFG_MCOON);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001645 } else {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001646 mmio_clrsetbits_32(clksrc_address,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001647 RCC_MCOCFG_MCOSRC_MASK,
1648 clksrc & RCC_MCOCFG_MCOSRC_MASK);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001649 mmio_clrsetbits_32(clksrc_address,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001650 RCC_MCOCFG_MCODIV_MASK,
1651 clkdiv << RCC_MCOCFG_MCODIV_SHIFT);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001652 mmio_setbits_32(clksrc_address, RCC_MCOCFG_MCOON);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001653 }
1654}
1655
Yann Gautiere4a3c352019-02-14 10:53:33 +01001656static void stm32mp1_set_rtcsrc(unsigned int clksrc, bool lse_css)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001657{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001658 uintptr_t address = stm32mp_rcc_base() + RCC_BDCR;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001659
1660 if (((mmio_read_32(address) & RCC_BDCR_RTCCKEN) == 0U) ||
1661 (clksrc != (uint32_t)CLK_RTC_DISABLED)) {
1662 mmio_clrsetbits_32(address,
1663 RCC_BDCR_RTCSRC_MASK,
Yann Gautier74aa83a2021-04-06 13:41:19 +02001664 (clksrc & RCC_SELR_SRC_MASK) << RCC_BDCR_RTCSRC_SHIFT);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001665
1666 mmio_setbits_32(address, RCC_BDCR_RTCCKEN);
1667 }
1668
1669 if (lse_css) {
1670 mmio_setbits_32(address, RCC_BDCR_LSECSSON);
1671 }
1672}
1673
Yann Gautiere4a3c352019-02-14 10:53:33 +01001674static void stm32mp1_stgen_config(void)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001675{
Yann Gautier9aea69e2018-07-24 17:13:36 +02001676 uint32_t cntfid0;
1677 unsigned long rate;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001678 unsigned long long counter;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001679
Yann Gautiera18f61b2020-05-05 17:58:40 +02001680 cntfid0 = mmio_read_32(STGEN_BASE + CNTFID_OFF);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001681 rate = get_clock_rate(stm32mp1_clk_get_parent(STGEN_K));
Yann Gautier9aea69e2018-07-24 17:13:36 +02001682
Yann Gautiere4a3c352019-02-14 10:53:33 +01001683 if (cntfid0 == rate) {
1684 return;
1685 }
Yann Gautier9aea69e2018-07-24 17:13:36 +02001686
Yann Gautiera18f61b2020-05-05 17:58:40 +02001687 mmio_clrbits_32(STGEN_BASE + CNTCR_OFF, CNTCR_EN);
1688 counter = (unsigned long long)mmio_read_32(STGEN_BASE + CNTCVL_OFF);
1689 counter |= ((unsigned long long)mmio_read_32(STGEN_BASE + CNTCVU_OFF)) << 32;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001690 counter = (counter * rate / cntfid0);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001691
Yann Gautiera18f61b2020-05-05 17:58:40 +02001692 mmio_write_32(STGEN_BASE + CNTCVL_OFF, (uint32_t)counter);
1693 mmio_write_32(STGEN_BASE + CNTCVU_OFF, (uint32_t)(counter >> 32));
1694 mmio_write_32(STGEN_BASE + CNTFID_OFF, rate);
1695 mmio_setbits_32(STGEN_BASE + CNTCR_OFF, CNTCR_EN);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001696
Yann Gautiere4a3c352019-02-14 10:53:33 +01001697 write_cntfrq((u_register_t)rate);
1698
1699 /* Need to update timer with new frequency */
1700 generic_delay_timer_init();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001701}
1702
1703void stm32mp1_stgen_increment(unsigned long long offset_in_ms)
1704{
Yann Gautier9aea69e2018-07-24 17:13:36 +02001705 unsigned long long cnt;
1706
Yann Gautiera18f61b2020-05-05 17:58:40 +02001707 cnt = ((unsigned long long)mmio_read_32(STGEN_BASE + CNTCVU_OFF) << 32) |
1708 mmio_read_32(STGEN_BASE + CNTCVL_OFF);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001709
Yann Gautiera18f61b2020-05-05 17:58:40 +02001710 cnt += (offset_in_ms * mmio_read_32(STGEN_BASE + CNTFID_OFF)) / 1000U;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001711
Yann Gautiera18f61b2020-05-05 17:58:40 +02001712 mmio_clrbits_32(STGEN_BASE + CNTCR_OFF, CNTCR_EN);
1713 mmio_write_32(STGEN_BASE + CNTCVL_OFF, (uint32_t)cnt);
1714 mmio_write_32(STGEN_BASE + CNTCVU_OFF, (uint32_t)(cnt >> 32));
1715 mmio_setbits_32(STGEN_BASE + CNTCR_OFF, CNTCR_EN);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001716}
1717
Yann Gautiere4a3c352019-02-14 10:53:33 +01001718static void stm32mp1_pkcs_config(uint32_t pkcs)
Yann Gautier9aea69e2018-07-24 17:13:36 +02001719{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001720 uintptr_t address = stm32mp_rcc_base() + ((pkcs >> 4) & 0xFFFU);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001721 uint32_t value = pkcs & 0xFU;
1722 uint32_t mask = 0xFU;
1723
1724 if ((pkcs & BIT(31)) != 0U) {
1725 mask <<= 4;
1726 value <<= 4;
1727 }
1728
1729 mmio_clrsetbits_32(address, mask, value);
1730}
1731
1732int stm32mp1_clk_init(void)
1733{
Yann Gautiere4a3c352019-02-14 10:53:33 +01001734 uintptr_t rcc_base = stm32mp_rcc_base();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001735 unsigned int clksrc[CLKSRC_NB];
1736 unsigned int clkdiv[CLKDIV_NB];
1737 unsigned int pllcfg[_PLL_NB][PLLCFG_NB];
1738 int plloff[_PLL_NB];
1739 int ret, len;
1740 enum stm32mp1_pll_id i;
1741 bool lse_css = false;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001742 bool pll3_preserve = false;
1743 bool pll4_preserve = false;
1744 bool pll4_bootrom = false;
Yann Gautierf9af3bc2018-11-09 15:57:18 +01001745 const fdt32_t *pkcs_cell;
Andre Przywaracc99f3f2020-03-26 12:51:21 +00001746 void *fdt;
1747
1748 if (fdt_get_address(&fdt) == 0) {
Yann Gautier360e0e92020-09-16 16:40:34 +02001749 return -FDT_ERR_NOTFOUND;
Andre Przywaracc99f3f2020-03-26 12:51:21 +00001750 }
Yann Gautier9aea69e2018-07-24 17:13:36 +02001751
1752 /* Check status field to disable security */
1753 if (!fdt_get_rcc_secure_status()) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001754 mmio_write_32(rcc_base + RCC_TZCR, 0);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001755 }
1756
Andre Przywaracc99f3f2020-03-26 12:51:21 +00001757 ret = fdt_rcc_read_uint32_array("st,clksrc", (uint32_t)CLKSRC_NB,
1758 clksrc);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001759 if (ret < 0) {
1760 return -FDT_ERR_NOTFOUND;
1761 }
1762
Andre Przywaracc99f3f2020-03-26 12:51:21 +00001763 ret = fdt_rcc_read_uint32_array("st,clkdiv", (uint32_t)CLKDIV_NB,
1764 clkdiv);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001765 if (ret < 0) {
1766 return -FDT_ERR_NOTFOUND;
1767 }
1768
1769 for (i = (enum stm32mp1_pll_id)0; i < _PLL_NB; i++) {
1770 char name[12];
1771
Antonio Nino Diaz00086e32018-08-16 16:46:06 +01001772 snprintf(name, sizeof(name), "st,pll@%d", i);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001773 plloff[i] = fdt_rcc_subnode_offset(name);
1774
1775 if (!fdt_check_node(plloff[i])) {
1776 continue;
1777 }
1778
Andre Przywaracc99f3f2020-03-26 12:51:21 +00001779 ret = fdt_read_uint32_array(fdt, plloff[i], "cfg",
1780 (int)PLLCFG_NB, pllcfg[i]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001781 if (ret < 0) {
1782 return -FDT_ERR_NOTFOUND;
1783 }
1784 }
1785
Yann Gautiere4a3c352019-02-14 10:53:33 +01001786 stm32mp1_mco_csg(clksrc[CLKSRC_MCO1], clkdiv[CLKDIV_MCO1]);
1787 stm32mp1_mco_csg(clksrc[CLKSRC_MCO2], clkdiv[CLKDIV_MCO2]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001788
1789 /*
1790 * Switch ON oscillator found in device-tree.
1791 * Note: HSI already ON after BootROM stage.
1792 */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001793 if (stm32mp1_osc[_LSI] != 0U) {
1794 stm32mp1_lsi_set(true);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001795 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001796 if (stm32mp1_osc[_LSE] != 0U) {
1797 bool bypass, digbyp;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001798 uint32_t lsedrv;
1799
1800 bypass = fdt_osc_read_bool(_LSE, "st,bypass");
Yann Gautiere4a3c352019-02-14 10:53:33 +01001801 digbyp = fdt_osc_read_bool(_LSE, "st,digbypass");
Yann Gautier9aea69e2018-07-24 17:13:36 +02001802 lse_css = fdt_osc_read_bool(_LSE, "st,css");
1803 lsedrv = fdt_osc_read_uint32_default(_LSE, "st,drive",
1804 LSEDRV_MEDIUM_HIGH);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001805 stm32mp1_lse_enable(bypass, digbyp, lsedrv);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001806 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001807 if (stm32mp1_osc[_HSE] != 0U) {
1808 bool bypass, digbyp, css;
Yann Gautier9aea69e2018-07-24 17:13:36 +02001809
Yann Gautiere4a3c352019-02-14 10:53:33 +01001810 bypass = fdt_osc_read_bool(_HSE, "st,bypass");
1811 digbyp = fdt_osc_read_bool(_HSE, "st,digbypass");
1812 css = fdt_osc_read_bool(_HSE, "st,css");
1813 stm32mp1_hse_enable(bypass, digbyp, css);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001814 }
1815 /*
1816 * CSI is mandatory for automatic I/O compensation (SYSCFG_CMPCR)
1817 * => switch on CSI even if node is not present in device tree
1818 */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001819 stm32mp1_csi_set(true);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001820
1821 /* Come back to HSI */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001822 ret = stm32mp1_set_clksrc(CLK_MPU_HSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001823 if (ret != 0) {
1824 return ret;
1825 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001826 ret = stm32mp1_set_clksrc(CLK_AXI_HSI);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001827 if (ret != 0) {
1828 return ret;
1829 }
Yann Gautiered342322019-02-15 17:33:27 +01001830 ret = stm32mp1_set_clksrc(CLK_MCU_HSI);
1831 if (ret != 0) {
1832 return ret;
1833 }
Yann Gautier9aea69e2018-07-24 17:13:36 +02001834
Yann Gautiere4a3c352019-02-14 10:53:33 +01001835 if ((mmio_read_32(rcc_base + RCC_MP_RSTSCLRR) &
1836 RCC_MP_RSTSCLRR_MPUP0RSTF) != 0) {
1837 pll3_preserve = stm32mp1_check_pll_conf(_PLL3,
1838 clksrc[CLKSRC_PLL3],
1839 pllcfg[_PLL3],
1840 plloff[_PLL3]);
1841 pll4_preserve = stm32mp1_check_pll_conf(_PLL4,
1842 clksrc[CLKSRC_PLL4],
1843 pllcfg[_PLL4],
1844 plloff[_PLL4]);
1845 }
1846
Yann Gautier9aea69e2018-07-24 17:13:36 +02001847 for (i = (enum stm32mp1_pll_id)0; i < _PLL_NB; i++) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001848 if (((i == _PLL3) && pll3_preserve) ||
1849 ((i == _PLL4) && pll4_preserve)) {
Yann Gautier9aea69e2018-07-24 17:13:36 +02001850 continue;
Yann Gautiere4a3c352019-02-14 10:53:33 +01001851 }
1852
1853 ret = stm32mp1_pll_stop(i);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001854 if (ret != 0) {
1855 return ret;
1856 }
1857 }
1858
1859 /* Configure HSIDIV */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001860 if (stm32mp1_osc[_HSI] != 0U) {
1861 ret = stm32mp1_hsidiv(stm32mp1_osc[_HSI]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001862 if (ret != 0) {
1863 return ret;
1864 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001865 stm32mp1_stgen_config();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001866 }
1867
1868 /* Select DIV */
1869 /* No ready bit when MPUSRC != CLK_MPU_PLL1P_DIV, MPUDIV is disabled */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001870 mmio_write_32(rcc_base + RCC_MPCKDIVR,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001871 clkdiv[CLKDIV_MPU] & RCC_DIVR_DIV_MASK);
Yann Gautiere4a3c352019-02-14 10:53:33 +01001872 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_AXI], rcc_base + RCC_AXIDIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001873 if (ret != 0) {
1874 return ret;
1875 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001876 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_APB4], rcc_base + RCC_APB4DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001877 if (ret != 0) {
1878 return ret;
1879 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001880 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_APB5], rcc_base + RCC_APB5DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001881 if (ret != 0) {
1882 return ret;
1883 }
Yann Gautiered342322019-02-15 17:33:27 +01001884 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_MCU], rcc_base + RCC_MCUDIVR);
1885 if (ret != 0) {
1886 return ret;
1887 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001888 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_APB1], rcc_base + RCC_APB1DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001889 if (ret != 0) {
1890 return ret;
1891 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001892 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_APB2], rcc_base + RCC_APB2DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001893 if (ret != 0) {
1894 return ret;
1895 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001896 ret = stm32mp1_set_clkdiv(clkdiv[CLKDIV_APB3], rcc_base + RCC_APB3DIVR);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001897 if (ret != 0) {
1898 return ret;
1899 }
1900
1901 /* No ready bit for RTC */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001902 mmio_write_32(rcc_base + RCC_RTCDIVR,
Yann Gautier9aea69e2018-07-24 17:13:36 +02001903 clkdiv[CLKDIV_RTC] & RCC_DIVR_DIV_MASK);
1904
1905 /* Configure PLLs source */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001906 ret = stm32mp1_set_clksrc(clksrc[CLKSRC_PLL12]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001907 if (ret != 0) {
1908 return ret;
1909 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001910
1911 if (!pll3_preserve) {
1912 ret = stm32mp1_set_clksrc(clksrc[CLKSRC_PLL3]);
1913 if (ret != 0) {
1914 return ret;
1915 }
Yann Gautier9aea69e2018-07-24 17:13:36 +02001916 }
1917
Yann Gautiere4a3c352019-02-14 10:53:33 +01001918 if (!pll4_preserve) {
1919 ret = stm32mp1_set_clksrc(clksrc[CLKSRC_PLL4]);
1920 if (ret != 0) {
1921 return ret;
1922 }
Yann Gautier9aea69e2018-07-24 17:13:36 +02001923 }
1924
1925 /* Configure and start PLLs */
1926 for (i = (enum stm32mp1_pll_id)0; i < _PLL_NB; i++) {
1927 uint32_t fracv;
1928 uint32_t csg[PLLCSG_NB];
1929
Yann Gautiere4a3c352019-02-14 10:53:33 +01001930 if (((i == _PLL3) && pll3_preserve) ||
1931 ((i == _PLL4) && pll4_preserve && !pll4_bootrom)) {
1932 continue;
1933 }
1934
Yann Gautier9aea69e2018-07-24 17:13:36 +02001935 if (!fdt_check_node(plloff[i])) {
1936 continue;
1937 }
1938
Yann Gautiere4a3c352019-02-14 10:53:33 +01001939 if ((i == _PLL4) && pll4_bootrom) {
1940 /* Set output divider if not done by the Bootrom */
1941 stm32mp1_pll_config_output(i, pllcfg[i]);
1942 continue;
1943 }
1944
Andre Przywara2d5690c2020-03-26 11:50:33 +00001945 fracv = fdt_read_uint32_default(fdt, plloff[i], "frac", 0);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001946
Yann Gautiere4a3c352019-02-14 10:53:33 +01001947 ret = stm32mp1_pll_config(i, pllcfg[i], fracv);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001948 if (ret != 0) {
1949 return ret;
1950 }
Andre Przywaracc99f3f2020-03-26 12:51:21 +00001951 ret = fdt_read_uint32_array(fdt, plloff[i], "csg",
1952 (uint32_t)PLLCSG_NB, csg);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001953 if (ret == 0) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01001954 stm32mp1_pll_csg(i, csg);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001955 } else if (ret != -FDT_ERR_NOTFOUND) {
1956 return ret;
1957 }
1958
Yann Gautiere4a3c352019-02-14 10:53:33 +01001959 stm32mp1_pll_start(i);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001960 }
1961 /* Wait and start PLLs ouptut when ready */
1962 for (i = (enum stm32mp1_pll_id)0; i < _PLL_NB; i++) {
1963 if (!fdt_check_node(plloff[i])) {
1964 continue;
1965 }
1966
Yann Gautiere4a3c352019-02-14 10:53:33 +01001967 ret = stm32mp1_pll_output(i, pllcfg[i][PLLCFG_O]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001968 if (ret != 0) {
1969 return ret;
1970 }
1971 }
1972 /* Wait LSE ready before to use it */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001973 if (stm32mp1_osc[_LSE] != 0U) {
1974 stm32mp1_lse_wait();
Yann Gautier9aea69e2018-07-24 17:13:36 +02001975 }
1976
1977 /* Configure with expected clock source */
Yann Gautiere4a3c352019-02-14 10:53:33 +01001978 ret = stm32mp1_set_clksrc(clksrc[CLKSRC_MPU]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001979 if (ret != 0) {
1980 return ret;
1981 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001982 ret = stm32mp1_set_clksrc(clksrc[CLKSRC_AXI]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001983 if (ret != 0) {
1984 return ret;
1985 }
Yann Gautiered342322019-02-15 17:33:27 +01001986 ret = stm32mp1_set_clksrc(clksrc[CLKSRC_MCU]);
1987 if (ret != 0) {
1988 return ret;
1989 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01001990 stm32mp1_set_rtcsrc(clksrc[CLKSRC_RTC], lse_css);
Yann Gautier9aea69e2018-07-24 17:13:36 +02001991
1992 /* Configure PKCK */
1993 pkcs_cell = fdt_rcc_read_prop("st,pkcs", &len);
1994 if (pkcs_cell != NULL) {
1995 bool ckper_disabled = false;
1996 uint32_t j;
1997
Yann Gautier9aea69e2018-07-24 17:13:36 +02001998 for (j = 0; j < ((uint32_t)len / sizeof(uint32_t)); j++) {
Yann Gautierf9af3bc2018-11-09 15:57:18 +01001999 uint32_t pkcs = fdt32_to_cpu(pkcs_cell[j]);
Yann Gautier9aea69e2018-07-24 17:13:36 +02002000
2001 if (pkcs == (uint32_t)CLK_CKPER_DISABLED) {
2002 ckper_disabled = true;
2003 continue;
2004 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01002005 stm32mp1_pkcs_config(pkcs);
Yann Gautier9aea69e2018-07-24 17:13:36 +02002006 }
2007
2008 /*
2009 * CKPER is source for some peripheral clocks
2010 * (FMC-NAND / QPSI-NOR) and switching source is allowed
2011 * only if previous clock is still ON
2012 * => deactivated CKPER only after switching clock
2013 */
2014 if (ckper_disabled) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01002015 stm32mp1_pkcs_config(CLK_CKPER_DISABLED);
Yann Gautier9aea69e2018-07-24 17:13:36 +02002016 }
2017 }
2018
2019 /* Switch OFF HSI if not found in device-tree */
Yann Gautiere4a3c352019-02-14 10:53:33 +01002020 if (stm32mp1_osc[_HSI] == 0U) {
2021 stm32mp1_hsi_set(false);
Yann Gautier9aea69e2018-07-24 17:13:36 +02002022 }
Yann Gautiere4a3c352019-02-14 10:53:33 +01002023 stm32mp1_stgen_config();
Yann Gautier9aea69e2018-07-24 17:13:36 +02002024
2025 /* Software Self-Refresh mode (SSR) during DDR initilialization */
Yann Gautiere4a3c352019-02-14 10:53:33 +01002026 mmio_clrsetbits_32(rcc_base + RCC_DDRITFCR,
Yann Gautier9aea69e2018-07-24 17:13:36 +02002027 RCC_DDRITFCR_DDRCKMOD_MASK,
2028 RCC_DDRITFCR_DDRCKMOD_SSR <<
2029 RCC_DDRITFCR_DDRCKMOD_SHIFT);
2030
2031 return 0;
2032}
2033
2034static void stm32mp1_osc_clk_init(const char *name,
Yann Gautier9aea69e2018-07-24 17:13:36 +02002035 enum stm32mp_osc_id index)
2036{
2037 uint32_t frequency;
2038
Yann Gautiere4a3c352019-02-14 10:53:33 +01002039 if (fdt_osc_read_freq(name, &frequency) == 0) {
2040 stm32mp1_osc[index] = frequency;
Yann Gautier9aea69e2018-07-24 17:13:36 +02002041 }
2042}
2043
2044static void stm32mp1_osc_init(void)
2045{
Yann Gautier9aea69e2018-07-24 17:13:36 +02002046 enum stm32mp_osc_id i;
2047
2048 for (i = (enum stm32mp_osc_id)0 ; i < NB_OSC; i++) {
Yann Gautiere4a3c352019-02-14 10:53:33 +01002049 stm32mp1_osc_clk_init(stm32mp_osc_node_label[i], i);
Yann Gautier9aea69e2018-07-24 17:13:36 +02002050 }
2051}
Etienne Carriere1368ada2020-05-13 11:49:49 +02002052
2053#ifdef STM32MP_SHARED_RESOURCES
2054/*
2055 * Get the parent ID of the target parent clock, for tagging as secure
2056 * shared clock dependencies.
2057 */
2058static int get_parent_id_parent(unsigned int parent_id)
2059{
2060 enum stm32mp1_parent_sel s = _UNKNOWN_SEL;
2061 enum stm32mp1_pll_id pll_id;
2062 uint32_t p_sel;
2063 uintptr_t rcc_base = stm32mp_rcc_base();
2064
2065 switch (parent_id) {
2066 case _ACLK:
2067 case _PCLK4:
2068 case _PCLK5:
2069 s = _AXIS_SEL;
2070 break;
2071 case _PLL1_P:
2072 case _PLL1_Q:
2073 case _PLL1_R:
2074 pll_id = _PLL1;
2075 break;
2076 case _PLL2_P:
2077 case _PLL2_Q:
2078 case _PLL2_R:
2079 pll_id = _PLL2;
2080 break;
2081 case _PLL3_P:
2082 case _PLL3_Q:
2083 case _PLL3_R:
2084 pll_id = _PLL3;
2085 break;
2086 case _PLL4_P:
2087 case _PLL4_Q:
2088 case _PLL4_R:
2089 pll_id = _PLL4;
2090 break;
2091 case _PCLK1:
2092 case _PCLK2:
2093 case _HCLK2:
2094 case _HCLK6:
2095 case _CK_PER:
2096 case _CK_MPU:
2097 case _CK_MCU:
2098 case _USB_PHY_48:
2099 /* We do not expect to access these */
2100 panic();
2101 break;
2102 default:
2103 /* Other parents have no parent */
2104 return -1;
2105 }
2106
2107 if (s != _UNKNOWN_SEL) {
2108 const struct stm32mp1_clk_sel *sel = clk_sel_ref(s);
2109
2110 p_sel = (mmio_read_32(rcc_base + sel->offset) >> sel->src) &
2111 sel->msk;
2112
2113 if (p_sel < sel->nb_parent) {
2114 return (int)sel->parent[p_sel];
2115 }
2116 } else {
2117 const struct stm32mp1_clk_pll *pll = pll_ref(pll_id);
2118
2119 p_sel = mmio_read_32(rcc_base + pll->rckxselr) &
2120 RCC_SELR_REFCLK_SRC_MASK;
2121
2122 if (pll->refclk[p_sel] != _UNKNOWN_OSC_ID) {
2123 return (int)pll->refclk[p_sel];
2124 }
2125 }
2126
2127 VERBOSE("No parent selected for %s\n",
2128 stm32mp1_clk_parent_name[parent_id]);
2129
2130 return -1;
2131}
2132
2133static void secure_parent_clocks(unsigned long parent_id)
2134{
2135 int grandparent_id;
2136
2137 switch (parent_id) {
2138 case _PLL3_P:
2139 case _PLL3_Q:
2140 case _PLL3_R:
2141 stm32mp_register_secure_periph(STM32MP1_SHRES_PLL3);
2142 break;
2143
2144 /* These clocks are always secure when RCC is secure */
2145 case _ACLK:
2146 case _HCLK2:
2147 case _HCLK6:
2148 case _PCLK4:
2149 case _PCLK5:
2150 case _PLL1_P:
2151 case _PLL1_Q:
2152 case _PLL1_R:
2153 case _PLL2_P:
2154 case _PLL2_Q:
2155 case _PLL2_R:
2156 case _HSI:
2157 case _HSI_KER:
2158 case _LSI:
2159 case _CSI:
2160 case _CSI_KER:
2161 case _HSE:
2162 case _HSE_KER:
2163 case _HSE_KER_DIV2:
Gabriel Fernandez4e3a51a2021-07-27 15:39:16 +02002164 case _HSE_RTC:
Etienne Carriere1368ada2020-05-13 11:49:49 +02002165 case _LSE:
2166 break;
2167
2168 default:
2169 VERBOSE("Cannot secure parent clock %s\n",
2170 stm32mp1_clk_parent_name[parent_id]);
2171 panic();
2172 }
2173
2174 grandparent_id = get_parent_id_parent(parent_id);
2175 if (grandparent_id >= 0) {
2176 secure_parent_clocks(grandparent_id);
2177 }
2178}
2179
2180void stm32mp1_register_clock_parents_secure(unsigned long clock_id)
2181{
2182 int parent_id;
2183
2184 if (!stm32mp1_rcc_is_secure()) {
2185 return;
2186 }
2187
2188 switch (clock_id) {
2189 case PLL1:
2190 case PLL2:
2191 /* PLL1/PLL2 are always secure: nothing to do */
2192 break;
2193 case PLL3:
2194 stm32mp_register_secure_periph(STM32MP1_SHRES_PLL3);
2195 break;
2196 case PLL4:
2197 ERROR("PLL4 cannot be secured\n");
2198 panic();
2199 break;
2200 default:
2201 /* Others are expected gateable clock */
2202 parent_id = stm32mp1_clk_get_parent(clock_id);
2203 if (parent_id < 0) {
2204 INFO("No parent found for clock %lu\n", clock_id);
2205 } else {
2206 secure_parent_clocks(parent_id);
2207 }
2208 break;
2209 }
2210}
2211#endif /* STM32MP_SHARED_RESOURCES */
Yann Gautier9aea69e2018-07-24 17:13:36 +02002212
Yann Gautierc7f9e962019-05-20 14:39:26 +02002213static void sync_earlyboot_clocks_state(void)
2214{
Etienne Carriere2a756c22019-12-08 08:23:35 +01002215 unsigned int idx;
2216 const unsigned long secure_enable[] = {
2217 AXIDCG,
2218 BSEC,
2219 DDRC1, DDRC1LP,
2220 DDRC2, DDRC2LP,
2221 DDRCAPB, DDRPHYCAPB, DDRPHYCAPBLP,
2222 DDRPHYC, DDRPHYCLP,
Lionel Debievecfa88cc2019-09-02 18:15:45 +02002223 RTCAPB,
Etienne Carriere2a756c22019-12-08 08:23:35 +01002224 TZC1, TZC2,
2225 TZPC,
2226 STGEN_K,
2227 };
2228
2229 for (idx = 0U; idx < ARRAY_SIZE(secure_enable); idx++) {
2230 stm32mp_clk_enable(secure_enable[idx]);
2231 }
Yann Gautierc7f9e962019-05-20 14:39:26 +02002232}
2233
Yann Gautier9aea69e2018-07-24 17:13:36 +02002234int stm32mp1_clk_probe(void)
2235{
Yann Gautier9aea69e2018-07-24 17:13:36 +02002236 stm32mp1_osc_init();
2237
Yann Gautierc7f9e962019-05-20 14:39:26 +02002238 sync_earlyboot_clocks_state();
2239
Yann Gautier9aea69e2018-07-24 17:13:36 +02002240 return 0;
2241}