1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
4 * Copyright (c) 2020, Linaro Ltd.
5 */
6
7 #include <linux/clk-provider.h>
8 #include <linux/module.h>
9 #include <linux/platform_device.h>
10 #include <linux/regmap.h>
11
12 #include <dt-bindings/clock/qcom,gcc-sdx55.h>
13
14 #include "common.h"
15 #include "clk-alpha-pll.h"
16 #include "clk-branch.h"
17 #include "clk-pll.h"
18 #include "clk-rcg.h"
19 #include "clk-regmap.h"
20 #include "gdsc.h"
21 #include "reset.h"
22
23 enum {
24 P_BI_TCXO,
25 P_CORE_BI_PLL_TEST_SE,
26 P_GPLL0_OUT_EVEN,
27 P_GPLL0_OUT_MAIN,
28 P_GPLL4_OUT_EVEN,
29 P_GPLL5_OUT_MAIN,
30 P_SLEEP_CLK,
31 };
32
33 static const struct pll_vco lucid_vco[] = {
34 { 249600000, 2000000000, 0 },
35 };
36
37 static struct clk_alpha_pll gpll0 = {
38 .offset = 0x0,
39 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID],
40 .vco_table = lucid_vco,
41 .num_vco = ARRAY_SIZE(lucid_vco),
42 .clkr = {
43 .enable_reg = 0x6d000,
44 .enable_mask = BIT(0),
45 .hw.init = &(struct clk_init_data){
46 .name = "gpll0",
47 .parent_data = &(const struct clk_parent_data){
48 .fw_name = "bi_tcxo",
49 },
50 .num_parents = 1,
51 .ops = &clk_alpha_pll_fixed_lucid_ops,
52 },
53 },
54 };
55
56 static const struct clk_div_table post_div_table_lucid_even[] = {
57 { 0x0, 1 },
58 { 0x1, 2 },
59 { 0x3, 4 },
60 { 0x7, 8 },
61 { }
62 };
63
64 static struct clk_alpha_pll_postdiv gpll0_out_even = {
65 .offset = 0x0,
66 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID],
67 .post_div_shift = 8,
68 .post_div_table = post_div_table_lucid_even,
69 .num_post_div = ARRAY_SIZE(post_div_table_lucid_even),
70 .width = 4,
71 .clkr.hw.init = &(struct clk_init_data){
72 .name = "gpll0_out_even",
73 .parent_hws = (const struct clk_hw*[]){
74 &gpll0.clkr.hw,
75 },
76 .num_parents = 1,
77 .ops = &clk_alpha_pll_postdiv_lucid_ops,
78 },
79 };
80
81 static struct clk_alpha_pll gpll4 = {
82 .offset = 0x76000,
83 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID],
84 .vco_table = lucid_vco,
85 .num_vco = ARRAY_SIZE(lucid_vco),
86 .clkr = {
87 .enable_reg = 0x6d000,
88 .enable_mask = BIT(4),
89 .hw.init = &(struct clk_init_data){
90 .name = "gpll4",
91 .parent_data = &(const struct clk_parent_data){
92 .fw_name = "bi_tcxo",
93 },
94 .num_parents = 1,
95 .ops = &clk_alpha_pll_fixed_lucid_ops,
96 },
97 },
98 };
99
100 static struct clk_alpha_pll_postdiv gpll4_out_even = {
101 .offset = 0x76000,
102 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID],
103 .post_div_shift = 8,
104 .post_div_table = post_div_table_lucid_even,
105 .num_post_div = ARRAY_SIZE(post_div_table_lucid_even),
106 .width = 4,
107 .clkr.hw.init = &(struct clk_init_data){
108 .name = "gpll4_out_even",
109 .parent_hws = (const struct clk_hw*[]){
110 &gpll4.clkr.hw,
111 },
112 .num_parents = 1,
113 .ops = &clk_alpha_pll_postdiv_lucid_ops,
114 },
115 };
116
117 static struct clk_alpha_pll gpll5 = {
118 .offset = 0x74000,
119 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID],
120 .vco_table = lucid_vco,
121 .num_vco = ARRAY_SIZE(lucid_vco),
122 .clkr = {
123 .enable_reg = 0x6d000,
124 .enable_mask = BIT(5),
125 .hw.init = &(struct clk_init_data){
126 .name = "gpll5",
127 .parent_data = &(const struct clk_parent_data){
128 .fw_name = "bi_tcxo",
129 },
130 .num_parents = 1,
131 .ops = &clk_alpha_pll_fixed_lucid_ops,
132 },
133 },
134 };
135
136 static const struct parent_map gcc_parent_map_0[] = {
137 { P_BI_TCXO, 0 },
138 { P_GPLL0_OUT_MAIN, 1 },
139 { P_GPLL0_OUT_EVEN, 6 },
140 { P_CORE_BI_PLL_TEST_SE, 7 },
141 };
142
143 static const struct clk_parent_data gcc_parents_0[] = {
144 { .fw_name = "bi_tcxo" },
145 { .hw = &gpll0.clkr.hw },
146 { .hw = &gpll0_out_even.clkr.hw },
147 { .fw_name = "core_bi_pll_test_se" },
148 };
149
150 static const struct clk_parent_data gcc_parents_0_ao[] = {
151 { .fw_name = "bi_tcxo_ao" },
152 { .hw = &gpll0.clkr.hw },
153 { .hw = &gpll0_out_even.clkr.hw },
154 { .fw_name = "core_bi_pll_test_se" },
155 };
156
157 static const struct parent_map gcc_parent_map_2[] = {
158 { P_BI_TCXO, 0 },
159 { P_GPLL0_OUT_MAIN, 1 },
160 { P_GPLL4_OUT_EVEN, 2 },
161 { P_GPLL5_OUT_MAIN, 5 },
162 { P_GPLL0_OUT_EVEN, 6 },
163 { P_CORE_BI_PLL_TEST_SE, 7 },
164 };
165
166 static const struct clk_parent_data gcc_parents_2[] = {
167 { .fw_name = "bi_tcxo" },
168 { .hw = &gpll0.clkr.hw },
169 { .hw = &gpll4_out_even.clkr.hw },
170 { .hw = &gpll5.clkr.hw },
171 { .hw = &gpll0_out_even.clkr.hw },
172 { .fw_name = "core_bi_pll_test_se" },
173 };
174
175 static const struct parent_map gcc_parent_map_3[] = {
176 { P_BI_TCXO, 0 },
177 { P_GPLL0_OUT_MAIN, 1 },
178 { P_SLEEP_CLK, 5 },
179 { P_GPLL0_OUT_EVEN, 6 },
180 { P_CORE_BI_PLL_TEST_SE, 7 },
181 };
182
183 static const struct clk_parent_data gcc_parents_3[] = {
184 { .fw_name = "bi_tcxo" },
185 { .hw = &gpll0.clkr.hw },
186 { .fw_name = "sleep_clk", .name = "sleep_clk" },
187 { .hw = &gpll0_out_even.clkr.hw },
188 { .fw_name = "core_bi_pll_test_se" },
189 };
190
191 static const struct parent_map gcc_parent_map_4[] = {
192 { P_BI_TCXO, 0 },
193 { P_SLEEP_CLK, 5 },
194 { P_CORE_BI_PLL_TEST_SE, 7 },
195 };
196
197 static const struct clk_parent_data gcc_parents_4[] = {
198 { .fw_name = "bi_tcxo" },
199 { .fw_name = "sleep_clk", .name = "sleep_clk" },
200 { .fw_name = "core_bi_pll_test_se" },
201 };
202
203 static const struct parent_map gcc_parent_map_5[] = {
204 { P_BI_TCXO, 0 },
205 { P_GPLL0_OUT_MAIN, 1 },
206 { P_GPLL4_OUT_EVEN, 2 },
207 { P_GPLL0_OUT_EVEN, 6 },
208 { P_CORE_BI_PLL_TEST_SE, 7 },
209 };
210
211 static const struct clk_parent_data gcc_parents_5[] = {
212 { .fw_name = "bi_tcxo" },
213 { .hw = &gpll0.clkr.hw },
214 { .hw = &gpll4_out_even.clkr.hw },
215 { .hw = &gpll0_out_even.clkr.hw },
216 { .fw_name = "core_bi_pll_test_se" },
217 };
218
219 static const struct freq_tbl ftbl_gcc_blsp1_qup1_i2c_apps_clk_src[] = {
220 F(9600000, P_BI_TCXO, 2, 0, 0),
221 F(19200000, P_BI_TCXO, 1, 0, 0),
222 F(50000000, P_GPLL0_OUT_MAIN, 12, 0, 0),
223 { }
224 };
225
226 static struct clk_rcg2 gcc_blsp1_qup1_i2c_apps_clk_src = {
227 .cmd_rcgr = 0x11024,
228 .mnd_width = 8,
229 .hid_width = 5,
230 .parent_map = gcc_parent_map_0,
231 .freq_tbl = ftbl_gcc_blsp1_qup1_i2c_apps_clk_src,
232 .clkr.hw.init = &(struct clk_init_data){
233 .name = "gcc_blsp1_qup1_i2c_apps_clk_src",
234 .parent_data = gcc_parents_0,
235 .num_parents = 4,
236 .ops = &clk_rcg2_ops,
237 },
238 };
239
240 static const struct freq_tbl ftbl_gcc_blsp1_qup1_spi_apps_clk_src[] = {
241 F(960000, P_BI_TCXO, 10, 1, 2),
242 F(4800000, P_BI_TCXO, 4, 0, 0),
243 F(9600000, P_BI_TCXO, 2, 0, 0),
244 F(15000000, P_GPLL0_OUT_EVEN, 5, 1, 4),
245 F(19200000, P_BI_TCXO, 1, 0, 0),
246 F(24000000, P_GPLL0_OUT_MAIN, 12.5, 1, 2),
247 F(25000000, P_GPLL0_OUT_MAIN, 12, 1, 2),
248 F(50000000, P_GPLL0_OUT_MAIN, 12, 0, 0),
249 { }
250 };
251
252 static struct clk_rcg2 gcc_blsp1_qup1_spi_apps_clk_src = {
253 .cmd_rcgr = 0x1100c,
254 .mnd_width = 8,
255 .hid_width = 5,
256 .parent_map = gcc_parent_map_0,
257 .freq_tbl = ftbl_gcc_blsp1_qup1_spi_apps_clk_src,
258 .clkr.hw.init = &(struct clk_init_data){
259 .name = "gcc_blsp1_qup1_spi_apps_clk_src",
260 .parent_data = gcc_parents_0,
261 .num_parents = 4,
262 .ops = &clk_rcg2_ops,
263 },
264 };
265
266 static struct clk_rcg2 gcc_blsp1_qup2_i2c_apps_clk_src = {
267 .cmd_rcgr = 0x13024,
268 .mnd_width = 8,
269 .hid_width = 5,
270 .parent_map = gcc_parent_map_0,
271 .freq_tbl = ftbl_gcc_blsp1_qup1_i2c_apps_clk_src,
272 .clkr.hw.init = &(struct clk_init_data){
273 .name = "gcc_blsp1_qup2_i2c_apps_clk_src",
274 .parent_data = gcc_parents_0,
275 .num_parents = 4,
276 .ops = &clk_rcg2_ops,
277 },
278 };
279
280 static struct clk_rcg2 gcc_blsp1_qup2_spi_apps_clk_src = {
281 .cmd_rcgr = 0x1300c,
282 .mnd_width = 8,
283 .hid_width = 5,
284 .parent_map = gcc_parent_map_0,
285 .freq_tbl = ftbl_gcc_blsp1_qup1_spi_apps_clk_src,
286 .clkr.hw.init = &(struct clk_init_data){
287 .name = "gcc_blsp1_qup2_spi_apps_clk_src",
288 .parent_data = gcc_parents_0,
289 .num_parents = 4,
290 .ops = &clk_rcg2_ops,
291 },
292 };
293
294 static struct clk_rcg2 gcc_blsp1_qup3_i2c_apps_clk_src = {
295 .cmd_rcgr = 0x15024,
296 .mnd_width = 8,
297 .hid_width = 5,
298 .parent_map = gcc_parent_map_0,
299 .freq_tbl = ftbl_gcc_blsp1_qup1_i2c_apps_clk_src,
300 .clkr.hw.init = &(struct clk_init_data){
301 .name = "gcc_blsp1_qup3_i2c_apps_clk_src",
302 .parent_data = gcc_parents_0,
303 .num_parents = 4,
304 .ops = &clk_rcg2_ops,
305 },
306 };
307
308 static struct clk_rcg2 gcc_blsp1_qup3_spi_apps_clk_src = {
309 .cmd_rcgr = 0x1500c,
310 .mnd_width = 8,
311 .hid_width = 5,
312 .parent_map = gcc_parent_map_0,
313 .freq_tbl = ftbl_gcc_blsp1_qup1_spi_apps_clk_src,
314 .clkr.hw.init = &(struct clk_init_data){
315 .name = "gcc_blsp1_qup3_spi_apps_clk_src",
316 .parent_data = gcc_parents_0,
317 .num_parents = 4,
318 .ops = &clk_rcg2_ops,
319 },
320 };
321
322 static struct clk_rcg2 gcc_blsp1_qup4_i2c_apps_clk_src = {
323 .cmd_rcgr = 0x17024,
324 .mnd_width = 8,
325 .hid_width = 5,
326 .parent_map = gcc_parent_map_0,
327 .freq_tbl = ftbl_gcc_blsp1_qup1_i2c_apps_clk_src,
328 .clkr.hw.init = &(struct clk_init_data){
329 .name = "gcc_blsp1_qup4_i2c_apps_clk_src",
330 .parent_data = gcc_parents_0,
331 .num_parents = 4,
332 .ops = &clk_rcg2_ops,
333 },
334 };
335
336 static struct clk_rcg2 gcc_blsp1_qup4_spi_apps_clk_src = {
337 .cmd_rcgr = 0x1700c,
338 .mnd_width = 8,
339 .hid_width = 5,
340 .parent_map = gcc_parent_map_0,
341 .freq_tbl = ftbl_gcc_blsp1_qup1_spi_apps_clk_src,
342 .clkr.hw.init = &(struct clk_init_data){
343 .name = "gcc_blsp1_qup4_spi_apps_clk_src",
344 .parent_data = gcc_parents_0,
345 .num_parents = 4,
346 .ops = &clk_rcg2_ops,
347 },
348 };
349
350 static const struct freq_tbl ftbl_gcc_blsp1_uart1_apps_clk_src[] = {
351 F(3686400, P_GPLL0_OUT_EVEN, 1, 192, 15625),
352 F(7372800, P_GPLL0_OUT_EVEN, 1, 384, 15625),
353 F(9600000, P_BI_TCXO, 2, 0, 0),
354 F(14745600, P_GPLL0_OUT_EVEN, 1, 768, 15625),
355 F(16000000, P_GPLL0_OUT_EVEN, 1, 4, 75),
356 F(19200000, P_BI_TCXO, 1, 0, 0),
357 F(19354839, P_GPLL0_OUT_MAIN, 15.5, 1, 2),
358 F(20000000, P_GPLL0_OUT_MAIN, 15, 1, 2),
359 F(20689655, P_GPLL0_OUT_MAIN, 14.5, 1, 2),
360 F(21428571, P_GPLL0_OUT_MAIN, 14, 1, 2),
361 F(22222222, P_GPLL0_OUT_MAIN, 13.5, 1, 2),
362 F(23076923, P_GPLL0_OUT_MAIN, 13, 1, 2),
363 F(24000000, P_GPLL0_OUT_MAIN, 5, 1, 5),
364 F(25000000, P_GPLL0_OUT_MAIN, 12, 1, 2),
365 F(26086957, P_GPLL0_OUT_MAIN, 11.5, 1, 2),
366 F(27272727, P_GPLL0_OUT_MAIN, 11, 1, 2),
367 F(28571429, P_GPLL0_OUT_MAIN, 10.5, 1, 2),
368 F(32000000, P_GPLL0_OUT_MAIN, 1, 4, 75),
369 F(40000000, P_GPLL0_OUT_MAIN, 15, 0, 0),
370 F(46400000, P_GPLL0_OUT_MAIN, 1, 29, 375),
371 F(48000000, P_GPLL0_OUT_MAIN, 12.5, 0, 0),
372 F(51200000, P_GPLL0_OUT_MAIN, 1, 32, 375),
373 F(56000000, P_GPLL0_OUT_MAIN, 1, 7, 75),
374 F(58982400, P_GPLL0_OUT_MAIN, 1, 1536, 15625),
375 F(60000000, P_GPLL0_OUT_MAIN, 10, 0, 0),
376 F(63157895, P_GPLL0_OUT_MAIN, 9.5, 0, 0),
377 { }
378 };
379
380 static struct clk_rcg2 gcc_blsp1_uart1_apps_clk_src = {
381 .cmd_rcgr = 0x1200c,
382 .mnd_width = 16,
383 .hid_width = 5,
384 .parent_map = gcc_parent_map_0,
385 .freq_tbl = ftbl_gcc_blsp1_uart1_apps_clk_src,
386 .clkr.hw.init = &(struct clk_init_data){
387 .name = "gcc_blsp1_uart1_apps_clk_src",
388 .parent_data = gcc_parents_0,
389 .num_parents = 4,
390 .ops = &clk_rcg2_ops,
391 },
392 };
393
394 static struct clk_rcg2 gcc_blsp1_uart2_apps_clk_src = {
395 .cmd_rcgr = 0x1400c,
396 .mnd_width = 16,
397 .hid_width = 5,
398 .parent_map = gcc_parent_map_0,
399 .freq_tbl = ftbl_gcc_blsp1_uart1_apps_clk_src,
400 .clkr.hw.init = &(struct clk_init_data){
401 .name = "gcc_blsp1_uart2_apps_clk_src",
402 .parent_data = gcc_parents_0,
403 .num_parents = 4,
404 .ops = &clk_rcg2_ops,
405 },
406 };
407
408 static struct clk_rcg2 gcc_blsp1_uart3_apps_clk_src = {
409 .cmd_rcgr = 0x1600c,
410 .mnd_width = 16,
411 .hid_width = 5,
412 .parent_map = gcc_parent_map_0,
413 .freq_tbl = ftbl_gcc_blsp1_uart1_apps_clk_src,
414 .clkr.hw.init = &(struct clk_init_data){
415 .name = "gcc_blsp1_uart3_apps_clk_src",
416 .parent_data = gcc_parents_0,
417 .num_parents = 4,
418 .ops = &clk_rcg2_ops,
419 },
420 };
421
422 static struct clk_rcg2 gcc_blsp1_uart4_apps_clk_src = {
423 .cmd_rcgr = 0x1800c,
424 .mnd_width = 16,
425 .hid_width = 5,
426 .parent_map = gcc_parent_map_0,
427 .freq_tbl = ftbl_gcc_blsp1_uart1_apps_clk_src,
428 .clkr.hw.init = &(struct clk_init_data){
429 .name = "gcc_blsp1_uart4_apps_clk_src",
430 .parent_data = gcc_parents_0,
431 .num_parents = 4,
432 .ops = &clk_rcg2_ops,
433 },
434 };
435
436 static const struct freq_tbl ftbl_gcc_cpuss_ahb_clk_src[] = {
437 F(19200000, P_BI_TCXO, 1, 0, 0),
438 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0),
439 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0),
440 F(133333333, P_GPLL0_OUT_MAIN, 4.5, 0, 0),
441 { }
442 };
443
444 static struct clk_rcg2 gcc_cpuss_ahb_clk_src = {
445 .cmd_rcgr = 0x24010,
446 .mnd_width = 0,
447 .hid_width = 5,
448 .parent_map = gcc_parent_map_0,
449 .freq_tbl = ftbl_gcc_cpuss_ahb_clk_src,
450 .clkr.hw.init = &(struct clk_init_data){
451 .name = "gcc_cpuss_ahb_clk_src",
452 .parent_data = gcc_parents_0_ao,
453 .num_parents = 4,
454 .ops = &clk_rcg2_ops,
455 },
456 };
457
458 static const struct freq_tbl ftbl_gcc_cpuss_rbcpr_clk_src[] = {
459 F(19200000, P_BI_TCXO, 1, 0, 0),
460 { }
461 };
462
463 static struct clk_rcg2 gcc_cpuss_rbcpr_clk_src = {
464 .cmd_rcgr = 0x2402c,
465 .mnd_width = 0,
466 .hid_width = 5,
467 .parent_map = gcc_parent_map_0,
468 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src,
469 .clkr.hw.init = &(struct clk_init_data){
470 .name = "gcc_cpuss_rbcpr_clk_src",
471 .parent_data = gcc_parents_0_ao,
472 .num_parents = 4,
473 .ops = &clk_rcg2_ops,
474 },
475 };
476
477 static const struct freq_tbl ftbl_gcc_emac_clk_src[] = {
478 F(2500000, P_BI_TCXO, 1, 25, 192),
479 F(5000000, P_BI_TCXO, 1, 25, 96),
480 F(19200000, P_BI_TCXO, 1, 0, 0),
481 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0),
482 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0),
483 F(250000000, P_GPLL4_OUT_EVEN, 2, 0, 0),
484 { }
485 };
486
487 static struct clk_rcg2 gcc_emac_clk_src = {
488 .cmd_rcgr = 0x47020,
489 .mnd_width = 8,
490 .hid_width = 5,
491 .parent_map = gcc_parent_map_5,
492 .freq_tbl = ftbl_gcc_emac_clk_src,
493 .clkr.hw.init = &(struct clk_init_data){
494 .name = "gcc_emac_clk_src",
495 .parent_data = gcc_parents_5,
496 .num_parents = 5,
497 .ops = &clk_rcg2_ops,
498 },
499 };
500
501 static const struct freq_tbl ftbl_gcc_emac_ptp_clk_src[] = {
502 F(19200000, P_BI_TCXO, 1, 0, 0),
503 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0),
504 F(230400000, P_GPLL5_OUT_MAIN, 3.5, 0, 0),
505 { }
506 };
507
508 static struct clk_rcg2 gcc_emac_ptp_clk_src = {
509 .cmd_rcgr = 0x47038,
510 .mnd_width = 0,
511 .hid_width = 5,
512 .parent_map = gcc_parent_map_2,
513 .freq_tbl = ftbl_gcc_emac_ptp_clk_src,
514 .clkr.hw.init = &(struct clk_init_data){
515 .name = "gcc_emac_ptp_clk_src",
516 .parent_data = gcc_parents_2,
517 .num_parents = 6,
518 .ops = &clk_rcg2_ops,
519 },
520 };
521
522 static const struct freq_tbl ftbl_gcc_gp1_clk_src[] = {
523 F(19200000, P_BI_TCXO, 1, 0, 0),
524 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0),
525 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0),
526 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0),
527 F(200000000, P_GPLL0_OUT_MAIN, 3, 0, 0),
528 { }
529 };
530
531 static struct clk_rcg2 gcc_gp1_clk_src = {
532 .cmd_rcgr = 0x2b004,
533 .mnd_width = 8,
534 .hid_width = 5,
535 .parent_map = gcc_parent_map_3,
536 .freq_tbl = ftbl_gcc_gp1_clk_src,
537 .clkr.hw.init = &(struct clk_init_data){
538 .name = "gcc_gp1_clk_src",
539 .parent_data = gcc_parents_3,
540 .num_parents = 5,
541 .ops = &clk_rcg2_ops,
542 },
543 };
544
545 static struct clk_rcg2 gcc_gp2_clk_src = {
546 .cmd_rcgr = 0x2c004,
547 .mnd_width = 8,
548 .hid_width = 5,
549 .parent_map = gcc_parent_map_3,
550 .freq_tbl = ftbl_gcc_gp1_clk_src,
551 .clkr.hw.init = &(struct clk_init_data){
552 .name = "gcc_gp2_clk_src",
553 .parent_data = gcc_parents_3,
554 .num_parents = 5,
555 .ops = &clk_rcg2_ops,
556 },
557 };
558
559 static struct clk_rcg2 gcc_gp3_clk_src = {
560 .cmd_rcgr = 0x2d004,
561 .mnd_width = 8,
562 .hid_width = 5,
563 .parent_map = gcc_parent_map_3,
564 .freq_tbl = ftbl_gcc_gp1_clk_src,
565 .clkr.hw.init = &(struct clk_init_data){
566 .name = "gcc_gp3_clk_src",
567 .parent_data = gcc_parents_3,
568 .num_parents = 5,
569 .ops = &clk_rcg2_ops,
570 },
571 };
572
573 static struct clk_rcg2 gcc_pcie_aux_phy_clk_src = {
574 .cmd_rcgr = 0x37034,
575 .mnd_width = 16,
576 .hid_width = 5,
577 .parent_map = gcc_parent_map_4,
578 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src,
579 .clkr.hw.init = &(struct clk_init_data){
580 .name = "gcc_pcie_aux_phy_clk_src",
581 .parent_data = gcc_parents_4,
582 .num_parents = 3,
583 .ops = &clk_rcg2_ops,
584 },
585 };
586
587 static const struct freq_tbl ftbl_gcc_pcie_rchng_phy_clk_src[] = {
588 F(100000000, P_GPLL0_OUT_EVEN, 3, 0, 0),
589 { }
590 };
591
592 static struct clk_rcg2 gcc_pcie_rchng_phy_clk_src = {
593 .cmd_rcgr = 0x37050,
594 .mnd_width = 0,
595 .hid_width = 5,
596 .parent_map = gcc_parent_map_3,
597 .freq_tbl = ftbl_gcc_pcie_rchng_phy_clk_src,
598 .clkr.hw.init = &(struct clk_init_data){
599 .name = "gcc_pcie_rchng_phy_clk_src",
600 .parent_data = gcc_parents_3,
601 .num_parents = 5,
602 .ops = &clk_rcg2_ops,
603 },
604 };
605
606 static const struct freq_tbl ftbl_gcc_pdm2_clk_src[] = {
607 F(9600000, P_BI_TCXO, 2, 0, 0),
608 F(19200000, P_BI_TCXO, 1, 0, 0),
609 F(60000000, P_GPLL0_OUT_MAIN, 10, 0, 0),
610 { }
611 };
612
613 static struct clk_rcg2 gcc_pdm2_clk_src = {
614 .cmd_rcgr = 0x19010,
615 .mnd_width = 0,
616 .hid_width = 5,
617 .parent_map = gcc_parent_map_0,
618 .freq_tbl = ftbl_gcc_pdm2_clk_src,
619 .clkr.hw.init = &(struct clk_init_data){
620 .name = "gcc_pdm2_clk_src",
621 .parent_data = gcc_parents_0,
622 .num_parents = 4,
623 .ops = &clk_rcg2_ops,
624 },
625 };
626
627 static struct clk_rcg2 gcc_sdcc1_apps_clk_src = {
628 .cmd_rcgr = 0xf00c,
629 .mnd_width = 8,
630 .hid_width = 5,
631 .parent_map = gcc_parent_map_0,
632 .freq_tbl = ftbl_gcc_gp1_clk_src,
633 .clkr.hw.init = &(struct clk_init_data){
634 .name = "gcc_sdcc1_apps_clk_src",
635 .parent_data = gcc_parents_0,
636 .num_parents = 4,
637 .ops = &clk_rcg2_ops,
638 },
639 };
640
641 static const struct freq_tbl ftbl_gcc_usb30_master_clk_src[] = {
642 F(200000000, P_GPLL0_OUT_EVEN, 1.5, 0, 0),
643 { }
644 };
645
646 static struct clk_rcg2 gcc_usb30_master_clk_src = {
647 .cmd_rcgr = 0xb024,
648 .mnd_width = 8,
649 .hid_width = 5,
650 .parent_map = gcc_parent_map_0,
651 .freq_tbl = ftbl_gcc_usb30_master_clk_src,
652 .clkr.hw.init = &(struct clk_init_data){
653 .name = "gcc_usb30_master_clk_src",
654 .parent_data = gcc_parents_0,
655 .num_parents = 4,
656 .ops = &clk_rcg2_ops,
657 },
658 };
659
660 static const struct freq_tbl ftbl_gcc_usb30_mock_utmi_clk_src[] = {
661 F(19200000, P_BI_TCXO, 1, 0, 0),
662 { }
663 };
664
665 static struct clk_rcg2 gcc_usb30_mock_utmi_clk_src = {
666 .cmd_rcgr = 0xb03c,
667 .mnd_width = 0,
668 .hid_width = 5,
669 .parent_map = gcc_parent_map_0,
670 .freq_tbl = ftbl_gcc_usb30_mock_utmi_clk_src,
671 .clkr.hw.init = &(struct clk_init_data){
672 .name = "gcc_usb30_mock_utmi_clk_src",
673 .parent_data = gcc_parents_0,
674 .num_parents = 4,
675 .ops = &clk_rcg2_ops,
676 },
677 };
678
679 static const struct freq_tbl ftbl_gcc_usb3_phy_aux_clk_src[] = {
680 F(1000000, P_BI_TCXO, 1, 5, 96),
681 F(19200000, P_BI_TCXO, 1, 0, 0),
682 { }
683 };
684
685 static struct clk_rcg2 gcc_usb3_phy_aux_clk_src = {
686 .cmd_rcgr = 0xb064,
687 .mnd_width = 16,
688 .hid_width = 5,
689 .parent_map = gcc_parent_map_4,
690 .freq_tbl = ftbl_gcc_usb3_phy_aux_clk_src,
691 .clkr.hw.init = &(struct clk_init_data){
692 .name = "gcc_usb3_phy_aux_clk_src",
693 .parent_data = gcc_parents_4,
694 .num_parents = 3,
695 .ops = &clk_rcg2_ops,
696 },
697 };
698
699 static struct clk_branch gcc_ahb_pcie_link_clk = {
700 .halt_reg = 0x22004,
701 .halt_check = BRANCH_HALT,
702 .clkr = {
703 .enable_reg = 0x22004,
704 .enable_mask = BIT(0),
705 .hw.init = &(struct clk_init_data){
706 .name = "gcc_ahb_pcie_link_clk",
707 .ops = &clk_branch2_ops,
708 },
709 },
710 };
711
712 static struct clk_branch gcc_blsp1_ahb_clk = {
713 .halt_reg = 0x10004,
714 .halt_check = BRANCH_HALT_VOTED,
715 .clkr = {
716 .enable_reg = 0x6d008,
717 .enable_mask = BIT(14),
718 .hw.init = &(struct clk_init_data){
719 .name = "gcc_blsp1_ahb_clk",
720 .ops = &clk_branch2_ops,
721 },
722 },
723 };
724
725 static struct clk_branch gcc_blsp1_qup1_i2c_apps_clk = {
726 .halt_reg = 0x11008,
727 .halt_check = BRANCH_HALT,
728 .clkr = {
729 .enable_reg = 0x11008,
730 .enable_mask = BIT(0),
731 .hw.init = &(struct clk_init_data){
732 .name = "gcc_blsp1_qup1_i2c_apps_clk",
733 .parent_hws = (const struct clk_hw *[]){
734 &gcc_blsp1_qup1_i2c_apps_clk_src.clkr.hw },
735 .num_parents = 1,
736 .flags = CLK_SET_RATE_PARENT,
737 .ops = &clk_branch2_ops,
738 },
739 },
740 };
741
742 static struct clk_branch gcc_blsp1_qup1_spi_apps_clk = {
743 .halt_reg = 0x11004,
744 .halt_check = BRANCH_HALT,
745 .clkr = {
746 .enable_reg = 0x11004,
747 .enable_mask = BIT(0),
748 .hw.init = &(struct clk_init_data){
749 .name = "gcc_blsp1_qup1_spi_apps_clk",
750 .parent_hws = (const struct clk_hw *[]){
751 &gcc_blsp1_qup1_spi_apps_clk_src.clkr.hw },
752 .num_parents = 1,
753 .flags = CLK_SET_RATE_PARENT,
754 .ops = &clk_branch2_ops,
755 },
756 },
757 };
758
759 static struct clk_branch gcc_blsp1_qup2_i2c_apps_clk = {
760 .halt_reg = 0x13008,
761 .halt_check = BRANCH_HALT,
762 .clkr = {
763 .enable_reg = 0x13008,
764 .enable_mask = BIT(0),
765 .hw.init = &(struct clk_init_data){
766 .name = "gcc_blsp1_qup2_i2c_apps_clk",
767 .parent_hws = (const struct clk_hw *[]){
768 &gcc_blsp1_qup2_i2c_apps_clk_src.clkr.hw },
769 .num_parents = 1,
770 .flags = CLK_SET_RATE_PARENT,
771 .ops = &clk_branch2_ops,
772 },
773 },
774 };
775
776 static struct clk_branch gcc_blsp1_qup2_spi_apps_clk = {
777 .halt_reg = 0x13004,
778 .halt_check = BRANCH_HALT,
779 .clkr = {
780 .enable_reg = 0x13004,
781 .enable_mask = BIT(0),
782 .hw.init = &(struct clk_init_data){
783 .name = "gcc_blsp1_qup2_spi_apps_clk",
784 .parent_hws = (const struct clk_hw *[]){
785 &gcc_blsp1_qup2_spi_apps_clk_src.clkr.hw },
786 .num_parents = 1,
787 .flags = CLK_SET_RATE_PARENT,
788 .ops = &clk_branch2_ops,
789 },
790 },
791 };
792
793 static struct clk_branch gcc_blsp1_qup3_i2c_apps_clk = {
794 .halt_reg = 0x15008,
795 .halt_check = BRANCH_HALT,
796 .clkr = {
797 .enable_reg = 0x15008,
798 .enable_mask = BIT(0),
799 .hw.init = &(struct clk_init_data){
800 .name = "gcc_blsp1_qup3_i2c_apps_clk",
801 .parent_hws = (const struct clk_hw *[]){
802 &gcc_blsp1_qup3_i2c_apps_clk_src.clkr.hw },
803 .num_parents = 1,
804 .flags = CLK_SET_RATE_PARENT,
805 .ops = &clk_branch2_ops,
806 },
807 },
808 };
809
810 static struct clk_branch gcc_blsp1_qup3_spi_apps_clk = {
811 .halt_reg = 0x15004,
812 .halt_check = BRANCH_HALT,
813 .clkr = {
814 .enable_reg = 0x15004,
815 .enable_mask = BIT(0),
816 .hw.init = &(struct clk_init_data){
817 .name = "gcc_blsp1_qup3_spi_apps_clk",
818 .parent_hws = (const struct clk_hw *[]){
819 &gcc_blsp1_qup3_spi_apps_clk_src.clkr.hw },
820 .num_parents = 1,
821 .flags = CLK_SET_RATE_PARENT,
822 .ops = &clk_branch2_ops,
823 },
824 },
825 };
826
827 static struct clk_branch gcc_blsp1_qup4_i2c_apps_clk = {
828 .halt_reg = 0x17008,
829 .halt_check = BRANCH_HALT,
830 .clkr = {
831 .enable_reg = 0x17008,
832 .enable_mask = BIT(0),
833 .hw.init = &(struct clk_init_data){
834 .name = "gcc_blsp1_qup4_i2c_apps_clk",
835 .parent_hws = (const struct clk_hw *[]){
836 &gcc_blsp1_qup4_i2c_apps_clk_src.clkr.hw },
837 .num_parents = 1,
838 .flags = CLK_SET_RATE_PARENT,
839 .ops = &clk_branch2_ops,
840 },
841 },
842 };
843
844 static struct clk_branch gcc_blsp1_qup4_spi_apps_clk = {
845 .halt_reg = 0x17004,
846 .halt_check = BRANCH_HALT,
847 .clkr = {
848 .enable_reg = 0x17004,
849 .enable_mask = BIT(0),
850 .hw.init = &(struct clk_init_data){
851 .name = "gcc_blsp1_qup4_spi_apps_clk",
852 .parent_hws = (const struct clk_hw *[]){
853 &gcc_blsp1_qup4_spi_apps_clk_src.clkr.hw },
854 .num_parents = 1,
855 .flags = CLK_SET_RATE_PARENT,
856 .ops = &clk_branch2_ops,
857 },
858 },
859 };
860
861 static struct clk_branch gcc_blsp1_uart1_apps_clk = {
862 .halt_reg = 0x12004,
863 .halt_check = BRANCH_HALT,
864 .clkr = {
865 .enable_reg = 0x12004,
866 .enable_mask = BIT(0),
867 .hw.init = &(struct clk_init_data){
868 .name = "gcc_blsp1_uart1_apps_clk",
869 .parent_hws = (const struct clk_hw *[]){
870 &gcc_blsp1_uart1_apps_clk_src.clkr.hw },
871 .num_parents = 1,
872 .flags = CLK_SET_RATE_PARENT,
873 .ops = &clk_branch2_ops,
874 },
875 },
876 };
877
878 static struct clk_branch gcc_blsp1_uart2_apps_clk = {
879 .halt_reg = 0x14004,
880 .halt_check = BRANCH_HALT,
881 .clkr = {
882 .enable_reg = 0x14004,
883 .enable_mask = BIT(0),
884 .hw.init = &(struct clk_init_data){
885 .name = "gcc_blsp1_uart2_apps_clk",
886 .parent_hws = (const struct clk_hw *[]){
887 &gcc_blsp1_uart2_apps_clk_src.clkr.hw },
888 .num_parents = 1,
889 .flags = CLK_SET_RATE_PARENT,
890 .ops = &clk_branch2_ops,
891 },
892 },
893 };
894
895 static struct clk_branch gcc_blsp1_uart3_apps_clk = {
896 .halt_reg = 0x16004,
897 .halt_check = BRANCH_HALT,
898 .clkr = {
899 .enable_reg = 0x16004,
900 .enable_mask = BIT(0),
901 .hw.init = &(struct clk_init_data){
902 .name = "gcc_blsp1_uart3_apps_clk",
903 .parent_hws = (const struct clk_hw *[]){
904 &gcc_blsp1_uart3_apps_clk_src.clkr.hw },
905 .num_parents = 1,
906 .flags = CLK_SET_RATE_PARENT,
907 .ops = &clk_branch2_ops,
908 },
909 },
910 };
911
912 static struct clk_branch gcc_blsp1_uart4_apps_clk = {
913 .halt_reg = 0x18004,
914 .halt_check = BRANCH_HALT,
915 .clkr = {
916 .enable_reg = 0x18004,
917 .enable_mask = BIT(0),
918 .hw.init = &(struct clk_init_data){
919 .name = "gcc_blsp1_uart4_apps_clk",
920 .parent_hws = (const struct clk_hw *[]){
921 &gcc_blsp1_uart4_apps_clk_src.clkr.hw },
922 .num_parents = 1,
923 .flags = CLK_SET_RATE_PARENT,
924 .ops = &clk_branch2_ops,
925 },
926 },
927 };
928
929 static struct clk_branch gcc_boot_rom_ahb_clk = {
930 .halt_reg = 0x1c004,
931 .halt_check = BRANCH_HALT_VOTED,
932 .hwcg_reg = 0x1c004,
933 .hwcg_bit = 1,
934 .clkr = {
935 .enable_reg = 0x6d008,
936 .enable_mask = BIT(10),
937 .hw.init = &(struct clk_init_data){
938 .name = "gcc_boot_rom_ahb_clk",
939 .ops = &clk_branch2_ops,
940 },
941 },
942 };
943
944 static struct clk_branch gcc_ce1_ahb_clk = {
945 .halt_reg = 0x2100c,
946 .halt_check = BRANCH_HALT_VOTED,
947 .hwcg_reg = 0x2100c,
948 .hwcg_bit = 1,
949 .clkr = {
950 .enable_reg = 0x6d008,
951 .enable_mask = BIT(3),
952 .hw.init = &(struct clk_init_data){
953 .name = "gcc_ce1_ahb_clk",
954 .ops = &clk_branch2_ops,
955 },
956 },
957 };
958
959 static struct clk_branch gcc_ce1_axi_clk = {
960 .halt_reg = 0x21008,
961 .halt_check = BRANCH_HALT_VOTED,
962 .clkr = {
963 .enable_reg = 0x6d008,
964 .enable_mask = BIT(4),
965 .hw.init = &(struct clk_init_data){
966 .name = "gcc_ce1_axi_clk",
967 .ops = &clk_branch2_ops,
968 },
969 },
970 };
971
972 static struct clk_branch gcc_ce1_clk = {
973 .halt_reg = 0x21004,
974 .halt_check = BRANCH_HALT_VOTED,
975 .clkr = {
976 .enable_reg = 0x6d008,
977 .enable_mask = BIT(5),
978 .hw.init = &(struct clk_init_data){
979 .name = "gcc_ce1_clk",
980 .ops = &clk_branch2_ops,
981 },
982 },
983 };
984
985 static struct clk_branch gcc_cpuss_rbcpr_clk = {
986 .halt_reg = 0x24008,
987 .halt_check = BRANCH_HALT,
988 .clkr = {
989 .enable_reg = 0x24008,
990 .enable_mask = BIT(0),
991 .hw.init = &(struct clk_init_data){
992 .name = "gcc_cpuss_rbcpr_clk",
993 .parent_hws = (const struct clk_hw *[]){
994 &gcc_cpuss_rbcpr_clk_src.clkr.hw },
995 .num_parents = 1,
996 .flags = CLK_SET_RATE_PARENT,
997 .ops = &clk_branch2_ops,
998 },
999 },
1000 };
1001
1002 static struct clk_branch gcc_eth_axi_clk = {
1003 .halt_reg = 0x4701c,
1004 .halt_check = BRANCH_HALT,
1005 .clkr = {
1006 .enable_reg = 0x4701c,
1007 .enable_mask = BIT(0),
1008 .hw.init = &(struct clk_init_data){
1009 .name = "gcc_eth_axi_clk",
1010 .ops = &clk_branch2_ops,
1011 },
1012 },
1013 };
1014
1015 static struct clk_branch gcc_eth_ptp_clk = {
1016 .halt_reg = 0x47018,
1017 .halt_check = BRANCH_HALT,
1018 .clkr = {
1019 .enable_reg = 0x47018,
1020 .enable_mask = BIT(0),
1021 .hw.init = &(struct clk_init_data){
1022 .name = "gcc_eth_ptp_clk",
1023 .parent_hws = (const struct clk_hw *[]){
1024 &gcc_emac_ptp_clk_src.clkr.hw },
1025 .num_parents = 1,
1026 .flags = CLK_SET_RATE_PARENT,
1027 .ops = &clk_branch2_ops,
1028 },
1029 },
1030 };
1031
1032 static struct clk_branch gcc_eth_rgmii_clk = {
1033 .halt_reg = 0x47010,
1034 .halt_check = BRANCH_HALT,
1035 .clkr = {
1036 .enable_reg = 0x47010,
1037 .enable_mask = BIT(0),
1038 .hw.init = &(struct clk_init_data){
1039 .name = "gcc_eth_rgmii_clk",
1040 .parent_hws = (const struct clk_hw *[]){
1041 &gcc_emac_clk_src.clkr.hw },
1042 .num_parents = 1,
1043 .flags = CLK_SET_RATE_PARENT,
1044 .ops = &clk_branch2_ops,
1045 },
1046 },
1047 };
1048
1049 static struct clk_branch gcc_eth_slave_ahb_clk = {
1050 .halt_reg = 0x47014,
1051 .halt_check = BRANCH_HALT,
1052 .clkr = {
1053 .enable_reg = 0x47014,
1054 .enable_mask = BIT(0),
1055 .hw.init = &(struct clk_init_data){
1056 .name = "gcc_eth_slave_ahb_clk",
1057 .ops = &clk_branch2_ops,
1058 },
1059 },
1060 };
1061
1062 static struct clk_branch gcc_gp1_clk = {
1063 .halt_reg = 0x2b000,
1064 .halt_check = BRANCH_HALT,
1065 .clkr = {
1066 .enable_reg = 0x2b000,
1067 .enable_mask = BIT(0),
1068 .hw.init = &(struct clk_init_data){
1069 .name = "gcc_gp1_clk",
1070 .parent_hws = (const struct clk_hw *[]){
1071 &gcc_gp1_clk_src.clkr.hw },
1072 .num_parents = 1,
1073 .flags = CLK_SET_RATE_PARENT,
1074 .ops = &clk_branch2_ops,
1075 },
1076 },
1077 };
1078
1079 static struct clk_branch gcc_gp2_clk = {
1080 .halt_reg = 0x2c000,
1081 .halt_check = BRANCH_HALT,
1082 .clkr = {
1083 .enable_reg = 0x2c000,
1084 .enable_mask = BIT(0),
1085 .hw.init = &(struct clk_init_data){
1086 .name = "gcc_gp2_clk",
1087 .parent_hws = (const struct clk_hw *[]){
1088 &gcc_gp2_clk_src.clkr.hw },
1089 .num_parents = 1,
1090 .flags = CLK_SET_RATE_PARENT,
1091 .ops = &clk_branch2_ops,
1092 },
1093 },
1094 };
1095
1096 static struct clk_branch gcc_gp3_clk = {
1097 .halt_reg = 0x2d000,
1098 .halt_check = BRANCH_HALT,
1099 .clkr = {
1100 .enable_reg = 0x2d000,
1101 .enable_mask = BIT(0),
1102 .hw.init = &(struct clk_init_data){
1103 .name = "gcc_gp3_clk",
1104 .parent_hws = (const struct clk_hw *[]){
1105 &gcc_gp3_clk_src.clkr.hw },
1106 .num_parents = 1,
1107 .flags = CLK_SET_RATE_PARENT,
1108 .ops = &clk_branch2_ops,
1109 },
1110 },
1111 };
1112
1113 static struct clk_branch gcc_pcie_0_clkref_clk = {
1114 .halt_reg = 0x88004,
1115 .halt_check = BRANCH_HALT_DELAY,
1116 .clkr = {
1117 .enable_reg = 0x88004,
1118 .enable_mask = BIT(0),
1119 .hw.init = &(struct clk_init_data){
1120 .name = "gcc_pcie_0_clkref_clk",
1121 .ops = &clk_branch2_ops,
1122 },
1123 },
1124 };
1125
1126 static struct clk_branch gcc_pcie_aux_clk = {
1127 .halt_reg = 0x37024,
1128 .halt_check = BRANCH_HALT_DELAY,
1129 .clkr = {
1130 .enable_reg = 0x6d010,
1131 .enable_mask = BIT(3),
1132 .hw.init = &(struct clk_init_data){
1133 .name = "gcc_pcie_aux_clk",
1134 .ops = &clk_branch2_ops,
1135 },
1136 },
1137 };
1138
1139 static struct clk_branch gcc_pcie_cfg_ahb_clk = {
1140 .halt_reg = 0x3701c,
1141 .halt_check = BRANCH_HALT_VOTED,
1142 .clkr = {
1143 .enable_reg = 0x6d010,
1144 .enable_mask = BIT(2),
1145 .hw.init = &(struct clk_init_data){
1146 .name = "gcc_pcie_cfg_ahb_clk",
1147 .ops = &clk_branch2_ops,
1148 },
1149 },
1150 };
1151
1152 static struct clk_branch gcc_pcie_mstr_axi_clk = {
1153 .halt_reg = 0x37018,
1154 .halt_check = BRANCH_HALT_VOTED,
1155 .clkr = {
1156 .enable_reg = 0x6d010,
1157 .enable_mask = BIT(1),
1158 .hw.init = &(struct clk_init_data){
1159 .name = "gcc_pcie_mstr_axi_clk",
1160 .ops = &clk_branch2_ops,
1161 },
1162 },
1163 };
1164
1165 static struct clk_branch gcc_pcie_pipe_clk = {
1166 .halt_reg = 0x3702c,
1167 .halt_check = BRANCH_HALT_DELAY,
1168 .clkr = {
1169 .enable_reg = 0x6d010,
1170 .enable_mask = BIT(4),
1171 .hw.init = &(struct clk_init_data){
1172 .name = "gcc_pcie_pipe_clk",
1173 .ops = &clk_branch2_ops,
1174 },
1175 },
1176 };
1177
1178 static struct clk_branch gcc_pcie_rchng_phy_clk = {
1179 .halt_reg = 0x37020,
1180 .halt_check = BRANCH_HALT_VOTED,
1181 .clkr = {
1182 .enable_reg = 0x6d010,
1183 .enable_mask = BIT(7),
1184 .hw.init = &(struct clk_init_data){
1185 .name = "gcc_pcie_rchng_phy_clk",
1186 .parent_hws = (const struct clk_hw *[]){
1187 &gcc_pcie_rchng_phy_clk_src.clkr.hw },
1188 .num_parents = 1,
1189 .flags = CLK_SET_RATE_PARENT,
1190 .ops = &clk_branch2_ops,
1191 },
1192 },
1193 };
1194
1195 static struct clk_branch gcc_pcie_sleep_clk = {
1196 .halt_reg = 0x37028,
1197 .halt_check = BRANCH_HALT_VOTED,
1198 .clkr = {
1199 .enable_reg = 0x6d010,
1200 .enable_mask = BIT(6),
1201 .hw.init = &(struct clk_init_data){
1202 .name = "gcc_pcie_sleep_clk",
1203 .parent_hws = (const struct clk_hw *[]){
1204 &gcc_pcie_aux_phy_clk_src.clkr.hw },
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_pcie_slv_axi_clk = {
1213 .halt_reg = 0x37014,
1214 .halt_check = BRANCH_HALT_VOTED,
1215 .hwcg_reg = 0x37014,
1216 .hwcg_bit = 1,
1217 .clkr = {
1218 .enable_reg = 0x6d010,
1219 .enable_mask = BIT(0),
1220 .hw.init = &(struct clk_init_data){
1221 .name = "gcc_pcie_slv_axi_clk",
1222 .ops = &clk_branch2_ops,
1223 },
1224 },
1225 };
1226
1227 static struct clk_branch gcc_pcie_slv_q2a_axi_clk = {
1228 .halt_reg = 0x37010,
1229 .halt_check = BRANCH_HALT_VOTED,
1230 .clkr = {
1231 .enable_reg = 0x6d010,
1232 .enable_mask = BIT(5),
1233 .hw.init = &(struct clk_init_data){
1234 .name = "gcc_pcie_slv_q2a_axi_clk",
1235 .ops = &clk_branch2_ops,
1236 },
1237 },
1238 };
1239
1240 static struct clk_branch gcc_pdm2_clk = {
1241 .halt_reg = 0x1900c,
1242 .halt_check = BRANCH_HALT,
1243 .clkr = {
1244 .enable_reg = 0x1900c,
1245 .enable_mask = BIT(0),
1246 .hw.init = &(struct clk_init_data){
1247 .name = "gcc_pdm2_clk",
1248 .parent_hws = (const struct clk_hw *[]){
1249 &gcc_pdm2_clk_src.clkr.hw },
1250 .num_parents = 1,
1251 .flags = CLK_SET_RATE_PARENT,
1252 .ops = &clk_branch2_ops,
1253 },
1254 },
1255 };
1256
1257 static struct clk_branch gcc_pdm_ahb_clk = {
1258 .halt_reg = 0x19004,
1259 .halt_check = BRANCH_HALT,
1260 .hwcg_reg = 0x19004,
1261 .hwcg_bit = 1,
1262 .clkr = {
1263 .enable_reg = 0x19004,
1264 .enable_mask = BIT(0),
1265 .hw.init = &(struct clk_init_data){
1266 .name = "gcc_pdm_ahb_clk",
1267 .ops = &clk_branch2_ops,
1268 },
1269 },
1270 };
1271
1272 static struct clk_branch gcc_pdm_xo4_clk = {
1273 .halt_reg = 0x19008,
1274 .halt_check = BRANCH_HALT,
1275 .clkr = {
1276 .enable_reg = 0x19008,
1277 .enable_mask = BIT(0),
1278 .hw.init = &(struct clk_init_data){
1279 .name = "gcc_pdm_xo4_clk",
1280 .ops = &clk_branch2_ops,
1281 },
1282 },
1283 };
1284
1285 static struct clk_branch gcc_sdcc1_ahb_clk = {
1286 .halt_reg = 0xf008,
1287 .halt_check = BRANCH_HALT,
1288 .clkr = {
1289 .enable_reg = 0xf008,
1290 .enable_mask = BIT(0),
1291 .hw.init = &(struct clk_init_data){
1292 .name = "gcc_sdcc1_ahb_clk",
1293 .ops = &clk_branch2_ops,
1294 },
1295 },
1296 };
1297
1298 static struct clk_branch gcc_sdcc1_apps_clk = {
1299 .halt_reg = 0xf004,
1300 .halt_check = BRANCH_HALT,
1301 .clkr = {
1302 .enable_reg = 0xf004,
1303 .enable_mask = BIT(0),
1304 .hw.init = &(struct clk_init_data){
1305 .name = "gcc_sdcc1_apps_clk",
1306 .parent_hws = (const struct clk_hw *[]){
1307 &gcc_sdcc1_apps_clk_src.clkr.hw },
1308 .num_parents = 1,
1309 .flags = CLK_SET_RATE_PARENT,
1310 .ops = &clk_branch2_ops,
1311 },
1312 },
1313 };
1314
1315 static struct clk_branch gcc_usb30_master_clk = {
1316 .halt_reg = 0xb010,
1317 .halt_check = BRANCH_HALT,
1318 .clkr = {
1319 .enable_reg = 0xb010,
1320 .enable_mask = BIT(0),
1321 .hw.init = &(struct clk_init_data){
1322 .name = "gcc_usb30_master_clk",
1323 .parent_hws = (const struct clk_hw *[]){
1324 &gcc_usb30_master_clk_src.clkr.hw },
1325 .num_parents = 1,
1326 .flags = CLK_SET_RATE_PARENT,
1327 .ops = &clk_branch2_ops,
1328 },
1329 },
1330 };
1331
1332 static struct clk_branch gcc_usb30_mock_utmi_clk = {
1333 .halt_reg = 0xb020,
1334 .halt_check = BRANCH_HALT,
1335 .clkr = {
1336 .enable_reg = 0xb020,
1337 .enable_mask = BIT(0),
1338 .hw.init = &(struct clk_init_data){
1339 .name = "gcc_usb30_mock_utmi_clk",
1340 .parent_hws = (const struct clk_hw *[]){
1341 &gcc_usb30_mock_utmi_clk_src.clkr.hw },
1342 .num_parents = 1,
1343 .flags = CLK_SET_RATE_PARENT,
1344 .ops = &clk_branch2_ops,
1345 },
1346 },
1347 };
1348
1349 static struct clk_branch gcc_usb30_mstr_axi_clk = {
1350 .halt_reg = 0xb014,
1351 .halt_check = BRANCH_HALT,
1352 .clkr = {
1353 .enable_reg = 0xb014,
1354 .enable_mask = BIT(0),
1355 .hw.init = &(struct clk_init_data){
1356 .name = "gcc_usb30_mstr_axi_clk",
1357 .ops = &clk_branch2_ops,
1358 },
1359 },
1360 };
1361
1362 static struct clk_branch gcc_usb30_sleep_clk = {
1363 .halt_reg = 0xb01c,
1364 .halt_check = BRANCH_HALT,
1365 .clkr = {
1366 .enable_reg = 0xb01c,
1367 .enable_mask = BIT(0),
1368 .hw.init = &(struct clk_init_data){
1369 .name = "gcc_usb30_sleep_clk",
1370 .ops = &clk_branch2_ops,
1371 },
1372 },
1373 };
1374
1375 static struct clk_branch gcc_usb30_slv_ahb_clk = {
1376 .halt_reg = 0xb018,
1377 .halt_check = BRANCH_HALT,
1378 .clkr = {
1379 .enable_reg = 0xb018,
1380 .enable_mask = BIT(0),
1381 .hw.init = &(struct clk_init_data){
1382 .name = "gcc_usb30_slv_ahb_clk",
1383 .ops = &clk_branch2_ops,
1384 },
1385 },
1386 };
1387
1388 static struct clk_branch gcc_usb3_phy_aux_clk = {
1389 .halt_reg = 0xb058,
1390 .halt_check = BRANCH_HALT,
1391 .clkr = {
1392 .enable_reg = 0xb058,
1393 .enable_mask = BIT(0),
1394 .hw.init = &(struct clk_init_data){
1395 .name = "gcc_usb3_phy_aux_clk",
1396 .parent_hws = (const struct clk_hw *[]){
1397 &gcc_usb3_phy_aux_clk_src.clkr.hw },
1398 .num_parents = 1,
1399 .flags = CLK_SET_RATE_PARENT,
1400 .ops = &clk_branch2_ops,
1401 },
1402 },
1403 };
1404
1405 static struct clk_branch gcc_usb3_phy_pipe_clk = {
1406 .halt_reg = 0xb05c,
1407 .halt_check = BRANCH_HALT_DELAY,
1408 .clkr = {
1409 .enable_reg = 0xb05c,
1410 .enable_mask = BIT(0),
1411 .hw.init = &(struct clk_init_data){
1412 .name = "gcc_usb3_phy_pipe_clk",
1413 .ops = &clk_branch2_ops,
1414 },
1415 },
1416 };
1417
1418 static struct clk_branch gcc_usb3_prim_clkref_clk = {
1419 .halt_reg = 0x88000,
1420 .halt_check = BRANCH_HALT_DELAY,
1421 .clkr = {
1422 .enable_reg = 0x88000,
1423 .enable_mask = BIT(0),
1424 .hw.init = &(struct clk_init_data){
1425 .name = "gcc_usb3_prim_clkref_clk",
1426 .ops = &clk_branch2_ops,
1427 },
1428 },
1429 };
1430
1431 static struct clk_branch gcc_usb_phy_cfg_ahb2phy_clk = {
1432 .halt_reg = 0xe004,
1433 .halt_check = BRANCH_HALT,
1434 .hwcg_reg = 0xe004,
1435 .hwcg_bit = 1,
1436 .clkr = {
1437 .enable_reg = 0xe004,
1438 .enable_mask = BIT(0),
1439 .hw.init = &(struct clk_init_data){
1440 .name = "gcc_usb_phy_cfg_ahb2phy_clk",
1441 .ops = &clk_branch2_ops,
1442 },
1443 },
1444 };
1445
1446 static struct clk_branch gcc_xo_pcie_link_clk = {
1447 .halt_reg = 0x22008,
1448 .halt_check = BRANCH_HALT,
1449 .clkr = {
1450 .enable_reg = 0x22008,
1451 .enable_mask = BIT(0),
1452 .hw.init = &(struct clk_init_data){
1453 .name = "gcc_xo_pcie_link_clk",
1454 .ops = &clk_branch2_ops,
1455 },
1456 },
1457 };
1458
1459 static struct gdsc usb30_gdsc = {
1460 .gdscr = 0x0b004,
1461 .pd = {
1462 .name = "usb30_gdsc",
1463 },
1464 .pwrsts = PWRSTS_OFF_ON,
1465 };
1466
1467 static struct gdsc pcie_gdsc = {
1468 .gdscr = 0x37004,
1469 .pd = {
1470 .name = "pcie_gdsc",
1471 },
1472 .pwrsts = PWRSTS_OFF_ON,
1473 };
1474
1475 static struct gdsc emac_gdsc = {
1476 .gdscr = 0x47004,
1477 .pd = {
1478 .name = "emac_gdsc",
1479 },
1480 .pwrsts = PWRSTS_OFF_ON,
1481 };
1482
1483 static struct clk_regmap *gcc_sdx55_clocks[] = {
1484 [GCC_AHB_PCIE_LINK_CLK] = &gcc_ahb_pcie_link_clk.clkr,
1485 [GCC_BLSP1_AHB_CLK] = &gcc_blsp1_ahb_clk.clkr,
1486 [GCC_BLSP1_QUP1_I2C_APPS_CLK] = &gcc_blsp1_qup1_i2c_apps_clk.clkr,
1487 [GCC_BLSP1_QUP1_I2C_APPS_CLK_SRC] =
1488 &gcc_blsp1_qup1_i2c_apps_clk_src.clkr,
1489 [GCC_BLSP1_QUP1_SPI_APPS_CLK] = &gcc_blsp1_qup1_spi_apps_clk.clkr,
1490 [GCC_BLSP1_QUP1_SPI_APPS_CLK_SRC] =
1491 &gcc_blsp1_qup1_spi_apps_clk_src.clkr,
1492 [GCC_BLSP1_QUP2_I2C_APPS_CLK] = &gcc_blsp1_qup2_i2c_apps_clk.clkr,
1493 [GCC_BLSP1_QUP2_I2C_APPS_CLK_SRC] =
1494 &gcc_blsp1_qup2_i2c_apps_clk_src.clkr,
1495 [GCC_BLSP1_QUP2_SPI_APPS_CLK] = &gcc_blsp1_qup2_spi_apps_clk.clkr,
1496 [GCC_BLSP1_QUP2_SPI_APPS_CLK_SRC] =
1497 &gcc_blsp1_qup2_spi_apps_clk_src.clkr,
1498 [GCC_BLSP1_QUP3_I2C_APPS_CLK] = &gcc_blsp1_qup3_i2c_apps_clk.clkr,
1499 [GCC_BLSP1_QUP3_I2C_APPS_CLK_SRC] =
1500 &gcc_blsp1_qup3_i2c_apps_clk_src.clkr,
1501 [GCC_BLSP1_QUP3_SPI_APPS_CLK] = &gcc_blsp1_qup3_spi_apps_clk.clkr,
1502 [GCC_BLSP1_QUP3_SPI_APPS_CLK_SRC] =
1503 &gcc_blsp1_qup3_spi_apps_clk_src.clkr,
1504 [GCC_BLSP1_QUP4_I2C_APPS_CLK] = &gcc_blsp1_qup4_i2c_apps_clk.clkr,
1505 [GCC_BLSP1_QUP4_I2C_APPS_CLK_SRC] =
1506 &gcc_blsp1_qup4_i2c_apps_clk_src.clkr,
1507 [GCC_BLSP1_QUP4_SPI_APPS_CLK] = &gcc_blsp1_qup4_spi_apps_clk.clkr,
1508 [GCC_BLSP1_QUP4_SPI_APPS_CLK_SRC] =
1509 &gcc_blsp1_qup4_spi_apps_clk_src.clkr,
1510 [GCC_BLSP1_UART1_APPS_CLK] = &gcc_blsp1_uart1_apps_clk.clkr,
1511 [GCC_BLSP1_UART1_APPS_CLK_SRC] = &gcc_blsp1_uart1_apps_clk_src.clkr,
1512 [GCC_BLSP1_UART2_APPS_CLK] = &gcc_blsp1_uart2_apps_clk.clkr,
1513 [GCC_BLSP1_UART2_APPS_CLK_SRC] = &gcc_blsp1_uart2_apps_clk_src.clkr,
1514 [GCC_BLSP1_UART3_APPS_CLK] = &gcc_blsp1_uart3_apps_clk.clkr,
1515 [GCC_BLSP1_UART3_APPS_CLK_SRC] = &gcc_blsp1_uart3_apps_clk_src.clkr,
1516 [GCC_BLSP1_UART4_APPS_CLK] = &gcc_blsp1_uart4_apps_clk.clkr,
1517 [GCC_BLSP1_UART4_APPS_CLK_SRC] = &gcc_blsp1_uart4_apps_clk_src.clkr,
1518 [GCC_BOOT_ROM_AHB_CLK] = &gcc_boot_rom_ahb_clk.clkr,
1519 [GCC_CE1_AHB_CLK] = &gcc_ce1_ahb_clk.clkr,
1520 [GCC_CE1_AXI_CLK] = &gcc_ce1_axi_clk.clkr,
1521 [GCC_CE1_CLK] = &gcc_ce1_clk.clkr,
1522 [GCC_CPUSS_AHB_CLK_SRC] = &gcc_cpuss_ahb_clk_src.clkr,
1523 [GCC_CPUSS_RBCPR_CLK] = &gcc_cpuss_rbcpr_clk.clkr,
1524 [GCC_CPUSS_RBCPR_CLK_SRC] = &gcc_cpuss_rbcpr_clk_src.clkr,
1525 [GCC_EMAC_CLK_SRC] = &gcc_emac_clk_src.clkr,
1526 [GCC_EMAC_PTP_CLK_SRC] = &gcc_emac_ptp_clk_src.clkr,
1527 [GCC_ETH_AXI_CLK] = &gcc_eth_axi_clk.clkr,
1528 [GCC_ETH_PTP_CLK] = &gcc_eth_ptp_clk.clkr,
1529 [GCC_ETH_RGMII_CLK] = &gcc_eth_rgmii_clk.clkr,
1530 [GCC_ETH_SLAVE_AHB_CLK] = &gcc_eth_slave_ahb_clk.clkr,
1531 [GCC_GP1_CLK] = &gcc_gp1_clk.clkr,
1532 [GCC_GP1_CLK_SRC] = &gcc_gp1_clk_src.clkr,
1533 [GCC_GP2_CLK] = &gcc_gp2_clk.clkr,
1534 [GCC_GP2_CLK_SRC] = &gcc_gp2_clk_src.clkr,
1535 [GCC_GP3_CLK] = &gcc_gp3_clk.clkr,
1536 [GCC_GP3_CLK_SRC] = &gcc_gp3_clk_src.clkr,
1537 [GCC_PCIE_0_CLKREF_CLK] = &gcc_pcie_0_clkref_clk.clkr,
1538 [GCC_PCIE_AUX_CLK] = &gcc_pcie_aux_clk.clkr,
1539 [GCC_PCIE_AUX_PHY_CLK_SRC] = &gcc_pcie_aux_phy_clk_src.clkr,
1540 [GCC_PCIE_CFG_AHB_CLK] = &gcc_pcie_cfg_ahb_clk.clkr,
1541 [GCC_PCIE_MSTR_AXI_CLK] = &gcc_pcie_mstr_axi_clk.clkr,
1542 [GCC_PCIE_PIPE_CLK] = &gcc_pcie_pipe_clk.clkr,
1543 [GCC_PCIE_RCHNG_PHY_CLK] = &gcc_pcie_rchng_phy_clk.clkr,
1544 [GCC_PCIE_RCHNG_PHY_CLK_SRC] = &gcc_pcie_rchng_phy_clk_src.clkr,
1545 [GCC_PCIE_SLEEP_CLK] = &gcc_pcie_sleep_clk.clkr,
1546 [GCC_PCIE_SLV_AXI_CLK] = &gcc_pcie_slv_axi_clk.clkr,
1547 [GCC_PCIE_SLV_Q2A_AXI_CLK] = &gcc_pcie_slv_q2a_axi_clk.clkr,
1548 [GCC_PDM2_CLK] = &gcc_pdm2_clk.clkr,
1549 [GCC_PDM2_CLK_SRC] = &gcc_pdm2_clk_src.clkr,
1550 [GCC_PDM_AHB_CLK] = &gcc_pdm_ahb_clk.clkr,
1551 [GCC_PDM_XO4_CLK] = &gcc_pdm_xo4_clk.clkr,
1552 [GCC_SDCC1_AHB_CLK] = &gcc_sdcc1_ahb_clk.clkr,
1553 [GCC_SDCC1_APPS_CLK] = &gcc_sdcc1_apps_clk.clkr,
1554 [GCC_SDCC1_APPS_CLK_SRC] = &gcc_sdcc1_apps_clk_src.clkr,
1555 [GCC_USB30_MASTER_CLK] = &gcc_usb30_master_clk.clkr,
1556 [GCC_USB30_MASTER_CLK_SRC] = &gcc_usb30_master_clk_src.clkr,
1557 [GCC_USB30_MOCK_UTMI_CLK] = &gcc_usb30_mock_utmi_clk.clkr,
1558 [GCC_USB30_MOCK_UTMI_CLK_SRC] = &gcc_usb30_mock_utmi_clk_src.clkr,
1559 [GCC_USB30_MSTR_AXI_CLK] = &gcc_usb30_mstr_axi_clk.clkr,
1560 [GCC_USB30_SLEEP_CLK] = &gcc_usb30_sleep_clk.clkr,
1561 [GCC_USB30_SLV_AHB_CLK] = &gcc_usb30_slv_ahb_clk.clkr,
1562 [GCC_USB3_PHY_AUX_CLK] = &gcc_usb3_phy_aux_clk.clkr,
1563 [GCC_USB3_PHY_AUX_CLK_SRC] = &gcc_usb3_phy_aux_clk_src.clkr,
1564 [GCC_USB3_PHY_PIPE_CLK] = &gcc_usb3_phy_pipe_clk.clkr,
1565 [GCC_USB3_PRIM_CLKREF_CLK] = &gcc_usb3_prim_clkref_clk.clkr,
1566 [GCC_USB_PHY_CFG_AHB2PHY_CLK] = &gcc_usb_phy_cfg_ahb2phy_clk.clkr,
1567 [GCC_XO_PCIE_LINK_CLK] = &gcc_xo_pcie_link_clk.clkr,
1568 [GPLL0] = &gpll0.clkr,
1569 [GPLL0_OUT_EVEN] = &gpll0_out_even.clkr,
1570 [GPLL4] = &gpll4.clkr,
1571 [GPLL4_OUT_EVEN] = &gpll4_out_even.clkr,
1572 [GPLL5] = &gpll5.clkr,
1573 };
1574
1575 static const struct qcom_reset_map gcc_sdx55_resets[] = {
1576 [GCC_EMAC_BCR] = { 0x47000 },
1577 [GCC_PCIE_BCR] = { 0x37000 },
1578 [GCC_PCIE_LINK_DOWN_BCR] = { 0x77000 },
1579 [GCC_PCIE_PHY_BCR] = { 0x39000 },
1580 [GCC_PCIE_PHY_COM_BCR] = { 0x78004 },
1581 [GCC_QUSB2PHY_BCR] = { 0xd000 },
1582 [GCC_USB30_BCR] = { 0xb000 },
1583 [GCC_USB3_PHY_BCR] = { 0xc000 },
1584 [GCC_USB3PHY_PHY_BCR] = { 0xc004 },
1585 [GCC_USB_PHY_CFG_AHB2PHY_BCR] = { 0xe000 },
1586 };
1587
1588 static struct gdsc *gcc_sdx55_gdscs[] = {
1589 [USB30_GDSC] = &usb30_gdsc,
1590 [PCIE_GDSC] = &pcie_gdsc,
1591 [EMAC_GDSC] = &emac_gdsc,
1592 };
1593
1594 static const struct regmap_config gcc_sdx55_regmap_config = {
1595 .reg_bits = 32,
1596 .reg_stride = 4,
1597 .val_bits = 32,
1598 .max_register = 0x9b040,
1599 .fast_io = true,
1600 };
1601
1602 static const struct qcom_cc_desc gcc_sdx55_desc = {
1603 .config = &gcc_sdx55_regmap_config,
1604 .clks = gcc_sdx55_clocks,
1605 .num_clks = ARRAY_SIZE(gcc_sdx55_clocks),
1606 .resets = gcc_sdx55_resets,
1607 .num_resets = ARRAY_SIZE(gcc_sdx55_resets),
1608 .gdscs = gcc_sdx55_gdscs,
1609 .num_gdscs = ARRAY_SIZE(gcc_sdx55_gdscs),
1610 };
1611
1612 static const struct of_device_id gcc_sdx55_match_table[] = {
1613 { .compatible = "qcom,gcc-sdx55" },
1614 { }
1615 };
1616 MODULE_DEVICE_TABLE(of, gcc_sdx55_match_table);
1617
gcc_sdx55_probe(struct platform_device * pdev)1618 static int gcc_sdx55_probe(struct platform_device *pdev)
1619 {
1620 struct regmap *regmap;
1621
1622 regmap = qcom_cc_map(pdev, &gcc_sdx55_desc);
1623 if (IS_ERR(regmap))
1624 return PTR_ERR(regmap);
1625
1626 /*
1627 * Keep the clocks always-ON as they are critical to the functioning
1628 * of the system:
1629 * GCC_SYS_NOC_CPUSS_AHB_CLK, GCC_CPUSS_AHB_CLK, GCC_CPUSS_GNOC_CLK
1630 */
1631 regmap_update_bits(regmap, 0x6d008, BIT(0), BIT(0));
1632 regmap_update_bits(regmap, 0x6d008, BIT(21), BIT(21));
1633 regmap_update_bits(regmap, 0x6d008, BIT(22), BIT(22));
1634
1635 return qcom_cc_really_probe(pdev, &gcc_sdx55_desc, regmap);
1636 }
1637
1638 static struct platform_driver gcc_sdx55_driver = {
1639 .probe = gcc_sdx55_probe,
1640 .driver = {
1641 .name = "gcc-sdx55",
1642 .of_match_table = gcc_sdx55_match_table,
1643 },
1644 };
1645
gcc_sdx55_init(void)1646 static int __init gcc_sdx55_init(void)
1647 {
1648 return platform_driver_register(&gcc_sdx55_driver);
1649 }
1650 subsys_initcall(gcc_sdx55_init);
1651
gcc_sdx55_exit(void)1652 static void __exit gcc_sdx55_exit(void)
1653 {
1654 platform_driver_unregister(&gcc_sdx55_driver);
1655 }
1656 module_exit(gcc_sdx55_exit);
1657
1658 MODULE_DESCRIPTION("QTI GCC SDX55 Driver");
1659 MODULE_LICENSE("GPL v2");
1660