1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2018, The Linux Foundation. All rights reserved.
4 */
5
6 #include <linux/kernel.h>
7 #include <linux/platform_device.h>
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/clk-provider.h>
11 #include <linux/regmap.h>
12 #include <linux/reset-controller.h>
13
14 #include <dt-bindings/clock/qcom,gcc-qcs404.h>
15
16 #include "clk-alpha-pll.h"
17 #include "clk-branch.h"
18 #include "clk-pll.h"
19 #include "clk-rcg.h"
20 #include "clk-regmap.h"
21 #include "common.h"
22 #include "gdsc.h"
23 #include "reset.h"
24
25 enum {
26 DT_XO,
27 DT_SLEEP_CLK,
28 DT_PCIE_0_PIPE_CLK,
29 DT_DSI0_PHY_PLL_OUT_DSICLK,
30 DT_DSI0_PHY_PLL_OUT_BYTECLK,
31 DT_HDMI_PHY_PLL_CLK,
32 };
33
34 enum {
35 P_DSI0_PHY_PLL_OUT_BYTECLK,
36 P_DSI0_PHY_PLL_OUT_DSICLK,
37 P_GPLL0_OUT_MAIN,
38 P_GPLL1_OUT_MAIN,
39 P_GPLL3_OUT_MAIN,
40 P_GPLL4_OUT_MAIN,
41 P_GPLL6_OUT_AUX,
42 P_HDMI_PHY_PLL_CLK,
43 P_PCIE_0_PIPE_CLK,
44 P_SLEEP_CLK,
45 P_XO,
46 };
47
48 static const struct parent_map gcc_parent_map_1[] = {
49 { P_XO, 0 },
50 };
51
52 static const struct clk_parent_data gcc_parent_data_1[] = {
53 { .index = DT_XO, .name = "xo-board" },
54 };
55
56 static struct clk_fixed_factor cxo = {
57 .mult = 1,
58 .div = 1,
59 .hw.init = &(struct clk_init_data){
60 .name = "cxo",
61 .parent_data = gcc_parent_data_1,
62 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
63 .ops = &clk_fixed_factor_ops,
64 },
65 };
66
67 static struct clk_alpha_pll gpll0_sleep_clk_src = {
68 .offset = 0x21000,
69 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
70 .clkr = {
71 .enable_reg = 0x45008,
72 .enable_mask = BIT(23),
73 .enable_is_inverted = true,
74 .hw.init = &(struct clk_init_data){
75 .name = "gpll0_sleep_clk_src",
76 .parent_data = gcc_parent_data_1,
77 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
78 .ops = &clk_alpha_pll_ops,
79 },
80 },
81 };
82
83 static struct clk_alpha_pll gpll0_out_main = {
84 .offset = 0x21000,
85 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
86 .flags = SUPPORTS_FSM_MODE,
87 .clkr = {
88 .enable_reg = 0x45000,
89 .enable_mask = BIT(0),
90 .hw.init = &(struct clk_init_data){
91 .name = "gpll0_out_main",
92 .parent_data = gcc_parent_data_1,
93 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
94 .ops = &clk_alpha_pll_ops,
95 },
96 },
97 };
98
99 static struct clk_alpha_pll gpll0_ao_out_main = {
100 .offset = 0x21000,
101 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
102 .flags = SUPPORTS_FSM_MODE,
103 .clkr = {
104 .enable_reg = 0x45000,
105 .enable_mask = BIT(0),
106 .hw.init = &(struct clk_init_data){
107 .name = "gpll0_ao_out_main",
108 .parent_data = gcc_parent_data_1,
109 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
110 .flags = CLK_IS_CRITICAL,
111 .ops = &clk_alpha_pll_fixed_ops,
112 },
113 },
114 };
115
116 static struct clk_alpha_pll gpll1_out_main = {
117 .offset = 0x20000,
118 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
119 .clkr = {
120 .enable_reg = 0x45000,
121 .enable_mask = BIT(1),
122 .hw.init = &(struct clk_init_data){
123 .name = "gpll1_out_main",
124 .parent_data = gcc_parent_data_1,
125 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
126 .ops = &clk_alpha_pll_ops,
127 },
128 },
129 };
130
131 /* 930MHz configuration */
132 static const struct alpha_pll_config gpll3_config = {
133 .l = 48,
134 .alpha = 0x0,
135 .alpha_en_mask = BIT(24),
136 .post_div_mask = 0xf << 8,
137 .post_div_val = 0x1 << 8,
138 .vco_mask = 0x3 << 20,
139 .main_output_mask = 0x1,
140 .config_ctl_val = 0x4001055b,
141 };
142
143 static const struct pll_vco gpll3_vco[] = {
144 { 700000000, 1400000000, 0 },
145 };
146
147 static struct clk_alpha_pll gpll3_out_main = {
148 .offset = 0x22000,
149 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
150 .vco_table = gpll3_vco,
151 .num_vco = ARRAY_SIZE(gpll3_vco),
152 .clkr = {
153 .hw.init = &(struct clk_init_data){
154 .name = "gpll3_out_main",
155 .parent_data = gcc_parent_data_1,
156 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
157 .ops = &clk_alpha_pll_ops,
158 },
159 },
160 };
161
162 static struct clk_alpha_pll gpll4_out_main = {
163 .offset = 0x24000,
164 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT],
165 .clkr = {
166 .enable_reg = 0x45000,
167 .enable_mask = BIT(5),
168 .hw.init = &(struct clk_init_data){
169 .name = "gpll4_out_main",
170 .parent_data = gcc_parent_data_1,
171 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
172 .ops = &clk_alpha_pll_ops,
173 },
174 },
175 };
176
177 static struct clk_pll gpll6 = {
178 .l_reg = 0x37004,
179 .m_reg = 0x37008,
180 .n_reg = 0x3700C,
181 .config_reg = 0x37014,
182 .mode_reg = 0x37000,
183 .status_reg = 0x3701C,
184 .status_bit = 17,
185 .clkr.hw.init = &(struct clk_init_data){
186 .name = "gpll6",
187 .parent_data = gcc_parent_data_1,
188 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
189 .ops = &clk_pll_ops,
190 },
191 };
192
193 static struct clk_regmap gpll6_out_aux = {
194 .enable_reg = 0x45000,
195 .enable_mask = BIT(7),
196 .hw.init = &(struct clk_init_data){
197 .name = "gpll6_out_aux",
198 .parent_hws = (const struct clk_hw*[]) {
199 &gpll6.clkr.hw,
200 },
201 .num_parents = 1,
202 .ops = &clk_pll_vote_ops,
203 },
204 };
205
206 static const struct parent_map gcc_parent_map_0[] = {
207 { P_XO, 0 },
208 { P_GPLL0_OUT_MAIN, 1 },
209 };
210
211 static const struct clk_parent_data gcc_parent_data_0[] = {
212 { .index = DT_XO, .name = "xo-board" },
213 { .hw = &gpll0_out_main.clkr.hw },
214 };
215
216 static const struct clk_parent_data gcc_parent_data_ao_0[] = {
217 { .index = DT_XO, .name = "xo-board" },
218 { .hw = &gpll0_ao_out_main.clkr.hw },
219 };
220
221 static const struct parent_map gcc_parent_map_2[] = {
222 { P_XO, 0 },
223 { P_GPLL0_OUT_MAIN, 1 },
224 { P_GPLL6_OUT_AUX, 2 },
225 { P_SLEEP_CLK, 6 },
226 };
227
228 static const struct clk_parent_data gcc_parent_data_2[] = {
229 { .index = DT_XO, .name = "xo-board" },
230 { .hw = &gpll0_out_main.clkr.hw },
231 { .hw = &gpll6_out_aux.hw },
232 { .index = DT_SLEEP_CLK, .name = "sleep_clk" },
233 };
234
235 static const struct parent_map gcc_parent_map_3[] = {
236 { P_XO, 0 },
237 { P_GPLL0_OUT_MAIN, 1 },
238 { P_GPLL6_OUT_AUX, 2 },
239 };
240
241 static const struct clk_parent_data gcc_parent_data_3[] = {
242 { .index = DT_XO, .name = "xo-board" },
243 { .hw = &gpll0_out_main.clkr.hw },
244 { .hw = &gpll6_out_aux.hw },
245 };
246
247 static const struct parent_map gcc_parent_map_4[] = {
248 { P_XO, 0 },
249 { P_GPLL1_OUT_MAIN, 1 },
250 };
251
252 static const struct clk_parent_data gcc_parent_data_4[] = {
253 { .index = DT_XO, .name = "xo-board" },
254 { .hw = &gpll1_out_main.clkr.hw },
255 };
256
257 static const struct parent_map gcc_parent_map_5[] = {
258 { P_XO, 0 },
259 { P_DSI0_PHY_PLL_OUT_BYTECLK, 1 },
260 };
261
262 static const struct clk_parent_data gcc_parent_data_5[] = {
263 { .index = DT_XO, .name = "xo-board" },
264 { .index = DT_DSI0_PHY_PLL_OUT_BYTECLK, .name = "dsi0pllbyte" },
265 };
266
267 static const struct parent_map gcc_parent_map_6[] = {
268 { P_XO, 0 },
269 { P_DSI0_PHY_PLL_OUT_BYTECLK, 2 },
270 };
271
272 static const struct clk_parent_data gcc_parent_data_6[] = {
273 { .index = DT_XO, .name = "xo-board" },
274 { .index = DT_DSI0_PHY_PLL_OUT_BYTECLK, .name = "dsi0pllbyte" },
275 };
276
277 static const struct parent_map gcc_parent_map_7[] = {
278 { P_XO, 0 },
279 { P_GPLL0_OUT_MAIN, 1 },
280 { P_GPLL3_OUT_MAIN, 2 },
281 { P_GPLL6_OUT_AUX, 3 },
282 };
283
284 static const struct clk_parent_data gcc_parent_data_7[] = {
285 { .index = DT_XO, .name = "xo-board" },
286 { .hw = &gpll0_out_main.clkr.hw },
287 { .hw = &gpll3_out_main.clkr.hw },
288 { .hw = &gpll6_out_aux.hw },
289 };
290
291 static const struct parent_map gcc_parent_map_8[] = {
292 { P_XO, 0 },
293 { P_HDMI_PHY_PLL_CLK, 1 },
294 };
295
296 static const struct clk_parent_data gcc_parent_data_8[] = {
297 { .index = DT_XO, .name = "xo-board" },
298 { .index = DT_HDMI_PHY_PLL_CLK, .name = "hdmi_pll" },
299 };
300
301 static const struct parent_map gcc_parent_map_9[] = {
302 { P_XO, 0 },
303 { P_GPLL0_OUT_MAIN, 1 },
304 { P_DSI0_PHY_PLL_OUT_DSICLK, 2 },
305 { P_GPLL6_OUT_AUX, 3 },
306 };
307
308 static const struct clk_parent_data gcc_parent_data_9[] = {
309 { .index = DT_XO, .name = "xo-board" },
310 { .hw = &gpll0_out_main.clkr.hw },
311 { .index = DT_DSI0_PHY_PLL_OUT_DSICLK, .name = "dsi0pll" },
312 { .hw = &gpll6_out_aux.hw },
313 };
314
315 static const struct parent_map gcc_parent_map_10[] = {
316 { P_XO, 0 },
317 { P_SLEEP_CLK, 1 },
318 };
319
320 static const struct clk_parent_data gcc_parent_data_10[] = {
321 { .index = DT_XO, .name = "xo-board" },
322 { .index = DT_SLEEP_CLK, .name = "sleep_clk" },
323 };
324
325 static const struct parent_map gcc_parent_map_11[] = {
326 { P_XO, 0 },
327 { P_PCIE_0_PIPE_CLK, 1 },
328 };
329
330 static const struct clk_parent_data gcc_parent_data_11[] = {
331 { .index = DT_XO, .name = "xo-board" },
332 { .fw_name = "pcie_0_pipe_clk", .name = "pcie_0_pipe_clk" },
333 };
334
335 static const struct parent_map gcc_parent_map_12[] = {
336 { P_XO, 0 },
337 { P_DSI0_PHY_PLL_OUT_DSICLK, 1 },
338 };
339
340 static const struct clk_parent_data gcc_parent_data_12[] = {
341 { .index = DT_XO, .name = "xo-board" },
342 { .index = DT_DSI0_PHY_PLL_OUT_DSICLK, .name = "dsi0pll" },
343 };
344
345 static const struct parent_map gcc_parent_map_13[] = {
346 { P_XO, 0 },
347 { P_GPLL0_OUT_MAIN, 1 },
348 { P_GPLL4_OUT_MAIN, 2 },
349 { P_GPLL6_OUT_AUX, 3 },
350 };
351
352 static const struct clk_parent_data gcc_parent_data_13[] = {
353 { .index = DT_XO, .name = "xo-board" },
354 { .hw = &gpll0_out_main.clkr.hw },
355 { .hw = &gpll4_out_main.clkr.hw },
356 { .hw = &gpll6_out_aux.hw },
357 };
358
359 static const struct parent_map gcc_parent_map_14[] = {
360 { P_XO, 0 },
361 { P_GPLL0_OUT_MAIN, 1 },
362 };
363
364 static const struct clk_parent_data gcc_parent_data_14[] = {
365 { .index = DT_XO, .name = "xo-board" },
366 { .hw = &gpll0_out_main.clkr.hw },
367 };
368
369 static const struct parent_map gcc_parent_map_15[] = {
370 { P_XO, 0 },
371 };
372
373 static const struct clk_parent_data gcc_parent_data_15[] = {
374 { .index = DT_XO, .name = "xo-board" },
375 };
376
377 static const struct parent_map gcc_parent_map_16[] = {
378 { P_XO, 0 },
379 { P_GPLL0_OUT_MAIN, 1 },
380 };
381
382 static const struct clk_parent_data gcc_parent_data_16[] = {
383 { .index = DT_XO, .name = "xo-board" },
384 { .hw = &gpll0_out_main.clkr.hw },
385 };
386
387 static const struct freq_tbl ftbl_apss_ahb_clk_src[] = {
388 F(19200000, P_XO, 1, 0, 0),
389 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
390 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
391 F(133333333, P_GPLL0_OUT_MAIN, 6, 0, 0),
392 { }
393 };
394
395 static struct clk_rcg2 apss_ahb_clk_src = {
396 .cmd_rcgr = 0x46000,
397 .mnd_width = 0,
398 .hid_width = 5,
399 .parent_map = gcc_parent_map_0,
400 .freq_tbl = ftbl_apss_ahb_clk_src,
401 .clkr.hw.init = &(struct clk_init_data){
402 .name = "apss_ahb_clk_src",
403 .parent_data = gcc_parent_data_ao_0,
404 .num_parents = ARRAY_SIZE(gcc_parent_data_ao_0),
405 .flags = CLK_IS_CRITICAL,
406 .ops = &clk_rcg2_ops,
407 },
408 };
409
410 static const struct freq_tbl ftbl_blsp1_qup0_i2c_apps_clk_src[] = {
411 F(19200000, P_XO, 1, 0, 0),
412 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
413 { }
414 };
415
416 static struct clk_rcg2 blsp1_qup0_i2c_apps_clk_src = {
417 .cmd_rcgr = 0x602c,
418 .mnd_width = 0,
419 .hid_width = 5,
420 .parent_map = gcc_parent_map_0,
421 .freq_tbl = ftbl_blsp1_qup0_i2c_apps_clk_src,
422 .clkr.hw.init = &(struct clk_init_data){
423 .name = "blsp1_qup0_i2c_apps_clk_src",
424 .parent_data = gcc_parent_data_0,
425 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
426 .ops = &clk_rcg2_ops,
427 },
428 };
429
430 static const struct freq_tbl ftbl_blsp1_qup0_spi_apps_clk_src[] = {
431 F(960000, P_XO, 10, 1, 2),
432 F(4800000, P_XO, 4, 0, 0),
433 F(9600000, P_XO, 2, 0, 0),
434 F(16000000, P_GPLL0_OUT_MAIN, 10, 1, 5),
435 F(19200000, P_XO, 1, 0, 0),
436 F(25000000, P_GPLL0_OUT_MAIN, 16, 1, 2),
437 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
438 { }
439 };
440
441 static struct clk_rcg2 blsp1_qup0_spi_apps_clk_src = {
442 .cmd_rcgr = 0x6034,
443 .mnd_width = 8,
444 .hid_width = 5,
445 .parent_map = gcc_parent_map_0,
446 .freq_tbl = ftbl_blsp1_qup0_spi_apps_clk_src,
447 .clkr.hw.init = &(struct clk_init_data){
448 .name = "blsp1_qup0_spi_apps_clk_src",
449 .parent_data = gcc_parent_data_0,
450 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
451 .ops = &clk_rcg2_ops,
452 },
453 };
454
455 static struct clk_rcg2 blsp1_qup1_i2c_apps_clk_src = {
456 .cmd_rcgr = 0x200c,
457 .mnd_width = 0,
458 .hid_width = 5,
459 .parent_map = gcc_parent_map_0,
460 .freq_tbl = ftbl_blsp1_qup0_i2c_apps_clk_src,
461 .clkr.hw.init = &(struct clk_init_data){
462 .name = "blsp1_qup1_i2c_apps_clk_src",
463 .parent_data = gcc_parent_data_0,
464 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
465 .ops = &clk_rcg2_ops,
466 },
467 };
468
469 static const struct freq_tbl ftbl_blsp1_qup1_spi_apps_clk_src[] = {
470 F(960000, P_XO, 10, 1, 2),
471 F(4800000, P_XO, 4, 0, 0),
472 F(9600000, P_XO, 2, 0, 0),
473 F(10480000, P_GPLL0_OUT_MAIN, 1, 3, 229),
474 F(16000000, P_GPLL0_OUT_MAIN, 10, 1, 5),
475 F(19200000, P_XO, 1, 0, 0),
476 F(20961000, P_GPLL0_OUT_MAIN, 1, 6, 229),
477 { }
478 };
479
480 static struct clk_rcg2 blsp1_qup1_spi_apps_clk_src = {
481 .cmd_rcgr = 0x2024,
482 .mnd_width = 8,
483 .hid_width = 5,
484 .parent_map = gcc_parent_map_0,
485 .freq_tbl = ftbl_blsp1_qup1_spi_apps_clk_src,
486 .clkr.hw.init = &(struct clk_init_data){
487 .name = "blsp1_qup1_spi_apps_clk_src",
488 .parent_data = gcc_parent_data_0,
489 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
490 .ops = &clk_rcg2_ops,
491 },
492 };
493
494 static struct clk_rcg2 blsp1_qup2_i2c_apps_clk_src = {
495 .cmd_rcgr = 0x3000,
496 .mnd_width = 0,
497 .hid_width = 5,
498 .parent_map = gcc_parent_map_0,
499 .freq_tbl = ftbl_blsp1_qup0_i2c_apps_clk_src,
500 .clkr.hw.init = &(struct clk_init_data){
501 .name = "blsp1_qup2_i2c_apps_clk_src",
502 .parent_data = gcc_parent_data_0,
503 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
504 .ops = &clk_rcg2_ops,
505 },
506 };
507
508 static const struct freq_tbl ftbl_blsp1_qup2_spi_apps_clk_src[] = {
509 F(960000, P_XO, 10, 1, 2),
510 F(4800000, P_XO, 4, 0, 0),
511 F(9600000, P_XO, 2, 0, 0),
512 F(15000000, P_GPLL0_OUT_MAIN, 1, 3, 160),
513 F(16000000, P_GPLL0_OUT_MAIN, 10, 1, 5),
514 F(19200000, P_XO, 1, 0, 0),
515 F(25000000, P_GPLL0_OUT_MAIN, 16, 1, 2),
516 F(30000000, P_GPLL0_OUT_MAIN, 1, 3, 80),
517 { }
518 };
519
520 static struct clk_rcg2 blsp1_qup2_spi_apps_clk_src = {
521 .cmd_rcgr = 0x3014,
522 .mnd_width = 8,
523 .hid_width = 5,
524 .parent_map = gcc_parent_map_0,
525 .freq_tbl = ftbl_blsp1_qup2_spi_apps_clk_src,
526 .clkr.hw.init = &(struct clk_init_data){
527 .name = "blsp1_qup2_spi_apps_clk_src",
528 .parent_data = gcc_parent_data_0,
529 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
530 .ops = &clk_rcg2_ops,
531 },
532 };
533
534 static struct clk_rcg2 blsp1_qup3_i2c_apps_clk_src = {
535 .cmd_rcgr = 0x4000,
536 .mnd_width = 0,
537 .hid_width = 5,
538 .parent_map = gcc_parent_map_0,
539 .freq_tbl = ftbl_blsp1_qup0_i2c_apps_clk_src,
540 .clkr.hw.init = &(struct clk_init_data){
541 .name = "blsp1_qup3_i2c_apps_clk_src",
542 .parent_data = gcc_parent_data_0,
543 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
544 .ops = &clk_rcg2_ops,
545 },
546 };
547
548 static struct clk_rcg2 blsp1_qup3_spi_apps_clk_src = {
549 .cmd_rcgr = 0x4024,
550 .mnd_width = 8,
551 .hid_width = 5,
552 .parent_map = gcc_parent_map_0,
553 .freq_tbl = ftbl_blsp1_qup0_spi_apps_clk_src,
554 .clkr.hw.init = &(struct clk_init_data){
555 .name = "blsp1_qup3_spi_apps_clk_src",
556 .parent_data = gcc_parent_data_0,
557 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
558 .ops = &clk_rcg2_ops,
559 },
560 };
561
562 static struct clk_rcg2 blsp1_qup4_i2c_apps_clk_src = {
563 .cmd_rcgr = 0x5000,
564 .mnd_width = 0,
565 .hid_width = 5,
566 .parent_map = gcc_parent_map_0,
567 .freq_tbl = ftbl_blsp1_qup0_i2c_apps_clk_src,
568 .clkr.hw.init = &(struct clk_init_data){
569 .name = "blsp1_qup4_i2c_apps_clk_src",
570 .parent_data = gcc_parent_data_0,
571 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
572 .ops = &clk_rcg2_ops,
573 },
574 };
575
576 static struct clk_rcg2 blsp1_qup4_spi_apps_clk_src = {
577 .cmd_rcgr = 0x5024,
578 .mnd_width = 8,
579 .hid_width = 5,
580 .parent_map = gcc_parent_map_0,
581 .freq_tbl = ftbl_blsp1_qup0_spi_apps_clk_src,
582 .clkr.hw.init = &(struct clk_init_data){
583 .name = "blsp1_qup4_spi_apps_clk_src",
584 .parent_data = gcc_parent_data_0,
585 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
586 .ops = &clk_rcg2_ops,
587 },
588 };
589
590 static const struct freq_tbl ftbl_blsp1_uart0_apps_clk_src[] = {
591 F(3686400, P_GPLL0_OUT_MAIN, 1, 72, 15625),
592 F(7372800, P_GPLL0_OUT_MAIN, 1, 144, 15625),
593 F(14745600, P_GPLL0_OUT_MAIN, 1, 288, 15625),
594 F(16000000, P_GPLL0_OUT_MAIN, 10, 1, 5),
595 F(19200000, P_XO, 1, 0, 0),
596 F(24000000, P_GPLL0_OUT_MAIN, 1, 3, 100),
597 F(25000000, P_GPLL0_OUT_MAIN, 16, 1, 2),
598 F(32000000, P_GPLL0_OUT_MAIN, 1, 1, 25),
599 F(40000000, P_GPLL0_OUT_MAIN, 1, 1, 20),
600 F(46400000, P_GPLL0_OUT_MAIN, 1, 29, 500),
601 F(48000000, P_GPLL0_OUT_MAIN, 1, 3, 50),
602 F(51200000, P_GPLL0_OUT_MAIN, 1, 8, 125),
603 F(56000000, P_GPLL0_OUT_MAIN, 1, 7, 100),
604 F(58982400, P_GPLL0_OUT_MAIN, 1, 1152, 15625),
605 F(60000000, P_GPLL0_OUT_MAIN, 1, 3, 40),
606 F(64000000, P_GPLL0_OUT_MAIN, 1, 2, 25),
607 { }
608 };
609
610 static struct clk_rcg2 blsp1_uart0_apps_clk_src = {
611 .cmd_rcgr = 0x600c,
612 .mnd_width = 16,
613 .hid_width = 5,
614 .parent_map = gcc_parent_map_0,
615 .freq_tbl = ftbl_blsp1_uart0_apps_clk_src,
616 .clkr.hw.init = &(struct clk_init_data){
617 .name = "blsp1_uart0_apps_clk_src",
618 .parent_data = gcc_parent_data_0,
619 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
620 .ops = &clk_rcg2_ops,
621 },
622 };
623
624 static struct clk_rcg2 blsp1_uart1_apps_clk_src = {
625 .cmd_rcgr = 0x2044,
626 .mnd_width = 16,
627 .hid_width = 5,
628 .parent_map = gcc_parent_map_0,
629 .freq_tbl = ftbl_blsp1_uart0_apps_clk_src,
630 .clkr.hw.init = &(struct clk_init_data){
631 .name = "blsp1_uart1_apps_clk_src",
632 .parent_data = gcc_parent_data_0,
633 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
634 .ops = &clk_rcg2_ops,
635 },
636 };
637
638 static struct clk_rcg2 blsp1_uart2_apps_clk_src = {
639 .cmd_rcgr = 0x3034,
640 .mnd_width = 16,
641 .hid_width = 5,
642 .parent_map = gcc_parent_map_0,
643 .freq_tbl = ftbl_blsp1_uart0_apps_clk_src,
644 .clkr.hw.init = &(struct clk_init_data){
645 .name = "blsp1_uart2_apps_clk_src",
646 .parent_data = gcc_parent_data_0,
647 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
648 .ops = &clk_rcg2_ops,
649 },
650 };
651
652 static struct clk_rcg2 blsp1_uart3_apps_clk_src = {
653 .cmd_rcgr = 0x4014,
654 .mnd_width = 16,
655 .hid_width = 5,
656 .cfg_off = 0x20,
657 .parent_map = gcc_parent_map_0,
658 .freq_tbl = ftbl_blsp1_uart0_apps_clk_src,
659 .clkr.hw.init = &(struct clk_init_data){
660 .name = "blsp1_uart3_apps_clk_src",
661 .parent_data = gcc_parent_data_0,
662 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
663 .ops = &clk_rcg2_ops,
664 },
665 };
666
667 static struct clk_rcg2 blsp2_qup0_i2c_apps_clk_src = {
668 .cmd_rcgr = 0xc00c,
669 .mnd_width = 0,
670 .hid_width = 5,
671 .parent_map = gcc_parent_map_0,
672 .freq_tbl = ftbl_blsp1_qup0_i2c_apps_clk_src,
673 .clkr.hw.init = &(struct clk_init_data){
674 .name = "blsp2_qup0_i2c_apps_clk_src",
675 .parent_data = gcc_parent_data_0,
676 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
677 .ops = &clk_rcg2_ops,
678 },
679 };
680
681 static struct clk_rcg2 blsp2_qup0_spi_apps_clk_src = {
682 .cmd_rcgr = 0xc024,
683 .mnd_width = 8,
684 .hid_width = 5,
685 .parent_map = gcc_parent_map_0,
686 .freq_tbl = ftbl_blsp1_qup0_spi_apps_clk_src,
687 .clkr.hw.init = &(struct clk_init_data){
688 .name = "blsp2_qup0_spi_apps_clk_src",
689 .parent_data = gcc_parent_data_0,
690 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
691 .ops = &clk_rcg2_ops,
692 },
693 };
694
695 static struct clk_rcg2 blsp2_uart0_apps_clk_src = {
696 .cmd_rcgr = 0xc044,
697 .mnd_width = 16,
698 .hid_width = 5,
699 .parent_map = gcc_parent_map_0,
700 .freq_tbl = ftbl_blsp1_uart0_apps_clk_src,
701 .clkr.hw.init = &(struct clk_init_data){
702 .name = "blsp2_uart0_apps_clk_src",
703 .parent_data = gcc_parent_data_0,
704 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
705 .ops = &clk_rcg2_ops,
706 },
707 };
708
709 static struct clk_rcg2 byte0_clk_src = {
710 .cmd_rcgr = 0x4d044,
711 .mnd_width = 0,
712 .hid_width = 5,
713 .parent_map = gcc_parent_map_5,
714 .clkr.hw.init = &(struct clk_init_data){
715 .name = "byte0_clk_src",
716 .parent_data = gcc_parent_data_5,
717 .num_parents = ARRAY_SIZE(gcc_parent_data_5),
718 .flags = CLK_SET_RATE_PARENT,
719 .ops = &clk_byte2_ops,
720 },
721 };
722
723 static const struct freq_tbl ftbl_emac_clk_src[] = {
724 F(5000000, P_GPLL1_OUT_MAIN, 2, 1, 50),
725 F(50000000, P_GPLL1_OUT_MAIN, 10, 0, 0),
726 F(125000000, P_GPLL1_OUT_MAIN, 4, 0, 0),
727 F(250000000, P_GPLL1_OUT_MAIN, 2, 0, 0),
728 { }
729 };
730
731 static struct clk_rcg2 emac_clk_src = {
732 .cmd_rcgr = 0x4e01c,
733 .mnd_width = 8,
734 .hid_width = 5,
735 .parent_map = gcc_parent_map_4,
736 .freq_tbl = ftbl_emac_clk_src,
737 .clkr.hw.init = &(struct clk_init_data){
738 .name = "emac_clk_src",
739 .parent_data = gcc_parent_data_4,
740 .num_parents = ARRAY_SIZE(gcc_parent_data_4),
741 .ops = &clk_rcg2_ops,
742 },
743 };
744
745 static const struct freq_tbl ftbl_emac_ptp_clk_src[] = {
746 F(50000000, P_GPLL1_OUT_MAIN, 10, 0, 0),
747 F(125000000, P_GPLL1_OUT_MAIN, 4, 0, 0),
748 F(250000000, P_GPLL1_OUT_MAIN, 2, 0, 0),
749 { }
750 };
751
752 static struct clk_rcg2 emac_ptp_clk_src = {
753 .cmd_rcgr = 0x4e014,
754 .mnd_width = 0,
755 .hid_width = 5,
756 .parent_map = gcc_parent_map_4,
757 .freq_tbl = ftbl_emac_ptp_clk_src,
758 .clkr.hw.init = &(struct clk_init_data){
759 .name = "emac_ptp_clk_src",
760 .parent_data = gcc_parent_data_4,
761 .num_parents = ARRAY_SIZE(gcc_parent_data_4),
762 .ops = &clk_rcg2_ops,
763 },
764 };
765
766 static const struct freq_tbl ftbl_esc0_clk_src[] = {
767 F(19200000, P_XO, 1, 0, 0),
768 { }
769 };
770
771 static struct clk_rcg2 esc0_clk_src = {
772 .cmd_rcgr = 0x4d05c,
773 .mnd_width = 0,
774 .hid_width = 5,
775 .parent_map = gcc_parent_map_6,
776 .freq_tbl = ftbl_esc0_clk_src,
777 .clkr.hw.init = &(struct clk_init_data){
778 .name = "esc0_clk_src",
779 .parent_data = gcc_parent_data_6,
780 .num_parents = ARRAY_SIZE(gcc_parent_data_6),
781 .ops = &clk_rcg2_ops,
782 },
783 };
784
785 static const struct freq_tbl ftbl_gfx3d_clk_src[] = {
786 F(19200000, P_XO, 1, 0, 0),
787 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
788 F(80000000, P_GPLL0_OUT_MAIN, 10, 0, 0),
789 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
790 F(160000000, P_GPLL0_OUT_MAIN, 5, 0, 0),
791 F(200000000, P_GPLL0_OUT_MAIN, 4, 0, 0),
792 F(228571429, P_GPLL0_OUT_MAIN, 3.5, 0, 0),
793 F(240000000, P_GPLL6_OUT_AUX, 4.5, 0, 0),
794 F(266666667, P_GPLL0_OUT_MAIN, 3, 0, 0),
795 F(270000000, P_GPLL6_OUT_AUX, 4, 0, 0),
796 F(320000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0),
797 F(400000000, P_GPLL0_OUT_MAIN, 2, 0, 0),
798 F(484800000, P_GPLL3_OUT_MAIN, 1, 0, 0),
799 F(523200000, P_GPLL3_OUT_MAIN, 1, 0, 0),
800 F(550000000, P_GPLL3_OUT_MAIN, 1, 0, 0),
801 F(598000000, P_GPLL3_OUT_MAIN, 1, 0, 0),
802 { }
803 };
804
805 static struct clk_rcg2 gfx3d_clk_src = {
806 .cmd_rcgr = 0x59000,
807 .mnd_width = 0,
808 .hid_width = 5,
809 .parent_map = gcc_parent_map_7,
810 .freq_tbl = ftbl_gfx3d_clk_src,
811 .clkr.hw.init = &(struct clk_init_data){
812 .name = "gfx3d_clk_src",
813 .parent_data = gcc_parent_data_7,
814 .num_parents = ARRAY_SIZE(gcc_parent_data_7),
815 .ops = &clk_rcg2_ops,
816 },
817 };
818
819 static const struct freq_tbl ftbl_gp1_clk_src[] = {
820 F(19200000, P_XO, 1, 0, 0),
821 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
822 F(200000000, P_GPLL0_OUT_MAIN, 4, 0, 0),
823 { }
824 };
825
826 static struct clk_rcg2 gp1_clk_src = {
827 .cmd_rcgr = 0x8004,
828 .mnd_width = 8,
829 .hid_width = 5,
830 .parent_map = gcc_parent_map_2,
831 .freq_tbl = ftbl_gp1_clk_src,
832 .clkr.hw.init = &(struct clk_init_data){
833 .name = "gp1_clk_src",
834 .parent_data = gcc_parent_data_2,
835 .num_parents = ARRAY_SIZE(gcc_parent_data_2),
836 .ops = &clk_rcg2_ops,
837 },
838 };
839
840 static struct clk_rcg2 gp2_clk_src = {
841 .cmd_rcgr = 0x9004,
842 .mnd_width = 8,
843 .hid_width = 5,
844 .parent_map = gcc_parent_map_2,
845 .freq_tbl = ftbl_gp1_clk_src,
846 .clkr.hw.init = &(struct clk_init_data){
847 .name = "gp2_clk_src",
848 .parent_data = gcc_parent_data_2,
849 .num_parents = ARRAY_SIZE(gcc_parent_data_2),
850 .ops = &clk_rcg2_ops,
851 },
852 };
853
854 static struct clk_rcg2 gp3_clk_src = {
855 .cmd_rcgr = 0xa004,
856 .mnd_width = 8,
857 .hid_width = 5,
858 .parent_map = gcc_parent_map_2,
859 .freq_tbl = ftbl_gp1_clk_src,
860 .clkr.hw.init = &(struct clk_init_data){
861 .name = "gp3_clk_src",
862 .parent_data = gcc_parent_data_2,
863 .num_parents = ARRAY_SIZE(gcc_parent_data_2),
864 .ops = &clk_rcg2_ops,
865 },
866 };
867
868 static struct clk_rcg2 hdmi_app_clk_src = {
869 .cmd_rcgr = 0x4d0e4,
870 .mnd_width = 0,
871 .hid_width = 5,
872 .parent_map = gcc_parent_map_1,
873 .freq_tbl = ftbl_esc0_clk_src,
874 .clkr.hw.init = &(struct clk_init_data){
875 .name = "hdmi_app_clk_src",
876 .parent_data = gcc_parent_data_1,
877 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
878 .ops = &clk_rcg2_ops,
879 },
880 };
881
882 static struct clk_rcg2 hdmi_pclk_clk_src = {
883 .cmd_rcgr = 0x4d0dc,
884 .mnd_width = 0,
885 .hid_width = 5,
886 .parent_map = gcc_parent_map_8,
887 .freq_tbl = ftbl_esc0_clk_src,
888 .clkr.hw.init = &(struct clk_init_data){
889 .name = "hdmi_pclk_clk_src",
890 .parent_data = gcc_parent_data_8,
891 .num_parents = ARRAY_SIZE(gcc_parent_data_8),
892 .ops = &clk_rcg2_ops,
893 },
894 };
895
896 static const struct freq_tbl ftbl_mdp_clk_src[] = {
897 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
898 F(80000000, P_GPLL0_OUT_MAIN, 10, 0, 0),
899 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
900 F(145454545, P_GPLL0_OUT_MAIN, 5.5, 0, 0),
901 F(160000000, P_GPLL0_OUT_MAIN, 5, 0, 0),
902 F(177777778, P_GPLL0_OUT_MAIN, 4.5, 0, 0),
903 F(200000000, P_GPLL0_OUT_MAIN, 4, 0, 0),
904 F(266666667, P_GPLL0_OUT_MAIN, 3, 0, 0),
905 F(320000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0),
906 { }
907 };
908
909 static struct clk_rcg2 mdp_clk_src = {
910 .cmd_rcgr = 0x4d014,
911 .mnd_width = 0,
912 .hid_width = 5,
913 .parent_map = gcc_parent_map_9,
914 .freq_tbl = ftbl_mdp_clk_src,
915 .clkr.hw.init = &(struct clk_init_data){
916 .name = "mdp_clk_src",
917 .parent_data = gcc_parent_data_9,
918 .num_parents = ARRAY_SIZE(gcc_parent_data_9),
919 .ops = &clk_rcg2_ops,
920 },
921 };
922
923 static const struct freq_tbl ftbl_pcie_0_aux_clk_src[] = {
924 F(1200000, P_XO, 16, 0, 0),
925 { }
926 };
927
928 static struct clk_rcg2 pcie_0_aux_clk_src = {
929 .cmd_rcgr = 0x3e024,
930 .mnd_width = 16,
931 .hid_width = 5,
932 .parent_map = gcc_parent_map_10,
933 .freq_tbl = ftbl_pcie_0_aux_clk_src,
934 .clkr.hw.init = &(struct clk_init_data){
935 .name = "pcie_0_aux_clk_src",
936 .parent_data = gcc_parent_data_10,
937 .num_parents = ARRAY_SIZE(gcc_parent_data_10),
938 .ops = &clk_rcg2_ops,
939 },
940 };
941
942 static const struct freq_tbl ftbl_pcie_0_pipe_clk_src[] = {
943 F(19200000, P_XO, 1, 0, 0),
944 F(125000000, P_PCIE_0_PIPE_CLK, 2, 0, 0),
945 F(250000000, P_PCIE_0_PIPE_CLK, 1, 0, 0),
946 { }
947 };
948
949 static struct clk_rcg2 pcie_0_pipe_clk_src = {
950 .cmd_rcgr = 0x3e01c,
951 .mnd_width = 0,
952 .hid_width = 5,
953 .parent_map = gcc_parent_map_11,
954 .freq_tbl = ftbl_pcie_0_pipe_clk_src,
955 .clkr.hw.init = &(struct clk_init_data){
956 .name = "pcie_0_pipe_clk_src",
957 .parent_data = gcc_parent_data_11,
958 .num_parents = ARRAY_SIZE(gcc_parent_data_11),
959 .ops = &clk_rcg2_ops,
960 },
961 };
962
963 static struct clk_rcg2 pclk0_clk_src = {
964 .cmd_rcgr = 0x4d000,
965 .mnd_width = 8,
966 .hid_width = 5,
967 .parent_map = gcc_parent_map_12,
968 .clkr.hw.init = &(struct clk_init_data){
969 .name = "pclk0_clk_src",
970 .parent_data = gcc_parent_data_12,
971 .num_parents = ARRAY_SIZE(gcc_parent_data_12),
972 .flags = CLK_SET_RATE_PARENT,
973 .ops = &clk_pixel_ops,
974 },
975 };
976
977 static const struct freq_tbl ftbl_pdm2_clk_src[] = {
978 F(19200000, P_XO, 1, 0, 0),
979 F(64000000, P_GPLL0_OUT_MAIN, 12.5, 0, 0),
980 { }
981 };
982
983 static struct clk_rcg2 pdm2_clk_src = {
984 .cmd_rcgr = 0x44010,
985 .mnd_width = 0,
986 .hid_width = 5,
987 .parent_map = gcc_parent_map_0,
988 .freq_tbl = ftbl_pdm2_clk_src,
989 .clkr.hw.init = &(struct clk_init_data){
990 .name = "pdm2_clk_src",
991 .parent_data = gcc_parent_data_0,
992 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
993 .ops = &clk_rcg2_ops,
994 },
995 };
996
997 static const struct freq_tbl ftbl_sdcc1_apps_clk_src[] = {
998 F(144000, P_XO, 16, 3, 25),
999 F(400000, P_XO, 12, 1, 4),
1000 F(20000000, P_GPLL0_OUT_MAIN, 10, 1, 4),
1001 F(25000000, P_GPLL0_OUT_MAIN, 16, 1, 2),
1002 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
1003 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
1004 F(177777778, P_GPLL0_OUT_MAIN, 4.5, 0, 0),
1005 F(192000000, P_GPLL4_OUT_MAIN, 6, 0, 0),
1006 F(200000000, P_GPLL0_OUT_MAIN, 4, 0, 0),
1007 F(384000000, P_GPLL4_OUT_MAIN, 3, 0, 0),
1008 { }
1009 };
1010
1011 static struct clk_rcg2 sdcc1_apps_clk_src = {
1012 .cmd_rcgr = 0x42004,
1013 .mnd_width = 8,
1014 .hid_width = 5,
1015 .parent_map = gcc_parent_map_13,
1016 .freq_tbl = ftbl_sdcc1_apps_clk_src,
1017 .clkr.hw.init = &(struct clk_init_data){
1018 .name = "sdcc1_apps_clk_src",
1019 .parent_data = gcc_parent_data_13,
1020 .num_parents = ARRAY_SIZE(gcc_parent_data_13),
1021 .ops = &clk_rcg2_floor_ops,
1022 },
1023 };
1024
1025 static const struct freq_tbl ftbl_sdcc1_ice_core_clk_src[] = {
1026 F(160000000, P_GPLL0_OUT_MAIN, 5, 0, 0),
1027 F(266666667, P_GPLL0_OUT_MAIN, 3, 0, 0),
1028 { }
1029 };
1030
1031 static struct clk_rcg2 sdcc1_ice_core_clk_src = {
1032 .cmd_rcgr = 0x5d000,
1033 .mnd_width = 8,
1034 .hid_width = 5,
1035 .parent_map = gcc_parent_map_3,
1036 .freq_tbl = ftbl_sdcc1_ice_core_clk_src,
1037 .clkr.hw.init = &(struct clk_init_data){
1038 .name = "sdcc1_ice_core_clk_src",
1039 .parent_data = gcc_parent_data_3,
1040 .num_parents = ARRAY_SIZE(gcc_parent_data_3),
1041 .ops = &clk_rcg2_ops,
1042 },
1043 };
1044
1045 static const struct freq_tbl ftbl_sdcc2_apps_clk_src[] = {
1046 F(144000, P_XO, 16, 3, 25),
1047 F(400000, P_XO, 12, 1, 4),
1048 F(20000000, P_GPLL0_OUT_MAIN, 10, 1, 4),
1049 F(25000000, P_GPLL0_OUT_MAIN, 16, 1, 2),
1050 F(50000000, P_GPLL0_OUT_MAIN, 16, 0, 0),
1051 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
1052 F(177777778, P_GPLL0_OUT_MAIN, 4.5, 0, 0),
1053 F(200000000, P_GPLL0_OUT_MAIN, 4, 0, 0),
1054 { }
1055 };
1056
1057 static struct clk_rcg2 sdcc2_apps_clk_src = {
1058 .cmd_rcgr = 0x43004,
1059 .mnd_width = 8,
1060 .hid_width = 5,
1061 .parent_map = gcc_parent_map_14,
1062 .freq_tbl = ftbl_sdcc2_apps_clk_src,
1063 .clkr.hw.init = &(struct clk_init_data){
1064 .name = "sdcc2_apps_clk_src",
1065 .parent_data = gcc_parent_data_14,
1066 .num_parents = ARRAY_SIZE(gcc_parent_data_14),
1067 .ops = &clk_rcg2_floor_ops,
1068 },
1069 };
1070
1071 static struct clk_rcg2 usb20_mock_utmi_clk_src = {
1072 .cmd_rcgr = 0x41048,
1073 .mnd_width = 0,
1074 .hid_width = 5,
1075 .parent_map = gcc_parent_map_1,
1076 .freq_tbl = ftbl_esc0_clk_src,
1077 .clkr.hw.init = &(struct clk_init_data){
1078 .name = "usb20_mock_utmi_clk_src",
1079 .parent_data = gcc_parent_data_1,
1080 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
1081 .ops = &clk_rcg2_ops,
1082 },
1083 };
1084
1085 static const struct freq_tbl ftbl_usb30_master_clk_src[] = {
1086 F(19200000, P_XO, 1, 0, 0),
1087 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
1088 F(200000000, P_GPLL0_OUT_MAIN, 4, 0, 0),
1089 F(266666667, P_GPLL0_OUT_MAIN, 3, 0, 0),
1090 { }
1091 };
1092
1093 static struct clk_rcg2 usb30_master_clk_src = {
1094 .cmd_rcgr = 0x39028,
1095 .mnd_width = 8,
1096 .hid_width = 5,
1097 .parent_map = gcc_parent_map_0,
1098 .freq_tbl = ftbl_usb30_master_clk_src,
1099 .clkr.hw.init = &(struct clk_init_data){
1100 .name = "usb30_master_clk_src",
1101 .parent_data = gcc_parent_data_0,
1102 .num_parents = ARRAY_SIZE(gcc_parent_data_0),
1103 .ops = &clk_rcg2_ops,
1104 },
1105 };
1106
1107 static struct clk_rcg2 usb30_mock_utmi_clk_src = {
1108 .cmd_rcgr = 0x3901c,
1109 .mnd_width = 0,
1110 .hid_width = 5,
1111 .parent_map = gcc_parent_map_1,
1112 .freq_tbl = ftbl_esc0_clk_src,
1113 .clkr.hw.init = &(struct clk_init_data){
1114 .name = "usb30_mock_utmi_clk_src",
1115 .parent_data = gcc_parent_data_1,
1116 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
1117 .ops = &clk_rcg2_ops,
1118 },
1119 };
1120
1121 static struct clk_rcg2 usb3_phy_aux_clk_src = {
1122 .cmd_rcgr = 0x3903c,
1123 .mnd_width = 0,
1124 .hid_width = 5,
1125 .parent_map = gcc_parent_map_1,
1126 .freq_tbl = ftbl_pcie_0_aux_clk_src,
1127 .clkr.hw.init = &(struct clk_init_data){
1128 .name = "usb3_phy_aux_clk_src",
1129 .parent_data = gcc_parent_data_1,
1130 .num_parents = ARRAY_SIZE(gcc_parent_data_1),
1131 .ops = &clk_rcg2_ops,
1132 },
1133 };
1134
1135 static const struct freq_tbl ftbl_usb_hs_system_clk_src[] = {
1136 F(19200000, P_XO, 1, 0, 0),
1137 F(80000000, P_GPLL0_OUT_MAIN, 10, 0, 0),
1138 F(100000000, P_GPLL0_OUT_MAIN, 8, 0, 0),
1139 F(133333333, P_GPLL0_OUT_MAIN, 6, 0, 0),
1140 F(177777778, P_GPLL0_OUT_MAIN, 4.5, 0, 0),
1141 { }
1142 };
1143
1144 static struct clk_rcg2 usb_hs_system_clk_src = {
1145 .cmd_rcgr = 0x41010,
1146 .mnd_width = 0,
1147 .hid_width = 5,
1148 .parent_map = gcc_parent_map_3,
1149 .freq_tbl = ftbl_usb_hs_system_clk_src,
1150 .clkr.hw.init = &(struct clk_init_data){
1151 .name = "usb_hs_system_clk_src",
1152 .parent_data = gcc_parent_data_3,
1153 .num_parents = ARRAY_SIZE(gcc_parent_data_3),
1154 .ops = &clk_rcg2_ops,
1155 },
1156 };
1157
1158 static struct clk_rcg2 vsync_clk_src = {
1159 .cmd_rcgr = 0x4d02c,
1160 .mnd_width = 0,
1161 .hid_width = 5,
1162 .parent_map = gcc_parent_map_15,
1163 .freq_tbl = ftbl_esc0_clk_src,
1164 .clkr.hw.init = &(struct clk_init_data){
1165 .name = "vsync_clk_src",
1166 .parent_data = gcc_parent_data_15,
1167 .num_parents = ARRAY_SIZE(gcc_parent_data_15),
1168 .ops = &clk_rcg2_ops,
1169 },
1170 };
1171
1172 static const struct freq_tbl ftbl_cdsp_bimc_clk_src[] = {
1173 F(19200000, P_XO, 1, 0, 0),
1174 F(133333333, P_GPLL0_OUT_MAIN, 6, 0, 0),
1175 F(266666667, P_GPLL0_OUT_MAIN, 3, 0, 0),
1176 F(320000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0),
1177 { }
1178 };
1179
1180 static struct clk_rcg2 cdsp_bimc_clk_src = {
1181 .cmd_rcgr = 0x5e010,
1182 .mnd_width = 0,
1183 .hid_width = 5,
1184 .parent_map = gcc_parent_map_16,
1185 .freq_tbl = ftbl_cdsp_bimc_clk_src,
1186 .clkr.hw.init = &(struct clk_init_data) {
1187 .name = "cdsp_bimc_clk_src",
1188 .parent_data = gcc_parent_data_16,
1189 .num_parents = ARRAY_SIZE(gcc_parent_data_16),
1190 .ops = &clk_rcg2_ops,
1191 },
1192 };
1193
1194 static struct clk_branch gcc_apss_ahb_clk = {
1195 .halt_reg = 0x4601c,
1196 .halt_check = BRANCH_HALT_VOTED,
1197 .clkr = {
1198 .enable_reg = 0x45004,
1199 .enable_mask = BIT(14),
1200 .hw.init = &(struct clk_init_data){
1201 .name = "gcc_apss_ahb_clk",
1202 .parent_hws = (const struct clk_hw*[]) {
1203 &apss_ahb_clk_src.clkr.hw,
1204 },
1205 .num_parents = 1,
1206 .flags = CLK_SET_RATE_PARENT,
1207 .ops = &clk_branch2_ops,
1208 },
1209 },
1210 };
1211
1212 static struct clk_branch gcc_apss_tcu_clk = {
1213 .halt_reg = 0x5b004,
1214 .halt_check = BRANCH_VOTED,
1215 .clkr = {
1216 .enable_reg = 0x4500c,
1217 .enable_mask = BIT(1),
1218 .hw.init = &(struct clk_init_data){
1219 .name = "gcc_apss_tcu_clk",
1220 .ops = &clk_branch2_ops,
1221 },
1222 },
1223 };
1224
1225 static struct clk_branch gcc_bimc_gfx_clk = {
1226 .halt_reg = 0x59034,
1227 .halt_check = BRANCH_HALT,
1228 .clkr = {
1229 .enable_reg = 0x59034,
1230 .enable_mask = BIT(0),
1231 .hw.init = &(struct clk_init_data){
1232 .name = "gcc_bimc_gfx_clk",
1233 .ops = &clk_branch2_ops,
1234 .parent_hws = (const struct clk_hw*[]) {
1235 &gcc_apss_tcu_clk.clkr.hw,
1236 },
1237
1238 },
1239 },
1240 };
1241
1242 static struct clk_branch gcc_bimc_gpu_clk = {
1243 .halt_reg = 0x59030,
1244 .halt_check = BRANCH_HALT,
1245 .clkr = {
1246 .enable_reg = 0x59030,
1247 .enable_mask = BIT(0),
1248 .hw.init = &(struct clk_init_data){
1249 .name = "gcc_bimc_gpu_clk",
1250 .ops = &clk_branch2_ops,
1251 },
1252 },
1253 };
1254
1255 static struct clk_branch gcc_bimc_cdsp_clk = {
1256 .halt_reg = 0x31030,
1257 .halt_check = BRANCH_HALT,
1258 .clkr = {
1259 .enable_reg = 0x31030,
1260 .enable_mask = BIT(0),
1261 .hw.init = &(struct clk_init_data) {
1262 .name = "gcc_bimc_cdsp_clk",
1263 .parent_hws = (const struct clk_hw*[]) {
1264 &cdsp_bimc_clk_src.clkr.hw
1265 },
1266 .num_parents = 1,
1267 .flags = CLK_SET_RATE_PARENT,
1268 .ops = &clk_branch2_ops,
1269 },
1270 },
1271 };
1272
1273 static struct clk_branch gcc_bimc_mdss_clk = {
1274 .halt_reg = 0x31038,
1275 .halt_check = BRANCH_HALT,
1276 .clkr = {
1277 .enable_reg = 0x31038,
1278 .enable_mask = BIT(0),
1279 .hw.init = &(struct clk_init_data){
1280 .name = "gcc_bimc_mdss_clk",
1281 .ops = &clk_branch2_ops,
1282 },
1283 },
1284 };
1285
1286 static struct clk_branch gcc_blsp1_ahb_clk = {
1287 .halt_reg = 0x1008,
1288 .halt_check = BRANCH_HALT_VOTED,
1289 .clkr = {
1290 .enable_reg = 0x45004,
1291 .enable_mask = BIT(10),
1292 .hw.init = &(struct clk_init_data){
1293 .name = "gcc_blsp1_ahb_clk",
1294 .ops = &clk_branch2_ops,
1295 },
1296 },
1297 };
1298
1299 static struct clk_branch gcc_dcc_clk = {
1300 .halt_reg = 0x77004,
1301 .halt_check = BRANCH_HALT,
1302 .clkr = {
1303 .enable_reg = 0x77004,
1304 .enable_mask = BIT(0),
1305 .hw.init = &(struct clk_init_data){
1306 .name = "gcc_dcc_clk",
1307 .ops = &clk_branch2_ops,
1308 },
1309 },
1310 };
1311
1312 static struct clk_branch gcc_dcc_xo_clk = {
1313 .halt_reg = 0x77008,
1314 .halt_check = BRANCH_HALT,
1315 .clkr = {
1316 .enable_reg = 0x77008,
1317 .enable_mask = BIT(0),
1318 .hw.init = &(struct clk_init_data){
1319 .name = "gcc_dcc_xo_clk",
1320 .ops = &clk_branch2_ops,
1321 },
1322 },
1323 };
1324
1325 static struct clk_branch gcc_blsp1_qup0_i2c_apps_clk = {
1326 .halt_reg = 0x6028,
1327 .halt_check = BRANCH_HALT,
1328 .clkr = {
1329 .enable_reg = 0x6028,
1330 .enable_mask = BIT(0),
1331 .hw.init = &(struct clk_init_data){
1332 .name = "gcc_blsp1_qup0_i2c_apps_clk",
1333 .parent_hws = (const struct clk_hw*[]) {
1334 &blsp1_qup0_i2c_apps_clk_src.clkr.hw,
1335 },
1336 .num_parents = 1,
1337 .flags = CLK_SET_RATE_PARENT,
1338 .ops = &clk_branch2_ops,
1339 },
1340 },
1341 };
1342
1343 static struct clk_branch gcc_blsp1_qup0_spi_apps_clk = {
1344 .halt_reg = 0x6024,
1345 .halt_check = BRANCH_HALT,
1346 .clkr = {
1347 .enable_reg = 0x6024,
1348 .enable_mask = BIT(0),
1349 .hw.init = &(struct clk_init_data){
1350 .name = "gcc_blsp1_qup0_spi_apps_clk",
1351 .parent_hws = (const struct clk_hw*[]) {
1352 &blsp1_qup0_spi_apps_clk_src.clkr.hw,
1353 },
1354 .num_parents = 1,
1355 .flags = CLK_SET_RATE_PARENT,
1356 .ops = &clk_branch2_ops,
1357 },
1358 },
1359 };
1360
1361 static struct clk_branch gcc_blsp1_qup1_i2c_apps_clk = {
1362 .halt_reg = 0x2008,
1363 .halt_check = BRANCH_HALT,
1364 .clkr = {
1365 .enable_reg = 0x2008,
1366 .enable_mask = BIT(0),
1367 .hw.init = &(struct clk_init_data){
1368 .name = "gcc_blsp1_qup1_i2c_apps_clk",
1369 .parent_hws = (const struct clk_hw*[]) {
1370 &blsp1_qup1_i2c_apps_clk_src.clkr.hw,
1371 },
1372 .num_parents = 1,
1373 .flags = CLK_SET_RATE_PARENT,
1374 .ops = &clk_branch2_ops,
1375 },
1376 },
1377 };
1378
1379 static struct clk_branch gcc_blsp1_qup1_spi_apps_clk = {
1380 .halt_reg = 0x2004,
1381 .halt_check = BRANCH_HALT,
1382 .clkr = {
1383 .enable_reg = 0x2004,
1384 .enable_mask = BIT(0),
1385 .hw.init = &(struct clk_init_data){
1386 .name = "gcc_blsp1_qup1_spi_apps_clk",
1387 .parent_hws = (const struct clk_hw*[]) {
1388 &blsp1_qup1_spi_apps_clk_src.clkr.hw,
1389 },
1390 .num_parents = 1,
1391 .flags = CLK_SET_RATE_PARENT,
1392 .ops = &clk_branch2_ops,
1393 },
1394 },
1395 };
1396
1397 static struct clk_branch gcc_blsp1_qup2_i2c_apps_clk = {
1398 .halt_reg = 0x3010,
1399 .halt_check = BRANCH_HALT,
1400 .clkr = {
1401 .enable_reg = 0x3010,
1402 .enable_mask = BIT(0),
1403 .hw.init = &(struct clk_init_data){
1404 .name = "gcc_blsp1_qup2_i2c_apps_clk",
1405 .parent_hws = (const struct clk_hw*[]) {
1406 &blsp1_qup2_i2c_apps_clk_src.clkr.hw,
1407 },
1408 .num_parents = 1,
1409 .flags = CLK_SET_RATE_PARENT,
1410 .ops = &clk_branch2_ops,
1411 },
1412 },
1413 };
1414
1415 static struct clk_branch gcc_blsp1_qup2_spi_apps_clk = {
1416 .halt_reg = 0x300c,
1417 .halt_check = BRANCH_HALT,
1418 .clkr = {
1419 .enable_reg = 0x300c,
1420 .enable_mask = BIT(0),
1421 .hw.init = &(struct clk_init_data){
1422 .name = "gcc_blsp1_qup2_spi_apps_clk",
1423 .parent_hws = (const struct clk_hw*[]) {
1424 &blsp1_qup2_spi_apps_clk_src.clkr.hw,
1425 },
1426 .num_parents = 1,
1427 .flags = CLK_SET_RATE_PARENT,
1428 .ops = &clk_branch2_ops,
1429 },
1430 },
1431 };
1432
1433 static struct clk_branch gcc_blsp1_qup3_i2c_apps_clk = {
1434 .halt_reg = 0x4020,
1435 .halt_check = BRANCH_HALT,
1436 .clkr = {
1437 .enable_reg = 0x4020,
1438 .enable_mask = BIT(0),
1439 .hw.init = &(struct clk_init_data){
1440 .name = "gcc_blsp1_qup3_i2c_apps_clk",
1441 .parent_hws = (const struct clk_hw*[]) {
1442 &blsp1_qup3_i2c_apps_clk_src.clkr.hw,
1443 },
1444 .num_parents = 1,
1445 .flags = CLK_SET_RATE_PARENT,
1446 .ops = &clk_branch2_ops,
1447 },
1448 },
1449 };
1450
1451 static struct clk_branch gcc_blsp1_qup3_spi_apps_clk = {
1452 .halt_reg = 0x401c,
1453 .halt_check = BRANCH_HALT,
1454 .clkr = {
1455 .enable_reg = 0x401c,
1456 .enable_mask = BIT(0),
1457 .hw.init = &(struct clk_init_data){
1458 .name = "gcc_blsp1_qup3_spi_apps_clk",
1459 .parent_hws = (const struct clk_hw*[]) {
1460 &blsp1_qup3_spi_apps_clk_src.clkr.hw,
1461 },
1462 .num_parents = 1,
1463 .flags = CLK_SET_RATE_PARENT,
1464 .ops = &clk_branch2_ops,
1465 },
1466 },
1467 };
1468
1469 static struct clk_branch gcc_blsp1_qup4_i2c_apps_clk = {
1470 .halt_reg = 0x5020,
1471 .halt_check = BRANCH_HALT,
1472 .clkr = {
1473 .enable_reg = 0x5020,
1474 .enable_mask = BIT(0),
1475 .hw.init = &(struct clk_init_data){
1476 .name = "gcc_blsp1_qup4_i2c_apps_clk",
1477 .parent_hws = (const struct clk_hw*[]) {
1478 &blsp1_qup4_i2c_apps_clk_src.clkr.hw,
1479 },
1480 .num_parents = 1,
1481 .flags = CLK_SET_RATE_PARENT,
1482 .ops = &clk_branch2_ops,
1483 },
1484 },
1485 };
1486
1487 static struct clk_branch gcc_blsp1_qup4_spi_apps_clk = {
1488 .halt_reg = 0x501c,
1489 .halt_check = BRANCH_HALT,
1490 .clkr = {
1491 .enable_reg = 0x501c,
1492 .enable_mask = BIT(0),
1493 .hw.init = &(struct clk_init_data){
1494 .name = "gcc_blsp1_qup4_spi_apps_clk",
1495 .parent_hws = (const struct clk_hw*[]) {
1496 &blsp1_qup4_spi_apps_clk_src.clkr.hw,
1497 },
1498 .num_parents = 1,
1499 .flags = CLK_SET_RATE_PARENT,
1500 .ops = &clk_branch2_ops,
1501 },
1502 },
1503 };
1504
1505 static struct clk_branch gcc_blsp1_uart0_apps_clk = {
1506 .halt_reg = 0x6004,
1507 .halt_check = BRANCH_HALT,
1508 .clkr = {
1509 .enable_reg = 0x6004,
1510 .enable_mask = BIT(0),
1511 .hw.init = &(struct clk_init_data){
1512 .name = "gcc_blsp1_uart0_apps_clk",
1513 .parent_hws = (const struct clk_hw*[]) {
1514 &blsp1_uart0_apps_clk_src.clkr.hw,
1515 },
1516 .num_parents = 1,
1517 .flags = CLK_SET_RATE_PARENT,
1518 .ops = &clk_branch2_ops,
1519 },
1520 },
1521 };
1522
1523 static struct clk_branch gcc_blsp1_uart1_apps_clk = {
1524 .halt_reg = 0x203c,
1525 .halt_check = BRANCH_HALT,
1526 .clkr = {
1527 .enable_reg = 0x203c,
1528 .enable_mask = BIT(0),
1529 .hw.init = &(struct clk_init_data){
1530 .name = "gcc_blsp1_uart1_apps_clk",
1531 .parent_hws = (const struct clk_hw*[]) {
1532 &blsp1_uart1_apps_clk_src.clkr.hw,
1533 },
1534 .num_parents = 1,
1535 .flags = CLK_SET_RATE_PARENT,
1536 .ops = &clk_branch2_ops,
1537 },
1538 },
1539 };
1540
1541 static struct clk_branch gcc_blsp1_uart2_apps_clk = {
1542 .halt_reg = 0x302c,
1543 .halt_check = BRANCH_HALT,
1544 .clkr = {
1545 .enable_reg = 0x302c,
1546 .enable_mask = BIT(0),
1547 .hw.init = &(struct clk_init_data){
1548 .name = "gcc_blsp1_uart2_apps_clk",
1549 .parent_hws = (const struct clk_hw*[]) {
1550 &blsp1_uart2_apps_clk_src.clkr.hw,
1551 },
1552 .num_parents = 1,
1553 .flags = CLK_SET_RATE_PARENT,
1554 .ops = &clk_branch2_ops,
1555 },
1556 },
1557 };
1558
1559 static struct clk_branch gcc_blsp1_uart3_apps_clk = {
1560 .halt_reg = 0x400c,
1561 .halt_check = BRANCH_HALT,
1562 .clkr = {
1563 .enable_reg = 0x400c,
1564 .enable_mask = BIT(0),
1565 .hw.init = &(struct clk_init_data){
1566 .name = "gcc_blsp1_uart3_apps_clk",
1567 .parent_hws = (const struct clk_hw*[]) {
1568 &blsp1_uart3_apps_clk_src.clkr.hw,
1569 },
1570 .num_parents = 1,
1571 .flags = CLK_SET_RATE_PARENT,
1572 .ops = &clk_branch2_ops,
1573 },
1574 },
1575 };
1576
1577 static struct clk_branch gcc_blsp2_ahb_clk = {
1578 .halt_reg = 0xb008,
1579 .halt_check = BRANCH_HALT_VOTED,
1580 .clkr = {
1581 .enable_reg = 0x45004,
1582 .enable_mask = BIT(20),
1583 .hw.init = &(struct clk_init_data){
1584 .name = "gcc_blsp2_ahb_clk",
1585 .ops = &clk_branch2_ops,
1586 },
1587 },
1588 };
1589
1590 static struct clk_branch gcc_blsp2_qup0_i2c_apps_clk = {
1591 .halt_reg = 0xc008,
1592 .halt_check = BRANCH_HALT,
1593 .clkr = {
1594 .enable_reg = 0xc008,
1595 .enable_mask = BIT(0),
1596 .hw.init = &(struct clk_init_data){
1597 .name = "gcc_blsp2_qup0_i2c_apps_clk",
1598 .parent_hws = (const struct clk_hw*[]) {
1599 &blsp2_qup0_i2c_apps_clk_src.clkr.hw,
1600 },
1601 .num_parents = 1,
1602 .flags = CLK_SET_RATE_PARENT,
1603 .ops = &clk_branch2_ops,
1604 },
1605 },
1606 };
1607
1608 static struct clk_branch gcc_blsp2_qup0_spi_apps_clk = {
1609 .halt_reg = 0xc004,
1610 .halt_check = BRANCH_HALT,
1611 .clkr = {
1612 .enable_reg = 0xc004,
1613 .enable_mask = BIT(0),
1614 .hw.init = &(struct clk_init_data){
1615 .name = "gcc_blsp2_qup0_spi_apps_clk",
1616 .parent_hws = (const struct clk_hw*[]) {
1617 &blsp2_qup0_spi_apps_clk_src.clkr.hw,
1618 },
1619 .num_parents = 1,
1620 .flags = CLK_SET_RATE_PARENT,
1621 .ops = &clk_branch2_ops,
1622 },
1623 },
1624 };
1625
1626 static struct clk_branch gcc_blsp2_uart0_apps_clk = {
1627 .halt_reg = 0xc03c,
1628 .halt_check = BRANCH_HALT,
1629 .clkr = {
1630 .enable_reg = 0xc03c,
1631 .enable_mask = BIT(0),
1632 .hw.init = &(struct clk_init_data){
1633 .name = "gcc_blsp2_uart0_apps_clk",
1634 .parent_hws = (const struct clk_hw*[]) {
1635 &blsp2_uart0_apps_clk_src.clkr.hw,
1636 },
1637 .num_parents = 1,
1638 .flags = CLK_SET_RATE_PARENT,
1639 .ops = &clk_branch2_ops,
1640 },
1641 },
1642 };
1643
1644 static struct clk_branch gcc_boot_rom_ahb_clk = {
1645 .halt_reg = 0x1300c,
1646 .halt_check = BRANCH_HALT_VOTED,
1647 .clkr = {
1648 .enable_reg = 0x45004,
1649 .enable_mask = BIT(7),
1650 .hw.init = &(struct clk_init_data){
1651 .name = "gcc_boot_rom_ahb_clk",
1652 .ops = &clk_branch2_ops,
1653 },
1654 },
1655 };
1656
1657 static struct clk_branch gcc_crypto_ahb_clk = {
1658 .halt_reg = 0x16024,
1659 .halt_check = BRANCH_VOTED,
1660 .clkr = {
1661 .enable_reg = 0x45004,
1662 .enable_mask = BIT(0),
1663 .hw.init = &(struct clk_init_data){
1664 .name = "gcc_crypto_ahb_clk",
1665 .ops = &clk_branch2_ops,
1666 },
1667 },
1668 };
1669
1670 static struct clk_branch gcc_crypto_axi_clk = {
1671 .halt_reg = 0x16020,
1672 .halt_check = BRANCH_VOTED,
1673 .clkr = {
1674 .enable_reg = 0x45004,
1675 .enable_mask = BIT(1),
1676 .hw.init = &(struct clk_init_data){
1677 .name = "gcc_crypto_axi_clk",
1678 .ops = &clk_branch2_ops,
1679 },
1680 },
1681 };
1682
1683 static struct clk_branch gcc_crypto_clk = {
1684 .halt_reg = 0x1601c,
1685 .halt_check = BRANCH_VOTED,
1686 .clkr = {
1687 .enable_reg = 0x45004,
1688 .enable_mask = BIT(2),
1689 .hw.init = &(struct clk_init_data){
1690 .name = "gcc_crypto_clk",
1691 .ops = &clk_branch2_ops,
1692 },
1693 },
1694 };
1695
1696 static struct clk_branch gcc_eth_axi_clk = {
1697 .halt_reg = 0x4e010,
1698 .halt_check = BRANCH_HALT,
1699 .clkr = {
1700 .enable_reg = 0x4e010,
1701 .enable_mask = BIT(0),
1702 .hw.init = &(struct clk_init_data){
1703 .name = "gcc_eth_axi_clk",
1704 .ops = &clk_branch2_ops,
1705 },
1706 },
1707 };
1708
1709 static struct clk_branch gcc_eth_ptp_clk = {
1710 .halt_reg = 0x4e004,
1711 .halt_check = BRANCH_HALT,
1712 .clkr = {
1713 .enable_reg = 0x4e004,
1714 .enable_mask = BIT(0),
1715 .hw.init = &(struct clk_init_data){
1716 .name = "gcc_eth_ptp_clk",
1717 .parent_hws = (const struct clk_hw*[]) {
1718 &emac_ptp_clk_src.clkr.hw,
1719 },
1720 .num_parents = 1,
1721 .flags = CLK_SET_RATE_PARENT,
1722 .ops = &clk_branch2_ops,
1723 },
1724 },
1725 };
1726
1727 static struct clk_branch gcc_eth_rgmii_clk = {
1728 .halt_reg = 0x4e008,
1729 .halt_check = BRANCH_HALT,
1730 .clkr = {
1731 .enable_reg = 0x4e008,
1732 .enable_mask = BIT(0),
1733 .hw.init = &(struct clk_init_data){
1734 .name = "gcc_eth_rgmii_clk",
1735 .parent_hws = (const struct clk_hw*[]) {
1736 &emac_clk_src.clkr.hw,
1737 },
1738 .num_parents = 1,
1739 .flags = CLK_SET_RATE_PARENT,
1740 .ops = &clk_branch2_ops,
1741 },
1742 },
1743 };
1744
1745 static struct clk_branch gcc_eth_slave_ahb_clk = {
1746 .halt_reg = 0x4e00c,
1747 .halt_check = BRANCH_HALT,
1748 .clkr = {
1749 .enable_reg = 0x4e00c,
1750 .enable_mask = BIT(0),
1751 .hw.init = &(struct clk_init_data){
1752 .name = "gcc_eth_slave_ahb_clk",
1753 .ops = &clk_branch2_ops,
1754 },
1755 },
1756 };
1757
1758 static struct clk_branch gcc_geni_ir_s_clk = {
1759 .halt_reg = 0xf008,
1760 .halt_check = BRANCH_HALT,
1761 .clkr = {
1762 .enable_reg = 0xf008,
1763 .enable_mask = BIT(0),
1764 .hw.init = &(struct clk_init_data){
1765 .name = "gcc_geni_ir_s_clk",
1766 .ops = &clk_branch2_ops,
1767 },
1768 },
1769 };
1770
1771 static struct clk_branch gcc_geni_ir_h_clk = {
1772 .halt_reg = 0xf004,
1773 .halt_check = BRANCH_HALT,
1774 .clkr = {
1775 .enable_reg = 0xf004,
1776 .enable_mask = BIT(0),
1777 .hw.init = &(struct clk_init_data){
1778 .name = "gcc_geni_ir_h_clk",
1779 .ops = &clk_branch2_ops,
1780 },
1781 },
1782 };
1783
1784 static struct clk_branch gcc_gfx_tcu_clk = {
1785 .halt_reg = 0x12020,
1786 .halt_check = BRANCH_VOTED,
1787 .clkr = {
1788 .enable_reg = 0x4500C,
1789 .enable_mask = BIT(2),
1790 .hw.init = &(struct clk_init_data){
1791 .name = "gcc_gfx_tcu_clk",
1792 .ops = &clk_branch2_ops,
1793 },
1794 },
1795 };
1796
1797 static struct clk_branch gcc_gfx_tbu_clk = {
1798 .halt_reg = 0x12010,
1799 .halt_check = BRANCH_VOTED,
1800 .clkr = {
1801 .enable_reg = 0x4500C,
1802 .enable_mask = BIT(3),
1803 .hw.init = &(struct clk_init_data){
1804 .name = "gcc_gfx_tbu_clk",
1805 .ops = &clk_branch2_ops,
1806 },
1807 },
1808 };
1809
1810 static struct clk_branch gcc_cdsp_tbu_clk = {
1811 .halt_reg = 0x1203c,
1812 .halt_check = BRANCH_VOTED,
1813 .clkr = {
1814 .enable_reg = 0x13020,
1815 .enable_mask = BIT(9),
1816 .hw.init = &(struct clk_init_data) {
1817 .name = "gcc_cdsp_tbu_clk",
1818 .parent_hws = (const struct clk_hw*[]) {
1819 &cdsp_bimc_clk_src.clkr.hw
1820 },
1821 .num_parents = 1,
1822 .flags = CLK_SET_RATE_PARENT,
1823 .ops = &clk_branch2_ops,
1824 },
1825 },
1826 };
1827
1828 static struct clk_branch gcc_gp1_clk = {
1829 .halt_reg = 0x8000,
1830 .halt_check = BRANCH_HALT,
1831 .clkr = {
1832 .enable_reg = 0x8000,
1833 .enable_mask = BIT(0),
1834 .hw.init = &(struct clk_init_data){
1835 .name = "gcc_gp1_clk",
1836 .parent_hws = (const struct clk_hw*[]) {
1837 &gp1_clk_src.clkr.hw,
1838 },
1839 .num_parents = 1,
1840 .flags = CLK_SET_RATE_PARENT,
1841 .ops = &clk_branch2_ops,
1842 },
1843 },
1844 };
1845
1846 static struct clk_branch gcc_gp2_clk = {
1847 .halt_reg = 0x9000,
1848 .halt_check = BRANCH_HALT,
1849 .clkr = {
1850 .enable_reg = 0x9000,
1851 .enable_mask = BIT(0),
1852 .hw.init = &(struct clk_init_data){
1853 .name = "gcc_gp2_clk",
1854 .parent_hws = (const struct clk_hw*[]) {
1855 &gp2_clk_src.clkr.hw,
1856 },
1857 .num_parents = 1,
1858 .flags = CLK_SET_RATE_PARENT,
1859 .ops = &clk_branch2_ops,
1860 },
1861 },
1862 };
1863
1864 static struct clk_branch gcc_gp3_clk = {
1865 .halt_reg = 0xa000,
1866 .halt_check = BRANCH_HALT,
1867 .clkr = {
1868 .enable_reg = 0xa000,
1869 .enable_mask = BIT(0),
1870 .hw.init = &(struct clk_init_data){
1871 .name = "gcc_gp3_clk",
1872 .parent_hws = (const struct clk_hw*[]) {
1873 &gp3_clk_src.clkr.hw,
1874 },
1875 .num_parents = 1,
1876 .flags = CLK_SET_RATE_PARENT,
1877 .ops = &clk_branch2_ops,
1878 },
1879 },
1880 };
1881
1882 static struct clk_branch gcc_gtcu_ahb_clk = {
1883 .halt_reg = 0x12044,
1884 .halt_check = BRANCH_VOTED,
1885 .clkr = {
1886 .enable_reg = 0x4500c,
1887 .enable_mask = BIT(13),
1888 .hw.init = &(struct clk_init_data){
1889 .name = "gcc_gtcu_ahb_clk",
1890 .ops = &clk_branch2_ops,
1891 },
1892 },
1893 };
1894
1895 static struct clk_branch gcc_mdp_tbu_clk = {
1896 .halt_reg = 0x1201c,
1897 .halt_check = BRANCH_VOTED,
1898 .clkr = {
1899 .enable_reg = 0x4500c,
1900 .enable_mask = BIT(4),
1901 .hw.init = &(struct clk_init_data){
1902 .name = "gcc_mdp_tbu_clk",
1903 .ops = &clk_branch2_ops,
1904 },
1905 },
1906 };
1907
1908 static struct clk_branch gcc_mdss_ahb_clk = {
1909 .halt_reg = 0x4d07c,
1910 .halt_check = BRANCH_HALT,
1911 .clkr = {
1912 .enable_reg = 0x4d07c,
1913 .enable_mask = BIT(0),
1914 .hw.init = &(struct clk_init_data){
1915 .name = "gcc_mdss_ahb_clk",
1916 .ops = &clk_branch2_ops,
1917 },
1918 },
1919 };
1920
1921 static struct clk_branch gcc_mdss_axi_clk = {
1922 .halt_reg = 0x4d080,
1923 .halt_check = BRANCH_HALT,
1924 .clkr = {
1925 .enable_reg = 0x4d080,
1926 .enable_mask = BIT(0),
1927 .hw.init = &(struct clk_init_data){
1928 .name = "gcc_mdss_axi_clk",
1929 .ops = &clk_branch2_ops,
1930 },
1931 },
1932 };
1933
1934 static struct clk_branch gcc_mdss_byte0_clk = {
1935 .halt_reg = 0x4d094,
1936 .halt_check = BRANCH_HALT,
1937 .clkr = {
1938 .enable_reg = 0x4d094,
1939 .enable_mask = BIT(0),
1940 .hw.init = &(struct clk_init_data){
1941 .name = "gcc_mdss_byte0_clk",
1942 .parent_hws = (const struct clk_hw*[]) {
1943 &byte0_clk_src.clkr.hw,
1944 },
1945 .num_parents = 1,
1946 .flags = CLK_SET_RATE_PARENT,
1947 .ops = &clk_branch2_ops,
1948 },
1949 },
1950 };
1951
1952 static struct clk_branch gcc_mdss_esc0_clk = {
1953 .halt_reg = 0x4d098,
1954 .halt_check = BRANCH_HALT,
1955 .clkr = {
1956 .enable_reg = 0x4d098,
1957 .enable_mask = BIT(0),
1958 .hw.init = &(struct clk_init_data){
1959 .name = "gcc_mdss_esc0_clk",
1960 .parent_hws = (const struct clk_hw*[]) {
1961 &esc0_clk_src.clkr.hw,
1962 },
1963 .num_parents = 1,
1964 .flags = CLK_SET_RATE_PARENT,
1965 .ops = &clk_branch2_ops,
1966 },
1967 },
1968 };
1969
1970 static struct clk_branch gcc_mdss_hdmi_app_clk = {
1971 .halt_reg = 0x4d0d8,
1972 .halt_check = BRANCH_HALT,
1973 .clkr = {
1974 .enable_reg = 0x4d0d8,
1975 .enable_mask = BIT(0),
1976 .hw.init = &(struct clk_init_data){
1977 .name = "gcc_mdss_hdmi_app_clk",
1978 .parent_hws = (const struct clk_hw*[]) {
1979 &hdmi_app_clk_src.clkr.hw,
1980 },
1981 .num_parents = 1,
1982 .flags = CLK_SET_RATE_PARENT,
1983 .ops = &clk_branch2_ops,
1984 },
1985 },
1986 };
1987
1988 static struct clk_branch gcc_mdss_hdmi_pclk_clk = {
1989 .halt_reg = 0x4d0d4,
1990 .halt_check = BRANCH_HALT,
1991 .clkr = {
1992 .enable_reg = 0x4d0d4,
1993 .enable_mask = BIT(0),
1994 .hw.init = &(struct clk_init_data){
1995 .name = "gcc_mdss_hdmi_pclk_clk",
1996 .parent_hws = (const struct clk_hw*[]) {
1997 &hdmi_pclk_clk_src.clkr.hw,
1998 },
1999 .num_parents = 1,
2000 .flags = CLK_SET_RATE_PARENT,
2001 .ops = &clk_branch2_ops,
2002 },
2003 },
2004 };
2005
2006 static struct clk_branch gcc_mdss_mdp_clk = {
2007 .halt_reg = 0x4d088,
2008 .halt_check = BRANCH_HALT,
2009 .clkr = {
2010 .enable_reg = 0x4d088,
2011 .enable_mask = BIT(0),
2012 .hw.init = &(struct clk_init_data){
2013 .name = "gcc_mdss_mdp_clk",
2014 .parent_hws = (const struct clk_hw*[]) {
2015 &mdp_clk_src.clkr.hw,
2016 },
2017 .num_parents = 1,
2018 .flags = CLK_SET_RATE_PARENT,
2019 .ops = &clk_branch2_ops,
2020 },
2021 },
2022 };
2023
2024 static struct clk_branch gcc_mdss_pclk0_clk = {
2025 .halt_reg = 0x4d084,
2026 .halt_check = BRANCH_HALT,
2027 .clkr = {
2028 .enable_reg = 0x4d084,
2029 .enable_mask = BIT(0),
2030 .hw.init = &(struct clk_init_data){
2031 .name = "gcc_mdss_pclk0_clk",
2032 .parent_hws = (const struct clk_hw*[]) {
2033 &pclk0_clk_src.clkr.hw,
2034 },
2035 .num_parents = 1,
2036 .flags = CLK_SET_RATE_PARENT,
2037 .ops = &clk_branch2_ops,
2038 },
2039 },
2040 };
2041
2042 static struct clk_branch gcc_mdss_vsync_clk = {
2043 .halt_reg = 0x4d090,
2044 .halt_check = BRANCH_HALT,
2045 .clkr = {
2046 .enable_reg = 0x4d090,
2047 .enable_mask = BIT(0),
2048 .hw.init = &(struct clk_init_data){
2049 .name = "gcc_mdss_vsync_clk",
2050 .parent_hws = (const struct clk_hw*[]) {
2051 &vsync_clk_src.clkr.hw,
2052 },
2053 .num_parents = 1,
2054 .flags = CLK_SET_RATE_PARENT,
2055 .ops = &clk_branch2_ops,
2056 },
2057 },
2058 };
2059
2060 static struct clk_branch gcc_oxili_ahb_clk = {
2061 .halt_reg = 0x59028,
2062 .halt_check = BRANCH_HALT,
2063 .clkr = {
2064 .enable_reg = 0x59028,
2065 .enable_mask = BIT(0),
2066 .hw.init = &(struct clk_init_data){
2067 .name = "gcc_oxili_ahb_clk",
2068 .ops = &clk_branch2_ops,
2069 },
2070 },
2071 };
2072
2073 static struct clk_branch gcc_oxili_gfx3d_clk = {
2074 .halt_reg = 0x59020,
2075 .halt_check = BRANCH_HALT,
2076 .clkr = {
2077 .enable_reg = 0x59020,
2078 .enable_mask = BIT(0),
2079 .hw.init = &(struct clk_init_data){
2080 .name = "gcc_oxili_gfx3d_clk",
2081 .parent_hws = (const struct clk_hw*[]) {
2082 &gfx3d_clk_src.clkr.hw,
2083 },
2084 .num_parents = 1,
2085 .flags = CLK_SET_RATE_PARENT,
2086 .ops = &clk_branch2_ops,
2087 },
2088 },
2089 };
2090
2091 static struct clk_branch gcc_pcie_0_aux_clk = {
2092 .halt_reg = 0x3e014,
2093 .halt_check = BRANCH_HALT_VOTED,
2094 .clkr = {
2095 .enable_reg = 0x45004,
2096 .enable_mask = BIT(27),
2097 .hw.init = &(struct clk_init_data){
2098 .name = "gcc_pcie_0_aux_clk",
2099 .parent_hws = (const struct clk_hw*[]) {
2100 &pcie_0_aux_clk_src.clkr.hw,
2101 },
2102 .num_parents = 1,
2103 .flags = CLK_SET_RATE_PARENT,
2104 .ops = &clk_branch2_ops,
2105 },
2106 },
2107 };
2108
2109 static struct clk_branch gcc_pcie_0_cfg_ahb_clk = {
2110 .halt_reg = 0x3e008,
2111 .halt_check = BRANCH_HALT_VOTED,
2112 .clkr = {
2113 .enable_reg = 0x45004,
2114 .enable_mask = BIT(11),
2115 .hw.init = &(struct clk_init_data){
2116 .name = "gcc_pcie_0_cfg_ahb_clk",
2117 .ops = &clk_branch2_ops,
2118 },
2119 },
2120 };
2121
2122 static struct clk_branch gcc_pcie_0_mstr_axi_clk = {
2123 .halt_reg = 0x3e018,
2124 .halt_check = BRANCH_HALT_VOTED,
2125 .clkr = {
2126 .enable_reg = 0x45004,
2127 .enable_mask = BIT(18),
2128 .hw.init = &(struct clk_init_data){
2129 .name = "gcc_pcie_0_mstr_axi_clk",
2130 .ops = &clk_branch2_ops,
2131 },
2132 },
2133 };
2134
2135 static struct clk_branch gcc_pcie_0_pipe_clk = {
2136 .halt_reg = 0x3e00c,
2137 .halt_check = BRANCH_HALT_VOTED,
2138 .clkr = {
2139 .enable_reg = 0x45004,
2140 .enable_mask = BIT(28),
2141 .hw.init = &(struct clk_init_data){
2142 .name = "gcc_pcie_0_pipe_clk",
2143 .parent_hws = (const struct clk_hw*[]) {
2144 &pcie_0_pipe_clk_src.clkr.hw,
2145 },
2146 .num_parents = 1,
2147 .flags = CLK_SET_RATE_PARENT,
2148 .ops = &clk_branch2_ops,
2149 },
2150 },
2151 };
2152
2153 static struct clk_branch gcc_pcie_0_slv_axi_clk = {
2154 .halt_reg = 0x3e010,
2155 .halt_check = BRANCH_HALT_VOTED,
2156 .clkr = {
2157 .enable_reg = 0x45004,
2158 .enable_mask = BIT(22),
2159 .hw.init = &(struct clk_init_data){
2160 .name = "gcc_pcie_0_slv_axi_clk",
2161 .ops = &clk_branch2_ops,
2162 },
2163 },
2164 };
2165
2166 static struct clk_branch gcc_pcnoc_usb2_clk = {
2167 .halt_reg = 0x27008,
2168 .halt_check = BRANCH_HALT,
2169 .clkr = {
2170 .enable_reg = 0x27008,
2171 .enable_mask = BIT(0),
2172 .hw.init = &(struct clk_init_data){
2173 .name = "gcc_pcnoc_usb2_clk",
2174 .flags = CLK_IS_CRITICAL,
2175 .ops = &clk_branch2_ops,
2176 },
2177 },
2178 };
2179
2180 static struct clk_branch gcc_pcnoc_usb3_clk = {
2181 .halt_reg = 0x2700c,
2182 .halt_check = BRANCH_HALT,
2183 .clkr = {
2184 .enable_reg = 0x2700c,
2185 .enable_mask = BIT(0),
2186 .hw.init = &(struct clk_init_data){
2187 .name = "gcc_pcnoc_usb3_clk",
2188 .flags = CLK_IS_CRITICAL,
2189 .ops = &clk_branch2_ops,
2190 },
2191 },
2192 };
2193
2194 static struct clk_branch gcc_pdm2_clk = {
2195 .halt_reg = 0x4400c,
2196 .halt_check = BRANCH_HALT,
2197 .clkr = {
2198 .enable_reg = 0x4400c,
2199 .enable_mask = BIT(0),
2200 .hw.init = &(struct clk_init_data){
2201 .name = "gcc_pdm2_clk",
2202 .parent_hws = (const struct clk_hw*[]) {
2203 &pdm2_clk_src.clkr.hw,
2204 },
2205 .num_parents = 1,
2206 .flags = CLK_SET_RATE_PARENT,
2207 .ops = &clk_branch2_ops,
2208 },
2209 },
2210 };
2211
2212 static struct clk_branch gcc_pdm_ahb_clk = {
2213 .halt_reg = 0x44004,
2214 .halt_check = BRANCH_HALT,
2215 .clkr = {
2216 .enable_reg = 0x44004,
2217 .enable_mask = BIT(0),
2218 .hw.init = &(struct clk_init_data){
2219 .name = "gcc_pdm_ahb_clk",
2220 .ops = &clk_branch2_ops,
2221 },
2222 },
2223 };
2224
2225 static struct clk_branch gcc_prng_ahb_clk = {
2226 .halt_reg = 0x13004,
2227 .halt_check = BRANCH_HALT_VOTED,
2228 .clkr = {
2229 .enable_reg = 0x45004,
2230 .enable_mask = BIT(8),
2231 .hw.init = &(struct clk_init_data){
2232 .name = "gcc_prng_ahb_clk",
2233 .ops = &clk_branch2_ops,
2234 },
2235 },
2236 };
2237
2238 /* PWM clks do not have XO as parent as src clk is a balance root */
2239 static struct clk_branch gcc_pwm0_xo512_clk = {
2240 .halt_reg = 0x44018,
2241 .halt_check = BRANCH_HALT,
2242 .clkr = {
2243 .enable_reg = 0x44018,
2244 .enable_mask = BIT(0),
2245 .hw.init = &(struct clk_init_data){
2246 .name = "gcc_pwm0_xo512_clk",
2247 .ops = &clk_branch2_ops,
2248 },
2249 },
2250 };
2251
2252 static struct clk_branch gcc_pwm1_xo512_clk = {
2253 .halt_reg = 0x49004,
2254 .halt_check = BRANCH_HALT,
2255 .clkr = {
2256 .enable_reg = 0x49004,
2257 .enable_mask = BIT(0),
2258 .hw.init = &(struct clk_init_data){
2259 .name = "gcc_pwm1_xo512_clk",
2260 .ops = &clk_branch2_ops,
2261 },
2262 },
2263 };
2264
2265 static struct clk_branch gcc_pwm2_xo512_clk = {
2266 .halt_reg = 0x4a004,
2267 .halt_check = BRANCH_HALT,
2268 .clkr = {
2269 .enable_reg = 0x4a004,
2270 .enable_mask = BIT(0),
2271 .hw.init = &(struct clk_init_data){
2272 .name = "gcc_pwm2_xo512_clk",
2273 .ops = &clk_branch2_ops,
2274 },
2275 },
2276 };
2277
2278 static struct clk_branch gcc_qdss_dap_clk = {
2279 .halt_reg = 0x29084,
2280 .halt_check = BRANCH_VOTED,
2281 .clkr = {
2282 .enable_reg = 0x45004,
2283 .enable_mask = BIT(21),
2284 .hw.init = &(struct clk_init_data){
2285 .name = "gcc_qdss_dap_clk",
2286 .ops = &clk_branch2_ops,
2287 },
2288 },
2289 };
2290
2291 static struct clk_branch gcc_sdcc1_ahb_clk = {
2292 .halt_reg = 0x4201c,
2293 .halt_check = BRANCH_HALT,
2294 .clkr = {
2295 .enable_reg = 0x4201c,
2296 .enable_mask = BIT(0),
2297 .hw.init = &(struct clk_init_data){
2298 .name = "gcc_sdcc1_ahb_clk",
2299 .ops = &clk_branch2_ops,
2300 },
2301 },
2302 };
2303
2304 static struct clk_branch gcc_sdcc1_apps_clk = {
2305 .halt_reg = 0x42018,
2306 .halt_check = BRANCH_HALT,
2307 .clkr = {
2308 .enable_reg = 0x42018,
2309 .enable_mask = BIT(0),
2310 .hw.init = &(struct clk_init_data){
2311 .name = "gcc_sdcc1_apps_clk",
2312 .parent_hws = (const struct clk_hw*[]) {
2313 &sdcc1_apps_clk_src.clkr.hw,
2314 },
2315 .num_parents = 1,
2316 .flags = CLK_SET_RATE_PARENT,
2317 .ops = &clk_branch2_ops,
2318 },
2319 },
2320 };
2321
2322 static struct clk_branch gcc_sdcc1_ice_core_clk = {
2323 .halt_reg = 0x5d014,
2324 .halt_check = BRANCH_HALT,
2325 .clkr = {
2326 .enable_reg = 0x5d014,
2327 .enable_mask = BIT(0),
2328 .hw.init = &(struct clk_init_data){
2329 .name = "gcc_sdcc1_ice_core_clk",
2330 .parent_hws = (const struct clk_hw*[]) {
2331 &sdcc1_ice_core_clk_src.clkr.hw,
2332 },
2333 .num_parents = 1,
2334 .flags = CLK_SET_RATE_PARENT,
2335 .ops = &clk_branch2_ops,
2336 },
2337 },
2338 };
2339
2340 static struct clk_branch gcc_cdsp_cfg_ahb_clk = {
2341 .halt_reg = 0x5e004,
2342 .halt_check = BRANCH_HALT,
2343 .clkr = {
2344 .enable_reg = 0x5e004,
2345 .enable_mask = BIT(0),
2346 .hw.init = &(struct clk_init_data) {
2347 .name = "gcc_cdsp_cfg_ahb_cbcr",
2348 .ops = &clk_branch2_ops,
2349 },
2350 },
2351 };
2352
2353 static struct clk_branch gcc_sdcc2_ahb_clk = {
2354 .halt_reg = 0x4301c,
2355 .halt_check = BRANCH_HALT,
2356 .clkr = {
2357 .enable_reg = 0x4301c,
2358 .enable_mask = BIT(0),
2359 .hw.init = &(struct clk_init_data){
2360 .name = "gcc_sdcc2_ahb_clk",
2361 .ops = &clk_branch2_ops,
2362 },
2363 },
2364 };
2365
2366 static struct clk_branch gcc_sdcc2_apps_clk = {
2367 .halt_reg = 0x43018,
2368 .halt_check = BRANCH_HALT,
2369 .clkr = {
2370 .enable_reg = 0x43018,
2371 .enable_mask = BIT(0),
2372 .hw.init = &(struct clk_init_data){
2373 .name = "gcc_sdcc2_apps_clk",
2374 .parent_hws = (const struct clk_hw*[]) {
2375 &sdcc2_apps_clk_src.clkr.hw,
2376 },
2377 .num_parents = 1,
2378 .flags = CLK_SET_RATE_PARENT,
2379 .ops = &clk_branch2_ops,
2380 },
2381 },
2382 };
2383
2384 static struct clk_branch gcc_smmu_cfg_clk = {
2385 .halt_reg = 0x12038,
2386 .halt_check = BRANCH_VOTED,
2387 .clkr = {
2388 .enable_reg = 0x3600C,
2389 .enable_mask = BIT(12),
2390 .hw.init = &(struct clk_init_data){
2391 .name = "gcc_smmu_cfg_clk",
2392 .ops = &clk_branch2_ops,
2393 },
2394 },
2395 };
2396
2397 static struct clk_branch gcc_sys_noc_usb3_clk = {
2398 .halt_reg = 0x26014,
2399 .halt_check = BRANCH_HALT,
2400 .clkr = {
2401 .enable_reg = 0x26014,
2402 .enable_mask = BIT(0),
2403 .hw.init = &(struct clk_init_data){
2404 .name = "gcc_sys_noc_usb3_clk",
2405 .parent_hws = (const struct clk_hw*[]) {
2406 &usb30_master_clk_src.clkr.hw,
2407 },
2408 .num_parents = 1,
2409 .ops = &clk_branch2_ops,
2410 },
2411 },
2412 };
2413
2414 static struct clk_branch gcc_usb_hs_inactivity_timers_clk = {
2415 .halt_reg = 0x4100C,
2416 .halt_check = BRANCH_HALT,
2417 .clkr = {
2418 .enable_reg = 0x4100C,
2419 .enable_mask = BIT(0),
2420 .hw.init = &(struct clk_init_data){
2421 .name = "gcc_usb_hs_inactivity_timers_clk",
2422 .ops = &clk_branch2_ops,
2423 },
2424 },
2425 };
2426
2427 static struct clk_branch gcc_usb20_mock_utmi_clk = {
2428 .halt_reg = 0x41044,
2429 .halt_check = BRANCH_HALT,
2430 .clkr = {
2431 .enable_reg = 0x41044,
2432 .enable_mask = BIT(0),
2433 .hw.init = &(struct clk_init_data){
2434 .name = "gcc_usb20_mock_utmi_clk",
2435 .parent_hws = (const struct clk_hw*[]) {
2436 &usb20_mock_utmi_clk_src.clkr.hw,
2437 },
2438 .num_parents = 1,
2439 .flags = CLK_SET_RATE_PARENT,
2440 .ops = &clk_branch2_ops,
2441 },
2442 },
2443 };
2444
2445 static struct clk_branch gcc_usb2a_phy_sleep_clk = {
2446 .halt_reg = 0x4102c,
2447 .halt_check = BRANCH_HALT,
2448 .clkr = {
2449 .enable_reg = 0x4102c,
2450 .enable_mask = BIT(0),
2451 .hw.init = &(struct clk_init_data){
2452 .name = "gcc_usb2a_phy_sleep_clk",
2453 .ops = &clk_branch2_ops,
2454 },
2455 },
2456 };
2457
2458 static struct clk_branch gcc_usb30_master_clk = {
2459 .halt_reg = 0x3900c,
2460 .halt_check = BRANCH_HALT,
2461 .clkr = {
2462 .enable_reg = 0x3900c,
2463 .enable_mask = BIT(0),
2464 .hw.init = &(struct clk_init_data){
2465 .name = "gcc_usb30_master_clk",
2466 .parent_hws = (const struct clk_hw*[]) {
2467 &usb30_master_clk_src.clkr.hw,
2468 },
2469 .num_parents = 1,
2470 .flags = CLK_SET_RATE_PARENT,
2471 .ops = &clk_branch2_ops,
2472 },
2473 },
2474 };
2475
2476 static struct clk_branch gcc_usb30_mock_utmi_clk = {
2477 .halt_reg = 0x39014,
2478 .halt_check = BRANCH_HALT,
2479 .clkr = {
2480 .enable_reg = 0x39014,
2481 .enable_mask = BIT(0),
2482 .hw.init = &(struct clk_init_data){
2483 .name = "gcc_usb30_mock_utmi_clk",
2484 .parent_hws = (const struct clk_hw*[]) {
2485 &usb30_mock_utmi_clk_src.clkr.hw,
2486 },
2487 .num_parents = 1,
2488 .flags = CLK_SET_RATE_PARENT,
2489 .ops = &clk_branch2_ops,
2490 },
2491 },
2492 };
2493
2494 static struct clk_branch gcc_usb30_sleep_clk = {
2495 .halt_reg = 0x39010,
2496 .halt_check = BRANCH_HALT,
2497 .clkr = {
2498 .enable_reg = 0x39010,
2499 .enable_mask = BIT(0),
2500 .hw.init = &(struct clk_init_data){
2501 .name = "gcc_usb30_sleep_clk",
2502 .ops = &clk_branch2_ops,
2503 },
2504 },
2505 };
2506
2507 static struct clk_branch gcc_usb3_phy_aux_clk = {
2508 .halt_reg = 0x39044,
2509 .halt_check = BRANCH_HALT,
2510 .clkr = {
2511 .enable_reg = 0x39044,
2512 .enable_mask = BIT(0),
2513 .hw.init = &(struct clk_init_data){
2514 .name = "gcc_usb3_phy_aux_clk",
2515 .parent_hws = (const struct clk_hw*[]) {
2516 &usb3_phy_aux_clk_src.clkr.hw,
2517 },
2518 .num_parents = 1,
2519 .flags = CLK_SET_RATE_PARENT,
2520 .ops = &clk_branch2_ops,
2521 },
2522 },
2523 };
2524
2525 static struct clk_branch gcc_usb3_phy_pipe_clk = {
2526 .halt_check = BRANCH_HALT_SKIP,
2527 .clkr = {
2528 .enable_reg = 0x39018,
2529 .enable_mask = BIT(0),
2530 .hw.init = &(struct clk_init_data){
2531 .name = "gcc_usb3_phy_pipe_clk",
2532 .ops = &clk_branch2_ops,
2533 },
2534 },
2535 };
2536
2537 static struct clk_branch gcc_usb_hs_phy_cfg_ahb_clk = {
2538 .halt_reg = 0x41030,
2539 .halt_check = BRANCH_HALT,
2540 .clkr = {
2541 .enable_reg = 0x41030,
2542 .enable_mask = BIT(0),
2543 .hw.init = &(struct clk_init_data){
2544 .name = "gcc_usb_hs_phy_cfg_ahb_clk",
2545 .ops = &clk_branch2_ops,
2546 },
2547 },
2548 };
2549
2550 static struct clk_branch gcc_usb_hs_system_clk = {
2551 .halt_reg = 0x41004,
2552 .halt_check = BRANCH_HALT,
2553 .clkr = {
2554 .enable_reg = 0x41004,
2555 .enable_mask = BIT(0),
2556 .hw.init = &(struct clk_init_data){
2557 .name = "gcc_usb_hs_system_clk",
2558 .parent_hws = (const struct clk_hw*[]) {
2559 &usb_hs_system_clk_src.clkr.hw,
2560 },
2561 .num_parents = 1,
2562 .flags = CLK_SET_RATE_PARENT,
2563 .ops = &clk_branch2_ops,
2564 },
2565 },
2566 };
2567
2568 static struct clk_branch gcc_wdsp_q6ss_ahbs_clk = {
2569 .halt_reg = 0x1e004,
2570 .halt_check = BRANCH_HALT,
2571 .clkr = {
2572 .enable_reg = 0x1e004,
2573 .enable_mask = BIT(0),
2574 .hw.init = &(struct clk_init_data){
2575 .name = "gcc_wdsp_q6ss_ahbs_clk",
2576 .ops = &clk_branch2_ops,
2577 },
2578 },
2579 };
2580
2581 static struct clk_branch gcc_wdsp_q6ss_axim_clk = {
2582 .halt_reg = 0x1e008,
2583 .halt_check = BRANCH_HALT,
2584 .clkr = {
2585 .enable_reg = 0x1e008,
2586 .enable_mask = BIT(0),
2587 .hw.init = &(struct clk_init_data){
2588 .name = "gcc_wdsp_q6ss_axim_clk",
2589 .ops = &clk_branch2_ops,
2590 },
2591 },
2592 };
2593
2594 static struct gdsc mdss_gdsc = {
2595 .gdscr = 0x4d078,
2596 .pd = {
2597 .name = "mdss",
2598 },
2599 .pwrsts = PWRSTS_OFF_ON,
2600 };
2601
2602 static struct gdsc oxili_gdsc = {
2603 .gdscr = 0x5901c,
2604 .pd = {
2605 .name = "oxili",
2606 },
2607 .pwrsts = PWRSTS_OFF_ON,
2608 };
2609
2610 static struct clk_hw *gcc_qcs404_hws[] = {
2611 &cxo.hw,
2612 };
2613
2614 static struct clk_regmap *gcc_qcs404_clocks[] = {
2615 [GCC_APSS_AHB_CLK_SRC] = &apss_ahb_clk_src.clkr,
2616 [GCC_BLSP1_QUP0_I2C_APPS_CLK_SRC] = &blsp1_qup0_i2c_apps_clk_src.clkr,
2617 [GCC_BLSP1_QUP0_SPI_APPS_CLK_SRC] = &blsp1_qup0_spi_apps_clk_src.clkr,
2618 [GCC_BLSP1_QUP1_I2C_APPS_CLK_SRC] = &blsp1_qup1_i2c_apps_clk_src.clkr,
2619 [GCC_BLSP1_QUP1_SPI_APPS_CLK_SRC] = &blsp1_qup1_spi_apps_clk_src.clkr,
2620 [GCC_BLSP1_QUP2_I2C_APPS_CLK_SRC] = &blsp1_qup2_i2c_apps_clk_src.clkr,
2621 [GCC_BLSP1_QUP2_SPI_APPS_CLK_SRC] = &blsp1_qup2_spi_apps_clk_src.clkr,
2622 [GCC_BLSP1_QUP3_I2C_APPS_CLK_SRC] = &blsp1_qup3_i2c_apps_clk_src.clkr,
2623 [GCC_BLSP1_QUP3_SPI_APPS_CLK_SRC] = &blsp1_qup3_spi_apps_clk_src.clkr,
2624 [GCC_BLSP1_QUP4_I2C_APPS_CLK_SRC] = &blsp1_qup4_i2c_apps_clk_src.clkr,
2625 [GCC_BLSP1_QUP4_SPI_APPS_CLK_SRC] = &blsp1_qup4_spi_apps_clk_src.clkr,
2626 [GCC_BLSP1_UART0_APPS_CLK_SRC] = &blsp1_uart0_apps_clk_src.clkr,
2627 [GCC_BLSP1_UART1_APPS_CLK_SRC] = &blsp1_uart1_apps_clk_src.clkr,
2628 [GCC_BLSP1_UART2_APPS_CLK_SRC] = &blsp1_uart2_apps_clk_src.clkr,
2629 [GCC_BLSP1_UART3_APPS_CLK_SRC] = &blsp1_uart3_apps_clk_src.clkr,
2630 [GCC_BLSP2_QUP0_I2C_APPS_CLK_SRC] = &blsp2_qup0_i2c_apps_clk_src.clkr,
2631 [GCC_BLSP2_QUP0_SPI_APPS_CLK_SRC] = &blsp2_qup0_spi_apps_clk_src.clkr,
2632 [GCC_BLSP2_UART0_APPS_CLK_SRC] = &blsp2_uart0_apps_clk_src.clkr,
2633 [GCC_BYTE0_CLK_SRC] = &byte0_clk_src.clkr,
2634 [GCC_EMAC_CLK_SRC] = &emac_clk_src.clkr,
2635 [GCC_EMAC_PTP_CLK_SRC] = &emac_ptp_clk_src.clkr,
2636 [GCC_ESC0_CLK_SRC] = &esc0_clk_src.clkr,
2637 [GCC_APSS_AHB_CLK] = &gcc_apss_ahb_clk.clkr,
2638 [GCC_BIMC_GFX_CLK] = &gcc_bimc_gfx_clk.clkr,
2639 [GCC_BIMC_CDSP_CLK] = &gcc_bimc_cdsp_clk.clkr,
2640 [GCC_BIMC_MDSS_CLK] = &gcc_bimc_mdss_clk.clkr,
2641 [GCC_BLSP1_AHB_CLK] = &gcc_blsp1_ahb_clk.clkr,
2642 [GCC_BLSP1_QUP0_I2C_APPS_CLK] = &gcc_blsp1_qup0_i2c_apps_clk.clkr,
2643 [GCC_BLSP1_QUP0_SPI_APPS_CLK] = &gcc_blsp1_qup0_spi_apps_clk.clkr,
2644 [GCC_BLSP1_QUP1_I2C_APPS_CLK] = &gcc_blsp1_qup1_i2c_apps_clk.clkr,
2645 [GCC_BLSP1_QUP1_SPI_APPS_CLK] = &gcc_blsp1_qup1_spi_apps_clk.clkr,
2646 [GCC_BLSP1_QUP2_I2C_APPS_CLK] = &gcc_blsp1_qup2_i2c_apps_clk.clkr,
2647 [GCC_BLSP1_QUP2_SPI_APPS_CLK] = &gcc_blsp1_qup2_spi_apps_clk.clkr,
2648 [GCC_BLSP1_QUP3_I2C_APPS_CLK] = &gcc_blsp1_qup3_i2c_apps_clk.clkr,
2649 [GCC_BLSP1_QUP3_SPI_APPS_CLK] = &gcc_blsp1_qup3_spi_apps_clk.clkr,
2650 [GCC_BLSP1_QUP4_I2C_APPS_CLK] = &gcc_blsp1_qup4_i2c_apps_clk.clkr,
2651 [GCC_BLSP1_QUP4_SPI_APPS_CLK] = &gcc_blsp1_qup4_spi_apps_clk.clkr,
2652 [GCC_BLSP1_UART0_APPS_CLK] = &gcc_blsp1_uart0_apps_clk.clkr,
2653 [GCC_BLSP1_UART1_APPS_CLK] = &gcc_blsp1_uart1_apps_clk.clkr,
2654 [GCC_BLSP1_UART2_APPS_CLK] = &gcc_blsp1_uart2_apps_clk.clkr,
2655 [GCC_BLSP1_UART3_APPS_CLK] = &gcc_blsp1_uart3_apps_clk.clkr,
2656 [GCC_BLSP2_AHB_CLK] = &gcc_blsp2_ahb_clk.clkr,
2657 [GCC_BLSP2_QUP0_I2C_APPS_CLK] = &gcc_blsp2_qup0_i2c_apps_clk.clkr,
2658 [GCC_BLSP2_QUP0_SPI_APPS_CLK] = &gcc_blsp2_qup0_spi_apps_clk.clkr,
2659 [GCC_BLSP2_UART0_APPS_CLK] = &gcc_blsp2_uart0_apps_clk.clkr,
2660 [GCC_BOOT_ROM_AHB_CLK] = &gcc_boot_rom_ahb_clk.clkr,
2661 [GCC_ETH_AXI_CLK] = &gcc_eth_axi_clk.clkr,
2662 [GCC_ETH_PTP_CLK] = &gcc_eth_ptp_clk.clkr,
2663 [GCC_ETH_RGMII_CLK] = &gcc_eth_rgmii_clk.clkr,
2664 [GCC_ETH_SLAVE_AHB_CLK] = &gcc_eth_slave_ahb_clk.clkr,
2665 [GCC_GENI_IR_S_CLK] = &gcc_geni_ir_s_clk.clkr,
2666 [GCC_GENI_IR_H_CLK] = &gcc_geni_ir_h_clk.clkr,
2667 [GCC_GP1_CLK] = &gcc_gp1_clk.clkr,
2668 [GCC_GP2_CLK] = &gcc_gp2_clk.clkr,
2669 [GCC_GP3_CLK] = &gcc_gp3_clk.clkr,
2670 [GCC_MDSS_AHB_CLK] = &gcc_mdss_ahb_clk.clkr,
2671 [GCC_MDSS_AXI_CLK] = &gcc_mdss_axi_clk.clkr,
2672 [GCC_MDSS_BYTE0_CLK] = &gcc_mdss_byte0_clk.clkr,
2673 [GCC_MDSS_ESC0_CLK] = &gcc_mdss_esc0_clk.clkr,
2674 [GCC_MDSS_HDMI_APP_CLK] = &gcc_mdss_hdmi_app_clk.clkr,
2675 [GCC_MDSS_HDMI_PCLK_CLK] = &gcc_mdss_hdmi_pclk_clk.clkr,
2676 [GCC_MDSS_MDP_CLK] = &gcc_mdss_mdp_clk.clkr,
2677 [GCC_MDSS_PCLK0_CLK] = &gcc_mdss_pclk0_clk.clkr,
2678 [GCC_MDSS_VSYNC_CLK] = &gcc_mdss_vsync_clk.clkr,
2679 [GCC_OXILI_AHB_CLK] = &gcc_oxili_ahb_clk.clkr,
2680 [GCC_OXILI_GFX3D_CLK] = &gcc_oxili_gfx3d_clk.clkr,
2681 [GCC_PCIE_0_AUX_CLK] = &gcc_pcie_0_aux_clk.clkr,
2682 [GCC_PCIE_0_CFG_AHB_CLK] = &gcc_pcie_0_cfg_ahb_clk.clkr,
2683 [GCC_PCIE_0_MSTR_AXI_CLK] = &gcc_pcie_0_mstr_axi_clk.clkr,
2684 [GCC_PCIE_0_PIPE_CLK] = &gcc_pcie_0_pipe_clk.clkr,
2685 [GCC_PCIE_0_SLV_AXI_CLK] = &gcc_pcie_0_slv_axi_clk.clkr,
2686 [GCC_PCNOC_USB2_CLK] = &gcc_pcnoc_usb2_clk.clkr,
2687 [GCC_PCNOC_USB3_CLK] = &gcc_pcnoc_usb3_clk.clkr,
2688 [GCC_PDM2_CLK] = &gcc_pdm2_clk.clkr,
2689 [GCC_PDM_AHB_CLK] = &gcc_pdm_ahb_clk.clkr,
2690 [GCC_PRNG_AHB_CLK] = &gcc_prng_ahb_clk.clkr,
2691 [GCC_PWM0_XO512_CLK] = &gcc_pwm0_xo512_clk.clkr,
2692 [GCC_PWM1_XO512_CLK] = &gcc_pwm1_xo512_clk.clkr,
2693 [GCC_PWM2_XO512_CLK] = &gcc_pwm2_xo512_clk.clkr,
2694 [GCC_SDCC1_AHB_CLK] = &gcc_sdcc1_ahb_clk.clkr,
2695 [GCC_SDCC1_APPS_CLK] = &gcc_sdcc1_apps_clk.clkr,
2696 [GCC_SDCC1_ICE_CORE_CLK] = &gcc_sdcc1_ice_core_clk.clkr,
2697 [GCC_CDSP_CFG_AHB_CLK] = &gcc_cdsp_cfg_ahb_clk.clkr,
2698 [GCC_SDCC2_AHB_CLK] = &gcc_sdcc2_ahb_clk.clkr,
2699 [GCC_SDCC2_APPS_CLK] = &gcc_sdcc2_apps_clk.clkr,
2700 [GCC_SYS_NOC_USB3_CLK] = &gcc_sys_noc_usb3_clk.clkr,
2701 [GCC_USB20_MOCK_UTMI_CLK] = &gcc_usb20_mock_utmi_clk.clkr,
2702 [GCC_USB2A_PHY_SLEEP_CLK] = &gcc_usb2a_phy_sleep_clk.clkr,
2703 [GCC_USB30_MASTER_CLK] = &gcc_usb30_master_clk.clkr,
2704 [GCC_USB30_MOCK_UTMI_CLK] = &gcc_usb30_mock_utmi_clk.clkr,
2705 [GCC_USB30_SLEEP_CLK] = &gcc_usb30_sleep_clk.clkr,
2706 [GCC_USB3_PHY_AUX_CLK] = &gcc_usb3_phy_aux_clk.clkr,
2707 [GCC_USB3_PHY_PIPE_CLK] = &gcc_usb3_phy_pipe_clk.clkr,
2708 [GCC_USB_HS_PHY_CFG_AHB_CLK] = &gcc_usb_hs_phy_cfg_ahb_clk.clkr,
2709 [GCC_USB_HS_SYSTEM_CLK] = &gcc_usb_hs_system_clk.clkr,
2710 [GCC_GFX3D_CLK_SRC] = &gfx3d_clk_src.clkr,
2711 [GCC_GP1_CLK_SRC] = &gp1_clk_src.clkr,
2712 [GCC_GP2_CLK_SRC] = &gp2_clk_src.clkr,
2713 [GCC_GP3_CLK_SRC] = &gp3_clk_src.clkr,
2714 [GCC_GPLL0_OUT_MAIN] = &gpll0_out_main.clkr,
2715 [GCC_GPLL0_AO_OUT_MAIN] = &gpll0_ao_out_main.clkr,
2716 [GCC_GPLL0_SLEEP_CLK_SRC] = &gpll0_sleep_clk_src.clkr,
2717 [GCC_GPLL1_OUT_MAIN] = &gpll1_out_main.clkr,
2718 [GCC_GPLL3_OUT_MAIN] = &gpll3_out_main.clkr,
2719 [GCC_GPLL4_OUT_MAIN] = &gpll4_out_main.clkr,
2720 [GCC_GPLL6] = &gpll6.clkr,
2721 [GCC_GPLL6_OUT_AUX] = &gpll6_out_aux,
2722 [GCC_HDMI_APP_CLK_SRC] = &hdmi_app_clk_src.clkr,
2723 [GCC_HDMI_PCLK_CLK_SRC] = &hdmi_pclk_clk_src.clkr,
2724 [GCC_MDP_CLK_SRC] = &mdp_clk_src.clkr,
2725 [GCC_PCIE_0_AUX_CLK_SRC] = &pcie_0_aux_clk_src.clkr,
2726 [GCC_PCIE_0_PIPE_CLK_SRC] = &pcie_0_pipe_clk_src.clkr,
2727 [GCC_PCLK0_CLK_SRC] = &pclk0_clk_src.clkr,
2728 [GCC_PDM2_CLK_SRC] = &pdm2_clk_src.clkr,
2729 [GCC_SDCC1_APPS_CLK_SRC] = &sdcc1_apps_clk_src.clkr,
2730 [GCC_SDCC1_ICE_CORE_CLK_SRC] = &sdcc1_ice_core_clk_src.clkr,
2731 [GCC_SDCC2_APPS_CLK_SRC] = &sdcc2_apps_clk_src.clkr,
2732 [GCC_USB20_MOCK_UTMI_CLK_SRC] = &usb20_mock_utmi_clk_src.clkr,
2733 [GCC_USB30_MASTER_CLK_SRC] = &usb30_master_clk_src.clkr,
2734 [GCC_USB30_MOCK_UTMI_CLK_SRC] = &usb30_mock_utmi_clk_src.clkr,
2735 [GCC_USB3_PHY_AUX_CLK_SRC] = &usb3_phy_aux_clk_src.clkr,
2736 [GCC_USB_HS_SYSTEM_CLK_SRC] = &usb_hs_system_clk_src.clkr,
2737 [GCC_VSYNC_CLK_SRC] = &vsync_clk_src.clkr,
2738 [GCC_CDSP_BIMC_CLK_SRC] = &cdsp_bimc_clk_src.clkr,
2739 [GCC_USB_HS_INACTIVITY_TIMERS_CLK] =
2740 &gcc_usb_hs_inactivity_timers_clk.clkr,
2741 [GCC_BIMC_GPU_CLK] = &gcc_bimc_gpu_clk.clkr,
2742 [GCC_GTCU_AHB_CLK] = &gcc_gtcu_ahb_clk.clkr,
2743 [GCC_GFX_TCU_CLK] = &gcc_gfx_tcu_clk.clkr,
2744 [GCC_GFX_TBU_CLK] = &gcc_gfx_tbu_clk.clkr,
2745 [GCC_SMMU_CFG_CLK] = &gcc_smmu_cfg_clk.clkr,
2746 [GCC_APSS_TCU_CLK] = &gcc_apss_tcu_clk.clkr,
2747 [GCC_CDSP_TBU_CLK] = &gcc_cdsp_tbu_clk.clkr,
2748 [GCC_CRYPTO_AHB_CLK] = &gcc_crypto_ahb_clk.clkr,
2749 [GCC_CRYPTO_AXI_CLK] = &gcc_crypto_axi_clk.clkr,
2750 [GCC_CRYPTO_CLK] = &gcc_crypto_clk.clkr,
2751 [GCC_MDP_TBU_CLK] = &gcc_mdp_tbu_clk.clkr,
2752 [GCC_QDSS_DAP_CLK] = &gcc_qdss_dap_clk.clkr,
2753 [GCC_DCC_CLK] = &gcc_dcc_clk.clkr,
2754 [GCC_DCC_XO_CLK] = &gcc_dcc_xo_clk.clkr,
2755 [GCC_WCSS_Q6_AHB_CLK] = &gcc_wdsp_q6ss_ahbs_clk.clkr,
2756 [GCC_WCSS_Q6_AXIM_CLK] = &gcc_wdsp_q6ss_axim_clk.clkr,
2757
2758 };
2759
2760 static struct gdsc *gcc_qcs404_gdscs[] = {
2761 [MDSS_GDSC] = &mdss_gdsc,
2762 [OXILI_GDSC] = &oxili_gdsc,
2763 };
2764
2765 static const struct qcom_reset_map gcc_qcs404_resets[] = {
2766 [GCC_GENI_IR_BCR] = { 0x0F000 },
2767 [GCC_CDSP_RESTART] = { 0x18000 },
2768 [GCC_USB_HS_BCR] = { 0x41000 },
2769 [GCC_USB2_HS_PHY_ONLY_BCR] = { 0x41034 },
2770 [GCC_QUSB2_PHY_BCR] = { 0x4103c },
2771 [GCC_USB_HS_PHY_CFG_AHB_BCR] = { 0x0000c, 1 },
2772 [GCC_USB2A_PHY_BCR] = { 0x0000c, 0 },
2773 [GCC_USB3_PHY_BCR] = { 0x39004 },
2774 [GCC_USB_30_BCR] = { 0x39000 },
2775 [GCC_USB3PHY_PHY_BCR] = { 0x39008 },
2776 [GCC_PCIE_0_BCR] = { 0x3e000 },
2777 [GCC_PCIE_0_PHY_BCR] = { 0x3e004 },
2778 [GCC_PCIE_0_LINK_DOWN_BCR] = { 0x3e038 },
2779 [GCC_PCIEPHY_0_PHY_BCR] = { 0x3e03c },
2780 [GCC_PCIE_0_AXI_MASTER_STICKY_ARES] = { 0x3e040, 6},
2781 [GCC_PCIE_0_AHB_ARES] = { 0x3e040, 5 },
2782 [GCC_PCIE_0_AXI_SLAVE_ARES] = { 0x3e040, 4 },
2783 [GCC_PCIE_0_AXI_MASTER_ARES] = { 0x3e040, 3 },
2784 [GCC_PCIE_0_CORE_STICKY_ARES] = { 0x3e040, 2 },
2785 [GCC_PCIE_0_SLEEP_ARES] = { 0x3e040, 1 },
2786 [GCC_PCIE_0_PIPE_ARES] = { 0x3e040, 0 },
2787 [GCC_EMAC_BCR] = { 0x4e000 },
2788 [GCC_WDSP_RESTART] = {0x19000},
2789 };
2790
2791 static const struct regmap_config gcc_qcs404_regmap_config = {
2792 .reg_bits = 32,
2793 .reg_stride = 4,
2794 .val_bits = 32,
2795 .max_register = 0x7f000,
2796 .fast_io = true,
2797 };
2798
2799 static const struct qcom_cc_desc gcc_qcs404_desc = {
2800 .config = &gcc_qcs404_regmap_config,
2801 .clks = gcc_qcs404_clocks,
2802 .num_clks = ARRAY_SIZE(gcc_qcs404_clocks),
2803 .resets = gcc_qcs404_resets,
2804 .num_resets = ARRAY_SIZE(gcc_qcs404_resets),
2805 .clk_hws = gcc_qcs404_hws,
2806 .num_clk_hws = ARRAY_SIZE(gcc_qcs404_hws),
2807 .gdscs = gcc_qcs404_gdscs,
2808 .num_gdscs = ARRAY_SIZE(gcc_qcs404_gdscs),
2809 };
2810
2811 static const struct of_device_id gcc_qcs404_match_table[] = {
2812 { .compatible = "qcom,gcc-qcs404" },
2813 { }
2814 };
2815 MODULE_DEVICE_TABLE(of, gcc_qcs404_match_table);
2816
gcc_qcs404_probe(struct platform_device * pdev)2817 static int gcc_qcs404_probe(struct platform_device *pdev)
2818 {
2819 struct regmap *regmap;
2820
2821 regmap = qcom_cc_map(pdev, &gcc_qcs404_desc);
2822 if (IS_ERR(regmap))
2823 return PTR_ERR(regmap);
2824
2825 clk_alpha_pll_configure(&gpll3_out_main, regmap, &gpll3_config);
2826
2827 return qcom_cc_really_probe(pdev, &gcc_qcs404_desc, regmap);
2828 }
2829
2830 static struct platform_driver gcc_qcs404_driver = {
2831 .probe = gcc_qcs404_probe,
2832 .driver = {
2833 .name = "gcc-qcs404",
2834 .of_match_table = gcc_qcs404_match_table,
2835 },
2836 };
2837
gcc_qcs404_init(void)2838 static int __init gcc_qcs404_init(void)
2839 {
2840 return platform_driver_register(&gcc_qcs404_driver);
2841 }
2842 core_initcall(gcc_qcs404_init);
2843
gcc_qcs404_exit(void)2844 static void __exit gcc_qcs404_exit(void)
2845 {
2846 platform_driver_unregister(&gcc_qcs404_driver);
2847 }
2848 module_exit(gcc_qcs404_exit);
2849
2850 MODULE_DESCRIPTION("Qualcomm GCC QCS404 Driver");
2851 MODULE_LICENSE("GPL v2");
2852