1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2021, The Linux Foundation. All rights reserved. 4 * Copyright (c) 2021, Konrad Dybcio <konrad.dybcio@somainline.org> 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-sm6350.h> 13 14 #include "clk-alpha-pll.h" 15 #include "clk-branch.h" 16 #include "clk-rcg.h" 17 #include "clk-regmap.h" 18 #include "clk-regmap-divider.h" 19 #include "clk-regmap-mux.h" 20 #include "common.h" 21 #include "gdsc.h" 22 #include "reset.h" 23 24 enum { 25 P_BI_TCXO, 26 P_GPLL0_OUT_EVEN, 27 P_GPLL0_OUT_MAIN, 28 P_GPLL0_OUT_ODD, 29 P_GPLL6_OUT_EVEN, 30 P_GPLL7_OUT_MAIN, 31 P_SLEEP_CLK, 32 }; 33 34 static struct clk_alpha_pll gpll0 = { 35 .offset = 0x0, 36 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 37 .clkr = { 38 .enable_reg = 0x52010, 39 .enable_mask = BIT(0), 40 .hw.init = &(struct clk_init_data){ 41 .name = "gpll0", 42 .parent_data = &(const struct clk_parent_data){ 43 .fw_name = "bi_tcxo", 44 }, 45 .num_parents = 1, 46 .ops = &clk_alpha_pll_fixed_fabia_ops, 47 }, 48 }, 49 }; 50 51 static const struct clk_div_table post_div_table_gpll0_out_even[] = { 52 { 0x1, 2 }, 53 { } 54 }; 55 56 static struct clk_alpha_pll_postdiv gpll0_out_even = { 57 .offset = 0x0, 58 .post_div_shift = 8, 59 .post_div_table = post_div_table_gpll0_out_even, 60 .num_post_div = ARRAY_SIZE(post_div_table_gpll0_out_even), 61 .width = 4, 62 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 63 .clkr.hw.init = &(struct clk_init_data){ 64 .name = "gpll0_out_even", 65 .parent_hws = (const struct clk_hw*[]){ 66 &gpll0.clkr.hw, 67 }, 68 .num_parents = 1, 69 .ops = &clk_alpha_pll_postdiv_fabia_ops, 70 }, 71 }; 72 73 static const struct clk_div_table post_div_table_gpll0_out_odd[] = { 74 { 0x3, 3 }, 75 { } 76 }; 77 78 static struct clk_alpha_pll_postdiv gpll0_out_odd = { 79 .offset = 0x0, 80 .post_div_shift = 12, 81 .post_div_table = post_div_table_gpll0_out_odd, 82 .num_post_div = ARRAY_SIZE(post_div_table_gpll0_out_odd), 83 .width = 4, 84 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 85 .clkr.hw.init = &(struct clk_init_data){ 86 .name = "gpll0_out_odd", 87 .parent_hws = (const struct clk_hw*[]){ 88 &gpll0.clkr.hw, 89 }, 90 .num_parents = 1, 91 .ops = &clk_alpha_pll_postdiv_fabia_ops, 92 }, 93 }; 94 95 static struct clk_alpha_pll gpll6 = { 96 .offset = 0x6000, 97 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 98 .clkr = { 99 .enable_reg = 0x52010, 100 .enable_mask = BIT(6), 101 .hw.init = &(struct clk_init_data){ 102 .name = "gpll6", 103 .parent_hws = (const struct clk_hw*[]){ 104 &gpll0.clkr.hw, 105 }, 106 .num_parents = 1, 107 .ops = &clk_alpha_pll_fixed_fabia_ops, 108 }, 109 }, 110 }; 111 112 static const struct clk_div_table post_div_table_gpll6_out_even[] = { 113 { 0x1, 2 }, 114 { } 115 }; 116 117 static struct clk_alpha_pll_postdiv gpll6_out_even = { 118 .offset = 0x6000, 119 .post_div_shift = 8, 120 .post_div_table = post_div_table_gpll6_out_even, 121 .num_post_div = ARRAY_SIZE(post_div_table_gpll6_out_even), 122 .width = 4, 123 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 124 .clkr.hw.init = &(struct clk_init_data){ 125 .name = "gpll6_out_even", 126 .parent_hws = (const struct clk_hw*[]){ 127 &gpll0.clkr.hw, 128 }, 129 .num_parents = 1, 130 .ops = &clk_alpha_pll_postdiv_fabia_ops, 131 }, 132 }; 133 134 static struct clk_alpha_pll gpll7 = { 135 .offset = 0x7000, 136 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 137 .clkr = { 138 .enable_reg = 0x52010, 139 .enable_mask = BIT(7), 140 .hw.init = &(struct clk_init_data){ 141 .name = "gpll7", 142 .parent_hws = (const struct clk_hw*[]){ 143 &gpll0.clkr.hw, 144 }, 145 .num_parents = 1, 146 .ops = &clk_alpha_pll_fixed_fabia_ops, 147 }, 148 }, 149 }; 150 151 static const struct parent_map gcc_parent_map_0[] = { 152 { P_BI_TCXO, 0 }, 153 { P_GPLL0_OUT_MAIN, 1 }, 154 { P_GPLL6_OUT_EVEN, 2 }, 155 { P_GPLL0_OUT_EVEN, 6 }, 156 }; 157 158 static const struct clk_parent_data gcc_parent_data_0[] = { 159 { .fw_name = "bi_tcxo" }, 160 { .hw = &gpll0.clkr.hw }, 161 { .hw = &gpll6_out_even.clkr.hw }, 162 { .hw = &gpll0_out_even.clkr.hw }, 163 }; 164 165 static const struct parent_map gcc_parent_map_1[] = { 166 { P_BI_TCXO, 0 }, 167 { P_GPLL0_OUT_EVEN, 6 }, 168 }; 169 170 static const struct clk_parent_data gcc_parent_data_1[] = { 171 { .fw_name = "bi_tcxo" }, 172 { .hw = &gpll0_out_even.clkr.hw }, 173 }; 174 175 static const struct parent_map gcc_parent_map_2[] = { 176 { P_BI_TCXO, 0 }, 177 { P_GPLL0_OUT_ODD, 2 }, 178 }; 179 180 static const struct clk_parent_data gcc_parent_data_2_ao[] = { 181 { .fw_name = "bi_tcxo_ao" }, 182 { .hw = &gpll0_out_odd.clkr.hw }, 183 }; 184 185 static const struct parent_map gcc_parent_map_4[] = { 186 { P_BI_TCXO, 0 }, 187 { P_GPLL0_OUT_MAIN, 1 }, 188 { P_GPLL0_OUT_ODD, 2 }, 189 }; 190 191 static const struct clk_parent_data gcc_parent_data_4[] = { 192 { .fw_name = "bi_tcxo" }, 193 { .hw = &gpll0.clkr.hw }, 194 { .hw = &gpll0_out_odd.clkr.hw }, 195 }; 196 197 static const struct parent_map gcc_parent_map_5[] = { 198 { P_BI_TCXO, 0 }, 199 { P_GPLL0_OUT_ODD, 2 }, 200 { P_SLEEP_CLK, 5 }, 201 { P_GPLL0_OUT_EVEN, 6 }, 202 }; 203 204 static const struct clk_parent_data gcc_parent_data_5[] = { 205 { .fw_name = "bi_tcxo" }, 206 { .hw = &gpll0_out_odd.clkr.hw }, 207 { .fw_name = "sleep_clk" }, 208 { .hw = &gpll0_out_even.clkr.hw }, 209 }; 210 211 static const struct parent_map gcc_parent_map_6[] = { 212 { P_BI_TCXO, 0 }, 213 { P_SLEEP_CLK, 5 }, 214 }; 215 216 static const struct clk_parent_data gcc_parent_data_6[] = { 217 { .fw_name = "bi_tcxo" }, 218 { .fw_name = "sleep_clk" } 219 }; 220 221 static const struct parent_map gcc_parent_map_7[] = { 222 { P_BI_TCXO, 0 }, 223 { P_GPLL6_OUT_EVEN, 2 }, 224 { P_GPLL0_OUT_EVEN, 6 }, 225 }; 226 227 static const struct clk_parent_data gcc_parent_data_7[] = { 228 { .fw_name = "bi_tcxo" }, 229 { .hw = &gpll6_out_even.clkr.hw }, 230 { .hw = &gpll0_out_even.clkr.hw }, 231 }; 232 233 static const struct parent_map gcc_parent_map_8[] = { 234 { P_BI_TCXO, 0 }, 235 { P_GPLL0_OUT_ODD, 2 }, 236 { P_GPLL7_OUT_MAIN, 3 }, 237 }; 238 239 static const struct clk_parent_data gcc_parent_data_8[] = { 240 { .fw_name = "bi_tcxo" }, 241 { .hw = &gpll0_out_odd.clkr.hw }, 242 { .hw = &gpll7.clkr.hw }, 243 }; 244 245 static struct clk_regmap_div gcc_gpu_gpll0_main_div_clk_src = { 246 .reg = 0x4514C, 247 .shift = 0, 248 .width = 2, 249 .clkr.hw.init = &(struct clk_init_data) { 250 .name = "gcc_gpu_gpll0_main_div_clk_src", 251 .parent_hws = (const struct clk_hw*[]){ 252 &gpll0.clkr.hw, 253 }, 254 .num_parents = 1, 255 .ops = &clk_regmap_div_ro_ops, 256 }, 257 }; 258 259 static struct clk_regmap_div gcc_npu_pll0_main_div_clk_src = { 260 .reg = 0x4ce00, 261 .shift = 0, 262 .width = 2, 263 .clkr.hw.init = &(struct clk_init_data) { 264 .name = "gcc_npu_pll0_main_div_clk_src", 265 .parent_hws = (const struct clk_hw*[]){ 266 &gpll0.clkr.hw, 267 }, 268 .num_parents = 1, 269 .ops = &clk_regmap_div_ro_ops, 270 }, 271 }; 272 273 static const struct freq_tbl ftbl_gcc_cpuss_ahb_clk_src[] = { 274 F(19200000, P_BI_TCXO, 1, 0, 0), 275 { } 276 }; 277 278 static struct clk_rcg2 gcc_cpuss_ahb_clk_src = { 279 .cmd_rcgr = 0x30014, 280 .mnd_width = 0, 281 .hid_width = 5, 282 .parent_map = gcc_parent_map_2, 283 .freq_tbl = ftbl_gcc_cpuss_ahb_clk_src, 284 .clkr.hw.init = &(struct clk_init_data){ 285 .name = "gcc_cpuss_ahb_clk_src", 286 .parent_data = gcc_parent_data_2_ao, 287 .num_parents = ARRAY_SIZE(gcc_parent_data_2_ao), 288 .ops = &clk_rcg2_ops, 289 }, 290 }; 291 292 static const struct freq_tbl ftbl_gcc_gp1_clk_src[] = { 293 F(19200000, P_BI_TCXO, 1, 0, 0), 294 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0), 295 F(50000000, P_GPLL0_OUT_ODD, 4, 0, 0), 296 F(100000000, P_GPLL0_OUT_ODD, 2, 0, 0), 297 F(200000000, P_GPLL0_OUT_ODD, 1, 0, 0), 298 { } 299 }; 300 301 static struct clk_rcg2 gcc_gp1_clk_src = { 302 .cmd_rcgr = 0x37004, 303 .mnd_width = 8, 304 .hid_width = 5, 305 .parent_map = gcc_parent_map_5, 306 .freq_tbl = ftbl_gcc_gp1_clk_src, 307 .clkr.hw.init = &(struct clk_init_data){ 308 .name = "gcc_gp1_clk_src", 309 .parent_data = gcc_parent_data_5, 310 .num_parents = ARRAY_SIZE(gcc_parent_data_5), 311 .ops = &clk_rcg2_ops, 312 }, 313 }; 314 315 static struct clk_rcg2 gcc_gp2_clk_src = { 316 .cmd_rcgr = 0x38004, 317 .mnd_width = 8, 318 .hid_width = 5, 319 .parent_map = gcc_parent_map_5, 320 .freq_tbl = ftbl_gcc_gp1_clk_src, 321 .clkr.hw.init = &(struct clk_init_data){ 322 .name = "gcc_gp2_clk_src", 323 .parent_data = gcc_parent_data_5, 324 .num_parents = ARRAY_SIZE(gcc_parent_data_5), 325 .ops = &clk_rcg2_ops, 326 }, 327 }; 328 329 static struct clk_rcg2 gcc_gp3_clk_src = { 330 .cmd_rcgr = 0x39004, 331 .mnd_width = 8, 332 .hid_width = 5, 333 .parent_map = gcc_parent_map_5, 334 .freq_tbl = ftbl_gcc_gp1_clk_src, 335 .clkr.hw.init = &(struct clk_init_data){ 336 .name = "gcc_gp3_clk_src", 337 .parent_data = gcc_parent_data_5, 338 .num_parents = ARRAY_SIZE(gcc_parent_data_5), 339 .ops = &clk_rcg2_ops, 340 }, 341 }; 342 343 static const struct freq_tbl ftbl_gcc_pdm2_clk_src[] = { 344 F(19200000, P_BI_TCXO, 1, 0, 0), 345 F(60000000, P_GPLL0_OUT_EVEN, 5, 0, 0), 346 { } 347 }; 348 349 static struct clk_rcg2 gcc_pdm2_clk_src = { 350 .cmd_rcgr = 0x23010, 351 .mnd_width = 0, 352 .hid_width = 5, 353 .parent_map = gcc_parent_map_1, 354 .freq_tbl = ftbl_gcc_pdm2_clk_src, 355 .clkr.hw.init = &(struct clk_init_data){ 356 .name = "gcc_pdm2_clk_src", 357 .parent_data = gcc_parent_data_1, 358 .num_parents = ARRAY_SIZE(gcc_parent_data_1), 359 .ops = &clk_rcg2_ops, 360 }, 361 }; 362 363 static const struct freq_tbl ftbl_gcc_qupv3_wrap0_s0_clk_src[] = { 364 F(7372800, P_GPLL0_OUT_EVEN, 1, 384, 15625), 365 F(14745600, P_GPLL0_OUT_EVEN, 1, 768, 15625), 366 F(19200000, P_BI_TCXO, 1, 0, 0), 367 F(29491200, P_GPLL0_OUT_EVEN, 1, 1536, 15625), 368 F(32000000, P_GPLL0_OUT_EVEN, 1, 8, 75), 369 F(48000000, P_GPLL0_OUT_EVEN, 1, 4, 25), 370 F(64000000, P_GPLL0_OUT_EVEN, 1, 16, 75), 371 F(75000000, P_GPLL0_OUT_EVEN, 4, 0, 0), 372 F(80000000, P_GPLL0_OUT_EVEN, 1, 4, 15), 373 F(96000000, P_GPLL0_OUT_EVEN, 1, 8, 25), 374 F(100000000, P_GPLL0_OUT_EVEN, 3, 0, 0), 375 F(102400000, P_GPLL0_OUT_EVEN, 1, 128, 375), 376 F(112000000, P_GPLL0_OUT_EVEN, 1, 28, 75), 377 F(117964800, P_GPLL0_OUT_EVEN, 1, 6144, 15625), 378 F(120000000, P_GPLL0_OUT_EVEN, 2.5, 0, 0), 379 F(128000000, P_GPLL6_OUT_EVEN, 3, 0, 0), 380 { } 381 }; 382 383 static struct clk_init_data gcc_qupv3_wrap0_s0_clk_src_init = { 384 .name = "gcc_qupv3_wrap0_s0_clk_src", 385 .parent_data = gcc_parent_data_0, 386 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 387 .ops = &clk_rcg2_ops, 388 }; 389 390 static struct clk_rcg2 gcc_qupv3_wrap0_s0_clk_src = { 391 .cmd_rcgr = 0x21148, 392 .mnd_width = 16, 393 .hid_width = 5, 394 .parent_map = gcc_parent_map_0, 395 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 396 .clkr.hw.init = &gcc_qupv3_wrap0_s0_clk_src_init, 397 }; 398 399 static struct clk_init_data gcc_qupv3_wrap0_s1_clk_src_init = { 400 .name = "gcc_qupv3_wrap0_s1_clk_src", 401 .parent_data = gcc_parent_data_0, 402 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 403 .ops = &clk_rcg2_ops, 404 }; 405 406 static struct clk_rcg2 gcc_qupv3_wrap0_s1_clk_src = { 407 .cmd_rcgr = 0x21278, 408 .mnd_width = 16, 409 .hid_width = 5, 410 .parent_map = gcc_parent_map_0, 411 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 412 .clkr.hw.init = &gcc_qupv3_wrap0_s1_clk_src_init, 413 }; 414 415 static struct clk_init_data gcc_qupv3_wrap0_s2_clk_src_init = { 416 .name = "gcc_qupv3_wrap0_s2_clk_src", 417 .parent_data = gcc_parent_data_0, 418 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 419 .ops = &clk_rcg2_ops, 420 }; 421 422 static struct clk_rcg2 gcc_qupv3_wrap0_s2_clk_src = { 423 .cmd_rcgr = 0x213a8, 424 .mnd_width = 16, 425 .hid_width = 5, 426 .parent_map = gcc_parent_map_0, 427 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 428 .clkr.hw.init = &gcc_qupv3_wrap0_s2_clk_src_init, 429 }; 430 431 static struct clk_init_data gcc_qupv3_wrap0_s3_clk_src_init = { 432 .name = "gcc_qupv3_wrap0_s3_clk_src", 433 .parent_data = gcc_parent_data_0, 434 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 435 .ops = &clk_rcg2_ops, 436 }; 437 438 static struct clk_rcg2 gcc_qupv3_wrap0_s3_clk_src = { 439 .cmd_rcgr = 0x214d8, 440 .mnd_width = 16, 441 .hid_width = 5, 442 .parent_map = gcc_parent_map_0, 443 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 444 .clkr.hw.init = &gcc_qupv3_wrap0_s3_clk_src_init, 445 }; 446 447 static struct clk_init_data gcc_qupv3_wrap0_s4_clk_src_init = { 448 .name = "gcc_qupv3_wrap0_s4_clk_src", 449 .parent_data = gcc_parent_data_0, 450 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 451 .ops = &clk_rcg2_ops, 452 }; 453 454 static struct clk_rcg2 gcc_qupv3_wrap0_s4_clk_src = { 455 .cmd_rcgr = 0x21608, 456 .mnd_width = 16, 457 .hid_width = 5, 458 .parent_map = gcc_parent_map_0, 459 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 460 .clkr.hw.init = &gcc_qupv3_wrap0_s4_clk_src_init, 461 }; 462 463 static struct clk_init_data gcc_qupv3_wrap0_s5_clk_src_init = { 464 .name = "gcc_qupv3_wrap0_s5_clk_src", 465 .parent_data = gcc_parent_data_0, 466 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 467 .ops = &clk_rcg2_ops, 468 }; 469 470 static struct clk_rcg2 gcc_qupv3_wrap0_s5_clk_src = { 471 .cmd_rcgr = 0x21738, 472 .mnd_width = 16, 473 .hid_width = 5, 474 .parent_map = gcc_parent_map_0, 475 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 476 .clkr.hw.init = &gcc_qupv3_wrap0_s5_clk_src_init, 477 }; 478 479 static struct clk_init_data gcc_qupv3_wrap1_s0_clk_src_init = { 480 .name = "gcc_qupv3_wrap1_s0_clk_src", 481 .parent_data = gcc_parent_data_0, 482 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 483 .ops = &clk_rcg2_ops, 484 }; 485 486 static struct clk_rcg2 gcc_qupv3_wrap1_s0_clk_src = { 487 .cmd_rcgr = 0x22018, 488 .mnd_width = 16, 489 .hid_width = 5, 490 .parent_map = gcc_parent_map_0, 491 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 492 .clkr.hw.init = &gcc_qupv3_wrap1_s0_clk_src_init, 493 }; 494 495 static struct clk_init_data gcc_qupv3_wrap1_s1_clk_src_init = { 496 .name = "gcc_qupv3_wrap1_s1_clk_src", 497 .parent_data = gcc_parent_data_0, 498 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 499 .ops = &clk_rcg2_ops, 500 }; 501 502 static struct clk_rcg2 gcc_qupv3_wrap1_s1_clk_src = { 503 .cmd_rcgr = 0x22148, 504 .mnd_width = 16, 505 .hid_width = 5, 506 .parent_map = gcc_parent_map_0, 507 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 508 .clkr.hw.init = &gcc_qupv3_wrap1_s1_clk_src_init, 509 }; 510 511 static struct clk_init_data gcc_qupv3_wrap1_s2_clk_src_init = { 512 .name = "gcc_qupv3_wrap1_s2_clk_src", 513 .parent_data = gcc_parent_data_0, 514 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 515 .ops = &clk_rcg2_ops, 516 }; 517 518 static struct clk_rcg2 gcc_qupv3_wrap1_s2_clk_src = { 519 .cmd_rcgr = 0x22278, 520 .mnd_width = 16, 521 .hid_width = 5, 522 .parent_map = gcc_parent_map_0, 523 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 524 .clkr.hw.init = &gcc_qupv3_wrap1_s2_clk_src_init, 525 }; 526 527 static struct clk_init_data gcc_qupv3_wrap1_s3_clk_src_init = { 528 .name = "gcc_qupv3_wrap1_s3_clk_src", 529 .parent_data = gcc_parent_data_0, 530 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 531 .ops = &clk_rcg2_ops, 532 }; 533 534 static struct clk_rcg2 gcc_qupv3_wrap1_s3_clk_src = { 535 .cmd_rcgr = 0x223a8, 536 .mnd_width = 16, 537 .hid_width = 5, 538 .parent_map = gcc_parent_map_0, 539 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 540 .clkr.hw.init = &gcc_qupv3_wrap1_s3_clk_src_init, 541 }; 542 543 static struct clk_init_data gcc_qupv3_wrap1_s4_clk_src_init = { 544 .name = "gcc_qupv3_wrap1_s4_clk_src", 545 .parent_data = gcc_parent_data_0, 546 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 547 .ops = &clk_rcg2_ops, 548 }; 549 550 static struct clk_rcg2 gcc_qupv3_wrap1_s4_clk_src = { 551 .cmd_rcgr = 0x224d8, 552 .mnd_width = 16, 553 .hid_width = 5, 554 .parent_map = gcc_parent_map_0, 555 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 556 .clkr.hw.init = &gcc_qupv3_wrap1_s4_clk_src_init, 557 }; 558 559 static struct clk_init_data gcc_qupv3_wrap1_s5_clk_src_init = { 560 .name = "gcc_qupv3_wrap1_s5_clk_src", 561 .parent_data = gcc_parent_data_0, 562 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 563 .ops = &clk_rcg2_ops, 564 }; 565 566 static struct clk_rcg2 gcc_qupv3_wrap1_s5_clk_src = { 567 .cmd_rcgr = 0x22608, 568 .mnd_width = 16, 569 .hid_width = 5, 570 .parent_map = gcc_parent_map_0, 571 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 572 .clkr.hw.init = &gcc_qupv3_wrap1_s5_clk_src_init, 573 }; 574 575 static const struct freq_tbl ftbl_gcc_sdcc1_apps_clk_src[] = { 576 F(144000, P_BI_TCXO, 16, 3, 25), 577 F(400000, P_BI_TCXO, 12, 1, 4), 578 F(19200000, P_BI_TCXO, 1, 0, 0), 579 F(20000000, P_GPLL0_OUT_EVEN, 5, 1, 3), 580 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0), 581 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0), 582 F(100000000, P_GPLL0_OUT_EVEN, 3, 0, 0), 583 F(192000000, P_GPLL6_OUT_EVEN, 2, 0, 0), 584 F(384000000, P_GPLL6_OUT_EVEN, 1, 0, 0), 585 { } 586 }; 587 588 static struct clk_rcg2 gcc_sdcc1_apps_clk_src = { 589 .cmd_rcgr = 0x4b024, 590 .mnd_width = 8, 591 .hid_width = 5, 592 .parent_map = gcc_parent_map_7, 593 .freq_tbl = ftbl_gcc_sdcc1_apps_clk_src, 594 .clkr.hw.init = &(struct clk_init_data){ 595 .name = "gcc_sdcc1_apps_clk_src", 596 .parent_data = gcc_parent_data_7, 597 .num_parents = ARRAY_SIZE(gcc_parent_data_7), 598 .ops = &clk_rcg2_ops, 599 }, 600 }; 601 602 static const struct freq_tbl ftbl_gcc_sdcc1_ice_core_clk_src[] = { 603 F(100000000, P_GPLL0_OUT_EVEN, 3, 0, 0), 604 F(150000000, P_GPLL0_OUT_EVEN, 2, 0, 0), 605 F(300000000, P_GPLL0_OUT_EVEN, 1, 0, 0), 606 { } 607 }; 608 609 static struct clk_rcg2 gcc_sdcc1_ice_core_clk_src = { 610 .cmd_rcgr = 0x4b00c, 611 .mnd_width = 0, 612 .hid_width = 5, 613 .parent_map = gcc_parent_map_1, 614 .freq_tbl = ftbl_gcc_sdcc1_ice_core_clk_src, 615 .clkr.hw.init = &(struct clk_init_data){ 616 .name = "gcc_sdcc1_ice_core_clk_src", 617 .parent_data = gcc_parent_data_1, 618 .num_parents = ARRAY_SIZE(gcc_parent_data_1), 619 .ops = &clk_rcg2_ops, 620 }, 621 }; 622 623 static const struct freq_tbl ftbl_gcc_sdcc2_apps_clk_src[] = { 624 F(400000, P_BI_TCXO, 12, 1, 4), 625 F(9600000, P_BI_TCXO, 2, 0, 0), 626 F(19200000, P_BI_TCXO, 1, 0, 0), 627 F(25000000, P_GPLL0_OUT_ODD, 8, 0, 0), 628 F(50000000, P_GPLL0_OUT_ODD, 4, 0, 0), 629 F(100000000, P_GPLL0_OUT_ODD, 2, 0, 0), 630 F(202000000, P_GPLL7_OUT_MAIN, 4, 0, 0), 631 { } 632 }; 633 634 static struct clk_rcg2 gcc_sdcc2_apps_clk_src = { 635 .cmd_rcgr = 0x2000c, 636 .mnd_width = 8, 637 .hid_width = 5, 638 .parent_map = gcc_parent_map_8, 639 .freq_tbl = ftbl_gcc_sdcc2_apps_clk_src, 640 .clkr.hw.init = &(struct clk_init_data){ 641 .name = "gcc_sdcc2_apps_clk_src", 642 .parent_data = gcc_parent_data_8, 643 .num_parents = ARRAY_SIZE(gcc_parent_data_8), 644 .ops = &clk_rcg2_floor_ops, 645 }, 646 }; 647 648 static const struct freq_tbl ftbl_gcc_ufs_phy_axi_clk_src[] = { 649 F(25000000, P_GPLL0_OUT_ODD, 8, 0, 0), 650 F(50000000, P_GPLL0_OUT_ODD, 4, 0, 0), 651 F(100000000, P_GPLL0_OUT_ODD, 2, 0, 0), 652 F(200000000, P_GPLL0_OUT_ODD, 1, 0, 0), 653 F(240000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0), 654 { } 655 }; 656 657 static struct clk_rcg2 gcc_ufs_phy_axi_clk_src = { 658 .cmd_rcgr = 0x3a01c, 659 .mnd_width = 8, 660 .hid_width = 5, 661 .parent_map = gcc_parent_map_4, 662 .freq_tbl = ftbl_gcc_ufs_phy_axi_clk_src, 663 .clkr.hw.init = &(struct clk_init_data){ 664 .name = "gcc_ufs_phy_axi_clk_src", 665 .parent_data = gcc_parent_data_4, 666 .num_parents = ARRAY_SIZE(gcc_parent_data_4), 667 .ops = &clk_rcg2_ops, 668 }, 669 }; 670 671 static const struct freq_tbl ftbl_gcc_ufs_phy_ice_core_clk_src[] = { 672 F(37500000, P_GPLL0_OUT_EVEN, 8, 0, 0), 673 F(75000000, P_GPLL0_OUT_EVEN, 4, 0, 0), 674 F(150000000, P_GPLL0_OUT_EVEN, 2, 0, 0), 675 F(300000000, P_GPLL0_OUT_EVEN, 1, 0, 0), 676 { } 677 }; 678 679 static struct clk_rcg2 gcc_ufs_phy_ice_core_clk_src = { 680 .cmd_rcgr = 0x3a048, 681 .mnd_width = 0, 682 .hid_width = 5, 683 .parent_map = gcc_parent_map_1, 684 .freq_tbl = ftbl_gcc_ufs_phy_ice_core_clk_src, 685 .clkr.hw.init = &(struct clk_init_data){ 686 .name = "gcc_ufs_phy_ice_core_clk_src", 687 .parent_data = gcc_parent_data_1, 688 .num_parents = ARRAY_SIZE(gcc_parent_data_1), 689 .ops = &clk_rcg2_ops, 690 }, 691 }; 692 693 static const struct freq_tbl ftbl_gcc_ufs_phy_phy_aux_clk_src[] = { 694 F(9600000, P_BI_TCXO, 2, 0, 0), 695 F(19200000, P_BI_TCXO, 1, 0, 0), 696 { } 697 }; 698 699 static struct clk_rcg2 gcc_ufs_phy_phy_aux_clk_src = { 700 .cmd_rcgr = 0x3a0b0, 701 .mnd_width = 0, 702 .hid_width = 5, 703 .freq_tbl = ftbl_gcc_ufs_phy_phy_aux_clk_src, 704 .clkr.hw.init = &(struct clk_init_data){ 705 .name = "gcc_ufs_phy_phy_aux_clk_src", 706 .parent_data = &(const struct clk_parent_data){ 707 .fw_name = "bi_tcxo", 708 }, 709 .num_parents = 1, 710 .ops = &clk_rcg2_ops, 711 }, 712 }; 713 714 static const struct freq_tbl ftbl_gcc_ufs_phy_unipro_core_clk_src[] = { 715 F(37500000, P_GPLL0_OUT_EVEN, 8, 0, 0), 716 F(75000000, P_GPLL0_OUT_EVEN, 4, 0, 0), 717 F(150000000, P_GPLL0_OUT_EVEN, 2, 0, 0), 718 { } 719 }; 720 721 static struct clk_rcg2 gcc_ufs_phy_unipro_core_clk_src = { 722 .cmd_rcgr = 0x3a060, 723 .mnd_width = 0, 724 .hid_width = 5, 725 .parent_map = gcc_parent_map_1, 726 .freq_tbl = ftbl_gcc_ufs_phy_unipro_core_clk_src, 727 .clkr.hw.init = &(struct clk_init_data){ 728 .name = "gcc_ufs_phy_unipro_core_clk_src", 729 .parent_data = gcc_parent_data_1, 730 .num_parents = ARRAY_SIZE(gcc_parent_data_1), 731 .ops = &clk_rcg2_ops, 732 }, 733 }; 734 735 static const struct freq_tbl ftbl_gcc_usb30_prim_master_clk_src[] = { 736 F(66666667, P_GPLL0_OUT_ODD, 3, 0, 0), 737 F(133333333, P_GPLL0_OUT_MAIN, 4.5, 0, 0), 738 F(200000000, P_GPLL0_OUT_MAIN, 3, 0, 0), 739 F(240000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0), 740 { } 741 }; 742 743 static struct clk_rcg2 gcc_usb30_prim_master_clk_src = { 744 .cmd_rcgr = 0x1a01c, 745 .mnd_width = 8, 746 .hid_width = 5, 747 .parent_map = gcc_parent_map_4, 748 .freq_tbl = ftbl_gcc_usb30_prim_master_clk_src, 749 .clkr.hw.init = &(struct clk_init_data){ 750 .name = "gcc_usb30_prim_master_clk_src", 751 .parent_data = gcc_parent_data_4, 752 .num_parents = ARRAY_SIZE(gcc_parent_data_4), 753 .ops = &clk_rcg2_ops, 754 }, 755 }; 756 757 static const struct freq_tbl ftbl_gcc_usb30_prim_mock_utmi_clk_src[] = { 758 F(19200000, P_BI_TCXO, 1, 0, 0), 759 { } 760 }; 761 762 static struct clk_rcg2 gcc_usb30_prim_mock_utmi_clk_src = { 763 .cmd_rcgr = 0x1a034, 764 .mnd_width = 0, 765 .hid_width = 5, 766 .freq_tbl = ftbl_gcc_usb30_prim_mock_utmi_clk_src, 767 .clkr.hw.init = &(struct clk_init_data){ 768 .name = "gcc_usb30_prim_mock_utmi_clk_src", 769 .parent_data = &(const struct clk_parent_data){ 770 .fw_name = "bi_tcxo", 771 }, 772 .num_parents = 1, 773 .ops = &clk_rcg2_ops, 774 }, 775 }; 776 777 static struct clk_rcg2 gcc_usb3_prim_phy_aux_clk_src = { 778 .cmd_rcgr = 0x1a060, 779 .mnd_width = 0, 780 .hid_width = 5, 781 .parent_map = gcc_parent_map_6, 782 .freq_tbl = ftbl_gcc_usb30_prim_mock_utmi_clk_src, 783 .clkr.hw.init = &(struct clk_init_data){ 784 .name = "gcc_usb3_prim_phy_aux_clk_src", 785 .parent_data = gcc_parent_data_6, 786 .num_parents = ARRAY_SIZE(gcc_parent_data_6), 787 .ops = &clk_rcg2_ops, 788 }, 789 }; 790 791 static struct clk_branch gcc_aggre_ufs_phy_axi_clk = { 792 .halt_reg = 0x3e014, 793 .halt_check = BRANCH_HALT_DELAY, 794 .hwcg_reg = 0x3e014, 795 .hwcg_bit = 1, 796 .clkr = { 797 .enable_reg = 0x3e014, 798 .enable_mask = BIT(0), 799 .hw.init = &(struct clk_init_data){ 800 .name = "gcc_aggre_ufs_phy_axi_clk", 801 .parent_hws = (const struct clk_hw*[]){ 802 &gcc_ufs_phy_axi_clk_src.clkr.hw, 803 }, 804 .num_parents = 1, 805 .flags = CLK_SET_RATE_PARENT, 806 .ops = &clk_branch2_ops, 807 }, 808 }, 809 }; 810 811 static struct clk_branch gcc_aggre_ufs_phy_axi_hw_ctl_clk = { 812 .halt_reg = 0x3e014, 813 .halt_check = BRANCH_HALT, 814 .hwcg_reg = 0x3e014, 815 .hwcg_bit = 1, 816 .clkr = { 817 .enable_reg = 0x3e014, 818 .enable_mask = BIT(1), 819 .hw.init = &(struct clk_init_data){ 820 .name = "gcc_aggre_ufs_phy_axi_hw_ctl_clk", 821 .parent_hws = (const struct clk_hw*[]){ 822 &gcc_ufs_phy_axi_clk_src.clkr.hw, 823 }, 824 .num_parents = 1, 825 .flags = CLK_SET_RATE_PARENT, 826 .ops = &clk_branch2_ops, 827 }, 828 }, 829 }; 830 831 static struct clk_branch gcc_ufs_phy_axi_hw_ctl_clk = { 832 .halt_reg = 0x3e014, 833 .halt_check = BRANCH_HALT, 834 .hwcg_reg = 0x3e014, 835 .hwcg_bit = 1, 836 .clkr = { 837 .enable_reg = 0x3e014, 838 .enable_mask = BIT(1), 839 .hw.init = &(struct clk_init_data){ 840 .name = "gcc_ufs_phy_axi_hw_ctl_clk", 841 .parent_hws = (const struct clk_hw*[]){ 842 &gcc_ufs_phy_axi_clk_src.clkr.hw, 843 }, 844 .num_parents = 1, 845 .flags = CLK_SET_RATE_PARENT, 846 .ops = &clk_branch2_ops, 847 }, 848 }, 849 }; 850 851 static struct clk_branch gcc_aggre_usb3_prim_axi_clk = { 852 .halt_reg = 0x3e010, 853 .halt_check = BRANCH_HALT, 854 .hwcg_reg = 0x3e010, 855 .hwcg_bit = 1, 856 .clkr = { 857 .enable_reg = 0x3e010, 858 .enable_mask = BIT(0), 859 .hw.init = &(struct clk_init_data){ 860 .name = "gcc_aggre_usb3_prim_axi_clk", 861 .parent_hws = (const struct clk_hw*[]){ 862 &gcc_usb30_prim_master_clk_src.clkr.hw, 863 }, 864 .num_parents = 1, 865 .flags = CLK_SET_RATE_PARENT, 866 .ops = &clk_branch2_ops, 867 }, 868 }, 869 }; 870 871 static struct clk_branch gcc_boot_rom_ahb_clk = { 872 .halt_reg = 0x26004, 873 .halt_check = BRANCH_HALT_VOTED, 874 .hwcg_reg = 0x26004, 875 .hwcg_bit = 1, 876 .clkr = { 877 .enable_reg = 0x52000, 878 .enable_mask = BIT(28), 879 .hw.init = &(struct clk_init_data){ 880 .name = "gcc_boot_rom_ahb_clk", 881 .ops = &clk_branch2_ops, 882 }, 883 }, 884 }; 885 886 static struct clk_branch gcc_camera_ahb_clk = { 887 .halt_reg = 0x17008, 888 .halt_check = BRANCH_HALT, 889 .hwcg_reg = 0x17008, 890 .hwcg_bit = 1, 891 .clkr = { 892 .enable_reg = 0x17008, 893 .enable_mask = BIT(0), 894 .hw.init = &(struct clk_init_data){ 895 .name = "gcc_camera_ahb_clk", 896 .flags = CLK_IS_CRITICAL, 897 .ops = &clk_branch2_ops, 898 }, 899 }, 900 }; 901 902 static struct clk_branch gcc_camera_axi_clk = { 903 .halt_reg = 0x17018, 904 .halt_check = BRANCH_HALT, 905 .hwcg_reg = 0x17018, 906 .hwcg_bit = 1, 907 .clkr = { 908 .enable_reg = 0x17018, 909 .enable_mask = BIT(0), 910 .hw.init = &(struct clk_init_data){ 911 .name = "gcc_camera_axi_clk", 912 .ops = &clk_branch2_ops, 913 }, 914 }, 915 }; 916 917 static struct clk_branch gcc_camera_throttle_nrt_axi_clk = { 918 .halt_reg = 0x17078, 919 .halt_check = BRANCH_VOTED, 920 .hwcg_reg = 0x17078, 921 .hwcg_bit = 1, 922 .clkr = { 923 .enable_reg = 0x17078, 924 .enable_mask = BIT(0), 925 .hw.init = &(struct clk_init_data){ 926 .name = "gcc_camera_throttle_nrt_axi_clk", 927 .ops = &clk_branch2_ops, 928 }, 929 }, 930 }; 931 932 static struct clk_branch gcc_camera_throttle_rt_axi_clk = { 933 .halt_reg = 0x17024, 934 .halt_check = BRANCH_VOTED, 935 .hwcg_reg = 0x17024, 936 .hwcg_bit = 1, 937 .clkr = { 938 .enable_reg = 0x17024, 939 .enable_mask = BIT(0), 940 .hw.init = &(struct clk_init_data){ 941 .name = "gcc_camera_throttle_rt_axi_clk", 942 .ops = &clk_branch2_ops, 943 }, 944 }, 945 }; 946 947 static struct clk_branch gcc_camera_xo_clk = { 948 .halt_reg = 0x17030, 949 .halt_check = BRANCH_HALT, 950 .clkr = { 951 .enable_reg = 0x17030, 952 .enable_mask = BIT(0), 953 .hw.init = &(struct clk_init_data){ 954 .name = "gcc_camera_xo_clk", 955 .flags = CLK_IS_CRITICAL, 956 .ops = &clk_branch2_ops, 957 }, 958 }, 959 }; 960 961 static struct clk_branch gcc_ce1_ahb_clk = { 962 .halt_reg = 0x2b00c, 963 .halt_check = BRANCH_HALT_VOTED, 964 .hwcg_reg = 0x2b00c, 965 .hwcg_bit = 1, 966 .clkr = { 967 .enable_reg = 0x52008, 968 .enable_mask = BIT(3), 969 .hw.init = &(struct clk_init_data){ 970 .name = "gcc_ce1_ahb_clk", 971 .ops = &clk_branch2_ops, 972 }, 973 }, 974 }; 975 976 static struct clk_branch gcc_ce1_axi_clk = { 977 .halt_reg = 0x2b008, 978 .halt_check = BRANCH_HALT_VOTED, 979 .clkr = { 980 .enable_reg = 0x52008, 981 .enable_mask = BIT(2), 982 .hw.init = &(struct clk_init_data){ 983 .name = "gcc_ce1_axi_clk", 984 .ops = &clk_branch2_ops, 985 }, 986 }, 987 }; 988 989 static struct clk_branch gcc_ce1_clk = { 990 .halt_reg = 0x2b004, 991 .halt_check = BRANCH_HALT_VOTED, 992 .clkr = { 993 .enable_reg = 0x52008, 994 .enable_mask = BIT(1), 995 .hw.init = &(struct clk_init_data){ 996 .name = "gcc_ce1_clk", 997 .ops = &clk_branch2_ops, 998 }, 999 }, 1000 }; 1001 1002 static struct clk_branch gcc_cfg_noc_usb3_prim_axi_clk = { 1003 .halt_reg = 0x1101c, 1004 .halt_check = BRANCH_HALT, 1005 .hwcg_reg = 0x1101c, 1006 .hwcg_bit = 1, 1007 .clkr = { 1008 .enable_reg = 0x1101c, 1009 .enable_mask = BIT(0), 1010 .hw.init = &(struct clk_init_data){ 1011 .name = "gcc_cfg_noc_usb3_prim_axi_clk", 1012 .parent_hws = (const struct clk_hw*[]){ 1013 &gcc_usb30_prim_master_clk_src.clkr.hw, 1014 }, 1015 .num_parents = 1, 1016 .flags = CLK_SET_RATE_PARENT, 1017 .ops = &clk_branch2_ops, 1018 }, 1019 }, 1020 }; 1021 1022 static struct clk_branch gcc_cpuss_ahb_clk = { 1023 .halt_reg = 0x30000, 1024 .halt_check = BRANCH_HALT_VOTED, 1025 .hwcg_reg = 0x30000, 1026 .hwcg_bit = 1, 1027 .clkr = { 1028 .enable_reg = 0x52008, 1029 .enable_mask = BIT(4), 1030 .hw.init = &(struct clk_init_data){ 1031 .name = "gcc_cpuss_ahb_clk", 1032 .parent_hws = (const struct clk_hw*[]){ 1033 &gcc_cpuss_ahb_clk_src.clkr.hw, 1034 }, 1035 .num_parents = 1, 1036 .flags = CLK_IS_CRITICAL | CLK_SET_RATE_PARENT, 1037 .ops = &clk_branch2_ops, 1038 }, 1039 }, 1040 }; 1041 1042 static struct clk_branch gcc_cpuss_gnoc_clk = { 1043 .halt_reg = 0x30004, 1044 .halt_check = BRANCH_HALT_VOTED, 1045 .hwcg_reg = 0x30004, 1046 .hwcg_bit = 1, 1047 .clkr = { 1048 .enable_reg = 0x52008, 1049 .enable_mask = BIT(5), 1050 .hw.init = &(struct clk_init_data){ 1051 .name = "gcc_cpuss_gnoc_clk", 1052 .flags = CLK_IS_CRITICAL, 1053 .ops = &clk_branch2_ops, 1054 }, 1055 }, 1056 }; 1057 1058 static struct clk_branch gcc_cpuss_rbcpr_clk = { 1059 .halt_reg = 0x30008, 1060 .halt_check = BRANCH_HALT, 1061 .clkr = { 1062 .enable_reg = 0x30008, 1063 .enable_mask = BIT(0), 1064 .hw.init = &(struct clk_init_data){ 1065 .name = "gcc_cpuss_rbcpr_clk", 1066 .ops = &clk_branch2_ops, 1067 }, 1068 }, 1069 }; 1070 1071 static struct clk_branch gcc_ddrss_gpu_axi_clk = { 1072 .halt_reg = 0x2d038, 1073 .halt_check = BRANCH_VOTED, 1074 .hwcg_reg = 0x2d038, 1075 .hwcg_bit = 1, 1076 .clkr = { 1077 .enable_reg = 0x2d038, 1078 .enable_mask = BIT(0), 1079 .hw.init = &(struct clk_init_data){ 1080 .name = "gcc_ddrss_gpu_axi_clk", 1081 .ops = &clk_branch2_ops, 1082 }, 1083 }, 1084 }; 1085 1086 static struct clk_branch gcc_disp_ahb_clk = { 1087 .halt_reg = 0x1700c, 1088 .halt_check = BRANCH_HALT, 1089 .hwcg_reg = 0x1700c, 1090 .hwcg_bit = 1, 1091 .clkr = { 1092 .enable_reg = 0x1700c, 1093 .enable_mask = BIT(0), 1094 .hw.init = &(struct clk_init_data){ 1095 .name = "gcc_disp_ahb_clk", 1096 .flags = CLK_IS_CRITICAL, 1097 .ops = &clk_branch2_ops, 1098 }, 1099 }, 1100 }; 1101 1102 static struct clk_branch gcc_disp_axi_clk = { 1103 .halt_reg = 0x1701c, 1104 .halt_check = BRANCH_HALT, 1105 .hwcg_reg = 0x1701c, 1106 .hwcg_bit = 1, 1107 .clkr = { 1108 .enable_reg = 0x1701c, 1109 .enable_mask = BIT(0), 1110 .hw.init = &(struct clk_init_data){ 1111 .name = "gcc_disp_axi_clk", 1112 .ops = &clk_branch2_ops, 1113 }, 1114 }, 1115 }; 1116 1117 static struct clk_branch gcc_disp_cc_sleep_clk = { 1118 .halt_reg = 0x17074, 1119 .halt_check = BRANCH_HALT_DELAY, 1120 .hwcg_reg = 0x17074, 1121 .hwcg_bit = 1, 1122 .clkr = { 1123 .enable_reg = 0x17074, 1124 .enable_mask = BIT(0), 1125 .hw.init = &(struct clk_init_data){ 1126 .name = "gcc_disp_cc_sleep_clk", 1127 .ops = &clk_branch2_ops, 1128 }, 1129 }, 1130 }; 1131 1132 static struct clk_branch gcc_disp_cc_xo_clk = { 1133 .halt_reg = 0x17070, 1134 .halt_check = BRANCH_HALT, 1135 .hwcg_reg = 0x17070, 1136 .hwcg_bit = 1, 1137 .clkr = { 1138 .enable_reg = 0x17070, 1139 .enable_mask = BIT(0), 1140 .hw.init = &(struct clk_init_data){ 1141 .name = "gcc_disp_cc_xo_clk", 1142 .flags = CLK_IS_CRITICAL, 1143 .ops = &clk_branch2_ops, 1144 }, 1145 }, 1146 }; 1147 1148 static struct clk_branch gcc_disp_gpll0_clk = { 1149 .halt_check = BRANCH_HALT_DELAY, 1150 .clkr = { 1151 .enable_reg = 0x52000, 1152 .enable_mask = BIT(2), 1153 .hw.init = &(struct clk_init_data){ 1154 .name = "gcc_disp_gpll0_clk", 1155 .parent_hws = (const struct clk_hw*[]){ 1156 &gpll0.clkr.hw, 1157 }, 1158 .num_parents = 1, 1159 .ops = &clk_branch2_ops, 1160 }, 1161 }, 1162 }; 1163 1164 static struct clk_branch gcc_disp_throttle_axi_clk = { 1165 .halt_reg = 0x17028, 1166 .halt_check = BRANCH_HALT, 1167 .hwcg_reg = 0x17028, 1168 .hwcg_bit = 1, 1169 .clkr = { 1170 .enable_reg = 0x17028, 1171 .enable_mask = BIT(0), 1172 .hw.init = &(struct clk_init_data){ 1173 .name = "gcc_disp_throttle_axi_clk", 1174 .ops = &clk_branch2_ops, 1175 }, 1176 }, 1177 }; 1178 1179 static struct clk_branch gcc_disp_xo_clk = { 1180 .halt_reg = 0x17034, 1181 .halt_check = BRANCH_HALT, 1182 .clkr = { 1183 .enable_reg = 0x17034, 1184 .enable_mask = BIT(0), 1185 .hw.init = &(struct clk_init_data){ 1186 .name = "gcc_disp_xo_clk", 1187 .ops = &clk_branch2_ops, 1188 }, 1189 }, 1190 }; 1191 1192 static struct clk_branch gcc_gp1_clk = { 1193 .halt_reg = 0x37000, 1194 .halt_check = BRANCH_HALT, 1195 .clkr = { 1196 .enable_reg = 0x37000, 1197 .enable_mask = BIT(0), 1198 .hw.init = &(struct clk_init_data){ 1199 .name = "gcc_gp1_clk", 1200 .parent_hws = (const struct clk_hw*[]){ 1201 &gcc_gp1_clk_src.clkr.hw, 1202 }, 1203 .num_parents = 1, 1204 .flags = CLK_SET_RATE_PARENT, 1205 .ops = &clk_branch2_ops, 1206 }, 1207 }, 1208 }; 1209 1210 static struct clk_branch gcc_gp2_clk = { 1211 .halt_reg = 0x38000, 1212 .halt_check = BRANCH_HALT, 1213 .clkr = { 1214 .enable_reg = 0x38000, 1215 .enable_mask = BIT(0), 1216 .hw.init = &(struct clk_init_data){ 1217 .name = "gcc_gp2_clk", 1218 .parent_hws = (const struct clk_hw*[]){ 1219 &gcc_gp2_clk_src.clkr.hw, 1220 }, 1221 .num_parents = 1, 1222 .flags = CLK_SET_RATE_PARENT, 1223 .ops = &clk_branch2_ops, 1224 }, 1225 }, 1226 }; 1227 1228 static struct clk_branch gcc_gp3_clk = { 1229 .halt_reg = 0x39000, 1230 .halt_check = BRANCH_HALT, 1231 .clkr = { 1232 .enable_reg = 0x39000, 1233 .enable_mask = BIT(0), 1234 .hw.init = &(struct clk_init_data){ 1235 .name = "gcc_gp3_clk", 1236 .parent_hws = (const struct clk_hw*[]){ 1237 &gcc_gp3_clk_src.clkr.hw, 1238 }, 1239 .num_parents = 1, 1240 .flags = CLK_SET_RATE_PARENT, 1241 .ops = &clk_branch2_ops, 1242 }, 1243 }, 1244 }; 1245 1246 static struct clk_branch gcc_gpu_cfg_ahb_clk = { 1247 .halt_reg = 0x45004, 1248 .halt_check = BRANCH_HALT, 1249 .hwcg_reg = 0x45004, 1250 .hwcg_bit = 1, 1251 .clkr = { 1252 .enable_reg = 0x45004, 1253 .enable_mask = BIT(0), 1254 .hw.init = &(struct clk_init_data){ 1255 .name = "gcc_gpu_cfg_ahb_clk", 1256 .flags = CLK_IS_CRITICAL, 1257 .ops = &clk_branch2_ops, 1258 }, 1259 }, 1260 }; 1261 1262 static struct clk_branch gcc_gpu_gpll0_clk = { 1263 .halt_check = BRANCH_HALT_DELAY, 1264 .clkr = { 1265 .enable_reg = 0x52008, 1266 .enable_mask = BIT(7), 1267 .hw.init = &(struct clk_init_data){ 1268 .name = "gcc_gpu_gpll0_clk", 1269 .parent_hws = (const struct clk_hw*[]){ 1270 &gpll0.clkr.hw, 1271 }, 1272 .num_parents = 1, 1273 .ops = &clk_branch2_ops, 1274 }, 1275 }, 1276 }; 1277 1278 static struct clk_branch gcc_gpu_gpll0_div_clk = { 1279 .halt_check = BRANCH_HALT_DELAY, 1280 .clkr = { 1281 .enable_reg = 0x52008, 1282 .enable_mask = BIT(8), 1283 .hw.init = &(struct clk_init_data){ 1284 .name = "gcc_gpu_gpll0_div_clk", 1285 .parent_hws = (const struct clk_hw*[]){ 1286 &gcc_gpu_gpll0_main_div_clk_src.clkr.hw, 1287 }, 1288 .num_parents = 1, 1289 .ops = &clk_branch2_ops, 1290 }, 1291 }, 1292 }; 1293 1294 static struct clk_branch gcc_gpu_memnoc_gfx_clk = { 1295 .halt_reg = 0x4500c, 1296 .halt_check = BRANCH_VOTED, 1297 .hwcg_reg = 0x4500c, 1298 .hwcg_bit = 1, 1299 .clkr = { 1300 .enable_reg = 0x4500c, 1301 .enable_mask = BIT(0), 1302 .hw.init = &(struct clk_init_data){ 1303 .name = "gcc_gpu_memnoc_gfx_clk", 1304 .ops = &clk_branch2_ops, 1305 }, 1306 }, 1307 }; 1308 1309 static struct clk_branch gcc_gpu_snoc_dvm_gfx_clk = { 1310 .halt_reg = 0x45014, 1311 .halt_check = BRANCH_HALT, 1312 .hwcg_reg = 0x45014, 1313 .hwcg_bit = 1, 1314 .clkr = { 1315 .enable_reg = 0x45014, 1316 .enable_mask = BIT(0), 1317 .hw.init = &(struct clk_init_data){ 1318 .name = "gcc_gpu_snoc_dvm_gfx_clk", 1319 .ops = &clk_branch2_ops, 1320 }, 1321 }, 1322 }; 1323 1324 static struct clk_branch gcc_npu_axi_clk = { 1325 .halt_reg = 0x4c008, 1326 .halt_check = BRANCH_VOTED, 1327 .hwcg_reg = 0x4c008, 1328 .hwcg_bit = 1, 1329 .clkr = { 1330 .enable_reg = 0x4c008, 1331 .enable_mask = BIT(0), 1332 .hw.init = &(struct clk_init_data){ 1333 .name = "gcc_npu_axi_clk", 1334 .ops = &clk_branch2_ops, 1335 }, 1336 }, 1337 }; 1338 1339 static struct clk_branch gcc_npu_bwmon_axi_clk = { 1340 .halt_reg = 0x4d004, 1341 .halt_check = BRANCH_HALT_DELAY, 1342 .hwcg_reg = 0x4d004, 1343 .hwcg_bit = 1, 1344 .clkr = { 1345 .enable_reg = 0x4d004, 1346 .enable_mask = BIT(0), 1347 .hw.init = &(struct clk_init_data){ 1348 .name = "gcc_npu_bwmon_axi_clk", 1349 .ops = &clk_branch2_ops, 1350 }, 1351 }, 1352 }; 1353 1354 static struct clk_branch gcc_npu_bwmon_dma_cfg_ahb_clk = { 1355 .halt_reg = 0x4d008, 1356 .halt_check = BRANCH_HALT, 1357 .clkr = { 1358 .enable_reg = 0x4d008, 1359 .enable_mask = BIT(0), 1360 .hw.init = &(struct clk_init_data){ 1361 .name = "gcc_npu_bwmon_dma_cfg_ahb_clk", 1362 .ops = &clk_branch2_ops, 1363 }, 1364 }, 1365 }; 1366 1367 static struct clk_branch gcc_npu_bwmon_dsp_cfg_ahb_clk = { 1368 .halt_reg = 0x4d00c, 1369 .halt_check = BRANCH_HALT, 1370 .clkr = { 1371 .enable_reg = 0x4d00c, 1372 .enable_mask = BIT(0), 1373 .hw.init = &(struct clk_init_data){ 1374 .name = "gcc_npu_bwmon_dsp_cfg_ahb_clk", 1375 .ops = &clk_branch2_ops, 1376 }, 1377 }, 1378 }; 1379 1380 static struct clk_branch gcc_npu_cfg_ahb_clk = { 1381 .halt_reg = 0x4c004, 1382 .halt_check = BRANCH_HALT, 1383 .hwcg_reg = 0x4c004, 1384 .hwcg_bit = 1, 1385 .clkr = { 1386 .enable_reg = 0x4c004, 1387 .enable_mask = BIT(0), 1388 .hw.init = &(struct clk_init_data){ 1389 .name = "gcc_npu_cfg_ahb_clk", 1390 .flags = CLK_IS_CRITICAL, 1391 .ops = &clk_branch2_ops, 1392 }, 1393 }, 1394 }; 1395 1396 static struct clk_branch gcc_npu_dma_clk = { 1397 .halt_reg = 0x4c140, 1398 .halt_check = BRANCH_VOTED, 1399 .hwcg_reg = 0x4c140, 1400 .hwcg_bit = 1, 1401 .clkr = { 1402 .enable_reg = 0x4c140, 1403 .enable_mask = BIT(0), 1404 .hw.init = &(struct clk_init_data){ 1405 .name = "gcc_npu_dma_clk", 1406 .ops = &clk_branch2_ops, 1407 }, 1408 }, 1409 }; 1410 1411 static struct clk_branch gcc_npu_gpll0_clk = { 1412 .halt_check = BRANCH_HALT_DELAY, 1413 .clkr = { 1414 .enable_reg = 0x52008, 1415 .enable_mask = BIT(9), 1416 .hw.init = &(struct clk_init_data){ 1417 .name = "gcc_npu_gpll0_clk", 1418 .parent_hws = (const struct clk_hw*[]){ 1419 &gpll0.clkr.hw, 1420 }, 1421 .num_parents = 1, 1422 .ops = &clk_branch2_ops, 1423 }, 1424 }, 1425 }; 1426 1427 static struct clk_branch gcc_npu_gpll0_div_clk = { 1428 .halt_check = BRANCH_HALT_DELAY, 1429 .clkr = { 1430 .enable_reg = 0x52008, 1431 .enable_mask = BIT(10), 1432 .hw.init = &(struct clk_init_data){ 1433 .name = "gcc_npu_gpll0_div_clk", 1434 .parent_hws = (const struct clk_hw*[]){ 1435 &gcc_npu_pll0_main_div_clk_src.clkr.hw, 1436 }, 1437 .num_parents = 1, 1438 .ops = &clk_branch2_ops, 1439 }, 1440 }, 1441 }; 1442 1443 static struct clk_branch gcc_pdm2_clk = { 1444 .halt_reg = 0x2300c, 1445 .halt_check = BRANCH_HALT, 1446 .clkr = { 1447 .enable_reg = 0x2300c, 1448 .enable_mask = BIT(0), 1449 .hw.init = &(struct clk_init_data){ 1450 .name = "gcc_pdm2_clk", 1451 .parent_hws = (const struct clk_hw*[]){ 1452 &gcc_pdm2_clk_src.clkr.hw, 1453 }, 1454 .num_parents = 1, 1455 .flags = CLK_SET_RATE_PARENT, 1456 .ops = &clk_branch2_ops, 1457 }, 1458 }, 1459 }; 1460 1461 static struct clk_branch gcc_pdm_ahb_clk = { 1462 .halt_reg = 0x23004, 1463 .halt_check = BRANCH_HALT, 1464 .hwcg_reg = 0x23004, 1465 .hwcg_bit = 1, 1466 .clkr = { 1467 .enable_reg = 0x23004, 1468 .enable_mask = BIT(0), 1469 .hw.init = &(struct clk_init_data){ 1470 .name = "gcc_pdm_ahb_clk", 1471 .ops = &clk_branch2_ops, 1472 }, 1473 }, 1474 }; 1475 1476 static struct clk_branch gcc_pdm_xo4_clk = { 1477 .halt_reg = 0x23008, 1478 .halt_check = BRANCH_HALT, 1479 .clkr = { 1480 .enable_reg = 0x23008, 1481 .enable_mask = BIT(0), 1482 .hw.init = &(struct clk_init_data){ 1483 .name = "gcc_pdm_xo4_clk", 1484 .ops = &clk_branch2_ops, 1485 }, 1486 }, 1487 }; 1488 1489 static struct clk_branch gcc_prng_ahb_clk = { 1490 .halt_reg = 0x24004, 1491 .halt_check = BRANCH_HALT_VOTED, 1492 .hwcg_reg = 0x24004, 1493 .hwcg_bit = 1, 1494 .clkr = { 1495 .enable_reg = 0x52000, 1496 .enable_mask = BIT(26), 1497 .hw.init = &(struct clk_init_data){ 1498 .name = "gcc_prng_ahb_clk", 1499 .ops = &clk_branch2_ops, 1500 }, 1501 }, 1502 }; 1503 1504 static struct clk_branch gcc_qupv3_wrap0_core_2x_clk = { 1505 .halt_reg = 0x21014, 1506 .halt_check = BRANCH_HALT_VOTED, 1507 .clkr = { 1508 .enable_reg = 0x52000, 1509 .enable_mask = BIT(9), 1510 .hw.init = &(struct clk_init_data){ 1511 .name = "gcc_qupv3_wrap0_core_2x_clk", 1512 .ops = &clk_branch2_ops, 1513 }, 1514 }, 1515 }; 1516 1517 static struct clk_branch gcc_qupv3_wrap0_core_clk = { 1518 .halt_reg = 0x2100c, 1519 .halt_check = BRANCH_HALT_VOTED, 1520 .clkr = { 1521 .enable_reg = 0x52000, 1522 .enable_mask = BIT(8), 1523 .hw.init = &(struct clk_init_data){ 1524 .name = "gcc_qupv3_wrap0_core_clk", 1525 .ops = &clk_branch2_ops, 1526 }, 1527 }, 1528 }; 1529 1530 static struct clk_branch gcc_qupv3_wrap0_s0_clk = { 1531 .halt_reg = 0x21144, 1532 .halt_check = BRANCH_HALT_VOTED, 1533 .clkr = { 1534 .enable_reg = 0x52000, 1535 .enable_mask = BIT(10), 1536 .hw.init = &(struct clk_init_data){ 1537 .name = "gcc_qupv3_wrap0_s0_clk", 1538 .parent_hws = (const struct clk_hw*[]){ 1539 &gcc_qupv3_wrap0_s0_clk_src.clkr.hw, 1540 }, 1541 .num_parents = 1, 1542 .flags = CLK_SET_RATE_PARENT, 1543 .ops = &clk_branch2_ops, 1544 }, 1545 }, 1546 }; 1547 1548 static struct clk_branch gcc_qupv3_wrap0_s1_clk = { 1549 .halt_reg = 0x21274, 1550 .halt_check = BRANCH_HALT_VOTED, 1551 .clkr = { 1552 .enable_reg = 0x52000, 1553 .enable_mask = BIT(11), 1554 .hw.init = &(struct clk_init_data){ 1555 .name = "gcc_qupv3_wrap0_s1_clk", 1556 .parent_hws = (const struct clk_hw*[]){ 1557 &gcc_qupv3_wrap0_s1_clk_src.clkr.hw, 1558 }, 1559 .num_parents = 1, 1560 .flags = CLK_SET_RATE_PARENT, 1561 .ops = &clk_branch2_ops, 1562 }, 1563 }, 1564 }; 1565 1566 static struct clk_branch gcc_qupv3_wrap0_s2_clk = { 1567 .halt_reg = 0x213a4, 1568 .halt_check = BRANCH_HALT_VOTED, 1569 .clkr = { 1570 .enable_reg = 0x52000, 1571 .enable_mask = BIT(12), 1572 .hw.init = &(struct clk_init_data){ 1573 .name = "gcc_qupv3_wrap0_s2_clk", 1574 .parent_hws = (const struct clk_hw*[]){ 1575 &gcc_qupv3_wrap0_s2_clk_src.clkr.hw, 1576 }, 1577 .num_parents = 1, 1578 .flags = CLK_SET_RATE_PARENT, 1579 .ops = &clk_branch2_ops, 1580 }, 1581 }, 1582 }; 1583 1584 static struct clk_branch gcc_qupv3_wrap0_s3_clk = { 1585 .halt_reg = 0x214d4, 1586 .halt_check = BRANCH_HALT_VOTED, 1587 .clkr = { 1588 .enable_reg = 0x52000, 1589 .enable_mask = BIT(13), 1590 .hw.init = &(struct clk_init_data){ 1591 .name = "gcc_qupv3_wrap0_s3_clk", 1592 .parent_hws = (const struct clk_hw*[]){ 1593 &gcc_qupv3_wrap0_s3_clk_src.clkr.hw, 1594 }, 1595 .num_parents = 1, 1596 .flags = CLK_SET_RATE_PARENT, 1597 .ops = &clk_branch2_ops, 1598 }, 1599 }, 1600 }; 1601 1602 static struct clk_branch gcc_qupv3_wrap0_s4_clk = { 1603 .halt_reg = 0x21604, 1604 .halt_check = BRANCH_HALT_VOTED, 1605 .clkr = { 1606 .enable_reg = 0x52000, 1607 .enable_mask = BIT(14), 1608 .hw.init = &(struct clk_init_data){ 1609 .name = "gcc_qupv3_wrap0_s4_clk", 1610 .parent_hws = (const struct clk_hw*[]){ 1611 &gcc_qupv3_wrap0_s4_clk_src.clkr.hw, 1612 }, 1613 .num_parents = 1, 1614 .flags = CLK_SET_RATE_PARENT, 1615 .ops = &clk_branch2_ops, 1616 }, 1617 }, 1618 }; 1619 1620 static struct clk_branch gcc_qupv3_wrap0_s5_clk = { 1621 .halt_reg = 0x21734, 1622 .halt_check = BRANCH_HALT_VOTED, 1623 .clkr = { 1624 .enable_reg = 0x52000, 1625 .enable_mask = BIT(15), 1626 .hw.init = &(struct clk_init_data){ 1627 .name = "gcc_qupv3_wrap0_s5_clk", 1628 .parent_hws = (const struct clk_hw*[]){ 1629 &gcc_qupv3_wrap0_s5_clk_src.clkr.hw, 1630 }, 1631 .num_parents = 1, 1632 .flags = CLK_SET_RATE_PARENT, 1633 .ops = &clk_branch2_ops, 1634 }, 1635 }, 1636 }; 1637 1638 static struct clk_branch gcc_qupv3_wrap1_core_2x_clk = { 1639 .halt_reg = 0x22004, 1640 .halt_check = BRANCH_HALT_VOTED, 1641 .clkr = { 1642 .enable_reg = 0x52000, 1643 .enable_mask = BIT(16), 1644 .hw.init = &(struct clk_init_data){ 1645 .name = "gcc_qupv3_wrap1_core_2x_clk", 1646 .ops = &clk_branch2_ops, 1647 }, 1648 }, 1649 }; 1650 1651 static struct clk_branch gcc_qupv3_wrap1_core_clk = { 1652 .halt_reg = 0x22008, 1653 .halt_check = BRANCH_HALT_VOTED, 1654 .clkr = { 1655 .enable_reg = 0x52000, 1656 .enable_mask = BIT(17), 1657 .hw.init = &(struct clk_init_data){ 1658 .name = "gcc_qupv3_wrap1_core_clk", 1659 .ops = &clk_branch2_ops, 1660 }, 1661 }, 1662 }; 1663 1664 static struct clk_branch gcc_qupv3_wrap1_s0_clk = { 1665 .halt_reg = 0x22014, 1666 .halt_check = BRANCH_HALT_VOTED, 1667 .clkr = { 1668 .enable_reg = 0x52000, 1669 .enable_mask = BIT(20), 1670 .hw.init = &(struct clk_init_data){ 1671 .name = "gcc_qupv3_wrap1_s0_clk", 1672 .parent_hws = (const struct clk_hw*[]){ 1673 &gcc_qupv3_wrap1_s0_clk_src.clkr.hw, 1674 }, 1675 .num_parents = 1, 1676 .flags = CLK_SET_RATE_PARENT, 1677 .ops = &clk_branch2_ops, 1678 }, 1679 }, 1680 }; 1681 1682 static struct clk_branch gcc_qupv3_wrap1_s1_clk = { 1683 .halt_reg = 0x22144, 1684 .halt_check = BRANCH_HALT_VOTED, 1685 .clkr = { 1686 .enable_reg = 0x52000, 1687 .enable_mask = BIT(21), 1688 .hw.init = &(struct clk_init_data){ 1689 .name = "gcc_qupv3_wrap1_s1_clk", 1690 .parent_hws = (const struct clk_hw*[]){ 1691 &gcc_qupv3_wrap1_s1_clk_src.clkr.hw, 1692 }, 1693 .num_parents = 1, 1694 .flags = CLK_SET_RATE_PARENT, 1695 .ops = &clk_branch2_ops, 1696 }, 1697 }, 1698 }; 1699 1700 static struct clk_branch gcc_qupv3_wrap1_s2_clk = { 1701 .halt_reg = 0x22274, 1702 .halt_check = BRANCH_HALT_VOTED, 1703 .clkr = { 1704 .enable_reg = 0x52000, 1705 .enable_mask = BIT(22), 1706 .hw.init = &(struct clk_init_data){ 1707 .name = "gcc_qupv3_wrap1_s2_clk", 1708 .parent_hws = (const struct clk_hw*[]){ 1709 &gcc_qupv3_wrap1_s2_clk_src.clkr.hw, 1710 }, 1711 .num_parents = 1, 1712 .flags = CLK_SET_RATE_PARENT, 1713 .ops = &clk_branch2_ops, 1714 }, 1715 }, 1716 }; 1717 1718 static struct clk_branch gcc_qupv3_wrap1_s3_clk = { 1719 .halt_reg = 0x223a4, 1720 .halt_check = BRANCH_HALT_VOTED, 1721 .clkr = { 1722 .enable_reg = 0x52000, 1723 .enable_mask = BIT(23), 1724 .hw.init = &(struct clk_init_data){ 1725 .name = "gcc_qupv3_wrap1_s3_clk", 1726 .parent_hws = (const struct clk_hw*[]){ 1727 &gcc_qupv3_wrap1_s3_clk_src.clkr.hw, 1728 }, 1729 .num_parents = 1, 1730 .flags = CLK_SET_RATE_PARENT, 1731 .ops = &clk_branch2_ops, 1732 }, 1733 }, 1734 }; 1735 1736 static struct clk_branch gcc_qupv3_wrap1_s4_clk = { 1737 .halt_reg = 0x224d4, 1738 .halt_check = BRANCH_HALT_VOTED, 1739 .clkr = { 1740 .enable_reg = 0x52000, 1741 .enable_mask = BIT(24), 1742 .hw.init = &(struct clk_init_data){ 1743 .name = "gcc_qupv3_wrap1_s4_clk", 1744 .parent_hws = (const struct clk_hw*[]){ 1745 &gcc_qupv3_wrap1_s4_clk_src.clkr.hw, 1746 }, 1747 .num_parents = 1, 1748 .flags = CLK_SET_RATE_PARENT, 1749 .ops = &clk_branch2_ops, 1750 }, 1751 }, 1752 }; 1753 1754 static struct clk_branch gcc_qupv3_wrap1_s5_clk = { 1755 .halt_reg = 0x22604, 1756 .halt_check = BRANCH_HALT_VOTED, 1757 .clkr = { 1758 .enable_reg = 0x52000, 1759 .enable_mask = BIT(25), 1760 .hw.init = &(struct clk_init_data){ 1761 .name = "gcc_qupv3_wrap1_s5_clk", 1762 .parent_hws = (const struct clk_hw*[]){ 1763 &gcc_qupv3_wrap1_s5_clk_src.clkr.hw, 1764 }, 1765 .num_parents = 1, 1766 .flags = CLK_SET_RATE_PARENT, 1767 .ops = &clk_branch2_ops, 1768 }, 1769 }, 1770 }; 1771 1772 static struct clk_branch gcc_qupv3_wrap_0_m_ahb_clk = { 1773 .halt_reg = 0x21004, 1774 .halt_check = BRANCH_HALT_VOTED, 1775 .hwcg_reg = 0x21004, 1776 .hwcg_bit = 1, 1777 .clkr = { 1778 .enable_reg = 0x52000, 1779 .enable_mask = BIT(6), 1780 .hw.init = &(struct clk_init_data){ 1781 .name = "gcc_qupv3_wrap_0_m_ahb_clk", 1782 .ops = &clk_branch2_ops, 1783 }, 1784 }, 1785 }; 1786 1787 static struct clk_branch gcc_qupv3_wrap_0_s_ahb_clk = { 1788 .halt_reg = 0x21008, 1789 .halt_check = BRANCH_HALT_VOTED, 1790 .hwcg_reg = 0x21008, 1791 .hwcg_bit = 1, 1792 .clkr = { 1793 .enable_reg = 0x52000, 1794 .enable_mask = BIT(7), 1795 .hw.init = &(struct clk_init_data){ 1796 .name = "gcc_qupv3_wrap_0_s_ahb_clk", 1797 .ops = &clk_branch2_ops, 1798 }, 1799 }, 1800 }; 1801 1802 static struct clk_branch gcc_qupv3_wrap_1_m_ahb_clk = { 1803 .halt_reg = 0x2200c, 1804 .halt_check = BRANCH_HALT_VOTED, 1805 .hwcg_reg = 0x2200c, 1806 .hwcg_bit = 1, 1807 .clkr = { 1808 .enable_reg = 0x52000, 1809 .enable_mask = BIT(18), 1810 .hw.init = &(struct clk_init_data){ 1811 .name = "gcc_qupv3_wrap_1_m_ahb_clk", 1812 .ops = &clk_branch2_ops, 1813 }, 1814 }, 1815 }; 1816 1817 static struct clk_branch gcc_qupv3_wrap_1_s_ahb_clk = { 1818 .halt_reg = 0x22010, 1819 .halt_check = BRANCH_HALT_VOTED, 1820 .hwcg_reg = 0x22010, 1821 .hwcg_bit = 1, 1822 .clkr = { 1823 .enable_reg = 0x52000, 1824 .enable_mask = BIT(19), 1825 .hw.init = &(struct clk_init_data){ 1826 .name = "gcc_qupv3_wrap_1_s_ahb_clk", 1827 .ops = &clk_branch2_ops, 1828 }, 1829 }, 1830 }; 1831 1832 static struct clk_branch gcc_sdcc1_ahb_clk = { 1833 .halt_reg = 0x4b004, 1834 .halt_check = BRANCH_HALT, 1835 .clkr = { 1836 .enable_reg = 0x4b004, 1837 .enable_mask = BIT(0), 1838 .hw.init = &(struct clk_init_data){ 1839 .name = "gcc_sdcc1_ahb_clk", 1840 .ops = &clk_branch2_ops, 1841 }, 1842 }, 1843 }; 1844 1845 static struct clk_branch gcc_sdcc1_apps_clk = { 1846 .halt_reg = 0x4b008, 1847 .halt_check = BRANCH_HALT, 1848 .clkr = { 1849 .enable_reg = 0x4b008, 1850 .enable_mask = BIT(0), 1851 .hw.init = &(struct clk_init_data){ 1852 .name = "gcc_sdcc1_apps_clk", 1853 .parent_hws = (const struct clk_hw*[]){ 1854 &gcc_sdcc1_apps_clk_src.clkr.hw, 1855 }, 1856 .num_parents = 1, 1857 .flags = CLK_SET_RATE_PARENT, 1858 .ops = &clk_branch2_ops, 1859 }, 1860 }, 1861 }; 1862 1863 static struct clk_branch gcc_sdcc1_ice_core_clk = { 1864 .halt_reg = 0x4b03c, 1865 .halt_check = BRANCH_HALT, 1866 .hwcg_reg = 0x4b03c, 1867 .hwcg_bit = 1, 1868 .clkr = { 1869 .enable_reg = 0x4b03c, 1870 .enable_mask = BIT(0), 1871 .hw.init = &(struct clk_init_data){ 1872 .name = "gcc_sdcc1_ice_core_clk", 1873 .parent_hws = (const struct clk_hw*[]){ 1874 &gcc_sdcc1_ice_core_clk_src.clkr.hw, 1875 }, 1876 .num_parents = 1, 1877 .flags = CLK_SET_RATE_PARENT, 1878 .ops = &clk_branch2_ops, 1879 }, 1880 }, 1881 }; 1882 1883 static struct clk_branch gcc_sdcc2_ahb_clk = { 1884 .halt_reg = 0x20008, 1885 .halt_check = BRANCH_HALT, 1886 .clkr = { 1887 .enable_reg = 0x20008, 1888 .enable_mask = BIT(0), 1889 .hw.init = &(struct clk_init_data){ 1890 .name = "gcc_sdcc2_ahb_clk", 1891 .ops = &clk_branch2_ops, 1892 }, 1893 }, 1894 }; 1895 1896 static struct clk_branch gcc_sdcc2_apps_clk = { 1897 .halt_reg = 0x20004, 1898 .halt_check = BRANCH_HALT, 1899 .clkr = { 1900 .enable_reg = 0x20004, 1901 .enable_mask = BIT(0), 1902 .hw.init = &(struct clk_init_data){ 1903 .name = "gcc_sdcc2_apps_clk", 1904 .parent_hws = (const struct clk_hw*[]){ 1905 &gcc_sdcc2_apps_clk_src.clkr.hw, 1906 }, 1907 .num_parents = 1, 1908 .flags = CLK_SET_RATE_PARENT, 1909 .ops = &clk_branch2_ops, 1910 }, 1911 }, 1912 }; 1913 1914 static struct clk_branch gcc_sys_noc_cpuss_ahb_clk = { 1915 .halt_reg = 0x10140, 1916 .halt_check = BRANCH_HALT_VOTED, 1917 .hwcg_reg = 0x10140, 1918 .hwcg_bit = 1, 1919 .clkr = { 1920 .enable_reg = 0x52000, 1921 .enable_mask = BIT(0), 1922 .hw.init = &(struct clk_init_data){ 1923 .name = "gcc_sys_noc_cpuss_ahb_clk", 1924 .parent_hws = (const struct clk_hw*[]){ 1925 &gcc_cpuss_ahb_clk_src.clkr.hw, 1926 }, 1927 .num_parents = 1, 1928 .flags = CLK_IS_CRITICAL | CLK_SET_RATE_PARENT, 1929 .ops = &clk_branch2_ops, 1930 }, 1931 }, 1932 }; 1933 1934 static struct clk_branch gcc_ufs_mem_clkref_clk = { 1935 .halt_reg = 0x8c000, 1936 .halt_check = BRANCH_HALT, 1937 .clkr = { 1938 .enable_reg = 0x8c000, 1939 .enable_mask = BIT(0), 1940 .hw.init = &(struct clk_init_data){ 1941 .name = "gcc_ufs_mem_clkref_clk", 1942 .ops = &clk_branch2_ops, 1943 }, 1944 }, 1945 }; 1946 1947 static struct clk_branch gcc_ufs_phy_ahb_clk = { 1948 .halt_reg = 0x3a00c, 1949 .halt_check = BRANCH_HALT, 1950 .hwcg_reg = 0x3a00c, 1951 .hwcg_bit = 1, 1952 .clkr = { 1953 .enable_reg = 0x3a00c, 1954 .enable_mask = BIT(0), 1955 .hw.init = &(struct clk_init_data){ 1956 .name = "gcc_ufs_phy_ahb_clk", 1957 .ops = &clk_branch2_ops, 1958 }, 1959 }, 1960 }; 1961 1962 static struct clk_branch gcc_ufs_phy_axi_clk = { 1963 .halt_reg = 0x3a034, 1964 .halt_check = BRANCH_HALT, 1965 .hwcg_reg = 0x3a034, 1966 .hwcg_bit = 1, 1967 .clkr = { 1968 .enable_reg = 0x3a034, 1969 .enable_mask = BIT(0), 1970 .hw.init = &(struct clk_init_data){ 1971 .name = "gcc_ufs_phy_axi_clk", 1972 .parent_hws = (const struct clk_hw*[]){ 1973 &gcc_ufs_phy_axi_clk_src.clkr.hw, 1974 }, 1975 .num_parents = 1, 1976 .flags = CLK_SET_RATE_PARENT, 1977 .ops = &clk_branch2_ops, 1978 }, 1979 }, 1980 }; 1981 1982 static struct clk_branch gcc_ufs_phy_ice_core_clk = { 1983 .halt_reg = 0x3a0a4, 1984 .halt_check = BRANCH_HALT, 1985 .hwcg_reg = 0x3a0a4, 1986 .hwcg_bit = 1, 1987 .clkr = { 1988 .enable_reg = 0x3a0a4, 1989 .enable_mask = BIT(0), 1990 .hw.init = &(struct clk_init_data){ 1991 .name = "gcc_ufs_phy_ice_core_clk", 1992 .parent_hws = (const struct clk_hw*[]){ 1993 &gcc_ufs_phy_ice_core_clk_src.clkr.hw, 1994 }, 1995 .num_parents = 1, 1996 .flags = CLK_SET_RATE_PARENT, 1997 .ops = &clk_branch2_ops, 1998 }, 1999 }, 2000 }; 2001 2002 static struct clk_branch gcc_ufs_phy_ice_core_hw_ctl_clk = { 2003 .halt_reg = 0x3a0a4, 2004 .halt_check = BRANCH_HALT, 2005 .hwcg_reg = 0x3a0a4, 2006 .hwcg_bit = 1, 2007 .clkr = { 2008 .enable_reg = 0x3a0a4, 2009 .enable_mask = BIT(1), 2010 .hw.init = &(struct clk_init_data){ 2011 .name = "gcc_ufs_phy_ice_core_hw_ctl_clk", 2012 .parent_hws = (const struct clk_hw*[]){ 2013 &gcc_ufs_phy_ice_core_clk_src.clkr.hw, 2014 }, 2015 .num_parents = 1, 2016 .flags = CLK_SET_RATE_PARENT, 2017 .ops = &clk_branch2_ops, 2018 }, 2019 }, 2020 }; 2021 2022 static struct clk_branch gcc_ufs_phy_phy_aux_clk = { 2023 .halt_reg = 0x3a0ac, 2024 .halt_check = BRANCH_HALT, 2025 .hwcg_reg = 0x3a0ac, 2026 .hwcg_bit = 1, 2027 .clkr = { 2028 .enable_reg = 0x3a0ac, 2029 .enable_mask = BIT(0), 2030 .hw.init = &(struct clk_init_data){ 2031 .name = "gcc_ufs_phy_phy_aux_clk", 2032 .parent_hws = (const struct clk_hw*[]){ 2033 &gcc_ufs_phy_phy_aux_clk_src.clkr.hw, 2034 }, 2035 .num_parents = 1, 2036 .flags = CLK_SET_RATE_PARENT, 2037 .ops = &clk_branch2_ops, 2038 }, 2039 }, 2040 }; 2041 2042 static struct clk_branch gcc_ufs_phy_phy_aux_hw_ctl_clk = { 2043 .halt_reg = 0x3a0ac, 2044 .halt_check = BRANCH_HALT, 2045 .hwcg_reg = 0x3a0ac, 2046 .hwcg_bit = 1, 2047 .clkr = { 2048 .enable_reg = 0x3a0ac, 2049 .enable_mask = BIT(1), 2050 .hw.init = &(struct clk_init_data){ 2051 .name = "gcc_ufs_phy_phy_aux_hw_ctl_clk", 2052 .parent_hws = (const struct clk_hw*[]){ 2053 &gcc_ufs_phy_phy_aux_clk_src.clkr.hw, 2054 }, 2055 .num_parents = 1, 2056 .flags = CLK_SET_RATE_PARENT, 2057 .ops = &clk_branch2_ops, 2058 }, 2059 }, 2060 }; 2061 2062 static struct clk_branch gcc_ufs_phy_rx_symbol_0_clk = { 2063 .halt_reg = 0x3a014, 2064 .halt_check = BRANCH_HALT_SKIP, 2065 .clkr = { 2066 .enable_reg = 0x3a014, 2067 .enable_mask = BIT(0), 2068 .hw.init = &(struct clk_init_data){ 2069 .name = "gcc_ufs_phy_rx_symbol_0_clk", 2070 .ops = &clk_branch2_ops, 2071 }, 2072 }, 2073 }; 2074 2075 static struct clk_branch gcc_ufs_phy_rx_symbol_1_clk = { 2076 .halt_reg = 0x3a018, 2077 .halt_check = BRANCH_HALT_SKIP, 2078 .clkr = { 2079 .enable_reg = 0x3a018, 2080 .enable_mask = BIT(0), 2081 .hw.init = &(struct clk_init_data){ 2082 .name = "gcc_ufs_phy_rx_symbol_1_clk", 2083 .ops = &clk_branch2_ops, 2084 }, 2085 }, 2086 }; 2087 2088 static struct clk_branch gcc_ufs_phy_tx_symbol_0_clk = { 2089 .halt_reg = 0x3a010, 2090 .halt_check = BRANCH_HALT_SKIP, 2091 .clkr = { 2092 .enable_reg = 0x3a010, 2093 .enable_mask = BIT(0), 2094 .hw.init = &(struct clk_init_data){ 2095 .name = "gcc_ufs_phy_tx_symbol_0_clk", 2096 .ops = &clk_branch2_ops, 2097 }, 2098 }, 2099 }; 2100 2101 static struct clk_branch gcc_ufs_phy_unipro_core_clk = { 2102 .halt_reg = 0x3a09c, 2103 .halt_check = BRANCH_HALT, 2104 .hwcg_reg = 0x3a09c, 2105 .hwcg_bit = 1, 2106 .clkr = { 2107 .enable_reg = 0x3a09c, 2108 .enable_mask = BIT(0), 2109 .hw.init = &(struct clk_init_data){ 2110 .name = "gcc_ufs_phy_unipro_core_clk", 2111 .parent_hws = (const struct clk_hw*[]){ 2112 &gcc_ufs_phy_unipro_core_clk_src.clkr.hw, 2113 }, 2114 .num_parents = 1, 2115 .flags = CLK_SET_RATE_PARENT, 2116 .ops = &clk_branch2_ops, 2117 }, 2118 }, 2119 }; 2120 2121 static struct clk_branch gcc_ufs_phy_unipro_core_hw_ctl_clk = { 2122 .halt_reg = 0x3a09c, 2123 .halt_check = BRANCH_HALT, 2124 .hwcg_reg = 0x3a09c, 2125 .hwcg_bit = 1, 2126 .clkr = { 2127 .enable_reg = 0x3a09c, 2128 .enable_mask = BIT(1), 2129 .hw.init = &(struct clk_init_data){ 2130 .name = "gcc_ufs_phy_unipro_core_hw_ctl_clk", 2131 .parent_hws = (const struct clk_hw*[]){ 2132 &gcc_ufs_phy_unipro_core_clk_src.clkr.hw, 2133 }, 2134 .num_parents = 1, 2135 .flags = CLK_SET_RATE_PARENT, 2136 .ops = &clk_branch2_ops, 2137 }, 2138 }, 2139 }; 2140 2141 static struct clk_branch gcc_usb30_prim_master_clk = { 2142 .halt_reg = 0x1a00c, 2143 .halt_check = BRANCH_HALT, 2144 .clkr = { 2145 .enable_reg = 0x1a00c, 2146 .enable_mask = BIT(0), 2147 .hw.init = &(struct clk_init_data){ 2148 .name = "gcc_usb30_prim_master_clk", 2149 .parent_hws = (const struct clk_hw*[]){ 2150 &gcc_usb30_prim_master_clk_src.clkr.hw, 2151 }, 2152 .num_parents = 1, 2153 .flags = CLK_SET_RATE_PARENT, 2154 .ops = &clk_branch2_ops, 2155 }, 2156 }, 2157 }; 2158 2159 static struct clk_branch gcc_usb30_prim_mock_utmi_clk = { 2160 .halt_reg = 0x1a018, 2161 .halt_check = BRANCH_HALT, 2162 .clkr = { 2163 .enable_reg = 0x1a018, 2164 .enable_mask = BIT(0), 2165 .hw.init = &(struct clk_init_data){ 2166 .name = "gcc_usb30_prim_mock_utmi_clk", 2167 .parent_hws = (const struct clk_hw*[]){ 2168 &gcc_usb30_prim_mock_utmi_clk_src.clkr.hw, 2169 }, 2170 .num_parents = 1, 2171 .flags = CLK_SET_RATE_PARENT, 2172 .ops = &clk_branch2_ops, 2173 }, 2174 }, 2175 }; 2176 2177 static struct clk_branch gcc_usb30_prim_sleep_clk = { 2178 .halt_reg = 0x1a014, 2179 .halt_check = BRANCH_HALT, 2180 .clkr = { 2181 .enable_reg = 0x1a014, 2182 .enable_mask = BIT(0), 2183 .hw.init = &(struct clk_init_data){ 2184 .name = "gcc_usb30_prim_sleep_clk", 2185 .ops = &clk_branch2_ops, 2186 }, 2187 }, 2188 }; 2189 2190 static struct clk_branch gcc_usb3_prim_clkref_clk = { 2191 .halt_reg = 0x8c010, 2192 .halt_check = BRANCH_HALT, 2193 .clkr = { 2194 .enable_reg = 0x8c010, 2195 .enable_mask = BIT(0), 2196 .hw.init = &(struct clk_init_data){ 2197 .name = "gcc_usb3_prim_clkref_clk", 2198 .ops = &clk_branch2_ops, 2199 }, 2200 }, 2201 }; 2202 2203 static struct clk_branch gcc_usb3_prim_phy_aux_clk = { 2204 .halt_reg = 0x1a050, 2205 .halt_check = BRANCH_HALT, 2206 .clkr = { 2207 .enable_reg = 0x1a050, 2208 .enable_mask = BIT(0), 2209 .hw.init = &(struct clk_init_data){ 2210 .name = "gcc_usb3_prim_phy_aux_clk", 2211 .parent_hws = (const struct clk_hw*[]){ 2212 &gcc_usb3_prim_phy_aux_clk_src.clkr.hw, 2213 }, 2214 .num_parents = 1, 2215 .flags = CLK_SET_RATE_PARENT, 2216 .ops = &clk_branch2_ops, 2217 }, 2218 }, 2219 }; 2220 2221 static struct clk_branch gcc_usb3_prim_phy_com_aux_clk = { 2222 .halt_reg = 0x1a054, 2223 .halt_check = BRANCH_HALT, 2224 .clkr = { 2225 .enable_reg = 0x1a054, 2226 .enable_mask = BIT(0), 2227 .hw.init = &(struct clk_init_data){ 2228 .name = "gcc_usb3_prim_phy_com_aux_clk", 2229 .parent_hws = (const struct clk_hw*[]){ 2230 &gcc_usb3_prim_phy_aux_clk_src.clkr.hw, 2231 }, 2232 .num_parents = 1, 2233 .flags = CLK_SET_RATE_PARENT, 2234 .ops = &clk_branch2_ops, 2235 }, 2236 }, 2237 }; 2238 2239 static struct clk_branch gcc_usb3_prim_phy_pipe_clk = { 2240 .halt_reg = 0x1a058, 2241 .halt_check = BRANCH_HALT_SKIP, 2242 .hwcg_reg = 0x1a058, 2243 .hwcg_bit = 1, 2244 .clkr = { 2245 .enable_reg = 0x1a058, 2246 .enable_mask = BIT(0), 2247 .hw.init = &(struct clk_init_data){ 2248 .name = "gcc_usb3_prim_phy_pipe_clk", 2249 .ops = &clk_branch2_ops, 2250 }, 2251 }, 2252 }; 2253 2254 static struct clk_branch gcc_video_ahb_clk = { 2255 .halt_reg = 0x17004, 2256 .halt_check = BRANCH_HALT, 2257 .hwcg_reg = 0x17004, 2258 .hwcg_bit = 1, 2259 .clkr = { 2260 .enable_reg = 0x17004, 2261 .enable_mask = BIT(0), 2262 .hw.init = &(struct clk_init_data){ 2263 .name = "gcc_video_ahb_clk", 2264 .flags = CLK_IS_CRITICAL, 2265 .ops = &clk_branch2_ops, 2266 }, 2267 }, 2268 }; 2269 2270 static struct clk_branch gcc_video_axi_clk = { 2271 .halt_reg = 0x17014, 2272 .halt_check = BRANCH_HALT, 2273 .hwcg_reg = 0x17014, 2274 .hwcg_bit = 1, 2275 .clkr = { 2276 .enable_reg = 0x17014, 2277 .enable_mask = BIT(0), 2278 .hw.init = &(struct clk_init_data){ 2279 .name = "gcc_video_axi_clk", 2280 .ops = &clk_branch2_ops, 2281 }, 2282 }, 2283 }; 2284 2285 static struct clk_branch gcc_video_throttle_axi_clk = { 2286 .halt_reg = 0x17020, 2287 .halt_check = BRANCH_HALT, 2288 .hwcg_reg = 0x17020, 2289 .hwcg_bit = 1, 2290 .clkr = { 2291 .enable_reg = 0x17020, 2292 .enable_mask = BIT(0), 2293 .hw.init = &(struct clk_init_data){ 2294 .name = "gcc_video_throttle_axi_clk", 2295 .ops = &clk_branch2_ops, 2296 }, 2297 }, 2298 }; 2299 2300 static struct clk_branch gcc_video_xo_clk = { 2301 .halt_reg = 0x1702c, 2302 .halt_check = BRANCH_HALT, 2303 .clkr = { 2304 .enable_reg = 0x1702c, 2305 .enable_mask = BIT(0), 2306 .hw.init = &(struct clk_init_data){ 2307 .name = "gcc_video_xo_clk", 2308 .flags = CLK_IS_CRITICAL, 2309 .ops = &clk_branch2_ops, 2310 }, 2311 }, 2312 }; 2313 2314 static struct gdsc usb30_prim_gdsc = { 2315 .gdscr = 0x1a004, 2316 .pd = { 2317 .name = "usb30_prim_gdsc", 2318 }, 2319 .pwrsts = PWRSTS_OFF_ON, 2320 }; 2321 2322 static struct gdsc ufs_phy_gdsc = { 2323 .gdscr = 0x3a004, 2324 .pd = { 2325 .name = "ufs_phy_gdsc", 2326 }, 2327 .pwrsts = PWRSTS_OFF_ON, 2328 }; 2329 2330 static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc = { 2331 .gdscr = 0xb7040, 2332 .pd = { 2333 .name = "hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc", 2334 }, 2335 .pwrsts = PWRSTS_OFF_ON, 2336 .flags = VOTABLE, 2337 }; 2338 2339 static struct gdsc hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc = { 2340 .gdscr = 0xb7044, 2341 .pd = { 2342 .name = "hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc", 2343 }, 2344 .pwrsts = PWRSTS_OFF_ON, 2345 .flags = VOTABLE, 2346 }; 2347 2348 static struct clk_regmap *gcc_sm6350_clocks[] = { 2349 [GCC_AGGRE_UFS_PHY_AXI_CLK] = &gcc_aggre_ufs_phy_axi_clk.clkr, 2350 [GCC_AGGRE_USB3_PRIM_AXI_CLK] = &gcc_aggre_usb3_prim_axi_clk.clkr, 2351 [GCC_BOOT_ROM_AHB_CLK] = &gcc_boot_rom_ahb_clk.clkr, 2352 [GCC_CAMERA_AHB_CLK] = &gcc_camera_ahb_clk.clkr, 2353 [GCC_CAMERA_AXI_CLK] = &gcc_camera_axi_clk.clkr, 2354 [GCC_CAMERA_THROTTLE_NRT_AXI_CLK] = 2355 &gcc_camera_throttle_nrt_axi_clk.clkr, 2356 [GCC_CAMERA_THROTTLE_RT_AXI_CLK] = &gcc_camera_throttle_rt_axi_clk.clkr, 2357 [GCC_CAMERA_XO_CLK] = &gcc_camera_xo_clk.clkr, 2358 [GCC_CE1_AHB_CLK] = &gcc_ce1_ahb_clk.clkr, 2359 [GCC_CE1_AXI_CLK] = &gcc_ce1_axi_clk.clkr, 2360 [GCC_CE1_CLK] = &gcc_ce1_clk.clkr, 2361 [GCC_CFG_NOC_USB3_PRIM_AXI_CLK] = &gcc_cfg_noc_usb3_prim_axi_clk.clkr, 2362 [GCC_CPUSS_AHB_CLK] = &gcc_cpuss_ahb_clk.clkr, 2363 [GCC_CPUSS_AHB_CLK_SRC] = &gcc_cpuss_ahb_clk_src.clkr, 2364 [GCC_CPUSS_GNOC_CLK] = &gcc_cpuss_gnoc_clk.clkr, 2365 [GCC_CPUSS_RBCPR_CLK] = &gcc_cpuss_rbcpr_clk.clkr, 2366 [GCC_DDRSS_GPU_AXI_CLK] = &gcc_ddrss_gpu_axi_clk.clkr, 2367 [GCC_DISP_AHB_CLK] = &gcc_disp_ahb_clk.clkr, 2368 [GCC_DISP_AXI_CLK] = &gcc_disp_axi_clk.clkr, 2369 [GCC_DISP_CC_SLEEP_CLK] = &gcc_disp_cc_sleep_clk.clkr, 2370 [GCC_DISP_CC_XO_CLK] = &gcc_disp_cc_xo_clk.clkr, 2371 [GCC_DISP_GPLL0_CLK] = &gcc_disp_gpll0_clk.clkr, 2372 [GCC_DISP_THROTTLE_AXI_CLK] = &gcc_disp_throttle_axi_clk.clkr, 2373 [GCC_DISP_XO_CLK] = &gcc_disp_xo_clk.clkr, 2374 [GCC_GP1_CLK] = &gcc_gp1_clk.clkr, 2375 [GCC_GP1_CLK_SRC] = &gcc_gp1_clk_src.clkr, 2376 [GCC_GP2_CLK] = &gcc_gp2_clk.clkr, 2377 [GCC_GP2_CLK_SRC] = &gcc_gp2_clk_src.clkr, 2378 [GCC_GP3_CLK] = &gcc_gp3_clk.clkr, 2379 [GCC_GP3_CLK_SRC] = &gcc_gp3_clk_src.clkr, 2380 [GCC_GPU_CFG_AHB_CLK] = &gcc_gpu_cfg_ahb_clk.clkr, 2381 [GCC_GPU_GPLL0_CLK] = &gcc_gpu_gpll0_clk.clkr, 2382 [GCC_GPU_GPLL0_DIV_CLK] = &gcc_gpu_gpll0_div_clk.clkr, 2383 [GCC_GPU_MEMNOC_GFX_CLK] = &gcc_gpu_memnoc_gfx_clk.clkr, 2384 [GCC_GPU_SNOC_DVM_GFX_CLK] = &gcc_gpu_snoc_dvm_gfx_clk.clkr, 2385 [GCC_NPU_AXI_CLK] = &gcc_npu_axi_clk.clkr, 2386 [GCC_NPU_BWMON_AXI_CLK] = &gcc_npu_bwmon_axi_clk.clkr, 2387 [GCC_NPU_BWMON_DMA_CFG_AHB_CLK] = &gcc_npu_bwmon_dma_cfg_ahb_clk.clkr, 2388 [GCC_NPU_BWMON_DSP_CFG_AHB_CLK] = &gcc_npu_bwmon_dsp_cfg_ahb_clk.clkr, 2389 [GCC_NPU_CFG_AHB_CLK] = &gcc_npu_cfg_ahb_clk.clkr, 2390 [GCC_NPU_DMA_CLK] = &gcc_npu_dma_clk.clkr, 2391 [GCC_NPU_GPLL0_CLK] = &gcc_npu_gpll0_clk.clkr, 2392 [GCC_NPU_GPLL0_DIV_CLK] = &gcc_npu_gpll0_div_clk.clkr, 2393 [GCC_PDM2_CLK] = &gcc_pdm2_clk.clkr, 2394 [GCC_PDM2_CLK_SRC] = &gcc_pdm2_clk_src.clkr, 2395 [GCC_PDM_AHB_CLK] = &gcc_pdm_ahb_clk.clkr, 2396 [GCC_PDM_XO4_CLK] = &gcc_pdm_xo4_clk.clkr, 2397 [GCC_PRNG_AHB_CLK] = &gcc_prng_ahb_clk.clkr, 2398 [GCC_QUPV3_WRAP0_CORE_2X_CLK] = &gcc_qupv3_wrap0_core_2x_clk.clkr, 2399 [GCC_QUPV3_WRAP0_CORE_CLK] = &gcc_qupv3_wrap0_core_clk.clkr, 2400 [GCC_QUPV3_WRAP0_S0_CLK] = &gcc_qupv3_wrap0_s0_clk.clkr, 2401 [GCC_QUPV3_WRAP0_S0_CLK_SRC] = &gcc_qupv3_wrap0_s0_clk_src.clkr, 2402 [GCC_QUPV3_WRAP0_S1_CLK] = &gcc_qupv3_wrap0_s1_clk.clkr, 2403 [GCC_QUPV3_WRAP0_S1_CLK_SRC] = &gcc_qupv3_wrap0_s1_clk_src.clkr, 2404 [GCC_QUPV3_WRAP0_S2_CLK] = &gcc_qupv3_wrap0_s2_clk.clkr, 2405 [GCC_QUPV3_WRAP0_S2_CLK_SRC] = &gcc_qupv3_wrap0_s2_clk_src.clkr, 2406 [GCC_QUPV3_WRAP0_S3_CLK] = &gcc_qupv3_wrap0_s3_clk.clkr, 2407 [GCC_QUPV3_WRAP0_S3_CLK_SRC] = &gcc_qupv3_wrap0_s3_clk_src.clkr, 2408 [GCC_QUPV3_WRAP0_S4_CLK] = &gcc_qupv3_wrap0_s4_clk.clkr, 2409 [GCC_QUPV3_WRAP0_S4_CLK_SRC] = &gcc_qupv3_wrap0_s4_clk_src.clkr, 2410 [GCC_QUPV3_WRAP0_S5_CLK] = &gcc_qupv3_wrap0_s5_clk.clkr, 2411 [GCC_QUPV3_WRAP0_S5_CLK_SRC] = &gcc_qupv3_wrap0_s5_clk_src.clkr, 2412 [GCC_QUPV3_WRAP1_CORE_2X_CLK] = &gcc_qupv3_wrap1_core_2x_clk.clkr, 2413 [GCC_QUPV3_WRAP1_CORE_CLK] = &gcc_qupv3_wrap1_core_clk.clkr, 2414 [GCC_QUPV3_WRAP1_S0_CLK] = &gcc_qupv3_wrap1_s0_clk.clkr, 2415 [GCC_QUPV3_WRAP1_S0_CLK_SRC] = &gcc_qupv3_wrap1_s0_clk_src.clkr, 2416 [GCC_QUPV3_WRAP1_S1_CLK] = &gcc_qupv3_wrap1_s1_clk.clkr, 2417 [GCC_QUPV3_WRAP1_S1_CLK_SRC] = &gcc_qupv3_wrap1_s1_clk_src.clkr, 2418 [GCC_QUPV3_WRAP1_S2_CLK] = &gcc_qupv3_wrap1_s2_clk.clkr, 2419 [GCC_QUPV3_WRAP1_S2_CLK_SRC] = &gcc_qupv3_wrap1_s2_clk_src.clkr, 2420 [GCC_QUPV3_WRAP1_S3_CLK] = &gcc_qupv3_wrap1_s3_clk.clkr, 2421 [GCC_QUPV3_WRAP1_S3_CLK_SRC] = &gcc_qupv3_wrap1_s3_clk_src.clkr, 2422 [GCC_QUPV3_WRAP1_S4_CLK] = &gcc_qupv3_wrap1_s4_clk.clkr, 2423 [GCC_QUPV3_WRAP1_S4_CLK_SRC] = &gcc_qupv3_wrap1_s4_clk_src.clkr, 2424 [GCC_QUPV3_WRAP1_S5_CLK] = &gcc_qupv3_wrap1_s5_clk.clkr, 2425 [GCC_QUPV3_WRAP1_S5_CLK_SRC] = &gcc_qupv3_wrap1_s5_clk_src.clkr, 2426 [GCC_QUPV3_WRAP_0_M_AHB_CLK] = &gcc_qupv3_wrap_0_m_ahb_clk.clkr, 2427 [GCC_QUPV3_WRAP_0_S_AHB_CLK] = &gcc_qupv3_wrap_0_s_ahb_clk.clkr, 2428 [GCC_QUPV3_WRAP_1_M_AHB_CLK] = &gcc_qupv3_wrap_1_m_ahb_clk.clkr, 2429 [GCC_QUPV3_WRAP_1_S_AHB_CLK] = &gcc_qupv3_wrap_1_s_ahb_clk.clkr, 2430 [GCC_SDCC1_AHB_CLK] = &gcc_sdcc1_ahb_clk.clkr, 2431 [GCC_SDCC1_APPS_CLK] = &gcc_sdcc1_apps_clk.clkr, 2432 [GCC_SDCC1_APPS_CLK_SRC] = &gcc_sdcc1_apps_clk_src.clkr, 2433 [GCC_SDCC1_ICE_CORE_CLK] = &gcc_sdcc1_ice_core_clk.clkr, 2434 [GCC_SDCC1_ICE_CORE_CLK_SRC] = &gcc_sdcc1_ice_core_clk_src.clkr, 2435 [GCC_SDCC2_AHB_CLK] = &gcc_sdcc2_ahb_clk.clkr, 2436 [GCC_SDCC2_APPS_CLK] = &gcc_sdcc2_apps_clk.clkr, 2437 [GCC_SDCC2_APPS_CLK_SRC] = &gcc_sdcc2_apps_clk_src.clkr, 2438 [GCC_SYS_NOC_CPUSS_AHB_CLK] = &gcc_sys_noc_cpuss_ahb_clk.clkr, 2439 [GCC_UFS_MEM_CLKREF_CLK] = &gcc_ufs_mem_clkref_clk.clkr, 2440 [GCC_UFS_PHY_AHB_CLK] = &gcc_ufs_phy_ahb_clk.clkr, 2441 [GCC_UFS_PHY_AXI_CLK] = &gcc_ufs_phy_axi_clk.clkr, 2442 [GCC_UFS_PHY_AXI_CLK_SRC] = &gcc_ufs_phy_axi_clk_src.clkr, 2443 [GCC_UFS_PHY_ICE_CORE_CLK] = &gcc_ufs_phy_ice_core_clk.clkr, 2444 [GCC_UFS_PHY_ICE_CORE_CLK_SRC] = &gcc_ufs_phy_ice_core_clk_src.clkr, 2445 [GCC_UFS_PHY_PHY_AUX_CLK] = &gcc_ufs_phy_phy_aux_clk.clkr, 2446 [GCC_UFS_PHY_PHY_AUX_CLK_SRC] = &gcc_ufs_phy_phy_aux_clk_src.clkr, 2447 [GCC_UFS_PHY_RX_SYMBOL_0_CLK] = &gcc_ufs_phy_rx_symbol_0_clk.clkr, 2448 [GCC_UFS_PHY_RX_SYMBOL_1_CLK] = &gcc_ufs_phy_rx_symbol_1_clk.clkr, 2449 [GCC_UFS_PHY_TX_SYMBOL_0_CLK] = &gcc_ufs_phy_tx_symbol_0_clk.clkr, 2450 [GCC_UFS_PHY_UNIPRO_CORE_CLK] = &gcc_ufs_phy_unipro_core_clk.clkr, 2451 [GCC_UFS_PHY_UNIPRO_CORE_CLK_SRC] = 2452 &gcc_ufs_phy_unipro_core_clk_src.clkr, 2453 [GCC_USB30_PRIM_MASTER_CLK] = &gcc_usb30_prim_master_clk.clkr, 2454 [GCC_USB30_PRIM_MASTER_CLK_SRC] = &gcc_usb30_prim_master_clk_src.clkr, 2455 [GCC_USB30_PRIM_MOCK_UTMI_CLK] = &gcc_usb30_prim_mock_utmi_clk.clkr, 2456 [GCC_USB30_PRIM_MOCK_UTMI_CLK_SRC] = 2457 &gcc_usb30_prim_mock_utmi_clk_src.clkr, 2458 [GCC_USB30_PRIM_SLEEP_CLK] = &gcc_usb30_prim_sleep_clk.clkr, 2459 [GCC_USB3_PRIM_CLKREF_CLK] = &gcc_usb3_prim_clkref_clk.clkr, 2460 [GCC_USB3_PRIM_PHY_AUX_CLK] = &gcc_usb3_prim_phy_aux_clk.clkr, 2461 [GCC_USB3_PRIM_PHY_AUX_CLK_SRC] = &gcc_usb3_prim_phy_aux_clk_src.clkr, 2462 [GCC_USB3_PRIM_PHY_COM_AUX_CLK] = &gcc_usb3_prim_phy_com_aux_clk.clkr, 2463 [GCC_USB3_PRIM_PHY_PIPE_CLK] = &gcc_usb3_prim_phy_pipe_clk.clkr, 2464 [GCC_VIDEO_AHB_CLK] = &gcc_video_ahb_clk.clkr, 2465 [GCC_VIDEO_AXI_CLK] = &gcc_video_axi_clk.clkr, 2466 [GCC_VIDEO_THROTTLE_AXI_CLK] = &gcc_video_throttle_axi_clk.clkr, 2467 [GCC_VIDEO_XO_CLK] = &gcc_video_xo_clk.clkr, 2468 [GPLL0] = &gpll0.clkr, 2469 [GPLL0_OUT_EVEN] = &gpll0_out_even.clkr, 2470 [GPLL0_OUT_ODD] = &gpll0_out_odd.clkr, 2471 [GPLL6] = &gpll6.clkr, 2472 [GPLL6_OUT_EVEN] = &gpll6_out_even.clkr, 2473 [GPLL7] = &gpll7.clkr, 2474 [GCC_UFS_PHY_PHY_AUX_HW_CTL_CLK] = &gcc_ufs_phy_phy_aux_hw_ctl_clk.clkr, 2475 [GCC_UFS_PHY_AXI_HW_CTL_CLK] = &gcc_ufs_phy_axi_hw_ctl_clk.clkr, 2476 [GCC_AGGRE_UFS_PHY_AXI_HW_CTL_CLK] = 2477 &gcc_aggre_ufs_phy_axi_hw_ctl_clk.clkr, 2478 [GCC_UFS_PHY_UNIPRO_CORE_HW_CTL_CLK] = 2479 &gcc_ufs_phy_unipro_core_hw_ctl_clk.clkr, 2480 [GCC_UFS_PHY_ICE_CORE_HW_CTL_CLK] = 2481 &gcc_ufs_phy_ice_core_hw_ctl_clk.clkr, 2482 [GCC_GPU_GPLL0_MAIN_DIV_CLK_SRC] = &gcc_gpu_gpll0_main_div_clk_src.clkr, 2483 [GCC_NPU_PLL0_MAIN_DIV_CLK_SRC] = &gcc_npu_pll0_main_div_clk_src.clkr, 2484 }; 2485 2486 static struct gdsc *gcc_sm6350_gdscs[] = { 2487 [USB30_PRIM_GDSC] = &usb30_prim_gdsc, 2488 [UFS_PHY_GDSC] = &ufs_phy_gdsc, 2489 [HLOS1_VOTE_MMNOC_MMU_TBU_HF0_GDSC] = &hlos1_vote_mmnoc_mmu_tbu_hf0_gdsc, 2490 [HLOS1_VOTE_MMNOC_MMU_TBU_HF1_GDSC] = &hlos1_vote_mmnoc_mmu_tbu_hf1_gdsc, 2491 }; 2492 2493 static const struct qcom_reset_map gcc_sm6350_resets[] = { 2494 [GCC_QUSB2PHY_PRIM_BCR] = { 0x1d000 }, 2495 [GCC_QUSB2PHY_SEC_BCR] = { 0x1e000 }, 2496 [GCC_SDCC1_BCR] = { 0x4b000 }, 2497 [GCC_SDCC2_BCR] = { 0x20000 }, 2498 [GCC_UFS_PHY_BCR] = { 0x3a000 }, 2499 [GCC_USB30_PRIM_BCR] = { 0x1a000 }, 2500 [GCC_USB3_PHY_PRIM_BCR] = { 0x1c000 }, 2501 [GCC_USB3_DP_PHY_PRIM_BCR] = { 0x1c008 }, 2502 }; 2503 2504 static const struct clk_rcg_dfs_data gcc_dfs_clocks[] = { 2505 DEFINE_RCG_DFS(gcc_qupv3_wrap0_s0_clk_src), 2506 DEFINE_RCG_DFS(gcc_qupv3_wrap0_s1_clk_src), 2507 DEFINE_RCG_DFS(gcc_qupv3_wrap0_s2_clk_src), 2508 DEFINE_RCG_DFS(gcc_qupv3_wrap0_s3_clk_src), 2509 DEFINE_RCG_DFS(gcc_qupv3_wrap0_s4_clk_src), 2510 DEFINE_RCG_DFS(gcc_qupv3_wrap0_s5_clk_src), 2511 DEFINE_RCG_DFS(gcc_qupv3_wrap1_s0_clk_src), 2512 DEFINE_RCG_DFS(gcc_qupv3_wrap1_s1_clk_src), 2513 DEFINE_RCG_DFS(gcc_qupv3_wrap1_s2_clk_src), 2514 DEFINE_RCG_DFS(gcc_qupv3_wrap1_s3_clk_src), 2515 DEFINE_RCG_DFS(gcc_qupv3_wrap1_s4_clk_src), 2516 DEFINE_RCG_DFS(gcc_qupv3_wrap1_s5_clk_src), 2517 }; 2518 2519 static const struct regmap_config gcc_sm6350_regmap_config = { 2520 .reg_bits = 32, 2521 .reg_stride = 4, 2522 .val_bits = 32, 2523 .max_register = 0xbf030, 2524 .fast_io = true, 2525 }; 2526 2527 static const struct qcom_cc_desc gcc_sm6350_desc = { 2528 .config = &gcc_sm6350_regmap_config, 2529 .clks = gcc_sm6350_clocks, 2530 .num_clks = ARRAY_SIZE(gcc_sm6350_clocks), 2531 .resets = gcc_sm6350_resets, 2532 .num_resets = ARRAY_SIZE(gcc_sm6350_resets), 2533 .gdscs = gcc_sm6350_gdscs, 2534 .num_gdscs = ARRAY_SIZE(gcc_sm6350_gdscs), 2535 }; 2536 2537 static const struct of_device_id gcc_sm6350_match_table[] = { 2538 { .compatible = "qcom,gcc-sm6350" }, 2539 { } 2540 }; 2541 MODULE_DEVICE_TABLE(of, gcc_sm6350_match_table); 2542 2543 static int gcc_sm6350_probe(struct platform_device *pdev) 2544 { 2545 struct regmap *regmap; 2546 int ret; 2547 2548 regmap = qcom_cc_map(pdev, &gcc_sm6350_desc); 2549 if (IS_ERR(regmap)) 2550 return PTR_ERR(regmap); 2551 2552 /* Disable the GPLL0 active input to NPU and GPU via MISC registers */ 2553 regmap_update_bits(regmap, 0x4cf00, 0x3, 0x3); 2554 regmap_update_bits(regmap, 0x45f00, 0x3, 0x3); 2555 2556 ret = qcom_cc_register_rcg_dfs(regmap, gcc_dfs_clocks, 2557 ARRAY_SIZE(gcc_dfs_clocks)); 2558 if (ret) 2559 return ret; 2560 2561 return qcom_cc_really_probe(pdev, &gcc_sm6350_desc, regmap); 2562 } 2563 2564 static struct platform_driver gcc_sm6350_driver = { 2565 .probe = gcc_sm6350_probe, 2566 .driver = { 2567 .name = "gcc-sm6350", 2568 .of_match_table = gcc_sm6350_match_table, 2569 }, 2570 }; 2571 2572 static int __init gcc_sm6350_init(void) 2573 { 2574 return platform_driver_register(&gcc_sm6350_driver); 2575 } 2576 core_initcall(gcc_sm6350_init); 2577 2578 static void __exit gcc_sm6350_exit(void) 2579 { 2580 platform_driver_unregister(&gcc_sm6350_driver); 2581 } 2582 module_exit(gcc_sm6350_exit); 2583 2584 MODULE_DESCRIPTION("QTI GCC SM6350 Driver"); 2585 MODULE_LICENSE("GPL v2"); 2586