1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2023, Qualcomm Innovation Center, Inc. All rights reserved.
4 */
5
6 #include <linux/clk-provider.h>
7 #include <linux/mod_devicetable.h>
8 #include <linux/module.h>
9 #include <linux/platform_device.h>
10 #include <linux/pm_runtime.h>
11 #include <linux/regmap.h>
12
13 #include <dt-bindings/clock/qcom,x1e80100-camcc.h>
14
15 #include "clk-alpha-pll.h"
16 #include "clk-branch.h"
17 #include "clk-rcg.h"
18 #include "clk-regmap.h"
19 #include "common.h"
20 #include "gdsc.h"
21 #include "reset.h"
22
23 enum {
24 DT_IFACE,
25 DT_BI_TCXO,
26 DT_BI_TCXO_AO,
27 DT_SLEEP_CLK,
28 };
29
30 enum {
31 P_BI_TCXO,
32 P_BI_TCXO_AO,
33 P_CAM_CC_PLL0_OUT_EVEN,
34 P_CAM_CC_PLL0_OUT_MAIN,
35 P_CAM_CC_PLL0_OUT_ODD,
36 P_CAM_CC_PLL1_OUT_EVEN,
37 P_CAM_CC_PLL2_OUT_EVEN,
38 P_CAM_CC_PLL2_OUT_MAIN,
39 P_CAM_CC_PLL3_OUT_EVEN,
40 P_CAM_CC_PLL4_OUT_EVEN,
41 P_CAM_CC_PLL6_OUT_EVEN,
42 P_CAM_CC_PLL8_OUT_EVEN,
43 P_SLEEP_CLK,
44 };
45
46 static const struct pll_vco lucid_ole_vco[] = {
47 { 249600000, 2300000000, 0 },
48 };
49
50 static const struct pll_vco rivian_ole_vco[] = {
51 { 777000000, 1285000000, 0 },
52 };
53
54 static const struct alpha_pll_config cam_cc_pll0_config = {
55 .l = 0x3e,
56 .alpha = 0x8000,
57 .config_ctl_val = 0x20485699,
58 .config_ctl_hi_val = 0x00182261,
59 .config_ctl_hi1_val = 0x82aa299c,
60 .test_ctl_val = 0x00000000,
61 .test_ctl_hi_val = 0x00000003,
62 .test_ctl_hi1_val = 0x00009000,
63 .test_ctl_hi2_val = 0x00000034,
64 .user_ctl_val = 0x00008400,
65 .user_ctl_hi_val = 0x00000005,
66 };
67
68 static struct clk_alpha_pll cam_cc_pll0 = {
69 .offset = 0x0,
70 .vco_table = lucid_ole_vco,
71 .num_vco = ARRAY_SIZE(lucid_ole_vco),
72 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
73 .clkr = {
74 .hw.init = &(const struct clk_init_data) {
75 .name = "cam_cc_pll0",
76 .parent_data = &(const struct clk_parent_data) {
77 .index = DT_BI_TCXO,
78 },
79 .num_parents = 1,
80 .ops = &clk_alpha_pll_lucid_evo_ops,
81 },
82 },
83 };
84
85 static const struct clk_div_table post_div_table_cam_cc_pll0_out_even[] = {
86 { 0x1, 2 },
87 { }
88 };
89
90 static struct clk_alpha_pll_postdiv cam_cc_pll0_out_even = {
91 .offset = 0x0,
92 .post_div_shift = 10,
93 .post_div_table = post_div_table_cam_cc_pll0_out_even,
94 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll0_out_even),
95 .width = 4,
96 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
97 .clkr.hw.init = &(const struct clk_init_data) {
98 .name = "cam_cc_pll0_out_even",
99 .parent_hws = (const struct clk_hw*[]) {
100 &cam_cc_pll0.clkr.hw,
101 },
102 .num_parents = 1,
103 .flags = CLK_SET_RATE_PARENT,
104 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
105 },
106 };
107
108 static const struct clk_div_table post_div_table_cam_cc_pll0_out_odd[] = {
109 { 0x2, 3 },
110 { }
111 };
112
113 static struct clk_alpha_pll_postdiv cam_cc_pll0_out_odd = {
114 .offset = 0x0,
115 .post_div_shift = 14,
116 .post_div_table = post_div_table_cam_cc_pll0_out_odd,
117 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll0_out_odd),
118 .width = 4,
119 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
120 .clkr.hw.init = &(const struct clk_init_data) {
121 .name = "cam_cc_pll0_out_odd",
122 .parent_hws = (const struct clk_hw*[]) {
123 &cam_cc_pll0.clkr.hw,
124 },
125 .num_parents = 1,
126 .flags = CLK_SET_RATE_PARENT,
127 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
128 },
129 };
130
131 static const struct alpha_pll_config cam_cc_pll1_config = {
132 .l = 0x1f,
133 .alpha = 0xaaaa,
134 .config_ctl_val = 0x20485699,
135 .config_ctl_hi_val = 0x00182261,
136 .config_ctl_hi1_val = 0x82aa299c,
137 .test_ctl_val = 0x00000000,
138 .test_ctl_hi_val = 0x00000003,
139 .test_ctl_hi1_val = 0x00009000,
140 .test_ctl_hi2_val = 0x00000034,
141 .user_ctl_val = 0x00000400,
142 .user_ctl_hi_val = 0x00000005,
143 };
144
145 static struct clk_alpha_pll cam_cc_pll1 = {
146 .offset = 0x1000,
147 .vco_table = lucid_ole_vco,
148 .num_vco = ARRAY_SIZE(lucid_ole_vco),
149 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
150 .clkr = {
151 .hw.init = &(const struct clk_init_data) {
152 .name = "cam_cc_pll1",
153 .parent_data = &(const struct clk_parent_data) {
154 .index = DT_BI_TCXO,
155 },
156 .num_parents = 1,
157 .ops = &clk_alpha_pll_lucid_evo_ops,
158 },
159 },
160 };
161
162 static const struct clk_div_table post_div_table_cam_cc_pll1_out_even[] = {
163 { 0x1, 2 },
164 { }
165 };
166
167 static struct clk_alpha_pll_postdiv cam_cc_pll1_out_even = {
168 .offset = 0x1000,
169 .post_div_shift = 10,
170 .post_div_table = post_div_table_cam_cc_pll1_out_even,
171 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll1_out_even),
172 .width = 4,
173 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
174 .clkr.hw.init = &(const struct clk_init_data) {
175 .name = "cam_cc_pll1_out_even",
176 .parent_hws = (const struct clk_hw*[]) {
177 &cam_cc_pll1.clkr.hw,
178 },
179 .num_parents = 1,
180 .flags = CLK_SET_RATE_PARENT,
181 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
182 },
183 };
184
185 static const struct alpha_pll_config cam_cc_pll2_config = {
186 .l = 0x32,
187 .alpha = 0x0,
188 .config_ctl_val = 0x10000030,
189 .config_ctl_hi_val = 0x80890263,
190 .config_ctl_hi1_val = 0x00000217,
191 .user_ctl_val = 0x00000001,
192 .user_ctl_hi_val = 0x00000000,
193 };
194
195 static struct clk_alpha_pll cam_cc_pll2 = {
196 .offset = 0x2000,
197 .vco_table = rivian_ole_vco,
198 .num_vco = ARRAY_SIZE(rivian_ole_vco),
199 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_RIVIAN_EVO],
200 .clkr = {
201 .hw.init = &(const struct clk_init_data) {
202 .name = "cam_cc_pll2",
203 .parent_data = &(const struct clk_parent_data) {
204 .index = DT_BI_TCXO,
205 },
206 .num_parents = 1,
207 .ops = &clk_alpha_pll_rivian_evo_ops,
208 },
209 },
210 };
211
212 static const struct alpha_pll_config cam_cc_pll3_config = {
213 .l = 0x24,
214 .alpha = 0x0,
215 .config_ctl_val = 0x20485699,
216 .config_ctl_hi_val = 0x00182261,
217 .config_ctl_hi1_val = 0x82aa299c,
218 .test_ctl_val = 0x00000000,
219 .test_ctl_hi_val = 0x00000003,
220 .test_ctl_hi1_val = 0x00009000,
221 .test_ctl_hi2_val = 0x00000034,
222 .user_ctl_val = 0x00000400,
223 .user_ctl_hi_val = 0x00000005,
224 };
225
226 static struct clk_alpha_pll cam_cc_pll3 = {
227 .offset = 0x3000,
228 .vco_table = lucid_ole_vco,
229 .num_vco = ARRAY_SIZE(lucid_ole_vco),
230 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
231 .clkr = {
232 .hw.init = &(const struct clk_init_data) {
233 .name = "cam_cc_pll3",
234 .parent_data = &(const struct clk_parent_data) {
235 .index = DT_BI_TCXO,
236 },
237 .num_parents = 1,
238 .ops = &clk_alpha_pll_lucid_evo_ops,
239 },
240 },
241 };
242
243 static const struct clk_div_table post_div_table_cam_cc_pll3_out_even[] = {
244 { 0x1, 2 },
245 { }
246 };
247
248 static struct clk_alpha_pll_postdiv cam_cc_pll3_out_even = {
249 .offset = 0x3000,
250 .post_div_shift = 10,
251 .post_div_table = post_div_table_cam_cc_pll3_out_even,
252 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll3_out_even),
253 .width = 4,
254 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
255 .clkr.hw.init = &(const struct clk_init_data) {
256 .name = "cam_cc_pll3_out_even",
257 .parent_hws = (const struct clk_hw*[]) {
258 &cam_cc_pll3.clkr.hw,
259 },
260 .num_parents = 1,
261 .flags = CLK_SET_RATE_PARENT,
262 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
263 },
264 };
265
266 static const struct alpha_pll_config cam_cc_pll4_config = {
267 .l = 0x24,
268 .alpha = 0x0,
269 .config_ctl_val = 0x20485699,
270 .config_ctl_hi_val = 0x00182261,
271 .config_ctl_hi1_val = 0x82aa299c,
272 .test_ctl_val = 0x00000000,
273 .test_ctl_hi_val = 0x00000003,
274 .test_ctl_hi1_val = 0x00009000,
275 .test_ctl_hi2_val = 0x00000034,
276 .user_ctl_val = 0x00000400,
277 .user_ctl_hi_val = 0x00000005,
278 };
279
280 static struct clk_alpha_pll cam_cc_pll4 = {
281 .offset = 0x4000,
282 .vco_table = lucid_ole_vco,
283 .num_vco = ARRAY_SIZE(lucid_ole_vco),
284 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
285 .clkr = {
286 .hw.init = &(const struct clk_init_data) {
287 .name = "cam_cc_pll4",
288 .parent_data = &(const struct clk_parent_data) {
289 .index = DT_BI_TCXO,
290 },
291 .num_parents = 1,
292 .ops = &clk_alpha_pll_lucid_evo_ops,
293 },
294 },
295 };
296
297 static const struct clk_div_table post_div_table_cam_cc_pll4_out_even[] = {
298 { 0x1, 2 },
299 { }
300 };
301
302 static struct clk_alpha_pll_postdiv cam_cc_pll4_out_even = {
303 .offset = 0x4000,
304 .post_div_shift = 10,
305 .post_div_table = post_div_table_cam_cc_pll4_out_even,
306 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll4_out_even),
307 .width = 4,
308 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
309 .clkr.hw.init = &(const struct clk_init_data) {
310 .name = "cam_cc_pll4_out_even",
311 .parent_hws = (const struct clk_hw*[]) {
312 &cam_cc_pll4.clkr.hw,
313 },
314 .num_parents = 1,
315 .flags = CLK_SET_RATE_PARENT,
316 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
317 },
318 };
319
320 static const struct alpha_pll_config cam_cc_pll6_config = {
321 .l = 0x24,
322 .alpha = 0x0,
323 .config_ctl_val = 0x20485699,
324 .config_ctl_hi_val = 0x00182261,
325 .config_ctl_hi1_val = 0x82aa299c,
326 .test_ctl_val = 0x00000000,
327 .test_ctl_hi_val = 0x00000003,
328 .test_ctl_hi1_val = 0x00009000,
329 .test_ctl_hi2_val = 0x00000034,
330 .user_ctl_val = 0x00000400,
331 .user_ctl_hi_val = 0x00000005,
332 };
333
334 static struct clk_alpha_pll cam_cc_pll6 = {
335 .offset = 0x6000,
336 .vco_table = lucid_ole_vco,
337 .num_vco = ARRAY_SIZE(lucid_ole_vco),
338 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
339 .clkr = {
340 .hw.init = &(const struct clk_init_data) {
341 .name = "cam_cc_pll6",
342 .parent_data = &(const struct clk_parent_data) {
343 .index = DT_BI_TCXO,
344 },
345 .num_parents = 1,
346 .ops = &clk_alpha_pll_lucid_evo_ops,
347 },
348 },
349 };
350
351 static const struct clk_div_table post_div_table_cam_cc_pll6_out_even[] = {
352 { 0x1, 2 },
353 { }
354 };
355
356 static struct clk_alpha_pll_postdiv cam_cc_pll6_out_even = {
357 .offset = 0x6000,
358 .post_div_shift = 10,
359 .post_div_table = post_div_table_cam_cc_pll6_out_even,
360 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll6_out_even),
361 .width = 4,
362 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
363 .clkr.hw.init = &(const struct clk_init_data) {
364 .name = "cam_cc_pll6_out_even",
365 .parent_hws = (const struct clk_hw*[]) {
366 &cam_cc_pll6.clkr.hw,
367 },
368 .num_parents = 1,
369 .flags = CLK_SET_RATE_PARENT,
370 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
371 },
372 };
373
374 static const struct alpha_pll_config cam_cc_pll8_config = {
375 .l = 0x32,
376 .alpha = 0x0,
377 .config_ctl_val = 0x20485699,
378 .config_ctl_hi_val = 0x00182261,
379 .config_ctl_hi1_val = 0x82aa299c,
380 .test_ctl_val = 0x00000000,
381 .test_ctl_hi_val = 0x00000003,
382 .test_ctl_hi1_val = 0x00009000,
383 .test_ctl_hi2_val = 0x00000034,
384 .user_ctl_val = 0x00000400,
385 .user_ctl_hi_val = 0x00000005,
386 };
387
388 static struct clk_alpha_pll cam_cc_pll8 = {
389 .offset = 0x8000,
390 .vco_table = lucid_ole_vco,
391 .num_vco = ARRAY_SIZE(lucid_ole_vco),
392 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
393 .clkr = {
394 .hw.init = &(const struct clk_init_data) {
395 .name = "cam_cc_pll8",
396 .parent_data = &(const struct clk_parent_data) {
397 .index = DT_BI_TCXO,
398 },
399 .num_parents = 1,
400 .ops = &clk_alpha_pll_lucid_evo_ops,
401 },
402 },
403 };
404
405 static const struct clk_div_table post_div_table_cam_cc_pll8_out_even[] = {
406 { 0x1, 2 },
407 { }
408 };
409
410 static struct clk_alpha_pll_postdiv cam_cc_pll8_out_even = {
411 .offset = 0x8000,
412 .post_div_shift = 10,
413 .post_div_table = post_div_table_cam_cc_pll8_out_even,
414 .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll8_out_even),
415 .width = 4,
416 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
417 .clkr.hw.init = &(const struct clk_init_data) {
418 .name = "cam_cc_pll8_out_even",
419 .parent_hws = (const struct clk_hw*[]) {
420 &cam_cc_pll8.clkr.hw,
421 },
422 .num_parents = 1,
423 .flags = CLK_SET_RATE_PARENT,
424 .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
425 },
426 };
427
428 static const struct parent_map cam_cc_parent_map_0[] = {
429 { P_BI_TCXO, 0 },
430 { P_CAM_CC_PLL0_OUT_MAIN, 1 },
431 { P_CAM_CC_PLL0_OUT_EVEN, 2 },
432 { P_CAM_CC_PLL0_OUT_ODD, 3 },
433 { P_CAM_CC_PLL8_OUT_EVEN, 5 },
434 };
435
436 static const struct clk_parent_data cam_cc_parent_data_0[] = {
437 { .index = DT_BI_TCXO },
438 { .hw = &cam_cc_pll0.clkr.hw },
439 { .hw = &cam_cc_pll0_out_even.clkr.hw },
440 { .hw = &cam_cc_pll0_out_odd.clkr.hw },
441 { .hw = &cam_cc_pll8_out_even.clkr.hw },
442 };
443
444 static const struct parent_map cam_cc_parent_map_1[] = {
445 { P_BI_TCXO, 0 },
446 { P_CAM_CC_PLL2_OUT_EVEN, 3 },
447 { P_CAM_CC_PLL2_OUT_MAIN, 5 },
448 };
449
450 static const struct clk_parent_data cam_cc_parent_data_1[] = {
451 { .index = DT_BI_TCXO },
452 { .hw = &cam_cc_pll2.clkr.hw },
453 { .hw = &cam_cc_pll2.clkr.hw },
454 };
455
456 static const struct parent_map cam_cc_parent_map_2[] = {
457 { P_BI_TCXO, 0 },
458 { P_CAM_CC_PLL3_OUT_EVEN, 6 },
459 };
460
461 static const struct clk_parent_data cam_cc_parent_data_2[] = {
462 { .index = DT_BI_TCXO },
463 { .hw = &cam_cc_pll3_out_even.clkr.hw },
464 };
465
466 static const struct parent_map cam_cc_parent_map_3[] = {
467 { P_BI_TCXO, 0 },
468 { P_CAM_CC_PLL4_OUT_EVEN, 6 },
469 };
470
471 static const struct clk_parent_data cam_cc_parent_data_3[] = {
472 { .index = DT_BI_TCXO },
473 { .hw = &cam_cc_pll4_out_even.clkr.hw },
474 };
475
476 static const struct parent_map cam_cc_parent_map_4[] = {
477 { P_BI_TCXO, 0 },
478 { P_CAM_CC_PLL1_OUT_EVEN, 4 },
479 };
480
481 static const struct clk_parent_data cam_cc_parent_data_4[] = {
482 { .index = DT_BI_TCXO },
483 { .hw = &cam_cc_pll1_out_even.clkr.hw },
484 };
485
486 static const struct parent_map cam_cc_parent_map_5[] = {
487 { P_BI_TCXO, 0 },
488 { P_CAM_CC_PLL6_OUT_EVEN, 6 },
489 };
490
491 static const struct clk_parent_data cam_cc_parent_data_5[] = {
492 { .index = DT_BI_TCXO },
493 { .hw = &cam_cc_pll6_out_even.clkr.hw },
494 };
495
496 static const struct parent_map cam_cc_parent_map_6[] = {
497 { P_SLEEP_CLK, 0 },
498 };
499
500 static const struct clk_parent_data cam_cc_parent_data_6_ao[] = {
501 { .index = DT_SLEEP_CLK },
502 };
503
504 static const struct parent_map cam_cc_parent_map_7[] = {
505 { P_BI_TCXO, 0 },
506 };
507
508 static const struct clk_parent_data cam_cc_parent_data_7_ao[] = {
509 { .index = DT_BI_TCXO_AO },
510 };
511
512 static const struct freq_tbl ftbl_cam_cc_bps_clk_src[] = {
513 F(19200000, P_BI_TCXO, 1, 0, 0),
514 F(160000000, P_CAM_CC_PLL0_OUT_ODD, 2.5, 0, 0),
515 F(200000000, P_CAM_CC_PLL0_OUT_ODD, 2, 0, 0),
516 F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
517 F(600000000, P_CAM_CC_PLL0_OUT_EVEN, 1, 0, 0),
518 { }
519 };
520
521 static struct clk_rcg2 cam_cc_bps_clk_src = {
522 .cmd_rcgr = 0x10278,
523 .mnd_width = 0,
524 .hid_width = 5,
525 .parent_map = cam_cc_parent_map_0,
526 .freq_tbl = ftbl_cam_cc_bps_clk_src,
527 .clkr.hw.init = &(const struct clk_init_data) {
528 .name = "cam_cc_bps_clk_src",
529 .parent_data = cam_cc_parent_data_0,
530 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
531 .flags = CLK_SET_RATE_PARENT,
532 .ops = &clk_rcg2_shared_ops,
533 },
534 };
535
536 static const struct freq_tbl ftbl_cam_cc_camnoc_axi_rt_clk_src[] = {
537 F(240000000, P_CAM_CC_PLL0_OUT_EVEN, 2.5, 0, 0),
538 F(300000000, P_CAM_CC_PLL0_OUT_EVEN, 2, 0, 0),
539 F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
540 { }
541 };
542
543 static struct clk_rcg2 cam_cc_camnoc_axi_rt_clk_src = {
544 .cmd_rcgr = 0x138f8,
545 .mnd_width = 0,
546 .hid_width = 5,
547 .parent_map = cam_cc_parent_map_0,
548 .freq_tbl = ftbl_cam_cc_camnoc_axi_rt_clk_src,
549 .clkr.hw.init = &(const struct clk_init_data) {
550 .name = "cam_cc_camnoc_axi_rt_clk_src",
551 .parent_data = cam_cc_parent_data_0,
552 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
553 .flags = CLK_SET_RATE_PARENT,
554 .ops = &clk_rcg2_shared_ops,
555 },
556 };
557
558 static const struct freq_tbl ftbl_cam_cc_cci_0_clk_src[] = {
559 F(19200000, P_BI_TCXO, 1, 0, 0),
560 F(30000000, P_CAM_CC_PLL8_OUT_EVEN, 16, 0, 0),
561 F(37500000, P_CAM_CC_PLL0_OUT_EVEN, 16, 0, 0),
562 { }
563 };
564
565 static struct clk_rcg2 cam_cc_cci_0_clk_src = {
566 .cmd_rcgr = 0x1365c,
567 .mnd_width = 8,
568 .hid_width = 5,
569 .parent_map = cam_cc_parent_map_0,
570 .freq_tbl = ftbl_cam_cc_cci_0_clk_src,
571 .clkr.hw.init = &(const struct clk_init_data) {
572 .name = "cam_cc_cci_0_clk_src",
573 .parent_data = cam_cc_parent_data_0,
574 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
575 .flags = CLK_SET_RATE_PARENT,
576 .ops = &clk_rcg2_ops,
577 },
578 };
579
580 static struct clk_rcg2 cam_cc_cci_1_clk_src = {
581 .cmd_rcgr = 0x1378c,
582 .mnd_width = 8,
583 .hid_width = 5,
584 .parent_map = cam_cc_parent_map_0,
585 .freq_tbl = ftbl_cam_cc_cci_0_clk_src,
586 .clkr.hw.init = &(const struct clk_init_data) {
587 .name = "cam_cc_cci_1_clk_src",
588 .parent_data = cam_cc_parent_data_0,
589 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
590 .flags = CLK_SET_RATE_PARENT,
591 .ops = &clk_rcg2_ops,
592 },
593 };
594
595 static const struct freq_tbl ftbl_cam_cc_cphy_rx_clk_src[] = {
596 F(19200000, P_BI_TCXO, 1, 0, 0),
597 F(300000000, P_CAM_CC_PLL0_OUT_MAIN, 4, 0, 0),
598 F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
599 F(480000000, P_CAM_CC_PLL0_OUT_MAIN, 2.5, 0, 0),
600 { }
601 };
602
603 static struct clk_rcg2 cam_cc_cphy_rx_clk_src = {
604 .cmd_rcgr = 0x11164,
605 .mnd_width = 0,
606 .hid_width = 5,
607 .parent_map = cam_cc_parent_map_0,
608 .freq_tbl = ftbl_cam_cc_cphy_rx_clk_src,
609 .clkr.hw.init = &(const struct clk_init_data) {
610 .name = "cam_cc_cphy_rx_clk_src",
611 .parent_data = cam_cc_parent_data_0,
612 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
613 .flags = CLK_SET_RATE_PARENT,
614 .ops = &clk_rcg2_ops,
615 },
616 };
617
618 static const struct freq_tbl ftbl_cam_cc_csi0phytimer_clk_src[] = {
619 F(19200000, P_BI_TCXO, 1, 0, 0),
620 F(266666667, P_CAM_CC_PLL0_OUT_ODD, 1.5, 0, 0),
621 F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
622 { }
623 };
624
625 static struct clk_rcg2 cam_cc_csi0phytimer_clk_src = {
626 .cmd_rcgr = 0x150e0,
627 .mnd_width = 0,
628 .hid_width = 5,
629 .parent_map = cam_cc_parent_map_0,
630 .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
631 .clkr.hw.init = &(const struct clk_init_data) {
632 .name = "cam_cc_csi0phytimer_clk_src",
633 .parent_data = cam_cc_parent_data_0,
634 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
635 .flags = CLK_SET_RATE_PARENT,
636 .ops = &clk_rcg2_ops,
637 },
638 };
639
640 static struct clk_rcg2 cam_cc_csi1phytimer_clk_src = {
641 .cmd_rcgr = 0x15104,
642 .mnd_width = 0,
643 .hid_width = 5,
644 .parent_map = cam_cc_parent_map_0,
645 .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
646 .clkr.hw.init = &(const struct clk_init_data) {
647 .name = "cam_cc_csi1phytimer_clk_src",
648 .parent_data = cam_cc_parent_data_0,
649 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
650 .flags = CLK_SET_RATE_PARENT,
651 .ops = &clk_rcg2_ops,
652 },
653 };
654
655 static struct clk_rcg2 cam_cc_csi2phytimer_clk_src = {
656 .cmd_rcgr = 0x15124,
657 .mnd_width = 0,
658 .hid_width = 5,
659 .parent_map = cam_cc_parent_map_0,
660 .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
661 .clkr.hw.init = &(const struct clk_init_data) {
662 .name = "cam_cc_csi2phytimer_clk_src",
663 .parent_data = cam_cc_parent_data_0,
664 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
665 .flags = CLK_SET_RATE_PARENT,
666 .ops = &clk_rcg2_ops,
667 },
668 };
669
670 static struct clk_rcg2 cam_cc_csi3phytimer_clk_src = {
671 .cmd_rcgr = 0x15258,
672 .mnd_width = 0,
673 .hid_width = 5,
674 .parent_map = cam_cc_parent_map_0,
675 .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
676 .clkr.hw.init = &(const struct clk_init_data) {
677 .name = "cam_cc_csi3phytimer_clk_src",
678 .parent_data = cam_cc_parent_data_0,
679 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
680 .flags = CLK_SET_RATE_PARENT,
681 .ops = &clk_rcg2_ops,
682 },
683 };
684
685 static struct clk_rcg2 cam_cc_csi4phytimer_clk_src = {
686 .cmd_rcgr = 0x1538c,
687 .mnd_width = 0,
688 .hid_width = 5,
689 .parent_map = cam_cc_parent_map_0,
690 .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
691 .clkr.hw.init = &(const struct clk_init_data) {
692 .name = "cam_cc_csi4phytimer_clk_src",
693 .parent_data = cam_cc_parent_data_0,
694 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
695 .flags = CLK_SET_RATE_PARENT,
696 .ops = &clk_rcg2_ops,
697 },
698 };
699
700 static struct clk_rcg2 cam_cc_csi5phytimer_clk_src = {
701 .cmd_rcgr = 0x154c0,
702 .mnd_width = 0,
703 .hid_width = 5,
704 .parent_map = cam_cc_parent_map_0,
705 .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
706 .clkr.hw.init = &(const struct clk_init_data) {
707 .name = "cam_cc_csi5phytimer_clk_src",
708 .parent_data = cam_cc_parent_data_0,
709 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
710 .flags = CLK_SET_RATE_PARENT,
711 .ops = &clk_rcg2_ops,
712 },
713 };
714
715 static const struct freq_tbl ftbl_cam_cc_csid_clk_src[] = {
716 F(300000000, P_CAM_CC_PLL0_OUT_MAIN, 4, 0, 0),
717 F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
718 F(480000000, P_CAM_CC_PLL0_OUT_MAIN, 2.5, 0, 0),
719 { }
720 };
721
722 static struct clk_rcg2 cam_cc_csid_clk_src = {
723 .cmd_rcgr = 0x138d4,
724 .mnd_width = 0,
725 .hid_width = 5,
726 .parent_map = cam_cc_parent_map_0,
727 .freq_tbl = ftbl_cam_cc_csid_clk_src,
728 .clkr.hw.init = &(const struct clk_init_data) {
729 .name = "cam_cc_csid_clk_src",
730 .parent_data = cam_cc_parent_data_0,
731 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
732 .flags = CLK_SET_RATE_PARENT,
733 .ops = &clk_rcg2_shared_ops,
734 },
735 };
736
737 static const struct freq_tbl ftbl_cam_cc_fast_ahb_clk_src[] = {
738 F(19200000, P_BI_TCXO, 1, 0, 0),
739 F(80000000, P_CAM_CC_PLL0_OUT_EVEN, 7.5, 0, 0),
740 F(100000000, P_CAM_CC_PLL0_OUT_EVEN, 6, 0, 0),
741 F(200000000, P_CAM_CC_PLL0_OUT_EVEN, 3, 0, 0),
742 F(300000000, P_CAM_CC_PLL0_OUT_MAIN, 4, 0, 0),
743 F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
744 { }
745 };
746
747 static struct clk_rcg2 cam_cc_fast_ahb_clk_src = {
748 .cmd_rcgr = 0x10018,
749 .mnd_width = 0,
750 .hid_width = 5,
751 .parent_map = cam_cc_parent_map_0,
752 .freq_tbl = ftbl_cam_cc_fast_ahb_clk_src,
753 .clkr.hw.init = &(const struct clk_init_data) {
754 .name = "cam_cc_fast_ahb_clk_src",
755 .parent_data = cam_cc_parent_data_0,
756 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
757 .flags = CLK_SET_RATE_PARENT,
758 .ops = &clk_rcg2_shared_ops,
759 },
760 };
761
762 static const struct freq_tbl ftbl_cam_cc_icp_clk_src[] = {
763 F(19200000, P_BI_TCXO, 1, 0, 0),
764 F(300000000, P_CAM_CC_PLL0_OUT_EVEN, 2, 0, 0),
765 F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
766 F(480000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
767 F(600000000, P_CAM_CC_PLL0_OUT_MAIN, 2, 0, 0),
768 { }
769 };
770
771 static struct clk_rcg2 cam_cc_icp_clk_src = {
772 .cmd_rcgr = 0x13520,
773 .mnd_width = 0,
774 .hid_width = 5,
775 .parent_map = cam_cc_parent_map_0,
776 .freq_tbl = ftbl_cam_cc_icp_clk_src,
777 .clkr.hw.init = &(const struct clk_init_data) {
778 .name = "cam_cc_icp_clk_src",
779 .parent_data = cam_cc_parent_data_0,
780 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
781 .flags = CLK_SET_RATE_PARENT,
782 .ops = &clk_rcg2_shared_ops,
783 },
784 };
785
786 static const struct freq_tbl ftbl_cam_cc_ife_0_clk_src[] = {
787 F(19200000, P_BI_TCXO, 1, 0, 0),
788 F(345600000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
789 F(432000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
790 F(594000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
791 F(675000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
792 F(727000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
793 { }
794 };
795
796 static struct clk_rcg2 cam_cc_ife_0_clk_src = {
797 .cmd_rcgr = 0x11018,
798 .mnd_width = 0,
799 .hid_width = 5,
800 .parent_map = cam_cc_parent_map_2,
801 .freq_tbl = ftbl_cam_cc_ife_0_clk_src,
802 .clkr.hw.init = &(const struct clk_init_data) {
803 .name = "cam_cc_ife_0_clk_src",
804 .parent_data = cam_cc_parent_data_2,
805 .num_parents = ARRAY_SIZE(cam_cc_parent_data_2),
806 .flags = CLK_SET_RATE_PARENT,
807 .ops = &clk_rcg2_shared_ops,
808 },
809 };
810
811 static const struct freq_tbl ftbl_cam_cc_ife_1_clk_src[] = {
812 F(19200000, P_BI_TCXO, 1, 0, 0),
813 F(345600000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
814 F(432000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
815 F(594000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
816 F(675000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
817 F(727000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
818 { }
819 };
820
821 static struct clk_rcg2 cam_cc_ife_1_clk_src = {
822 .cmd_rcgr = 0x12018,
823 .mnd_width = 0,
824 .hid_width = 5,
825 .parent_map = cam_cc_parent_map_3,
826 .freq_tbl = ftbl_cam_cc_ife_1_clk_src,
827 .clkr.hw.init = &(const struct clk_init_data) {
828 .name = "cam_cc_ife_1_clk_src",
829 .parent_data = cam_cc_parent_data_3,
830 .num_parents = ARRAY_SIZE(cam_cc_parent_data_3),
831 .flags = CLK_SET_RATE_PARENT,
832 .ops = &clk_rcg2_shared_ops,
833 },
834 };
835
836 static const struct freq_tbl ftbl_cam_cc_ife_lite_clk_src[] = {
837 F(266666667, P_CAM_CC_PLL0_OUT_ODD, 1.5, 0, 0),
838 F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
839 F(480000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
840 { }
841 };
842
843 static struct clk_rcg2 cam_cc_ife_lite_clk_src = {
844 .cmd_rcgr = 0x13000,
845 .mnd_width = 0,
846 .hid_width = 5,
847 .parent_map = cam_cc_parent_map_0,
848 .freq_tbl = ftbl_cam_cc_ife_lite_clk_src,
849 .clkr.hw.init = &(const struct clk_init_data) {
850 .name = "cam_cc_ife_lite_clk_src",
851 .parent_data = cam_cc_parent_data_0,
852 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
853 .flags = CLK_SET_RATE_PARENT,
854 .ops = &clk_rcg2_shared_ops,
855 },
856 };
857
858 static struct clk_rcg2 cam_cc_ife_lite_csid_clk_src = {
859 .cmd_rcgr = 0x1313c,
860 .mnd_width = 0,
861 .hid_width = 5,
862 .parent_map = cam_cc_parent_map_0,
863 .freq_tbl = ftbl_cam_cc_ife_lite_clk_src,
864 .clkr.hw.init = &(const struct clk_init_data) {
865 .name = "cam_cc_ife_lite_csid_clk_src",
866 .parent_data = cam_cc_parent_data_0,
867 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
868 .flags = CLK_SET_RATE_PARENT,
869 .ops = &clk_rcg2_shared_ops,
870 },
871 };
872
873 static const struct freq_tbl ftbl_cam_cc_ipe_nps_clk_src[] = {
874 F(304000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
875 F(364000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
876 F(500000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
877 F(600000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
878 F(700000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
879 { }
880 };
881
882 static struct clk_rcg2 cam_cc_ipe_nps_clk_src = {
883 .cmd_rcgr = 0x103cc,
884 .mnd_width = 0,
885 .hid_width = 5,
886 .parent_map = cam_cc_parent_map_4,
887 .freq_tbl = ftbl_cam_cc_ipe_nps_clk_src,
888 .clkr.hw.init = &(const struct clk_init_data) {
889 .name = "cam_cc_ipe_nps_clk_src",
890 .parent_data = cam_cc_parent_data_4,
891 .num_parents = ARRAY_SIZE(cam_cc_parent_data_4),
892 .flags = CLK_SET_RATE_PARENT,
893 .ops = &clk_rcg2_shared_ops,
894 },
895 };
896
897 static const struct freq_tbl ftbl_cam_cc_jpeg_clk_src[] = {
898 F(19200000, P_BI_TCXO, 1, 0, 0),
899 F(160000000, P_CAM_CC_PLL0_OUT_ODD, 2.5, 0, 0),
900 F(200000000, P_CAM_CC_PLL0_OUT_ODD, 2, 0, 0),
901 F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
902 F(480000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
903 F(600000000, P_CAM_CC_PLL0_OUT_EVEN, 1, 0, 0),
904 { }
905 };
906
907 static struct clk_rcg2 cam_cc_jpeg_clk_src = {
908 .cmd_rcgr = 0x133dc,
909 .mnd_width = 0,
910 .hid_width = 5,
911 .parent_map = cam_cc_parent_map_0,
912 .freq_tbl = ftbl_cam_cc_jpeg_clk_src,
913 .clkr.hw.init = &(const struct clk_init_data) {
914 .name = "cam_cc_jpeg_clk_src",
915 .parent_data = cam_cc_parent_data_0,
916 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
917 .flags = CLK_SET_RATE_PARENT,
918 .ops = &clk_rcg2_shared_ops,
919 },
920 };
921
922 static const struct freq_tbl ftbl_cam_cc_mclk0_clk_src[] = {
923 F(19200000, P_BI_TCXO, 1, 0, 0),
924 F(24000000, P_CAM_CC_PLL2_OUT_MAIN, 10, 1, 4),
925 F(68571429, P_CAM_CC_PLL2_OUT_MAIN, 14, 0, 0),
926 { }
927 };
928
929 static struct clk_rcg2 cam_cc_mclk0_clk_src = {
930 .cmd_rcgr = 0x15000,
931 .mnd_width = 8,
932 .hid_width = 5,
933 .parent_map = cam_cc_parent_map_1,
934 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
935 .clkr.hw.init = &(const struct clk_init_data) {
936 .name = "cam_cc_mclk0_clk_src",
937 .parent_data = cam_cc_parent_data_1,
938 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
939 .flags = CLK_SET_RATE_PARENT,
940 .ops = &clk_rcg2_ops,
941 },
942 };
943
944 static struct clk_rcg2 cam_cc_mclk1_clk_src = {
945 .cmd_rcgr = 0x1501c,
946 .mnd_width = 8,
947 .hid_width = 5,
948 .parent_map = cam_cc_parent_map_1,
949 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
950 .clkr.hw.init = &(const struct clk_init_data) {
951 .name = "cam_cc_mclk1_clk_src",
952 .parent_data = cam_cc_parent_data_1,
953 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
954 .flags = CLK_SET_RATE_PARENT,
955 .ops = &clk_rcg2_ops,
956 },
957 };
958
959 static struct clk_rcg2 cam_cc_mclk2_clk_src = {
960 .cmd_rcgr = 0x15038,
961 .mnd_width = 8,
962 .hid_width = 5,
963 .parent_map = cam_cc_parent_map_1,
964 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
965 .clkr.hw.init = &(const struct clk_init_data) {
966 .name = "cam_cc_mclk2_clk_src",
967 .parent_data = cam_cc_parent_data_1,
968 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
969 .flags = CLK_SET_RATE_PARENT,
970 .ops = &clk_rcg2_ops,
971 },
972 };
973
974 static struct clk_rcg2 cam_cc_mclk3_clk_src = {
975 .cmd_rcgr = 0x15054,
976 .mnd_width = 8,
977 .hid_width = 5,
978 .parent_map = cam_cc_parent_map_1,
979 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
980 .clkr.hw.init = &(const struct clk_init_data) {
981 .name = "cam_cc_mclk3_clk_src",
982 .parent_data = cam_cc_parent_data_1,
983 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
984 .flags = CLK_SET_RATE_PARENT,
985 .ops = &clk_rcg2_ops,
986 },
987 };
988
989 static struct clk_rcg2 cam_cc_mclk4_clk_src = {
990 .cmd_rcgr = 0x15070,
991 .mnd_width = 8,
992 .hid_width = 5,
993 .parent_map = cam_cc_parent_map_1,
994 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
995 .clkr.hw.init = &(const struct clk_init_data) {
996 .name = "cam_cc_mclk4_clk_src",
997 .parent_data = cam_cc_parent_data_1,
998 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
999 .flags = CLK_SET_RATE_PARENT,
1000 .ops = &clk_rcg2_ops,
1001 },
1002 };
1003
1004 static struct clk_rcg2 cam_cc_mclk5_clk_src = {
1005 .cmd_rcgr = 0x1508c,
1006 .mnd_width = 8,
1007 .hid_width = 5,
1008 .parent_map = cam_cc_parent_map_1,
1009 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
1010 .clkr.hw.init = &(const struct clk_init_data) {
1011 .name = "cam_cc_mclk5_clk_src",
1012 .parent_data = cam_cc_parent_data_1,
1013 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
1014 .flags = CLK_SET_RATE_PARENT,
1015 .ops = &clk_rcg2_ops,
1016 },
1017 };
1018
1019 static struct clk_rcg2 cam_cc_mclk6_clk_src = {
1020 .cmd_rcgr = 0x150a8,
1021 .mnd_width = 8,
1022 .hid_width = 5,
1023 .parent_map = cam_cc_parent_map_1,
1024 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
1025 .clkr.hw.init = &(const struct clk_init_data) {
1026 .name = "cam_cc_mclk6_clk_src",
1027 .parent_data = cam_cc_parent_data_1,
1028 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
1029 .flags = CLK_SET_RATE_PARENT,
1030 .ops = &clk_rcg2_ops,
1031 },
1032 };
1033
1034 static struct clk_rcg2 cam_cc_mclk7_clk_src = {
1035 .cmd_rcgr = 0x150c4,
1036 .mnd_width = 8,
1037 .hid_width = 5,
1038 .parent_map = cam_cc_parent_map_1,
1039 .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
1040 .clkr.hw.init = &(const struct clk_init_data) {
1041 .name = "cam_cc_mclk7_clk_src",
1042 .parent_data = cam_cc_parent_data_1,
1043 .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
1044 .flags = CLK_SET_RATE_PARENT,
1045 .ops = &clk_rcg2_ops,
1046 },
1047 };
1048
1049 static const struct freq_tbl ftbl_cam_cc_sfe_0_clk_src[] = {
1050 F(345600000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
1051 F(432000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
1052 F(594000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
1053 F(675000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
1054 F(727000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
1055 { }
1056 };
1057
1058 static struct clk_rcg2 cam_cc_sfe_0_clk_src = {
1059 .cmd_rcgr = 0x13294,
1060 .mnd_width = 0,
1061 .hid_width = 5,
1062 .parent_map = cam_cc_parent_map_5,
1063 .freq_tbl = ftbl_cam_cc_sfe_0_clk_src,
1064 .clkr.hw.init = &(const struct clk_init_data) {
1065 .name = "cam_cc_sfe_0_clk_src",
1066 .parent_data = cam_cc_parent_data_5,
1067 .num_parents = ARRAY_SIZE(cam_cc_parent_data_5),
1068 .flags = CLK_SET_RATE_PARENT,
1069 .ops = &clk_rcg2_shared_ops,
1070 },
1071 };
1072
1073 static const struct freq_tbl ftbl_cam_cc_sleep_clk_src[] = {
1074 F(32000, P_SLEEP_CLK, 1, 0, 0),
1075 { }
1076 };
1077
1078 static struct clk_rcg2 cam_cc_sleep_clk_src = {
1079 .cmd_rcgr = 0x13aa0,
1080 .mnd_width = 0,
1081 .hid_width = 5,
1082 .parent_map = cam_cc_parent_map_6,
1083 .freq_tbl = ftbl_cam_cc_sleep_clk_src,
1084 .clkr.hw.init = &(const struct clk_init_data) {
1085 .name = "cam_cc_sleep_clk_src",
1086 .parent_data = cam_cc_parent_data_6_ao,
1087 .num_parents = ARRAY_SIZE(cam_cc_parent_data_6_ao),
1088 .flags = CLK_SET_RATE_PARENT,
1089 .ops = &clk_rcg2_ops,
1090 },
1091 };
1092
1093 static const struct freq_tbl ftbl_cam_cc_slow_ahb_clk_src[] = {
1094 F(19200000, P_BI_TCXO, 1, 0, 0),
1095 F(64000000, P_CAM_CC_PLL8_OUT_EVEN, 7.5, 0, 0),
1096 F(80000000, P_CAM_CC_PLL0_OUT_EVEN, 7.5, 0, 0),
1097 { }
1098 };
1099
1100 static struct clk_rcg2 cam_cc_slow_ahb_clk_src = {
1101 .cmd_rcgr = 0x10148,
1102 .mnd_width = 8,
1103 .hid_width = 5,
1104 .parent_map = cam_cc_parent_map_0,
1105 .freq_tbl = ftbl_cam_cc_slow_ahb_clk_src,
1106 .clkr.hw.init = &(const struct clk_init_data) {
1107 .name = "cam_cc_slow_ahb_clk_src",
1108 .parent_data = cam_cc_parent_data_0,
1109 .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
1110 .flags = CLK_SET_RATE_PARENT,
1111 .ops = &clk_rcg2_shared_ops,
1112 },
1113 };
1114
1115 static const struct freq_tbl ftbl_cam_cc_xo_clk_src[] = {
1116 F(19200000, P_BI_TCXO, 1, 0, 0),
1117 { }
1118 };
1119
1120 static struct clk_rcg2 cam_cc_xo_clk_src = {
1121 .cmd_rcgr = 0x13a84,
1122 .mnd_width = 0,
1123 .hid_width = 5,
1124 .parent_map = cam_cc_parent_map_7,
1125 .freq_tbl = ftbl_cam_cc_xo_clk_src,
1126 .clkr.hw.init = &(const struct clk_init_data) {
1127 .name = "cam_cc_xo_clk_src",
1128 .parent_data = cam_cc_parent_data_7_ao,
1129 .num_parents = ARRAY_SIZE(cam_cc_parent_data_7_ao),
1130 .flags = CLK_SET_RATE_PARENT,
1131 .ops = &clk_rcg2_ops,
1132 },
1133 };
1134
1135 static struct clk_branch cam_cc_bps_ahb_clk = {
1136 .halt_reg = 0x10274,
1137 .halt_check = BRANCH_HALT,
1138 .clkr = {
1139 .enable_reg = 0x10274,
1140 .enable_mask = BIT(0),
1141 .hw.init = &(const struct clk_init_data) {
1142 .name = "cam_cc_bps_ahb_clk",
1143 .parent_hws = (const struct clk_hw*[]) {
1144 &cam_cc_slow_ahb_clk_src.clkr.hw,
1145 },
1146 .num_parents = 1,
1147 .flags = CLK_SET_RATE_PARENT,
1148 .ops = &clk_branch2_ops,
1149 },
1150 },
1151 };
1152
1153 static struct clk_branch cam_cc_bps_clk = {
1154 .halt_reg = 0x103a4,
1155 .halt_check = BRANCH_HALT,
1156 .clkr = {
1157 .enable_reg = 0x103a4,
1158 .enable_mask = BIT(0),
1159 .hw.init = &(const struct clk_init_data) {
1160 .name = "cam_cc_bps_clk",
1161 .parent_hws = (const struct clk_hw*[]) {
1162 &cam_cc_bps_clk_src.clkr.hw,
1163 },
1164 .num_parents = 1,
1165 .flags = CLK_SET_RATE_PARENT,
1166 .ops = &clk_branch2_ops,
1167 },
1168 },
1169 };
1170
1171 static struct clk_branch cam_cc_bps_fast_ahb_clk = {
1172 .halt_reg = 0x10144,
1173 .halt_check = BRANCH_HALT,
1174 .clkr = {
1175 .enable_reg = 0x10144,
1176 .enable_mask = BIT(0),
1177 .hw.init = &(const struct clk_init_data) {
1178 .name = "cam_cc_bps_fast_ahb_clk",
1179 .parent_hws = (const struct clk_hw*[]) {
1180 &cam_cc_fast_ahb_clk_src.clkr.hw,
1181 },
1182 .num_parents = 1,
1183 .flags = CLK_SET_RATE_PARENT,
1184 .ops = &clk_branch2_ops,
1185 },
1186 },
1187 };
1188
1189 static struct clk_branch cam_cc_camnoc_axi_nrt_clk = {
1190 .halt_reg = 0x13920,
1191 .halt_check = BRANCH_HALT,
1192 .clkr = {
1193 .enable_reg = 0x13920,
1194 .enable_mask = BIT(0),
1195 .hw.init = &(const struct clk_init_data) {
1196 .name = "cam_cc_camnoc_axi_nrt_clk",
1197 .parent_hws = (const struct clk_hw*[]) {
1198 &cam_cc_camnoc_axi_rt_clk_src.clkr.hw,
1199 },
1200 .num_parents = 1,
1201 .flags = CLK_SET_RATE_PARENT,
1202 .ops = &clk_branch2_ops,
1203 },
1204 },
1205 };
1206
1207 static struct clk_branch cam_cc_camnoc_axi_rt_clk = {
1208 .halt_reg = 0x13910,
1209 .halt_check = BRANCH_HALT,
1210 .clkr = {
1211 .enable_reg = 0x13910,
1212 .enable_mask = BIT(0),
1213 .hw.init = &(const struct clk_init_data) {
1214 .name = "cam_cc_camnoc_axi_rt_clk",
1215 .parent_hws = (const struct clk_hw*[]) {
1216 &cam_cc_camnoc_axi_rt_clk_src.clkr.hw,
1217 },
1218 .num_parents = 1,
1219 .flags = CLK_SET_RATE_PARENT,
1220 .ops = &clk_branch2_ops,
1221 },
1222 },
1223 };
1224
1225 static struct clk_branch cam_cc_camnoc_dcd_xo_clk = {
1226 .halt_reg = 0x1392c,
1227 .halt_check = BRANCH_HALT,
1228 .clkr = {
1229 .enable_reg = 0x1392c,
1230 .enable_mask = BIT(0),
1231 .hw.init = &(const struct clk_init_data) {
1232 .name = "cam_cc_camnoc_dcd_xo_clk",
1233 .parent_hws = (const struct clk_hw*[]) {
1234 &cam_cc_xo_clk_src.clkr.hw,
1235 },
1236 .num_parents = 1,
1237 .flags = CLK_SET_RATE_PARENT,
1238 .ops = &clk_branch2_ops,
1239 },
1240 },
1241 };
1242
1243 static struct clk_branch cam_cc_camnoc_xo_clk = {
1244 .halt_reg = 0x13930,
1245 .halt_check = BRANCH_HALT,
1246 .clkr = {
1247 .enable_reg = 0x13930,
1248 .enable_mask = BIT(0),
1249 .hw.init = &(const struct clk_init_data) {
1250 .name = "cam_cc_camnoc_xo_clk",
1251 .parent_hws = (const struct clk_hw*[]) {
1252 &cam_cc_xo_clk_src.clkr.hw,
1253 },
1254 .num_parents = 1,
1255 .flags = CLK_SET_RATE_PARENT,
1256 .ops = &clk_branch2_ops,
1257 },
1258 },
1259 };
1260
1261 static struct clk_branch cam_cc_cci_0_clk = {
1262 .halt_reg = 0x13788,
1263 .halt_check = BRANCH_HALT,
1264 .clkr = {
1265 .enable_reg = 0x13788,
1266 .enable_mask = BIT(0),
1267 .hw.init = &(const struct clk_init_data) {
1268 .name = "cam_cc_cci_0_clk",
1269 .parent_hws = (const struct clk_hw*[]) {
1270 &cam_cc_cci_0_clk_src.clkr.hw,
1271 },
1272 .num_parents = 1,
1273 .flags = CLK_SET_RATE_PARENT,
1274 .ops = &clk_branch2_ops,
1275 },
1276 },
1277 };
1278
1279 static struct clk_branch cam_cc_cci_1_clk = {
1280 .halt_reg = 0x138b8,
1281 .halt_check = BRANCH_HALT,
1282 .clkr = {
1283 .enable_reg = 0x138b8,
1284 .enable_mask = BIT(0),
1285 .hw.init = &(const struct clk_init_data) {
1286 .name = "cam_cc_cci_1_clk",
1287 .parent_hws = (const struct clk_hw*[]) {
1288 &cam_cc_cci_1_clk_src.clkr.hw,
1289 },
1290 .num_parents = 1,
1291 .flags = CLK_SET_RATE_PARENT,
1292 .ops = &clk_branch2_ops,
1293 },
1294 },
1295 };
1296
1297 static struct clk_branch cam_cc_core_ahb_clk = {
1298 .halt_reg = 0x13a80,
1299 .halt_check = BRANCH_HALT_VOTED,
1300 .clkr = {
1301 .enable_reg = 0x13a80,
1302 .enable_mask = BIT(0),
1303 .hw.init = &(const struct clk_init_data) {
1304 .name = "cam_cc_core_ahb_clk",
1305 .parent_hws = (const struct clk_hw*[]) {
1306 &cam_cc_slow_ahb_clk_src.clkr.hw,
1307 },
1308 .num_parents = 1,
1309 .flags = CLK_SET_RATE_PARENT,
1310 .ops = &clk_branch2_ops,
1311 },
1312 },
1313 };
1314
1315 static struct clk_branch cam_cc_cpas_ahb_clk = {
1316 .halt_reg = 0x138bc,
1317 .halt_check = BRANCH_HALT,
1318 .clkr = {
1319 .enable_reg = 0x138bc,
1320 .enable_mask = BIT(0),
1321 .hw.init = &(const struct clk_init_data) {
1322 .name = "cam_cc_cpas_ahb_clk",
1323 .parent_hws = (const struct clk_hw*[]) {
1324 &cam_cc_slow_ahb_clk_src.clkr.hw,
1325 },
1326 .num_parents = 1,
1327 .flags = CLK_SET_RATE_PARENT,
1328 .ops = &clk_branch2_ops,
1329 },
1330 },
1331 };
1332
1333 static struct clk_branch cam_cc_cpas_bps_clk = {
1334 .halt_reg = 0x103b0,
1335 .halt_check = BRANCH_HALT,
1336 .clkr = {
1337 .enable_reg = 0x103b0,
1338 .enable_mask = BIT(0),
1339 .hw.init = &(const struct clk_init_data) {
1340 .name = "cam_cc_cpas_bps_clk",
1341 .parent_hws = (const struct clk_hw*[]) {
1342 &cam_cc_bps_clk_src.clkr.hw,
1343 },
1344 .num_parents = 1,
1345 .flags = CLK_SET_RATE_PARENT,
1346 .ops = &clk_branch2_ops,
1347 },
1348 },
1349 };
1350
1351 static struct clk_branch cam_cc_cpas_fast_ahb_clk = {
1352 .halt_reg = 0x138c8,
1353 .halt_check = BRANCH_HALT,
1354 .clkr = {
1355 .enable_reg = 0x138c8,
1356 .enable_mask = BIT(0),
1357 .hw.init = &(const struct clk_init_data) {
1358 .name = "cam_cc_cpas_fast_ahb_clk",
1359 .parent_hws = (const struct clk_hw*[]) {
1360 &cam_cc_fast_ahb_clk_src.clkr.hw,
1361 },
1362 .num_parents = 1,
1363 .flags = CLK_SET_RATE_PARENT,
1364 .ops = &clk_branch2_ops,
1365 },
1366 },
1367 };
1368
1369 static struct clk_branch cam_cc_cpas_ife_0_clk = {
1370 .halt_reg = 0x11150,
1371 .halt_check = BRANCH_HALT,
1372 .clkr = {
1373 .enable_reg = 0x11150,
1374 .enable_mask = BIT(0),
1375 .hw.init = &(const struct clk_init_data) {
1376 .name = "cam_cc_cpas_ife_0_clk",
1377 .parent_hws = (const struct clk_hw*[]) {
1378 &cam_cc_ife_0_clk_src.clkr.hw,
1379 },
1380 .num_parents = 1,
1381 .flags = CLK_SET_RATE_PARENT,
1382 .ops = &clk_branch2_ops,
1383 },
1384 },
1385 };
1386
1387 static struct clk_branch cam_cc_cpas_ife_1_clk = {
1388 .halt_reg = 0x1203c,
1389 .halt_check = BRANCH_HALT,
1390 .clkr = {
1391 .enable_reg = 0x1203c,
1392 .enable_mask = BIT(0),
1393 .hw.init = &(const struct clk_init_data) {
1394 .name = "cam_cc_cpas_ife_1_clk",
1395 .parent_hws = (const struct clk_hw*[]) {
1396 &cam_cc_ife_1_clk_src.clkr.hw,
1397 },
1398 .num_parents = 1,
1399 .flags = CLK_SET_RATE_PARENT,
1400 .ops = &clk_branch2_ops,
1401 },
1402 },
1403 };
1404
1405 static struct clk_branch cam_cc_cpas_ife_lite_clk = {
1406 .halt_reg = 0x13138,
1407 .halt_check = BRANCH_HALT,
1408 .clkr = {
1409 .enable_reg = 0x13138,
1410 .enable_mask = BIT(0),
1411 .hw.init = &(const struct clk_init_data) {
1412 .name = "cam_cc_cpas_ife_lite_clk",
1413 .parent_hws = (const struct clk_hw*[]) {
1414 &cam_cc_ife_lite_clk_src.clkr.hw,
1415 },
1416 .num_parents = 1,
1417 .flags = CLK_SET_RATE_PARENT,
1418 .ops = &clk_branch2_ops,
1419 },
1420 },
1421 };
1422
1423 static struct clk_branch cam_cc_cpas_ipe_nps_clk = {
1424 .halt_reg = 0x10504,
1425 .halt_check = BRANCH_HALT,
1426 .clkr = {
1427 .enable_reg = 0x10504,
1428 .enable_mask = BIT(0),
1429 .hw.init = &(const struct clk_init_data) {
1430 .name = "cam_cc_cpas_ipe_nps_clk",
1431 .parent_hws = (const struct clk_hw*[]) {
1432 &cam_cc_ipe_nps_clk_src.clkr.hw,
1433 },
1434 .num_parents = 1,
1435 .flags = CLK_SET_RATE_PARENT,
1436 .ops = &clk_branch2_ops,
1437 },
1438 },
1439 };
1440
1441 static struct clk_branch cam_cc_cpas_sfe_0_clk = {
1442 .halt_reg = 0x133cc,
1443 .halt_check = BRANCH_HALT,
1444 .clkr = {
1445 .enable_reg = 0x133cc,
1446 .enable_mask = BIT(0),
1447 .hw.init = &(const struct clk_init_data) {
1448 .name = "cam_cc_cpas_sfe_0_clk",
1449 .parent_hws = (const struct clk_hw*[]) {
1450 &cam_cc_sfe_0_clk_src.clkr.hw,
1451 },
1452 .num_parents = 1,
1453 .flags = CLK_SET_RATE_PARENT,
1454 .ops = &clk_branch2_ops,
1455 },
1456 },
1457 };
1458
1459 static struct clk_branch cam_cc_csi0phytimer_clk = {
1460 .halt_reg = 0x150f8,
1461 .halt_check = BRANCH_HALT,
1462 .clkr = {
1463 .enable_reg = 0x150f8,
1464 .enable_mask = BIT(0),
1465 .hw.init = &(const struct clk_init_data) {
1466 .name = "cam_cc_csi0phytimer_clk",
1467 .parent_hws = (const struct clk_hw*[]) {
1468 &cam_cc_csi0phytimer_clk_src.clkr.hw,
1469 },
1470 .num_parents = 1,
1471 .flags = CLK_SET_RATE_PARENT,
1472 .ops = &clk_branch2_ops,
1473 },
1474 },
1475 };
1476
1477 static struct clk_branch cam_cc_csi1phytimer_clk = {
1478 .halt_reg = 0x1511c,
1479 .halt_check = BRANCH_HALT,
1480 .clkr = {
1481 .enable_reg = 0x1511c,
1482 .enable_mask = BIT(0),
1483 .hw.init = &(const struct clk_init_data) {
1484 .name = "cam_cc_csi1phytimer_clk",
1485 .parent_hws = (const struct clk_hw*[]) {
1486 &cam_cc_csi1phytimer_clk_src.clkr.hw,
1487 },
1488 .num_parents = 1,
1489 .flags = CLK_SET_RATE_PARENT,
1490 .ops = &clk_branch2_ops,
1491 },
1492 },
1493 };
1494
1495 static struct clk_branch cam_cc_csi2phytimer_clk = {
1496 .halt_reg = 0x15250,
1497 .halt_check = BRANCH_HALT,
1498 .clkr = {
1499 .enable_reg = 0x15250,
1500 .enable_mask = BIT(0),
1501 .hw.init = &(const struct clk_init_data) {
1502 .name = "cam_cc_csi2phytimer_clk",
1503 .parent_hws = (const struct clk_hw*[]) {
1504 &cam_cc_csi2phytimer_clk_src.clkr.hw,
1505 },
1506 .num_parents = 1,
1507 .flags = CLK_SET_RATE_PARENT,
1508 .ops = &clk_branch2_ops,
1509 },
1510 },
1511 };
1512
1513 static struct clk_branch cam_cc_csi3phytimer_clk = {
1514 .halt_reg = 0x15384,
1515 .halt_check = BRANCH_HALT,
1516 .clkr = {
1517 .enable_reg = 0x15384,
1518 .enable_mask = BIT(0),
1519 .hw.init = &(const struct clk_init_data) {
1520 .name = "cam_cc_csi3phytimer_clk",
1521 .parent_hws = (const struct clk_hw*[]) {
1522 &cam_cc_csi3phytimer_clk_src.clkr.hw,
1523 },
1524 .num_parents = 1,
1525 .flags = CLK_SET_RATE_PARENT,
1526 .ops = &clk_branch2_ops,
1527 },
1528 },
1529 };
1530
1531 static struct clk_branch cam_cc_csi4phytimer_clk = {
1532 .halt_reg = 0x154b8,
1533 .halt_check = BRANCH_HALT,
1534 .clkr = {
1535 .enable_reg = 0x154b8,
1536 .enable_mask = BIT(0),
1537 .hw.init = &(const struct clk_init_data) {
1538 .name = "cam_cc_csi4phytimer_clk",
1539 .parent_hws = (const struct clk_hw*[]) {
1540 &cam_cc_csi4phytimer_clk_src.clkr.hw,
1541 },
1542 .num_parents = 1,
1543 .flags = CLK_SET_RATE_PARENT,
1544 .ops = &clk_branch2_ops,
1545 },
1546 },
1547 };
1548
1549 static struct clk_branch cam_cc_csi5phytimer_clk = {
1550 .halt_reg = 0x155ec,
1551 .halt_check = BRANCH_HALT,
1552 .clkr = {
1553 .enable_reg = 0x155ec,
1554 .enable_mask = BIT(0),
1555 .hw.init = &(const struct clk_init_data) {
1556 .name = "cam_cc_csi5phytimer_clk",
1557 .parent_hws = (const struct clk_hw*[]) {
1558 &cam_cc_csi5phytimer_clk_src.clkr.hw,
1559 },
1560 .num_parents = 1,
1561 .flags = CLK_SET_RATE_PARENT,
1562 .ops = &clk_branch2_ops,
1563 },
1564 },
1565 };
1566
1567 static struct clk_branch cam_cc_csid_clk = {
1568 .halt_reg = 0x138ec,
1569 .halt_check = BRANCH_HALT,
1570 .clkr = {
1571 .enable_reg = 0x138ec,
1572 .enable_mask = BIT(0),
1573 .hw.init = &(const struct clk_init_data) {
1574 .name = "cam_cc_csid_clk",
1575 .parent_hws = (const struct clk_hw*[]) {
1576 &cam_cc_csid_clk_src.clkr.hw,
1577 },
1578 .num_parents = 1,
1579 .flags = CLK_SET_RATE_PARENT,
1580 .ops = &clk_branch2_ops,
1581 },
1582 },
1583 };
1584
1585 static struct clk_branch cam_cc_csid_csiphy_rx_clk = {
1586 .halt_reg = 0x15100,
1587 .halt_check = BRANCH_HALT,
1588 .clkr = {
1589 .enable_reg = 0x15100,
1590 .enable_mask = BIT(0),
1591 .hw.init = &(const struct clk_init_data) {
1592 .name = "cam_cc_csid_csiphy_rx_clk",
1593 .parent_hws = (const struct clk_hw*[]) {
1594 &cam_cc_cphy_rx_clk_src.clkr.hw,
1595 },
1596 .num_parents = 1,
1597 .flags = CLK_SET_RATE_PARENT,
1598 .ops = &clk_branch2_ops,
1599 },
1600 },
1601 };
1602
1603 static struct clk_branch cam_cc_csiphy0_clk = {
1604 .halt_reg = 0x150fc,
1605 .halt_check = BRANCH_HALT,
1606 .clkr = {
1607 .enable_reg = 0x150fc,
1608 .enable_mask = BIT(0),
1609 .hw.init = &(const struct clk_init_data) {
1610 .name = "cam_cc_csiphy0_clk",
1611 .parent_hws = (const struct clk_hw*[]) {
1612 &cam_cc_cphy_rx_clk_src.clkr.hw,
1613 },
1614 .num_parents = 1,
1615 .flags = CLK_SET_RATE_PARENT,
1616 .ops = &clk_branch2_ops,
1617 },
1618 },
1619 };
1620
1621 static struct clk_branch cam_cc_csiphy1_clk = {
1622 .halt_reg = 0x15120,
1623 .halt_check = BRANCH_HALT,
1624 .clkr = {
1625 .enable_reg = 0x15120,
1626 .enable_mask = BIT(0),
1627 .hw.init = &(const struct clk_init_data) {
1628 .name = "cam_cc_csiphy1_clk",
1629 .parent_hws = (const struct clk_hw*[]) {
1630 &cam_cc_cphy_rx_clk_src.clkr.hw,
1631 },
1632 .num_parents = 1,
1633 .flags = CLK_SET_RATE_PARENT,
1634 .ops = &clk_branch2_ops,
1635 },
1636 },
1637 };
1638
1639 static struct clk_branch cam_cc_csiphy2_clk = {
1640 .halt_reg = 0x15254,
1641 .halt_check = BRANCH_HALT,
1642 .clkr = {
1643 .enable_reg = 0x15254,
1644 .enable_mask = BIT(0),
1645 .hw.init = &(const struct clk_init_data) {
1646 .name = "cam_cc_csiphy2_clk",
1647 .parent_hws = (const struct clk_hw*[]) {
1648 &cam_cc_cphy_rx_clk_src.clkr.hw,
1649 },
1650 .num_parents = 1,
1651 .flags = CLK_SET_RATE_PARENT,
1652 .ops = &clk_branch2_ops,
1653 },
1654 },
1655 };
1656
1657 static struct clk_branch cam_cc_csiphy3_clk = {
1658 .halt_reg = 0x15388,
1659 .halt_check = BRANCH_HALT,
1660 .clkr = {
1661 .enable_reg = 0x15388,
1662 .enable_mask = BIT(0),
1663 .hw.init = &(const struct clk_init_data) {
1664 .name = "cam_cc_csiphy3_clk",
1665 .parent_hws = (const struct clk_hw*[]) {
1666 &cam_cc_cphy_rx_clk_src.clkr.hw,
1667 },
1668 .num_parents = 1,
1669 .flags = CLK_SET_RATE_PARENT,
1670 .ops = &clk_branch2_ops,
1671 },
1672 },
1673 };
1674
1675 static struct clk_branch cam_cc_csiphy4_clk = {
1676 .halt_reg = 0x154bc,
1677 .halt_check = BRANCH_HALT,
1678 .clkr = {
1679 .enable_reg = 0x154bc,
1680 .enable_mask = BIT(0),
1681 .hw.init = &(const struct clk_init_data) {
1682 .name = "cam_cc_csiphy4_clk",
1683 .parent_hws = (const struct clk_hw*[]) {
1684 &cam_cc_cphy_rx_clk_src.clkr.hw,
1685 },
1686 .num_parents = 1,
1687 .flags = CLK_SET_RATE_PARENT,
1688 .ops = &clk_branch2_ops,
1689 },
1690 },
1691 };
1692
1693 static struct clk_branch cam_cc_csiphy5_clk = {
1694 .halt_reg = 0x155f0,
1695 .halt_check = BRANCH_HALT,
1696 .clkr = {
1697 .enable_reg = 0x155f0,
1698 .enable_mask = BIT(0),
1699 .hw.init = &(const struct clk_init_data) {
1700 .name = "cam_cc_csiphy5_clk",
1701 .parent_hws = (const struct clk_hw*[]) {
1702 &cam_cc_cphy_rx_clk_src.clkr.hw,
1703 },
1704 .num_parents = 1,
1705 .flags = CLK_SET_RATE_PARENT,
1706 .ops = &clk_branch2_ops,
1707 },
1708 },
1709 };
1710
1711 static struct clk_branch cam_cc_icp_ahb_clk = {
1712 .halt_reg = 0x13658,
1713 .halt_check = BRANCH_HALT,
1714 .clkr = {
1715 .enable_reg = 0x13658,
1716 .enable_mask = BIT(0),
1717 .hw.init = &(const struct clk_init_data) {
1718 .name = "cam_cc_icp_ahb_clk",
1719 .parent_hws = (const struct clk_hw*[]) {
1720 &cam_cc_slow_ahb_clk_src.clkr.hw,
1721 },
1722 .num_parents = 1,
1723 .flags = CLK_SET_RATE_PARENT,
1724 .ops = &clk_branch2_ops,
1725 },
1726 },
1727 };
1728
1729 static struct clk_branch cam_cc_icp_clk = {
1730 .halt_reg = 0x1364c,
1731 .halt_check = BRANCH_HALT,
1732 .clkr = {
1733 .enable_reg = 0x1364c,
1734 .enable_mask = BIT(0),
1735 .hw.init = &(const struct clk_init_data) {
1736 .name = "cam_cc_icp_clk",
1737 .parent_hws = (const struct clk_hw*[]) {
1738 &cam_cc_icp_clk_src.clkr.hw,
1739 },
1740 .num_parents = 1,
1741 .flags = CLK_SET_RATE_PARENT,
1742 .ops = &clk_branch2_ops,
1743 },
1744 },
1745 };
1746
1747 static struct clk_branch cam_cc_ife_0_clk = {
1748 .halt_reg = 0x11144,
1749 .halt_check = BRANCH_HALT,
1750 .clkr = {
1751 .enable_reg = 0x11144,
1752 .enable_mask = BIT(0),
1753 .hw.init = &(const struct clk_init_data) {
1754 .name = "cam_cc_ife_0_clk",
1755 .parent_hws = (const struct clk_hw*[]) {
1756 &cam_cc_ife_0_clk_src.clkr.hw,
1757 },
1758 .num_parents = 1,
1759 .flags = CLK_SET_RATE_PARENT,
1760 .ops = &clk_branch2_ops,
1761 },
1762 },
1763 };
1764
1765 static struct clk_branch cam_cc_ife_0_dsp_clk = {
1766 .halt_reg = 0x11154,
1767 .halt_check = BRANCH_HALT,
1768 .clkr = {
1769 .enable_reg = 0x11154,
1770 .enable_mask = BIT(0),
1771 .hw.init = &(const struct clk_init_data) {
1772 .name = "cam_cc_ife_0_dsp_clk",
1773 .parent_hws = (const struct clk_hw*[]) {
1774 &cam_cc_ife_0_clk_src.clkr.hw,
1775 },
1776 .num_parents = 1,
1777 .flags = CLK_SET_RATE_PARENT,
1778 .ops = &clk_branch2_ops,
1779 },
1780 },
1781 };
1782
1783 static struct clk_branch cam_cc_ife_0_fast_ahb_clk = {
1784 .halt_reg = 0x11160,
1785 .halt_check = BRANCH_HALT,
1786 .clkr = {
1787 .enable_reg = 0x11160,
1788 .enable_mask = BIT(0),
1789 .hw.init = &(const struct clk_init_data) {
1790 .name = "cam_cc_ife_0_fast_ahb_clk",
1791 .parent_hws = (const struct clk_hw*[]) {
1792 &cam_cc_fast_ahb_clk_src.clkr.hw,
1793 },
1794 .num_parents = 1,
1795 .flags = CLK_SET_RATE_PARENT,
1796 .ops = &clk_branch2_ops,
1797 },
1798 },
1799 };
1800
1801 static struct clk_branch cam_cc_ife_1_clk = {
1802 .halt_reg = 0x12030,
1803 .halt_check = BRANCH_HALT,
1804 .clkr = {
1805 .enable_reg = 0x12030,
1806 .enable_mask = BIT(0),
1807 .hw.init = &(const struct clk_init_data) {
1808 .name = "cam_cc_ife_1_clk",
1809 .parent_hws = (const struct clk_hw*[]) {
1810 &cam_cc_ife_1_clk_src.clkr.hw,
1811 },
1812 .num_parents = 1,
1813 .flags = CLK_SET_RATE_PARENT,
1814 .ops = &clk_branch2_ops,
1815 },
1816 },
1817 };
1818
1819 static struct clk_branch cam_cc_ife_1_dsp_clk = {
1820 .halt_reg = 0x12040,
1821 .halt_check = BRANCH_HALT,
1822 .clkr = {
1823 .enable_reg = 0x12040,
1824 .enable_mask = BIT(0),
1825 .hw.init = &(const struct clk_init_data) {
1826 .name = "cam_cc_ife_1_dsp_clk",
1827 .parent_hws = (const struct clk_hw*[]) {
1828 &cam_cc_ife_1_clk_src.clkr.hw,
1829 },
1830 .num_parents = 1,
1831 .flags = CLK_SET_RATE_PARENT,
1832 .ops = &clk_branch2_ops,
1833 },
1834 },
1835 };
1836
1837 static struct clk_branch cam_cc_ife_1_fast_ahb_clk = {
1838 .halt_reg = 0x1204c,
1839 .halt_check = BRANCH_HALT,
1840 .clkr = {
1841 .enable_reg = 0x1204c,
1842 .enable_mask = BIT(0),
1843 .hw.init = &(const struct clk_init_data) {
1844 .name = "cam_cc_ife_1_fast_ahb_clk",
1845 .parent_hws = (const struct clk_hw*[]) {
1846 &cam_cc_fast_ahb_clk_src.clkr.hw,
1847 },
1848 .num_parents = 1,
1849 .flags = CLK_SET_RATE_PARENT,
1850 .ops = &clk_branch2_ops,
1851 },
1852 },
1853 };
1854
1855 static struct clk_branch cam_cc_ife_lite_ahb_clk = {
1856 .halt_reg = 0x13278,
1857 .halt_check = BRANCH_HALT,
1858 .clkr = {
1859 .enable_reg = 0x13278,
1860 .enable_mask = BIT(0),
1861 .hw.init = &(const struct clk_init_data) {
1862 .name = "cam_cc_ife_lite_ahb_clk",
1863 .parent_hws = (const struct clk_hw*[]) {
1864 &cam_cc_slow_ahb_clk_src.clkr.hw,
1865 },
1866 .num_parents = 1,
1867 .flags = CLK_SET_RATE_PARENT,
1868 .ops = &clk_branch2_ops,
1869 },
1870 },
1871 };
1872
1873 static struct clk_branch cam_cc_ife_lite_clk = {
1874 .halt_reg = 0x1312c,
1875 .halt_check = BRANCH_HALT,
1876 .clkr = {
1877 .enable_reg = 0x1312c,
1878 .enable_mask = BIT(0),
1879 .hw.init = &(const struct clk_init_data) {
1880 .name = "cam_cc_ife_lite_clk",
1881 .parent_hws = (const struct clk_hw*[]) {
1882 &cam_cc_ife_lite_clk_src.clkr.hw,
1883 },
1884 .num_parents = 1,
1885 .flags = CLK_SET_RATE_PARENT,
1886 .ops = &clk_branch2_ops,
1887 },
1888 },
1889 };
1890
1891 static struct clk_branch cam_cc_ife_lite_cphy_rx_clk = {
1892 .halt_reg = 0x13274,
1893 .halt_check = BRANCH_HALT,
1894 .clkr = {
1895 .enable_reg = 0x13274,
1896 .enable_mask = BIT(0),
1897 .hw.init = &(const struct clk_init_data) {
1898 .name = "cam_cc_ife_lite_cphy_rx_clk",
1899 .parent_hws = (const struct clk_hw*[]) {
1900 &cam_cc_cphy_rx_clk_src.clkr.hw,
1901 },
1902 .num_parents = 1,
1903 .flags = CLK_SET_RATE_PARENT,
1904 .ops = &clk_branch2_ops,
1905 },
1906 },
1907 };
1908
1909 static struct clk_branch cam_cc_ife_lite_csid_clk = {
1910 .halt_reg = 0x13268,
1911 .halt_check = BRANCH_HALT,
1912 .clkr = {
1913 .enable_reg = 0x13268,
1914 .enable_mask = BIT(0),
1915 .hw.init = &(const struct clk_init_data) {
1916 .name = "cam_cc_ife_lite_csid_clk",
1917 .parent_hws = (const struct clk_hw*[]) {
1918 &cam_cc_ife_lite_csid_clk_src.clkr.hw,
1919 },
1920 .num_parents = 1,
1921 .flags = CLK_SET_RATE_PARENT,
1922 .ops = &clk_branch2_ops,
1923 },
1924 },
1925 };
1926
1927 static struct clk_branch cam_cc_ipe_nps_ahb_clk = {
1928 .halt_reg = 0x1051c,
1929 .halt_check = BRANCH_HALT,
1930 .clkr = {
1931 .enable_reg = 0x1051c,
1932 .enable_mask = BIT(0),
1933 .hw.init = &(const struct clk_init_data) {
1934 .name = "cam_cc_ipe_nps_ahb_clk",
1935 .parent_hws = (const struct clk_hw*[]) {
1936 &cam_cc_slow_ahb_clk_src.clkr.hw,
1937 },
1938 .num_parents = 1,
1939 .flags = CLK_SET_RATE_PARENT,
1940 .ops = &clk_branch2_ops,
1941 },
1942 },
1943 };
1944
1945 static struct clk_branch cam_cc_ipe_nps_clk = {
1946 .halt_reg = 0x104f8,
1947 .halt_check = BRANCH_HALT,
1948 .clkr = {
1949 .enable_reg = 0x104f8,
1950 .enable_mask = BIT(0),
1951 .hw.init = &(const struct clk_init_data) {
1952 .name = "cam_cc_ipe_nps_clk",
1953 .parent_hws = (const struct clk_hw*[]) {
1954 &cam_cc_ipe_nps_clk_src.clkr.hw,
1955 },
1956 .num_parents = 1,
1957 .flags = CLK_SET_RATE_PARENT,
1958 .ops = &clk_branch2_ops,
1959 },
1960 },
1961 };
1962
1963 static struct clk_branch cam_cc_ipe_nps_fast_ahb_clk = {
1964 .halt_reg = 0x10520,
1965 .halt_check = BRANCH_HALT,
1966 .clkr = {
1967 .enable_reg = 0x10520,
1968 .enable_mask = BIT(0),
1969 .hw.init = &(const struct clk_init_data) {
1970 .name = "cam_cc_ipe_nps_fast_ahb_clk",
1971 .parent_hws = (const struct clk_hw*[]) {
1972 &cam_cc_fast_ahb_clk_src.clkr.hw,
1973 },
1974 .num_parents = 1,
1975 .flags = CLK_SET_RATE_PARENT,
1976 .ops = &clk_branch2_ops,
1977 },
1978 },
1979 };
1980
1981 static struct clk_branch cam_cc_ipe_pps_clk = {
1982 .halt_reg = 0x10508,
1983 .halt_check = BRANCH_HALT,
1984 .clkr = {
1985 .enable_reg = 0x10508,
1986 .enable_mask = BIT(0),
1987 .hw.init = &(const struct clk_init_data) {
1988 .name = "cam_cc_ipe_pps_clk",
1989 .parent_hws = (const struct clk_hw*[]) {
1990 &cam_cc_ipe_nps_clk_src.clkr.hw,
1991 },
1992 .num_parents = 1,
1993 .flags = CLK_SET_RATE_PARENT,
1994 .ops = &clk_branch2_ops,
1995 },
1996 },
1997 };
1998
1999 static struct clk_branch cam_cc_ipe_pps_fast_ahb_clk = {
2000 .halt_reg = 0x10524,
2001 .halt_check = BRANCH_HALT,
2002 .clkr = {
2003 .enable_reg = 0x10524,
2004 .enable_mask = BIT(0),
2005 .hw.init = &(const struct clk_init_data) {
2006 .name = "cam_cc_ipe_pps_fast_ahb_clk",
2007 .parent_hws = (const struct clk_hw*[]) {
2008 &cam_cc_fast_ahb_clk_src.clkr.hw,
2009 },
2010 .num_parents = 1,
2011 .flags = CLK_SET_RATE_PARENT,
2012 .ops = &clk_branch2_ops,
2013 },
2014 },
2015 };
2016
2017 static struct clk_branch cam_cc_jpeg_clk = {
2018 .halt_reg = 0x13508,
2019 .halt_check = BRANCH_HALT,
2020 .clkr = {
2021 .enable_reg = 0x13508,
2022 .enable_mask = BIT(0),
2023 .hw.init = &(const struct clk_init_data) {
2024 .name = "cam_cc_jpeg_clk",
2025 .parent_hws = (const struct clk_hw*[]) {
2026 &cam_cc_jpeg_clk_src.clkr.hw,
2027 },
2028 .num_parents = 1,
2029 .flags = CLK_SET_RATE_PARENT,
2030 .ops = &clk_branch2_ops,
2031 },
2032 },
2033 };
2034
2035 static struct clk_branch cam_cc_mclk0_clk = {
2036 .halt_reg = 0x15018,
2037 .halt_check = BRANCH_HALT,
2038 .clkr = {
2039 .enable_reg = 0x15018,
2040 .enable_mask = BIT(0),
2041 .hw.init = &(const struct clk_init_data) {
2042 .name = "cam_cc_mclk0_clk",
2043 .parent_hws = (const struct clk_hw*[]) {
2044 &cam_cc_mclk0_clk_src.clkr.hw,
2045 },
2046 .num_parents = 1,
2047 .flags = CLK_SET_RATE_PARENT,
2048 .ops = &clk_branch2_ops,
2049 },
2050 },
2051 };
2052
2053 static struct clk_branch cam_cc_mclk1_clk = {
2054 .halt_reg = 0x15034,
2055 .halt_check = BRANCH_HALT,
2056 .clkr = {
2057 .enable_reg = 0x15034,
2058 .enable_mask = BIT(0),
2059 .hw.init = &(const struct clk_init_data) {
2060 .name = "cam_cc_mclk1_clk",
2061 .parent_hws = (const struct clk_hw*[]) {
2062 &cam_cc_mclk1_clk_src.clkr.hw,
2063 },
2064 .num_parents = 1,
2065 .flags = CLK_SET_RATE_PARENT,
2066 .ops = &clk_branch2_ops,
2067 },
2068 },
2069 };
2070
2071 static struct clk_branch cam_cc_mclk2_clk = {
2072 .halt_reg = 0x15050,
2073 .halt_check = BRANCH_HALT,
2074 .clkr = {
2075 .enable_reg = 0x15050,
2076 .enable_mask = BIT(0),
2077 .hw.init = &(const struct clk_init_data) {
2078 .name = "cam_cc_mclk2_clk",
2079 .parent_hws = (const struct clk_hw*[]) {
2080 &cam_cc_mclk2_clk_src.clkr.hw,
2081 },
2082 .num_parents = 1,
2083 .flags = CLK_SET_RATE_PARENT,
2084 .ops = &clk_branch2_ops,
2085 },
2086 },
2087 };
2088
2089 static struct clk_branch cam_cc_mclk3_clk = {
2090 .halt_reg = 0x1506c,
2091 .halt_check = BRANCH_HALT,
2092 .clkr = {
2093 .enable_reg = 0x1506c,
2094 .enable_mask = BIT(0),
2095 .hw.init = &(const struct clk_init_data) {
2096 .name = "cam_cc_mclk3_clk",
2097 .parent_hws = (const struct clk_hw*[]) {
2098 &cam_cc_mclk3_clk_src.clkr.hw,
2099 },
2100 .num_parents = 1,
2101 .flags = CLK_SET_RATE_PARENT,
2102 .ops = &clk_branch2_ops,
2103 },
2104 },
2105 };
2106
2107 static struct clk_branch cam_cc_mclk4_clk = {
2108 .halt_reg = 0x15088,
2109 .halt_check = BRANCH_HALT,
2110 .clkr = {
2111 .enable_reg = 0x15088,
2112 .enable_mask = BIT(0),
2113 .hw.init = &(const struct clk_init_data) {
2114 .name = "cam_cc_mclk4_clk",
2115 .parent_hws = (const struct clk_hw*[]) {
2116 &cam_cc_mclk4_clk_src.clkr.hw,
2117 },
2118 .num_parents = 1,
2119 .flags = CLK_SET_RATE_PARENT,
2120 .ops = &clk_branch2_ops,
2121 },
2122 },
2123 };
2124
2125 static struct clk_branch cam_cc_mclk5_clk = {
2126 .halt_reg = 0x150a4,
2127 .halt_check = BRANCH_HALT,
2128 .clkr = {
2129 .enable_reg = 0x150a4,
2130 .enable_mask = BIT(0),
2131 .hw.init = &(const struct clk_init_data) {
2132 .name = "cam_cc_mclk5_clk",
2133 .parent_hws = (const struct clk_hw*[]) {
2134 &cam_cc_mclk5_clk_src.clkr.hw,
2135 },
2136 .num_parents = 1,
2137 .flags = CLK_SET_RATE_PARENT,
2138 .ops = &clk_branch2_ops,
2139 },
2140 },
2141 };
2142
2143 static struct clk_branch cam_cc_mclk6_clk = {
2144 .halt_reg = 0x150c0,
2145 .halt_check = BRANCH_HALT,
2146 .clkr = {
2147 .enable_reg = 0x150c0,
2148 .enable_mask = BIT(0),
2149 .hw.init = &(const struct clk_init_data) {
2150 .name = "cam_cc_mclk6_clk",
2151 .parent_hws = (const struct clk_hw*[]) {
2152 &cam_cc_mclk6_clk_src.clkr.hw,
2153 },
2154 .num_parents = 1,
2155 .flags = CLK_SET_RATE_PARENT,
2156 .ops = &clk_branch2_ops,
2157 },
2158 },
2159 };
2160
2161 static struct clk_branch cam_cc_mclk7_clk = {
2162 .halt_reg = 0x150dc,
2163 .halt_check = BRANCH_HALT,
2164 .clkr = {
2165 .enable_reg = 0x150dc,
2166 .enable_mask = BIT(0),
2167 .hw.init = &(const struct clk_init_data) {
2168 .name = "cam_cc_mclk7_clk",
2169 .parent_hws = (const struct clk_hw*[]) {
2170 &cam_cc_mclk7_clk_src.clkr.hw,
2171 },
2172 .num_parents = 1,
2173 .flags = CLK_SET_RATE_PARENT,
2174 .ops = &clk_branch2_ops,
2175 },
2176 },
2177 };
2178
2179 static struct clk_branch cam_cc_sfe_0_clk = {
2180 .halt_reg = 0x133c0,
2181 .halt_check = BRANCH_HALT,
2182 .clkr = {
2183 .enable_reg = 0x133c0,
2184 .enable_mask = BIT(0),
2185 .hw.init = &(const struct clk_init_data) {
2186 .name = "cam_cc_sfe_0_clk",
2187 .parent_hws = (const struct clk_hw*[]) {
2188 &cam_cc_sfe_0_clk_src.clkr.hw,
2189 },
2190 .num_parents = 1,
2191 .flags = CLK_SET_RATE_PARENT,
2192 .ops = &clk_branch2_ops,
2193 },
2194 },
2195 };
2196
2197 static struct clk_branch cam_cc_sfe_0_fast_ahb_clk = {
2198 .halt_reg = 0x133d8,
2199 .halt_check = BRANCH_HALT,
2200 .clkr = {
2201 .enable_reg = 0x133d8,
2202 .enable_mask = BIT(0),
2203 .hw.init = &(const struct clk_init_data) {
2204 .name = "cam_cc_sfe_0_fast_ahb_clk",
2205 .parent_hws = (const struct clk_hw*[]) {
2206 &cam_cc_fast_ahb_clk_src.clkr.hw,
2207 },
2208 .num_parents = 1,
2209 .flags = CLK_SET_RATE_PARENT,
2210 .ops = &clk_branch2_ops,
2211 },
2212 },
2213 };
2214
2215 static struct gdsc cam_cc_bps_gdsc = {
2216 .gdscr = 0x10004,
2217 .en_rest_wait_val = 0x2,
2218 .en_few_wait_val = 0x2,
2219 .clk_dis_wait_val = 0xf,
2220 .pd = {
2221 .name = "cam_cc_bps_gdsc",
2222 },
2223 .pwrsts = PWRSTS_OFF_ON,
2224 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
2225 };
2226
2227 static struct gdsc cam_cc_ife_0_gdsc = {
2228 .gdscr = 0x11004,
2229 .en_rest_wait_val = 0x2,
2230 .en_few_wait_val = 0x2,
2231 .clk_dis_wait_val = 0xf,
2232 .pd = {
2233 .name = "cam_cc_ife_0_gdsc",
2234 },
2235 .pwrsts = PWRSTS_OFF_ON,
2236 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
2237 };
2238
2239 static struct gdsc cam_cc_ife_1_gdsc = {
2240 .gdscr = 0x12004,
2241 .en_rest_wait_val = 0x2,
2242 .en_few_wait_val = 0x2,
2243 .clk_dis_wait_val = 0xf,
2244 .pd = {
2245 .name = "cam_cc_ife_1_gdsc",
2246 },
2247 .pwrsts = PWRSTS_OFF_ON,
2248 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
2249 };
2250
2251 static struct gdsc cam_cc_ipe_0_gdsc = {
2252 .gdscr = 0x103b8,
2253 .en_rest_wait_val = 0x2,
2254 .en_few_wait_val = 0x2,
2255 .clk_dis_wait_val = 0xf,
2256 .pd = {
2257 .name = "cam_cc_ipe_0_gdsc",
2258 },
2259 .pwrsts = PWRSTS_OFF_ON,
2260 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
2261 };
2262
2263 static struct gdsc cam_cc_sfe_0_gdsc = {
2264 .gdscr = 0x13280,
2265 .en_rest_wait_val = 0x2,
2266 .en_few_wait_val = 0x2,
2267 .clk_dis_wait_val = 0xf,
2268 .pd = {
2269 .name = "cam_cc_sfe_0_gdsc",
2270 },
2271 .pwrsts = PWRSTS_OFF_ON,
2272 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
2273 };
2274
2275 static struct gdsc cam_cc_titan_top_gdsc = {
2276 .gdscr = 0x13a6c,
2277 .en_rest_wait_val = 0x2,
2278 .en_few_wait_val = 0x2,
2279 .clk_dis_wait_val = 0xf,
2280 .pd = {
2281 .name = "cam_cc_titan_top_gdsc",
2282 },
2283 .pwrsts = PWRSTS_OFF_ON,
2284 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
2285 };
2286
2287 static struct clk_regmap *cam_cc_x1e80100_clocks[] = {
2288 [CAM_CC_BPS_AHB_CLK] = &cam_cc_bps_ahb_clk.clkr,
2289 [CAM_CC_BPS_CLK] = &cam_cc_bps_clk.clkr,
2290 [CAM_CC_BPS_CLK_SRC] = &cam_cc_bps_clk_src.clkr,
2291 [CAM_CC_BPS_FAST_AHB_CLK] = &cam_cc_bps_fast_ahb_clk.clkr,
2292 [CAM_CC_CAMNOC_AXI_NRT_CLK] = &cam_cc_camnoc_axi_nrt_clk.clkr,
2293 [CAM_CC_CAMNOC_AXI_RT_CLK] = &cam_cc_camnoc_axi_rt_clk.clkr,
2294 [CAM_CC_CAMNOC_AXI_RT_CLK_SRC] = &cam_cc_camnoc_axi_rt_clk_src.clkr,
2295 [CAM_CC_CAMNOC_DCD_XO_CLK] = &cam_cc_camnoc_dcd_xo_clk.clkr,
2296 [CAM_CC_CAMNOC_XO_CLK] = &cam_cc_camnoc_xo_clk.clkr,
2297 [CAM_CC_CCI_0_CLK] = &cam_cc_cci_0_clk.clkr,
2298 [CAM_CC_CCI_0_CLK_SRC] = &cam_cc_cci_0_clk_src.clkr,
2299 [CAM_CC_CCI_1_CLK] = &cam_cc_cci_1_clk.clkr,
2300 [CAM_CC_CCI_1_CLK_SRC] = &cam_cc_cci_1_clk_src.clkr,
2301 [CAM_CC_CORE_AHB_CLK] = &cam_cc_core_ahb_clk.clkr,
2302 [CAM_CC_CPAS_AHB_CLK] = &cam_cc_cpas_ahb_clk.clkr,
2303 [CAM_CC_CPAS_BPS_CLK] = &cam_cc_cpas_bps_clk.clkr,
2304 [CAM_CC_CPAS_FAST_AHB_CLK] = &cam_cc_cpas_fast_ahb_clk.clkr,
2305 [CAM_CC_CPAS_IFE_0_CLK] = &cam_cc_cpas_ife_0_clk.clkr,
2306 [CAM_CC_CPAS_IFE_1_CLK] = &cam_cc_cpas_ife_1_clk.clkr,
2307 [CAM_CC_CPAS_IFE_LITE_CLK] = &cam_cc_cpas_ife_lite_clk.clkr,
2308 [CAM_CC_CPAS_IPE_NPS_CLK] = &cam_cc_cpas_ipe_nps_clk.clkr,
2309 [CAM_CC_CPAS_SFE_0_CLK] = &cam_cc_cpas_sfe_0_clk.clkr,
2310 [CAM_CC_CPHY_RX_CLK_SRC] = &cam_cc_cphy_rx_clk_src.clkr,
2311 [CAM_CC_CSI0PHYTIMER_CLK] = &cam_cc_csi0phytimer_clk.clkr,
2312 [CAM_CC_CSI0PHYTIMER_CLK_SRC] = &cam_cc_csi0phytimer_clk_src.clkr,
2313 [CAM_CC_CSI1PHYTIMER_CLK] = &cam_cc_csi1phytimer_clk.clkr,
2314 [CAM_CC_CSI1PHYTIMER_CLK_SRC] = &cam_cc_csi1phytimer_clk_src.clkr,
2315 [CAM_CC_CSI2PHYTIMER_CLK] = &cam_cc_csi2phytimer_clk.clkr,
2316 [CAM_CC_CSI2PHYTIMER_CLK_SRC] = &cam_cc_csi2phytimer_clk_src.clkr,
2317 [CAM_CC_CSI3PHYTIMER_CLK] = &cam_cc_csi3phytimer_clk.clkr,
2318 [CAM_CC_CSI3PHYTIMER_CLK_SRC] = &cam_cc_csi3phytimer_clk_src.clkr,
2319 [CAM_CC_CSI4PHYTIMER_CLK] = &cam_cc_csi4phytimer_clk.clkr,
2320 [CAM_CC_CSI4PHYTIMER_CLK_SRC] = &cam_cc_csi4phytimer_clk_src.clkr,
2321 [CAM_CC_CSI5PHYTIMER_CLK] = &cam_cc_csi5phytimer_clk.clkr,
2322 [CAM_CC_CSI5PHYTIMER_CLK_SRC] = &cam_cc_csi5phytimer_clk_src.clkr,
2323 [CAM_CC_CSID_CLK] = &cam_cc_csid_clk.clkr,
2324 [CAM_CC_CSID_CLK_SRC] = &cam_cc_csid_clk_src.clkr,
2325 [CAM_CC_CSID_CSIPHY_RX_CLK] = &cam_cc_csid_csiphy_rx_clk.clkr,
2326 [CAM_CC_CSIPHY0_CLK] = &cam_cc_csiphy0_clk.clkr,
2327 [CAM_CC_CSIPHY1_CLK] = &cam_cc_csiphy1_clk.clkr,
2328 [CAM_CC_CSIPHY2_CLK] = &cam_cc_csiphy2_clk.clkr,
2329 [CAM_CC_CSIPHY3_CLK] = &cam_cc_csiphy3_clk.clkr,
2330 [CAM_CC_CSIPHY4_CLK] = &cam_cc_csiphy4_clk.clkr,
2331 [CAM_CC_CSIPHY5_CLK] = &cam_cc_csiphy5_clk.clkr,
2332 [CAM_CC_FAST_AHB_CLK_SRC] = &cam_cc_fast_ahb_clk_src.clkr,
2333 [CAM_CC_ICP_AHB_CLK] = &cam_cc_icp_ahb_clk.clkr,
2334 [CAM_CC_ICP_CLK] = &cam_cc_icp_clk.clkr,
2335 [CAM_CC_ICP_CLK_SRC] = &cam_cc_icp_clk_src.clkr,
2336 [CAM_CC_IFE_0_CLK] = &cam_cc_ife_0_clk.clkr,
2337 [CAM_CC_IFE_0_CLK_SRC] = &cam_cc_ife_0_clk_src.clkr,
2338 [CAM_CC_IFE_0_DSP_CLK] = &cam_cc_ife_0_dsp_clk.clkr,
2339 [CAM_CC_IFE_0_FAST_AHB_CLK] = &cam_cc_ife_0_fast_ahb_clk.clkr,
2340 [CAM_CC_IFE_1_CLK] = &cam_cc_ife_1_clk.clkr,
2341 [CAM_CC_IFE_1_CLK_SRC] = &cam_cc_ife_1_clk_src.clkr,
2342 [CAM_CC_IFE_1_DSP_CLK] = &cam_cc_ife_1_dsp_clk.clkr,
2343 [CAM_CC_IFE_1_FAST_AHB_CLK] = &cam_cc_ife_1_fast_ahb_clk.clkr,
2344 [CAM_CC_IFE_LITE_AHB_CLK] = &cam_cc_ife_lite_ahb_clk.clkr,
2345 [CAM_CC_IFE_LITE_CLK] = &cam_cc_ife_lite_clk.clkr,
2346 [CAM_CC_IFE_LITE_CLK_SRC] = &cam_cc_ife_lite_clk_src.clkr,
2347 [CAM_CC_IFE_LITE_CPHY_RX_CLK] = &cam_cc_ife_lite_cphy_rx_clk.clkr,
2348 [CAM_CC_IFE_LITE_CSID_CLK] = &cam_cc_ife_lite_csid_clk.clkr,
2349 [CAM_CC_IFE_LITE_CSID_CLK_SRC] = &cam_cc_ife_lite_csid_clk_src.clkr,
2350 [CAM_CC_IPE_NPS_AHB_CLK] = &cam_cc_ipe_nps_ahb_clk.clkr,
2351 [CAM_CC_IPE_NPS_CLK] = &cam_cc_ipe_nps_clk.clkr,
2352 [CAM_CC_IPE_NPS_CLK_SRC] = &cam_cc_ipe_nps_clk_src.clkr,
2353 [CAM_CC_IPE_NPS_FAST_AHB_CLK] = &cam_cc_ipe_nps_fast_ahb_clk.clkr,
2354 [CAM_CC_IPE_PPS_CLK] = &cam_cc_ipe_pps_clk.clkr,
2355 [CAM_CC_IPE_PPS_FAST_AHB_CLK] = &cam_cc_ipe_pps_fast_ahb_clk.clkr,
2356 [CAM_CC_JPEG_CLK] = &cam_cc_jpeg_clk.clkr,
2357 [CAM_CC_JPEG_CLK_SRC] = &cam_cc_jpeg_clk_src.clkr,
2358 [CAM_CC_MCLK0_CLK] = &cam_cc_mclk0_clk.clkr,
2359 [CAM_CC_MCLK0_CLK_SRC] = &cam_cc_mclk0_clk_src.clkr,
2360 [CAM_CC_MCLK1_CLK] = &cam_cc_mclk1_clk.clkr,
2361 [CAM_CC_MCLK1_CLK_SRC] = &cam_cc_mclk1_clk_src.clkr,
2362 [CAM_CC_MCLK2_CLK] = &cam_cc_mclk2_clk.clkr,
2363 [CAM_CC_MCLK2_CLK_SRC] = &cam_cc_mclk2_clk_src.clkr,
2364 [CAM_CC_MCLK3_CLK] = &cam_cc_mclk3_clk.clkr,
2365 [CAM_CC_MCLK3_CLK_SRC] = &cam_cc_mclk3_clk_src.clkr,
2366 [CAM_CC_MCLK4_CLK] = &cam_cc_mclk4_clk.clkr,
2367 [CAM_CC_MCLK4_CLK_SRC] = &cam_cc_mclk4_clk_src.clkr,
2368 [CAM_CC_MCLK5_CLK] = &cam_cc_mclk5_clk.clkr,
2369 [CAM_CC_MCLK5_CLK_SRC] = &cam_cc_mclk5_clk_src.clkr,
2370 [CAM_CC_MCLK6_CLK] = &cam_cc_mclk6_clk.clkr,
2371 [CAM_CC_MCLK6_CLK_SRC] = &cam_cc_mclk6_clk_src.clkr,
2372 [CAM_CC_MCLK7_CLK] = &cam_cc_mclk7_clk.clkr,
2373 [CAM_CC_MCLK7_CLK_SRC] = &cam_cc_mclk7_clk_src.clkr,
2374 [CAM_CC_PLL0] = &cam_cc_pll0.clkr,
2375 [CAM_CC_PLL0_OUT_EVEN] = &cam_cc_pll0_out_even.clkr,
2376 [CAM_CC_PLL0_OUT_ODD] = &cam_cc_pll0_out_odd.clkr,
2377 [CAM_CC_PLL1] = &cam_cc_pll1.clkr,
2378 [CAM_CC_PLL1_OUT_EVEN] = &cam_cc_pll1_out_even.clkr,
2379 [CAM_CC_PLL2] = &cam_cc_pll2.clkr,
2380 [CAM_CC_PLL3] = &cam_cc_pll3.clkr,
2381 [CAM_CC_PLL3_OUT_EVEN] = &cam_cc_pll3_out_even.clkr,
2382 [CAM_CC_PLL4] = &cam_cc_pll4.clkr,
2383 [CAM_CC_PLL4_OUT_EVEN] = &cam_cc_pll4_out_even.clkr,
2384 [CAM_CC_PLL6] = &cam_cc_pll6.clkr,
2385 [CAM_CC_PLL6_OUT_EVEN] = &cam_cc_pll6_out_even.clkr,
2386 [CAM_CC_PLL8] = &cam_cc_pll8.clkr,
2387 [CAM_CC_PLL8_OUT_EVEN] = &cam_cc_pll8_out_even.clkr,
2388 [CAM_CC_SFE_0_CLK] = &cam_cc_sfe_0_clk.clkr,
2389 [CAM_CC_SFE_0_CLK_SRC] = &cam_cc_sfe_0_clk_src.clkr,
2390 [CAM_CC_SFE_0_FAST_AHB_CLK] = &cam_cc_sfe_0_fast_ahb_clk.clkr,
2391 [CAM_CC_SLEEP_CLK_SRC] = &cam_cc_sleep_clk_src.clkr,
2392 [CAM_CC_SLOW_AHB_CLK_SRC] = &cam_cc_slow_ahb_clk_src.clkr,
2393 [CAM_CC_XO_CLK_SRC] = &cam_cc_xo_clk_src.clkr,
2394 };
2395
2396 static struct gdsc *cam_cc_x1e80100_gdscs[] = {
2397 [CAM_CC_BPS_GDSC] = &cam_cc_bps_gdsc,
2398 [CAM_CC_IFE_0_GDSC] = &cam_cc_ife_0_gdsc,
2399 [CAM_CC_IFE_1_GDSC] = &cam_cc_ife_1_gdsc,
2400 [CAM_CC_IPE_0_GDSC] = &cam_cc_ipe_0_gdsc,
2401 [CAM_CC_SFE_0_GDSC] = &cam_cc_sfe_0_gdsc,
2402 [CAM_CC_TITAN_TOP_GDSC] = &cam_cc_titan_top_gdsc,
2403 };
2404
2405 static const struct qcom_reset_map cam_cc_x1e80100_resets[] = {
2406 [CAM_CC_BPS_BCR] = { 0x10000 },
2407 [CAM_CC_ICP_BCR] = { 0x1351c },
2408 [CAM_CC_IFE_0_BCR] = { 0x11000 },
2409 [CAM_CC_IFE_1_BCR] = { 0x12000 },
2410 [CAM_CC_IPE_0_BCR] = { 0x103b4 },
2411 [CAM_CC_SFE_0_BCR] = { 0x1327c },
2412 };
2413
2414 static const struct regmap_config cam_cc_x1e80100_regmap_config = {
2415 .reg_bits = 32,
2416 .reg_stride = 4,
2417 .val_bits = 32,
2418 .max_register = 0x1603c,
2419 .fast_io = true,
2420 };
2421
2422 static const struct qcom_cc_desc cam_cc_x1e80100_desc = {
2423 .config = &cam_cc_x1e80100_regmap_config,
2424 .clks = cam_cc_x1e80100_clocks,
2425 .num_clks = ARRAY_SIZE(cam_cc_x1e80100_clocks),
2426 .resets = cam_cc_x1e80100_resets,
2427 .num_resets = ARRAY_SIZE(cam_cc_x1e80100_resets),
2428 .gdscs = cam_cc_x1e80100_gdscs,
2429 .num_gdscs = ARRAY_SIZE(cam_cc_x1e80100_gdscs),
2430 };
2431
2432 static const struct of_device_id cam_cc_x1e80100_match_table[] = {
2433 { .compatible = "qcom,x1e80100-camcc" },
2434 { }
2435 };
2436 MODULE_DEVICE_TABLE(of, cam_cc_x1e80100_match_table);
2437
cam_cc_x1e80100_probe(struct platform_device * pdev)2438 static int cam_cc_x1e80100_probe(struct platform_device *pdev)
2439 {
2440 struct regmap *regmap;
2441 int ret;
2442
2443 ret = devm_pm_runtime_enable(&pdev->dev);
2444 if (ret)
2445 return ret;
2446
2447 ret = pm_runtime_resume_and_get(&pdev->dev);
2448 if (ret)
2449 return ret;
2450
2451 regmap = qcom_cc_map(pdev, &cam_cc_x1e80100_desc);
2452 if (IS_ERR(regmap)) {
2453 pm_runtime_put(&pdev->dev);
2454 return PTR_ERR(regmap);
2455 }
2456
2457 clk_lucid_ole_pll_configure(&cam_cc_pll0, regmap, &cam_cc_pll0_config);
2458 clk_lucid_ole_pll_configure(&cam_cc_pll1, regmap, &cam_cc_pll1_config);
2459 clk_rivian_evo_pll_configure(&cam_cc_pll2, regmap, &cam_cc_pll2_config);
2460 clk_lucid_ole_pll_configure(&cam_cc_pll3, regmap, &cam_cc_pll3_config);
2461 clk_lucid_ole_pll_configure(&cam_cc_pll4, regmap, &cam_cc_pll4_config);
2462 clk_lucid_ole_pll_configure(&cam_cc_pll6, regmap, &cam_cc_pll6_config);
2463 clk_lucid_ole_pll_configure(&cam_cc_pll8, regmap, &cam_cc_pll8_config);
2464
2465 /* Keep clocks always enabled */
2466 qcom_branch_set_clk_en(regmap, 0x13a9c); /* CAM_CC_GDSC_CLK */
2467 qcom_branch_set_clk_en(regmap, 0x13ab8); /* CAM_CC_SLEEP_CLK */
2468
2469 ret = qcom_cc_really_probe(&pdev->dev, &cam_cc_x1e80100_desc, regmap);
2470
2471 pm_runtime_put(&pdev->dev);
2472
2473 return ret;
2474 }
2475
2476 static struct platform_driver cam_cc_x1e80100_driver = {
2477 .probe = cam_cc_x1e80100_probe,
2478 .driver = {
2479 .name = "camcc-x1e80100",
2480 .of_match_table = cam_cc_x1e80100_match_table,
2481 },
2482 };
2483
2484 module_platform_driver(cam_cc_x1e80100_driver);
2485
2486 MODULE_DESCRIPTION("QTI Camera Clock Controller X1E80100 Driver");
2487 MODULE_LICENSE("GPL");
2488