1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (c) 2017-2019, The Linux Foundation. All rights reserved. 3 4 #include <linux/kernel.h> 5 #include <linux/bitops.h> 6 #include <linux/err.h> 7 #include <linux/platform_device.h> 8 #include <linux/module.h> 9 #include <linux/of.h> 10 #include <linux/clk-provider.h> 11 #include <linux/regmap.h> 12 #include <linux/reset-controller.h> 13 14 #include <dt-bindings/clock/qcom,gcc-sm8150.h> 15 16 #include "common.h" 17 #include "clk-alpha-pll.h" 18 #include "clk-branch.h" 19 #include "clk-pll.h" 20 #include "clk-rcg.h" 21 #include "clk-regmap.h" 22 #include "reset.h" 23 #include "gdsc.h" 24 25 enum { 26 P_BI_TCXO, 27 P_AUD_REF_CLK, 28 P_GPLL0_OUT_EVEN, 29 P_GPLL0_OUT_MAIN, 30 P_GPLL7_OUT_MAIN, 31 P_GPLL9_OUT_MAIN, 32 P_SLEEP_CLK, 33 }; 34 35 static struct clk_alpha_pll gpll0 = { 36 .offset = 0x0, 37 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_TRION], 38 .clkr = { 39 .enable_reg = 0x52000, 40 .enable_mask = BIT(0), 41 .hw.init = &(struct clk_init_data){ 42 .name = "gpll0", 43 .parent_data = &(const struct clk_parent_data){ 44 .fw_name = "bi_tcxo", 45 .name = "bi_tcxo", 46 }, 47 .num_parents = 1, 48 .ops = &clk_alpha_pll_fixed_trion_ops, 49 }, 50 }, 51 }; 52 53 static const struct clk_div_table post_div_table_trion_even[] = { 54 { 0x0, 1 }, 55 { 0x1, 2 }, 56 { 0x3, 4 }, 57 { 0x7, 8 }, 58 { } 59 }; 60 61 static struct clk_alpha_pll_postdiv gpll0_out_even = { 62 .offset = 0x0, 63 .post_div_shift = 8, 64 .post_div_table = post_div_table_trion_even, 65 .num_post_div = ARRAY_SIZE(post_div_table_trion_even), 66 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_TRION], 67 .width = 4, 68 .clkr.hw.init = &(struct clk_init_data){ 69 .name = "gpll0_out_even", 70 .parent_hws = (const struct clk_hw*[]){ 71 &gpll0.clkr.hw, 72 }, 73 .num_parents = 1, 74 .ops = &clk_alpha_pll_postdiv_trion_ops, 75 }, 76 }; 77 78 static struct clk_alpha_pll gpll7 = { 79 .offset = 0x1a000, 80 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_TRION], 81 .clkr = { 82 .enable_reg = 0x52000, 83 .enable_mask = BIT(7), 84 .hw.init = &(struct clk_init_data){ 85 .name = "gpll7", 86 .parent_data = &(const struct clk_parent_data){ 87 .fw_name = "bi_tcxo", 88 .name = "bi_tcxo", 89 }, 90 .num_parents = 1, 91 .ops = &clk_alpha_pll_fixed_trion_ops, 92 }, 93 }, 94 }; 95 96 static struct clk_alpha_pll gpll9 = { 97 .offset = 0x1c000, 98 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_TRION], 99 .clkr = { 100 .enable_reg = 0x52000, 101 .enable_mask = BIT(9), 102 .hw.init = &(struct clk_init_data){ 103 .name = "gpll9", 104 .parent_data = &(const struct clk_parent_data){ 105 .fw_name = "bi_tcxo", 106 .name = "bi_tcxo", 107 }, 108 .num_parents = 1, 109 .ops = &clk_alpha_pll_fixed_trion_ops, 110 }, 111 }, 112 }; 113 114 static const struct parent_map gcc_parent_map_0[] = { 115 { P_BI_TCXO, 0 }, 116 { P_GPLL0_OUT_MAIN, 1 }, 117 { P_GPLL0_OUT_EVEN, 6 }, 118 }; 119 120 static const struct clk_parent_data gcc_parents_0[] = { 121 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 122 { .hw = &gpll0.clkr.hw }, 123 { .hw = &gpll0_out_even.clkr.hw }, 124 }; 125 126 static const struct parent_map gcc_parent_map_1[] = { 127 { P_BI_TCXO, 0 }, 128 { P_GPLL0_OUT_MAIN, 1 }, 129 { P_SLEEP_CLK, 5 }, 130 { P_GPLL0_OUT_EVEN, 6 }, 131 }; 132 133 static const struct clk_parent_data gcc_parents_1[] = { 134 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 135 { .hw = &gpll0.clkr.hw }, 136 { .fw_name = "sleep_clk", .name = "sleep_clk" }, 137 { .hw = &gpll0_out_even.clkr.hw }, 138 }; 139 140 static const struct parent_map gcc_parent_map_2[] = { 141 { P_BI_TCXO, 0 }, 142 { P_SLEEP_CLK, 5 }, 143 }; 144 145 static const struct clk_parent_data gcc_parents_2[] = { 146 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 147 { .fw_name = "sleep_clk", .name = "sleep_clk" }, 148 }; 149 150 static const struct parent_map gcc_parent_map_3[] = { 151 { P_BI_TCXO, 0 }, 152 { P_GPLL0_OUT_MAIN, 1 }, 153 }; 154 155 static const struct clk_parent_data gcc_parents_3[] = { 156 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 157 { .hw = &gpll0.clkr.hw }, 158 }; 159 160 static const struct parent_map gcc_parent_map_4[] = { 161 { P_BI_TCXO, 0 }, 162 }; 163 164 static const struct clk_parent_data gcc_parents_4[] = { 165 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 166 }; 167 168 static const struct parent_map gcc_parent_map_5[] = { 169 { P_BI_TCXO, 0 }, 170 { P_GPLL0_OUT_MAIN, 1 }, 171 { P_GPLL7_OUT_MAIN, 3 }, 172 { P_GPLL0_OUT_EVEN, 6 }, 173 }; 174 175 static const struct clk_parent_data gcc_parents_5[] = { 176 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 177 { .hw = &gpll0.clkr.hw }, 178 { .hw = &gpll7.clkr.hw }, 179 { .hw = &gpll0_out_even.clkr.hw }, 180 }; 181 182 static const struct parent_map gcc_parent_map_6[] = { 183 { P_BI_TCXO, 0 }, 184 { P_GPLL0_OUT_MAIN, 1 }, 185 { P_GPLL9_OUT_MAIN, 2 }, 186 { P_GPLL0_OUT_EVEN, 6 }, 187 }; 188 189 static const struct clk_parent_data gcc_parents_6[] = { 190 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 191 { .hw = &gpll0.clkr.hw }, 192 { .hw = &gpll9.clkr.hw }, 193 { .hw = &gpll0_out_even.clkr.hw }, 194 }; 195 196 static const struct parent_map gcc_parent_map_7[] = { 197 { P_BI_TCXO, 0 }, 198 { P_GPLL0_OUT_MAIN, 1 }, 199 { P_AUD_REF_CLK, 2 }, 200 { P_GPLL0_OUT_EVEN, 6 }, 201 }; 202 203 static const struct clk_parent_data gcc_parents_7[] = { 204 { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 205 { .hw = &gpll0.clkr.hw }, 206 { .fw_name = "aud_ref_clk", .name = "aud_ref_clk" }, 207 { .hw = &gpll0_out_even.clkr.hw }, 208 }; 209 210 static const struct freq_tbl ftbl_gcc_cpuss_ahb_clk_src[] = { 211 F(19200000, P_BI_TCXO, 1, 0, 0), 212 F(50000000, P_GPLL0_OUT_MAIN, 12, 0, 0), 213 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0), 214 { } 215 }; 216 217 static struct clk_rcg2 gcc_cpuss_ahb_clk_src = { 218 .cmd_rcgr = 0x48014, 219 .mnd_width = 0, 220 .hid_width = 5, 221 .parent_map = gcc_parent_map_0, 222 .freq_tbl = ftbl_gcc_cpuss_ahb_clk_src, 223 .clkr.hw.init = &(struct clk_init_data){ 224 .name = "gcc_cpuss_ahb_clk_src", 225 .parent_data = gcc_parents_0, 226 .num_parents = ARRAY_SIZE(gcc_parents_0), 227 .flags = CLK_SET_RATE_PARENT, 228 .ops = &clk_rcg2_ops, 229 }, 230 }; 231 232 static const struct freq_tbl ftbl_gcc_emac_ptp_clk_src[] = { 233 F(19200000, P_BI_TCXO, 1, 0, 0), 234 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0), 235 F(125000000, P_GPLL7_OUT_MAIN, 4, 0, 0), 236 F(250000000, P_GPLL7_OUT_MAIN, 2, 0, 0), 237 { } 238 }; 239 240 static struct clk_rcg2 gcc_emac_ptp_clk_src = { 241 .cmd_rcgr = 0x6038, 242 .mnd_width = 0, 243 .hid_width = 5, 244 .parent_map = gcc_parent_map_5, 245 .freq_tbl = ftbl_gcc_emac_ptp_clk_src, 246 .clkr.hw.init = &(struct clk_init_data){ 247 .name = "gcc_emac_ptp_clk_src", 248 .parent_data = gcc_parents_5, 249 .num_parents = ARRAY_SIZE(gcc_parents_5), 250 .flags = CLK_SET_RATE_PARENT, 251 .ops = &clk_rcg2_ops, 252 }, 253 }; 254 255 static const struct freq_tbl ftbl_gcc_emac_rgmii_clk_src[] = { 256 F(2500000, P_BI_TCXO, 1, 25, 192), 257 F(5000000, P_BI_TCXO, 1, 25, 96), 258 F(19200000, P_BI_TCXO, 1, 0, 0), 259 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0), 260 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0), 261 F(125000000, P_GPLL7_OUT_MAIN, 4, 0, 0), 262 F(250000000, P_GPLL7_OUT_MAIN, 2, 0, 0), 263 { } 264 }; 265 266 static struct clk_rcg2 gcc_emac_rgmii_clk_src = { 267 .cmd_rcgr = 0x601c, 268 .mnd_width = 8, 269 .hid_width = 5, 270 .parent_map = gcc_parent_map_5, 271 .freq_tbl = ftbl_gcc_emac_rgmii_clk_src, 272 .clkr.hw.init = &(struct clk_init_data){ 273 .name = "gcc_emac_rgmii_clk_src", 274 .parent_data = gcc_parents_5, 275 .num_parents = ARRAY_SIZE(gcc_parents_5), 276 .flags = CLK_SET_RATE_PARENT, 277 .ops = &clk_rcg2_ops, 278 }, 279 }; 280 281 static const struct freq_tbl ftbl_gcc_gp1_clk_src[] = { 282 F(19200000, P_BI_TCXO, 1, 0, 0), 283 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0), 284 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0), 285 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0), 286 F(200000000, P_GPLL0_OUT_MAIN, 3, 0, 0), 287 { } 288 }; 289 290 static struct clk_rcg2 gcc_gp1_clk_src = { 291 .cmd_rcgr = 0x64004, 292 .mnd_width = 8, 293 .hid_width = 5, 294 .parent_map = gcc_parent_map_1, 295 .freq_tbl = ftbl_gcc_gp1_clk_src, 296 .clkr.hw.init = &(struct clk_init_data){ 297 .name = "gcc_gp1_clk_src", 298 .parent_data = gcc_parents_1, 299 .num_parents = ARRAY_SIZE(gcc_parents_1), 300 .flags = CLK_SET_RATE_PARENT, 301 .ops = &clk_rcg2_ops, 302 }, 303 }; 304 305 static struct clk_rcg2 gcc_gp2_clk_src = { 306 .cmd_rcgr = 0x65004, 307 .mnd_width = 8, 308 .hid_width = 5, 309 .parent_map = gcc_parent_map_1, 310 .freq_tbl = ftbl_gcc_gp1_clk_src, 311 .clkr.hw.init = &(struct clk_init_data){ 312 .name = "gcc_gp2_clk_src", 313 .parent_data = gcc_parents_1, 314 .num_parents = ARRAY_SIZE(gcc_parents_1), 315 .flags = CLK_SET_RATE_PARENT, 316 .ops = &clk_rcg2_ops, 317 }, 318 }; 319 320 static struct clk_rcg2 gcc_gp3_clk_src = { 321 .cmd_rcgr = 0x66004, 322 .mnd_width = 8, 323 .hid_width = 5, 324 .parent_map = gcc_parent_map_1, 325 .freq_tbl = ftbl_gcc_gp1_clk_src, 326 .clkr.hw.init = &(struct clk_init_data){ 327 .name = "gcc_gp3_clk_src", 328 .parent_data = gcc_parents_1, 329 .num_parents = ARRAY_SIZE(gcc_parents_1), 330 .flags = CLK_SET_RATE_PARENT, 331 .ops = &clk_rcg2_ops, 332 }, 333 }; 334 335 static const struct freq_tbl ftbl_gcc_pcie_0_aux_clk_src[] = { 336 F(9600000, P_BI_TCXO, 2, 0, 0), 337 F(19200000, P_BI_TCXO, 1, 0, 0), 338 { } 339 }; 340 341 static struct clk_rcg2 gcc_pcie_0_aux_clk_src = { 342 .cmd_rcgr = 0x6b02c, 343 .mnd_width = 16, 344 .hid_width = 5, 345 .parent_map = gcc_parent_map_2, 346 .freq_tbl = ftbl_gcc_pcie_0_aux_clk_src, 347 .clkr.hw.init = &(struct clk_init_data){ 348 .name = "gcc_pcie_0_aux_clk_src", 349 .parent_data = gcc_parents_2, 350 .num_parents = ARRAY_SIZE(gcc_parents_2), 351 .flags = CLK_SET_RATE_PARENT, 352 .ops = &clk_rcg2_ops, 353 }, 354 }; 355 356 static struct clk_rcg2 gcc_pcie_1_aux_clk_src = { 357 .cmd_rcgr = 0x8d02c, 358 .mnd_width = 16, 359 .hid_width = 5, 360 .parent_map = gcc_parent_map_2, 361 .freq_tbl = ftbl_gcc_pcie_0_aux_clk_src, 362 .clkr.hw.init = &(struct clk_init_data){ 363 .name = "gcc_pcie_1_aux_clk_src", 364 .parent_data = gcc_parents_2, 365 .num_parents = ARRAY_SIZE(gcc_parents_2), 366 .flags = CLK_SET_RATE_PARENT, 367 .ops = &clk_rcg2_ops, 368 }, 369 }; 370 371 static const struct freq_tbl ftbl_gcc_pcie_phy_refgen_clk_src[] = { 372 F(19200000, P_BI_TCXO, 1, 0, 0), 373 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0), 374 { } 375 }; 376 377 static struct clk_rcg2 gcc_pcie_phy_refgen_clk_src = { 378 .cmd_rcgr = 0x6f014, 379 .mnd_width = 0, 380 .hid_width = 5, 381 .parent_map = gcc_parent_map_0, 382 .freq_tbl = ftbl_gcc_pcie_phy_refgen_clk_src, 383 .clkr.hw.init = &(struct clk_init_data){ 384 .name = "gcc_pcie_phy_refgen_clk_src", 385 .parent_data = gcc_parents_0, 386 .num_parents = ARRAY_SIZE(gcc_parents_0), 387 .flags = CLK_SET_RATE_PARENT, 388 .ops = &clk_rcg2_ops, 389 }, 390 }; 391 392 static const struct freq_tbl ftbl_gcc_pdm2_clk_src[] = { 393 F(9600000, P_BI_TCXO, 2, 0, 0), 394 F(19200000, P_BI_TCXO, 1, 0, 0), 395 F(60000000, P_GPLL0_OUT_MAIN, 10, 0, 0), 396 { } 397 }; 398 399 static struct clk_rcg2 gcc_pdm2_clk_src = { 400 .cmd_rcgr = 0x33010, 401 .mnd_width = 0, 402 .hid_width = 5, 403 .parent_map = gcc_parent_map_0, 404 .freq_tbl = ftbl_gcc_pdm2_clk_src, 405 .clkr.hw.init = &(struct clk_init_data){ 406 .name = "gcc_pdm2_clk_src", 407 .parent_data = gcc_parents_0, 408 .num_parents = ARRAY_SIZE(gcc_parents_0), 409 .flags = CLK_SET_RATE_PARENT, 410 .ops = &clk_rcg2_ops, 411 }, 412 }; 413 414 static const struct freq_tbl ftbl_gcc_qspi_core_clk_src[] = { 415 F(19200000, P_BI_TCXO, 1, 0, 0), 416 F(75000000, P_GPLL0_OUT_EVEN, 4, 0, 0), 417 F(150000000, P_GPLL0_OUT_MAIN, 4, 0, 0), 418 F(300000000, P_GPLL0_OUT_MAIN, 2, 0, 0), 419 { } 420 }; 421 422 static struct clk_rcg2 gcc_qspi_core_clk_src = { 423 .cmd_rcgr = 0x4b008, 424 .mnd_width = 0, 425 .hid_width = 5, 426 .parent_map = gcc_parent_map_0, 427 .freq_tbl = ftbl_gcc_qspi_core_clk_src, 428 .clkr.hw.init = &(struct clk_init_data){ 429 .name = "gcc_qspi_core_clk_src", 430 .parent_data = gcc_parents_0, 431 .num_parents = ARRAY_SIZE(gcc_parents_0), 432 .flags = CLK_SET_RATE_PARENT, 433 .ops = &clk_rcg2_ops, 434 }, 435 }; 436 437 static const struct freq_tbl ftbl_gcc_qupv3_wrap0_s0_clk_src[] = { 438 F(7372800, P_GPLL0_OUT_EVEN, 1, 384, 15625), 439 F(14745600, P_GPLL0_OUT_EVEN, 1, 768, 15625), 440 F(19200000, P_BI_TCXO, 1, 0, 0), 441 F(29491200, P_GPLL0_OUT_EVEN, 1, 1536, 15625), 442 F(32000000, P_GPLL0_OUT_EVEN, 1, 8, 75), 443 F(48000000, P_GPLL0_OUT_EVEN, 1, 4, 25), 444 F(64000000, P_GPLL0_OUT_EVEN, 1, 16, 75), 445 F(80000000, P_GPLL0_OUT_EVEN, 1, 4, 15), 446 F(96000000, P_GPLL0_OUT_EVEN, 1, 8, 25), 447 F(100000000, P_GPLL0_OUT_EVEN, 3, 0, 0), 448 F(102400000, P_GPLL0_OUT_EVEN, 1, 128, 375), 449 F(112000000, P_GPLL0_OUT_EVEN, 1, 28, 75), 450 F(117964800, P_GPLL0_OUT_EVEN, 1, 6144, 15625), 451 F(120000000, P_GPLL0_OUT_EVEN, 2.5, 0, 0), 452 F(128000000, P_GPLL0_OUT_MAIN, 1, 16, 75), 453 { } 454 }; 455 456 static struct clk_rcg2 gcc_qupv3_wrap0_s0_clk_src = { 457 .cmd_rcgr = 0x17148, 458 .mnd_width = 16, 459 .hid_width = 5, 460 .parent_map = gcc_parent_map_0, 461 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 462 .clkr.hw.init = &(struct clk_init_data){ 463 .name = "gcc_qupv3_wrap0_s0_clk_src", 464 .parent_data = gcc_parents_0, 465 .num_parents = ARRAY_SIZE(gcc_parents_0), 466 .flags = CLK_SET_RATE_PARENT, 467 .ops = &clk_rcg2_ops, 468 }, 469 }; 470 471 static struct clk_rcg2 gcc_qupv3_wrap0_s1_clk_src = { 472 .cmd_rcgr = 0x17278, 473 .mnd_width = 16, 474 .hid_width = 5, 475 .parent_map = gcc_parent_map_0, 476 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 477 .clkr.hw.init = &(struct clk_init_data){ 478 .name = "gcc_qupv3_wrap0_s1_clk_src", 479 .parent_data = gcc_parents_0, 480 .num_parents = ARRAY_SIZE(gcc_parents_0), 481 .flags = CLK_SET_RATE_PARENT, 482 .ops = &clk_rcg2_ops, 483 }, 484 }; 485 486 static struct clk_rcg2 gcc_qupv3_wrap0_s2_clk_src = { 487 .cmd_rcgr = 0x173a8, 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 = &(struct clk_init_data){ 493 .name = "gcc_qupv3_wrap0_s2_clk_src", 494 .parent_data = gcc_parents_0, 495 .num_parents = ARRAY_SIZE(gcc_parents_0), 496 .flags = CLK_SET_RATE_PARENT, 497 .ops = &clk_rcg2_ops, 498 }, 499 }; 500 501 static struct clk_rcg2 gcc_qupv3_wrap0_s3_clk_src = { 502 .cmd_rcgr = 0x174d8, 503 .mnd_width = 16, 504 .hid_width = 5, 505 .parent_map = gcc_parent_map_0, 506 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 507 .clkr.hw.init = &(struct clk_init_data){ 508 .name = "gcc_qupv3_wrap0_s3_clk_src", 509 .parent_data = gcc_parents_0, 510 .num_parents = ARRAY_SIZE(gcc_parents_0), 511 .flags = CLK_SET_RATE_PARENT, 512 .ops = &clk_rcg2_ops, 513 }, 514 }; 515 516 static struct clk_rcg2 gcc_qupv3_wrap0_s4_clk_src = { 517 .cmd_rcgr = 0x17608, 518 .mnd_width = 16, 519 .hid_width = 5, 520 .parent_map = gcc_parent_map_0, 521 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 522 .clkr.hw.init = &(struct clk_init_data){ 523 .name = "gcc_qupv3_wrap0_s4_clk_src", 524 .parent_data = gcc_parents_0, 525 .num_parents = ARRAY_SIZE(gcc_parents_0), 526 .flags = CLK_SET_RATE_PARENT, 527 .ops = &clk_rcg2_ops, 528 }, 529 }; 530 531 static struct clk_rcg2 gcc_qupv3_wrap0_s5_clk_src = { 532 .cmd_rcgr = 0x17738, 533 .mnd_width = 16, 534 .hid_width = 5, 535 .parent_map = gcc_parent_map_0, 536 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 537 .clkr.hw.init = &(struct clk_init_data){ 538 .name = "gcc_qupv3_wrap0_s5_clk_src", 539 .parent_data = gcc_parents_0, 540 .num_parents = ARRAY_SIZE(gcc_parents_0), 541 .flags = CLK_SET_RATE_PARENT, 542 .ops = &clk_rcg2_ops, 543 }, 544 }; 545 546 static struct clk_rcg2 gcc_qupv3_wrap0_s6_clk_src = { 547 .cmd_rcgr = 0x17868, 548 .mnd_width = 16, 549 .hid_width = 5, 550 .parent_map = gcc_parent_map_0, 551 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 552 .clkr.hw.init = &(struct clk_init_data){ 553 .name = "gcc_qupv3_wrap0_s6_clk_src", 554 .parent_data = gcc_parents_0, 555 .num_parents = ARRAY_SIZE(gcc_parents_0), 556 .flags = CLK_SET_RATE_PARENT, 557 .ops = &clk_rcg2_ops, 558 }, 559 }; 560 561 static struct clk_rcg2 gcc_qupv3_wrap0_s7_clk_src = { 562 .cmd_rcgr = 0x17998, 563 .mnd_width = 16, 564 .hid_width = 5, 565 .parent_map = gcc_parent_map_0, 566 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 567 .clkr.hw.init = &(struct clk_init_data){ 568 .name = "gcc_qupv3_wrap0_s7_clk_src", 569 .parent_data = gcc_parents_0, 570 .num_parents = ARRAY_SIZE(gcc_parents_0), 571 .flags = CLK_SET_RATE_PARENT, 572 .ops = &clk_rcg2_ops, 573 }, 574 }; 575 576 static struct clk_rcg2 gcc_qupv3_wrap1_s0_clk_src = { 577 .cmd_rcgr = 0x18148, 578 .mnd_width = 16, 579 .hid_width = 5, 580 .parent_map = gcc_parent_map_0, 581 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 582 .clkr.hw.init = &(struct clk_init_data){ 583 .name = "gcc_qupv3_wrap1_s0_clk_src", 584 .parent_data = gcc_parents_0, 585 .num_parents = ARRAY_SIZE(gcc_parents_0), 586 .flags = CLK_SET_RATE_PARENT, 587 .ops = &clk_rcg2_ops, 588 }, 589 }; 590 591 static struct clk_rcg2 gcc_qupv3_wrap1_s1_clk_src = { 592 .cmd_rcgr = 0x18278, 593 .mnd_width = 16, 594 .hid_width = 5, 595 .parent_map = gcc_parent_map_0, 596 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 597 .clkr.hw.init = &(struct clk_init_data){ 598 .name = "gcc_qupv3_wrap1_s1_clk_src", 599 .parent_data = gcc_parents_0, 600 .num_parents = ARRAY_SIZE(gcc_parents_0), 601 .flags = CLK_SET_RATE_PARENT, 602 .ops = &clk_rcg2_ops, 603 }, 604 }; 605 606 static struct clk_rcg2 gcc_qupv3_wrap1_s2_clk_src = { 607 .cmd_rcgr = 0x183a8, 608 .mnd_width = 16, 609 .hid_width = 5, 610 .parent_map = gcc_parent_map_0, 611 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 612 .clkr.hw.init = &(struct clk_init_data){ 613 .name = "gcc_qupv3_wrap1_s2_clk_src", 614 .parent_data = gcc_parents_0, 615 .num_parents = ARRAY_SIZE(gcc_parents_0), 616 .flags = CLK_SET_RATE_PARENT, 617 .ops = &clk_rcg2_ops, 618 }, 619 }; 620 621 static struct clk_rcg2 gcc_qupv3_wrap1_s3_clk_src = { 622 .cmd_rcgr = 0x184d8, 623 .mnd_width = 16, 624 .hid_width = 5, 625 .parent_map = gcc_parent_map_0, 626 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 627 .clkr.hw.init = &(struct clk_init_data){ 628 .name = "gcc_qupv3_wrap1_s3_clk_src", 629 .parent_data = gcc_parents_0, 630 .num_parents = ARRAY_SIZE(gcc_parents_0), 631 .flags = CLK_SET_RATE_PARENT, 632 .ops = &clk_rcg2_ops, 633 }, 634 }; 635 636 static struct clk_rcg2 gcc_qupv3_wrap1_s4_clk_src = { 637 .cmd_rcgr = 0x18608, 638 .mnd_width = 16, 639 .hid_width = 5, 640 .parent_map = gcc_parent_map_0, 641 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 642 .clkr.hw.init = &(struct clk_init_data){ 643 .name = "gcc_qupv3_wrap1_s4_clk_src", 644 .parent_data = gcc_parents_0, 645 .num_parents = ARRAY_SIZE(gcc_parents_0), 646 .flags = CLK_SET_RATE_PARENT, 647 .ops = &clk_rcg2_ops, 648 }, 649 }; 650 651 static struct clk_rcg2 gcc_qupv3_wrap1_s5_clk_src = { 652 .cmd_rcgr = 0x18738, 653 .mnd_width = 16, 654 .hid_width = 5, 655 .parent_map = gcc_parent_map_0, 656 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 657 .clkr.hw.init = &(struct clk_init_data){ 658 .name = "gcc_qupv3_wrap1_s5_clk_src", 659 .parent_data = gcc_parents_0, 660 .num_parents = ARRAY_SIZE(gcc_parents_0), 661 .flags = CLK_SET_RATE_PARENT, 662 .ops = &clk_rcg2_ops, 663 }, 664 }; 665 666 static struct clk_rcg2 gcc_qupv3_wrap2_s0_clk_src = { 667 .cmd_rcgr = 0x1e148, 668 .mnd_width = 16, 669 .hid_width = 5, 670 .parent_map = gcc_parent_map_0, 671 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 672 .clkr.hw.init = &(struct clk_init_data){ 673 .name = "gcc_qupv3_wrap2_s0_clk_src", 674 .parent_data = gcc_parents_0, 675 .num_parents = ARRAY_SIZE(gcc_parents_0), 676 .flags = CLK_SET_RATE_PARENT, 677 .ops = &clk_rcg2_ops, 678 }, 679 }; 680 681 static struct clk_rcg2 gcc_qupv3_wrap2_s1_clk_src = { 682 .cmd_rcgr = 0x1e278, 683 .mnd_width = 16, 684 .hid_width = 5, 685 .parent_map = gcc_parent_map_0, 686 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 687 .clkr.hw.init = &(struct clk_init_data){ 688 .name = "gcc_qupv3_wrap2_s1_clk_src", 689 .parent_data = gcc_parents_0, 690 .num_parents = ARRAY_SIZE(gcc_parents_0), 691 .flags = CLK_SET_RATE_PARENT, 692 .ops = &clk_rcg2_ops, 693 }, 694 }; 695 696 static struct clk_rcg2 gcc_qupv3_wrap2_s2_clk_src = { 697 .cmd_rcgr = 0x1e3a8, 698 .mnd_width = 16, 699 .hid_width = 5, 700 .parent_map = gcc_parent_map_0, 701 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 702 .clkr.hw.init = &(struct clk_init_data){ 703 .name = "gcc_qupv3_wrap2_s2_clk_src", 704 .parent_data = gcc_parents_0, 705 .num_parents = ARRAY_SIZE(gcc_parents_0), 706 .flags = CLK_SET_RATE_PARENT, 707 .ops = &clk_rcg2_ops, 708 }, 709 }; 710 711 static struct clk_rcg2 gcc_qupv3_wrap2_s3_clk_src = { 712 .cmd_rcgr = 0x1e4d8, 713 .mnd_width = 16, 714 .hid_width = 5, 715 .parent_map = gcc_parent_map_0, 716 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 717 .clkr.hw.init = &(struct clk_init_data){ 718 .name = "gcc_qupv3_wrap2_s3_clk_src", 719 .parent_data = gcc_parents_0, 720 .num_parents = ARRAY_SIZE(gcc_parents_0), 721 .flags = CLK_SET_RATE_PARENT, 722 .ops = &clk_rcg2_ops, 723 }, 724 }; 725 726 static struct clk_rcg2 gcc_qupv3_wrap2_s4_clk_src = { 727 .cmd_rcgr = 0x1e608, 728 .mnd_width = 16, 729 .hid_width = 5, 730 .parent_map = gcc_parent_map_0, 731 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 732 .clkr.hw.init = &(struct clk_init_data){ 733 .name = "gcc_qupv3_wrap2_s4_clk_src", 734 .parent_data = gcc_parents_0, 735 .num_parents = ARRAY_SIZE(gcc_parents_0), 736 .flags = CLK_SET_RATE_PARENT, 737 .ops = &clk_rcg2_ops, 738 }, 739 }; 740 741 static struct clk_rcg2 gcc_qupv3_wrap2_s5_clk_src = { 742 .cmd_rcgr = 0x1e738, 743 .mnd_width = 16, 744 .hid_width = 5, 745 .parent_map = gcc_parent_map_0, 746 .freq_tbl = ftbl_gcc_qupv3_wrap0_s0_clk_src, 747 .clkr.hw.init = &(struct clk_init_data){ 748 .name = "gcc_qupv3_wrap2_s5_clk_src", 749 .parent_data = gcc_parents_0, 750 .num_parents = ARRAY_SIZE(gcc_parents_0), 751 .flags = CLK_SET_RATE_PARENT, 752 .ops = &clk_rcg2_ops, 753 }, 754 }; 755 756 static const struct freq_tbl ftbl_gcc_sdcc2_apps_clk_src[] = { 757 F(400000, P_BI_TCXO, 12, 1, 4), 758 F(9600000, P_BI_TCXO, 2, 0, 0), 759 F(19200000, P_BI_TCXO, 1, 0, 0), 760 F(25000000, P_GPLL0_OUT_MAIN, 12, 1, 2), 761 F(50000000, P_GPLL0_OUT_MAIN, 12, 0, 0), 762 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0), 763 F(202000000, P_GPLL9_OUT_MAIN, 4, 0, 0), 764 { } 765 }; 766 767 static struct clk_rcg2 gcc_sdcc2_apps_clk_src = { 768 .cmd_rcgr = 0x1400c, 769 .mnd_width = 8, 770 .hid_width = 5, 771 .parent_map = gcc_parent_map_6, 772 .freq_tbl = ftbl_gcc_sdcc2_apps_clk_src, 773 .clkr.hw.init = &(struct clk_init_data){ 774 .name = "gcc_sdcc2_apps_clk_src", 775 .parent_data = gcc_parents_6, 776 .num_parents = ARRAY_SIZE(gcc_parents_6), 777 .flags = CLK_OPS_PARENT_ENABLE, 778 .ops = &clk_rcg2_floor_ops, 779 }, 780 }; 781 782 static const struct freq_tbl ftbl_gcc_sdcc4_apps_clk_src[] = { 783 F(400000, P_BI_TCXO, 12, 1, 4), 784 F(9600000, P_BI_TCXO, 2, 0, 0), 785 F(19200000, P_BI_TCXO, 1, 0, 0), 786 F(25000000, P_GPLL0_OUT_MAIN, 12, 1, 2), 787 F(50000000, P_GPLL0_OUT_MAIN, 12, 0, 0), 788 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0), 789 { } 790 }; 791 792 static struct clk_rcg2 gcc_sdcc4_apps_clk_src = { 793 .cmd_rcgr = 0x1600c, 794 .mnd_width = 8, 795 .hid_width = 5, 796 .parent_map = gcc_parent_map_3, 797 .freq_tbl = ftbl_gcc_sdcc4_apps_clk_src, 798 .clkr.hw.init = &(struct clk_init_data){ 799 .name = "gcc_sdcc4_apps_clk_src", 800 .parent_data = gcc_parents_3, 801 .num_parents = ARRAY_SIZE(gcc_parents_3), 802 .flags = CLK_SET_RATE_PARENT, 803 .ops = &clk_rcg2_floor_ops, 804 }, 805 }; 806 807 static const struct freq_tbl ftbl_gcc_tsif_ref_clk_src[] = { 808 F(105495, P_BI_TCXO, 2, 1, 91), 809 { } 810 }; 811 812 static struct clk_rcg2 gcc_tsif_ref_clk_src = { 813 .cmd_rcgr = 0x36010, 814 .mnd_width = 8, 815 .hid_width = 5, 816 .parent_map = gcc_parent_map_7, 817 .freq_tbl = ftbl_gcc_tsif_ref_clk_src, 818 .clkr.hw.init = &(struct clk_init_data){ 819 .name = "gcc_tsif_ref_clk_src", 820 .parent_data = gcc_parents_7, 821 .num_parents = ARRAY_SIZE(gcc_parents_7), 822 .flags = CLK_SET_RATE_PARENT, 823 .ops = &clk_rcg2_ops, 824 }, 825 }; 826 827 static const struct freq_tbl ftbl_gcc_ufs_card_axi_clk_src[] = { 828 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0), 829 F(50000000, P_GPLL0_OUT_EVEN, 6, 0, 0), 830 F(100000000, P_GPLL0_OUT_MAIN, 6, 0, 0), 831 F(200000000, P_GPLL0_OUT_MAIN, 3, 0, 0), 832 F(240000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0), 833 { } 834 }; 835 836 static struct clk_rcg2 gcc_ufs_card_axi_clk_src = { 837 .cmd_rcgr = 0x75020, 838 .mnd_width = 8, 839 .hid_width = 5, 840 .parent_map = gcc_parent_map_0, 841 .freq_tbl = ftbl_gcc_ufs_card_axi_clk_src, 842 .clkr.hw.init = &(struct clk_init_data){ 843 .name = "gcc_ufs_card_axi_clk_src", 844 .parent_data = gcc_parents_0, 845 .num_parents = ARRAY_SIZE(gcc_parents_0), 846 .flags = CLK_SET_RATE_PARENT, 847 .ops = &clk_rcg2_ops, 848 }, 849 }; 850 851 static const struct freq_tbl ftbl_gcc_ufs_card_ice_core_clk_src[] = { 852 F(37500000, P_GPLL0_OUT_EVEN, 8, 0, 0), 853 F(75000000, P_GPLL0_OUT_EVEN, 4, 0, 0), 854 F(150000000, P_GPLL0_OUT_MAIN, 4, 0, 0), 855 F(300000000, P_GPLL0_OUT_MAIN, 2, 0, 0), 856 { } 857 }; 858 859 static struct clk_rcg2 gcc_ufs_card_ice_core_clk_src = { 860 .cmd_rcgr = 0x75060, 861 .mnd_width = 0, 862 .hid_width = 5, 863 .parent_map = gcc_parent_map_0, 864 .freq_tbl = ftbl_gcc_ufs_card_ice_core_clk_src, 865 .clkr.hw.init = &(struct clk_init_data){ 866 .name = "gcc_ufs_card_ice_core_clk_src", 867 .parent_data = gcc_parents_0, 868 .num_parents = ARRAY_SIZE(gcc_parents_0), 869 .flags = CLK_SET_RATE_PARENT, 870 .ops = &clk_rcg2_ops, 871 }, 872 }; 873 874 static const struct freq_tbl ftbl_gcc_ufs_card_phy_aux_clk_src[] = { 875 F(19200000, P_BI_TCXO, 1, 0, 0), 876 { } 877 }; 878 879 static struct clk_rcg2 gcc_ufs_card_phy_aux_clk_src = { 880 .cmd_rcgr = 0x75094, 881 .mnd_width = 0, 882 .hid_width = 5, 883 .parent_map = gcc_parent_map_4, 884 .freq_tbl = ftbl_gcc_ufs_card_phy_aux_clk_src, 885 .clkr.hw.init = &(struct clk_init_data){ 886 .name = "gcc_ufs_card_phy_aux_clk_src", 887 .parent_data = gcc_parents_4, 888 .num_parents = ARRAY_SIZE(gcc_parents_4), 889 .flags = CLK_SET_RATE_PARENT, 890 .ops = &clk_rcg2_ops, 891 }, 892 }; 893 894 static const struct freq_tbl ftbl_gcc_ufs_card_unipro_core_clk_src[] = { 895 F(37500000, P_GPLL0_OUT_EVEN, 8, 0, 0), 896 F(75000000, P_GPLL0_OUT_MAIN, 8, 0, 0), 897 F(150000000, P_GPLL0_OUT_MAIN, 4, 0, 0), 898 { } 899 }; 900 901 static struct clk_rcg2 gcc_ufs_card_unipro_core_clk_src = { 902 .cmd_rcgr = 0x75078, 903 .mnd_width = 0, 904 .hid_width = 5, 905 .parent_map = gcc_parent_map_0, 906 .freq_tbl = ftbl_gcc_ufs_card_unipro_core_clk_src, 907 .clkr.hw.init = &(struct clk_init_data){ 908 .name = "gcc_ufs_card_unipro_core_clk_src", 909 .parent_data = gcc_parents_0, 910 .num_parents = ARRAY_SIZE(gcc_parents_0), 911 .flags = CLK_SET_RATE_PARENT, 912 .ops = &clk_rcg2_ops, 913 }, 914 }; 915 916 static const struct freq_tbl ftbl_gcc_ufs_phy_axi_clk_src[] = { 917 F(25000000, P_GPLL0_OUT_EVEN, 12, 0, 0), 918 F(37500000, P_GPLL0_OUT_EVEN, 8, 0, 0), 919 F(75000000, P_GPLL0_OUT_EVEN, 4, 0, 0), 920 F(150000000, P_GPLL0_OUT_MAIN, 4, 0, 0), 921 F(300000000, P_GPLL0_OUT_MAIN, 2, 0, 0), 922 { } 923 }; 924 925 static struct clk_rcg2 gcc_ufs_phy_axi_clk_src = { 926 .cmd_rcgr = 0x77020, 927 .mnd_width = 8, 928 .hid_width = 5, 929 .parent_map = gcc_parent_map_0, 930 .freq_tbl = ftbl_gcc_ufs_phy_axi_clk_src, 931 .clkr.hw.init = &(struct clk_init_data){ 932 .name = "gcc_ufs_phy_axi_clk_src", 933 .parent_data = gcc_parents_0, 934 .num_parents = ARRAY_SIZE(gcc_parents_0), 935 .flags = CLK_SET_RATE_PARENT, 936 .ops = &clk_rcg2_ops, 937 }, 938 }; 939 940 static struct clk_rcg2 gcc_ufs_phy_ice_core_clk_src = { 941 .cmd_rcgr = 0x77060, 942 .mnd_width = 0, 943 .hid_width = 5, 944 .parent_map = gcc_parent_map_0, 945 .freq_tbl = ftbl_gcc_ufs_card_ice_core_clk_src, 946 .clkr.hw.init = &(struct clk_init_data){ 947 .name = "gcc_ufs_phy_ice_core_clk_src", 948 .parent_data = gcc_parents_0, 949 .num_parents = ARRAY_SIZE(gcc_parents_0), 950 .flags = CLK_SET_RATE_PARENT, 951 .ops = &clk_rcg2_ops, 952 }, 953 }; 954 955 static struct clk_rcg2 gcc_ufs_phy_phy_aux_clk_src = { 956 .cmd_rcgr = 0x77094, 957 .mnd_width = 0, 958 .hid_width = 5, 959 .parent_map = gcc_parent_map_4, 960 .freq_tbl = ftbl_gcc_pcie_0_aux_clk_src, 961 .clkr.hw.init = &(struct clk_init_data){ 962 .name = "gcc_ufs_phy_phy_aux_clk_src", 963 .parent_data = gcc_parents_4, 964 .num_parents = ARRAY_SIZE(gcc_parents_4), 965 .flags = CLK_SET_RATE_PARENT, 966 .ops = &clk_rcg2_ops, 967 }, 968 }; 969 970 static struct clk_rcg2 gcc_ufs_phy_unipro_core_clk_src = { 971 .cmd_rcgr = 0x77078, 972 .mnd_width = 0, 973 .hid_width = 5, 974 .parent_map = gcc_parent_map_0, 975 .freq_tbl = ftbl_gcc_ufs_card_ice_core_clk_src, 976 .clkr.hw.init = &(struct clk_init_data){ 977 .name = "gcc_ufs_phy_unipro_core_clk_src", 978 .parent_data = gcc_parents_0, 979 .num_parents = ARRAY_SIZE(gcc_parents_0), 980 .flags = CLK_SET_RATE_PARENT, 981 .ops = &clk_rcg2_ops, 982 }, 983 }; 984 985 static const struct freq_tbl ftbl_gcc_usb30_prim_master_clk_src[] = { 986 F(33333333, P_GPLL0_OUT_EVEN, 9, 0, 0), 987 F(66666667, P_GPLL0_OUT_EVEN, 4.5, 0, 0), 988 F(133333333, P_GPLL0_OUT_MAIN, 4.5, 0, 0), 989 F(200000000, P_GPLL0_OUT_MAIN, 3, 0, 0), 990 F(240000000, P_GPLL0_OUT_MAIN, 2.5, 0, 0), 991 { } 992 }; 993 994 static struct clk_rcg2 gcc_usb30_prim_master_clk_src = { 995 .cmd_rcgr = 0xf01c, 996 .mnd_width = 8, 997 .hid_width = 5, 998 .parent_map = gcc_parent_map_0, 999 .freq_tbl = ftbl_gcc_usb30_prim_master_clk_src, 1000 .clkr.hw.init = &(struct clk_init_data){ 1001 .name = "gcc_usb30_prim_master_clk_src", 1002 .parent_data = gcc_parents_0, 1003 .num_parents = ARRAY_SIZE(gcc_parents_0), 1004 .flags = CLK_SET_RATE_PARENT, 1005 .ops = &clk_rcg2_ops, 1006 }, 1007 }; 1008 1009 static const struct freq_tbl ftbl_gcc_usb30_prim_mock_utmi_clk_src[] = { 1010 F(19200000, P_BI_TCXO, 1, 0, 0), 1011 F(20000000, P_GPLL0_OUT_EVEN, 15, 0, 0), 1012 F(60000000, P_GPLL0_OUT_EVEN, 5, 0, 0), 1013 { } 1014 }; 1015 1016 static struct clk_rcg2 gcc_usb30_prim_mock_utmi_clk_src = { 1017 .cmd_rcgr = 0xf034, 1018 .mnd_width = 0, 1019 .hid_width = 5, 1020 .parent_map = gcc_parent_map_0, 1021 .freq_tbl = ftbl_gcc_usb30_prim_mock_utmi_clk_src, 1022 .clkr.hw.init = &(struct clk_init_data){ 1023 .name = "gcc_usb30_prim_mock_utmi_clk_src", 1024 .parent_data = gcc_parents_0, 1025 .num_parents = ARRAY_SIZE(gcc_parents_0), 1026 .flags = CLK_SET_RATE_PARENT, 1027 .ops = &clk_rcg2_ops, 1028 }, 1029 }; 1030 1031 static struct clk_rcg2 gcc_usb30_sec_master_clk_src = { 1032 .cmd_rcgr = 0x1001c, 1033 .mnd_width = 8, 1034 .hid_width = 5, 1035 .parent_map = gcc_parent_map_0, 1036 .freq_tbl = ftbl_gcc_usb30_prim_master_clk_src, 1037 .clkr.hw.init = &(struct clk_init_data){ 1038 .name = "gcc_usb30_sec_master_clk_src", 1039 .parent_data = gcc_parents_0, 1040 .num_parents = ARRAY_SIZE(gcc_parents_0), 1041 .flags = CLK_SET_RATE_PARENT, 1042 .ops = &clk_rcg2_ops, 1043 }, 1044 }; 1045 1046 static struct clk_rcg2 gcc_usb30_sec_mock_utmi_clk_src = { 1047 .cmd_rcgr = 0x10034, 1048 .mnd_width = 0, 1049 .hid_width = 5, 1050 .parent_map = gcc_parent_map_0, 1051 .freq_tbl = ftbl_gcc_usb30_prim_mock_utmi_clk_src, 1052 .clkr.hw.init = &(struct clk_init_data){ 1053 .name = "gcc_usb30_sec_mock_utmi_clk_src", 1054 .parent_data = gcc_parents_0, 1055 .num_parents = ARRAY_SIZE(gcc_parents_0), 1056 .flags = CLK_SET_RATE_PARENT, 1057 .ops = &clk_rcg2_ops, 1058 }, 1059 }; 1060 1061 static struct clk_rcg2 gcc_usb3_prim_phy_aux_clk_src = { 1062 .cmd_rcgr = 0xf060, 1063 .mnd_width = 0, 1064 .hid_width = 5, 1065 .parent_map = gcc_parent_map_2, 1066 .freq_tbl = ftbl_gcc_ufs_card_phy_aux_clk_src, 1067 .clkr.hw.init = &(struct clk_init_data){ 1068 .name = "gcc_usb3_prim_phy_aux_clk_src", 1069 .parent_data = gcc_parents_2, 1070 .num_parents = ARRAY_SIZE(gcc_parents_2), 1071 .flags = CLK_SET_RATE_PARENT, 1072 .ops = &clk_rcg2_ops, 1073 }, 1074 }; 1075 1076 static struct clk_rcg2 gcc_usb3_sec_phy_aux_clk_src = { 1077 .cmd_rcgr = 0x10060, 1078 .mnd_width = 0, 1079 .hid_width = 5, 1080 .parent_map = gcc_parent_map_2, 1081 .freq_tbl = ftbl_gcc_ufs_card_phy_aux_clk_src, 1082 .clkr.hw.init = &(struct clk_init_data){ 1083 .name = "gcc_usb3_sec_phy_aux_clk_src", 1084 .parent_data = gcc_parents_2, 1085 .num_parents = ARRAY_SIZE(gcc_parents_2), 1086 .flags = CLK_SET_RATE_PARENT, 1087 .ops = &clk_rcg2_ops, 1088 }, 1089 }; 1090 1091 static struct clk_branch gcc_aggre_noc_pcie_tbu_clk = { 1092 .halt_reg = 0x90018, 1093 .halt_check = BRANCH_HALT, 1094 .clkr = { 1095 .enable_reg = 0x90018, 1096 .enable_mask = BIT(0), 1097 .hw.init = &(struct clk_init_data){ 1098 .name = "gcc_aggre_noc_pcie_tbu_clk", 1099 .ops = &clk_branch2_ops, 1100 }, 1101 }, 1102 }; 1103 1104 static struct clk_branch gcc_aggre_ufs_card_axi_clk = { 1105 .halt_reg = 0x750c0, 1106 .halt_check = BRANCH_HALT, 1107 .hwcg_reg = 0x750c0, 1108 .hwcg_bit = 1, 1109 .clkr = { 1110 .enable_reg = 0x750c0, 1111 .enable_mask = BIT(0), 1112 .hw.init = &(struct clk_init_data){ 1113 .name = "gcc_aggre_ufs_card_axi_clk", 1114 .parent_hws = (const struct clk_hw *[]){ 1115 &gcc_ufs_card_axi_clk_src.clkr.hw }, 1116 .num_parents = 1, 1117 .flags = CLK_SET_RATE_PARENT, 1118 .ops = &clk_branch2_ops, 1119 }, 1120 }, 1121 }; 1122 1123 static struct clk_branch gcc_aggre_ufs_card_axi_hw_ctl_clk = { 1124 .halt_reg = 0x750c0, 1125 .halt_check = BRANCH_HALT, 1126 .hwcg_reg = 0x750c0, 1127 .hwcg_bit = 1, 1128 .clkr = { 1129 .enable_reg = 0x750c0, 1130 .enable_mask = BIT(1), 1131 .hw.init = &(struct clk_init_data){ 1132 .name = "gcc_aggre_ufs_card_axi_hw_ctl_clk", 1133 .parent_hws = (const struct clk_hw *[]){ 1134 &gcc_aggre_ufs_card_axi_clk.clkr.hw }, 1135 .num_parents = 1, 1136 .flags = CLK_SET_RATE_PARENT, 1137 .ops = &clk_branch_simple_ops, 1138 }, 1139 }, 1140 }; 1141 1142 static struct clk_branch gcc_aggre_ufs_phy_axi_clk = { 1143 .halt_reg = 0x770c0, 1144 .halt_check = BRANCH_HALT, 1145 .hwcg_reg = 0x770c0, 1146 .hwcg_bit = 1, 1147 .clkr = { 1148 .enable_reg = 0x770c0, 1149 .enable_mask = BIT(0), 1150 .hw.init = &(struct clk_init_data){ 1151 .name = "gcc_aggre_ufs_phy_axi_clk", 1152 .parent_hws = (const struct clk_hw *[]){ 1153 &gcc_ufs_phy_axi_clk_src.clkr.hw }, 1154 .num_parents = 1, 1155 .flags = CLK_SET_RATE_PARENT, 1156 .ops = &clk_branch2_ops, 1157 }, 1158 }, 1159 }; 1160 1161 static struct clk_branch gcc_aggre_ufs_phy_axi_hw_ctl_clk = { 1162 .halt_reg = 0x770c0, 1163 .halt_check = BRANCH_HALT, 1164 .hwcg_reg = 0x770c0, 1165 .hwcg_bit = 1, 1166 .clkr = { 1167 .enable_reg = 0x770c0, 1168 .enable_mask = BIT(1), 1169 .hw.init = &(struct clk_init_data){ 1170 .name = "gcc_aggre_ufs_phy_axi_hw_ctl_clk", 1171 .parent_hws = (const struct clk_hw *[]){ 1172 &gcc_aggre_ufs_phy_axi_clk.clkr.hw }, 1173 .num_parents = 1, 1174 .flags = CLK_SET_RATE_PARENT, 1175 .ops = &clk_branch_simple_ops, 1176 }, 1177 }, 1178 }; 1179 1180 static struct clk_branch gcc_aggre_usb3_prim_axi_clk = { 1181 .halt_reg = 0xf07c, 1182 .halt_check = BRANCH_HALT, 1183 .clkr = { 1184 .enable_reg = 0xf07c, 1185 .enable_mask = BIT(0), 1186 .hw.init = &(struct clk_init_data){ 1187 .name = "gcc_aggre_usb3_prim_axi_clk", 1188 .parent_hws = (const struct clk_hw *[]){ 1189 &gcc_usb30_prim_master_clk_src.clkr.hw }, 1190 .num_parents = 1, 1191 .flags = CLK_SET_RATE_PARENT, 1192 .ops = &clk_branch2_ops, 1193 }, 1194 }, 1195 }; 1196 1197 static struct clk_branch gcc_aggre_usb3_sec_axi_clk = { 1198 .halt_reg = 0x1007c, 1199 .halt_check = BRANCH_HALT, 1200 .clkr = { 1201 .enable_reg = 0x1007c, 1202 .enable_mask = BIT(0), 1203 .hw.init = &(struct clk_init_data){ 1204 .name = "gcc_aggre_usb3_sec_axi_clk", 1205 .parent_hws = (const struct clk_hw *[]){ 1206 &gcc_usb30_sec_master_clk_src.clkr.hw }, 1207 .num_parents = 1, 1208 .flags = CLK_SET_RATE_PARENT, 1209 .ops = &clk_branch2_ops, 1210 }, 1211 }, 1212 }; 1213 1214 static struct clk_branch gcc_boot_rom_ahb_clk = { 1215 .halt_reg = 0x38004, 1216 .halt_check = BRANCH_HALT_VOTED, 1217 .hwcg_reg = 0x38004, 1218 .hwcg_bit = 1, 1219 .clkr = { 1220 .enable_reg = 0x52004, 1221 .enable_mask = BIT(10), 1222 .hw.init = &(struct clk_init_data){ 1223 .name = "gcc_boot_rom_ahb_clk", 1224 .ops = &clk_branch2_ops, 1225 }, 1226 }, 1227 }; 1228 1229 /* 1230 * Clock ON depends on external parent 'config noc', so cant poll 1231 * delay and also mark as crtitical for camss boot 1232 */ 1233 static struct clk_branch gcc_camera_ahb_clk = { 1234 .halt_reg = 0xb008, 1235 .halt_check = BRANCH_HALT_DELAY, 1236 .hwcg_reg = 0xb008, 1237 .hwcg_bit = 1, 1238 .clkr = { 1239 .enable_reg = 0xb008, 1240 .enable_mask = BIT(0), 1241 .hw.init = &(struct clk_init_data){ 1242 .name = "gcc_camera_ahb_clk", 1243 .flags = CLK_IS_CRITICAL, 1244 .ops = &clk_branch2_ops, 1245 }, 1246 }, 1247 }; 1248 1249 static struct clk_branch gcc_camera_hf_axi_clk = { 1250 .halt_reg = 0xb030, 1251 .halt_check = BRANCH_HALT, 1252 .clkr = { 1253 .enable_reg = 0xb030, 1254 .enable_mask = BIT(0), 1255 .hw.init = &(struct clk_init_data){ 1256 .name = "gcc_camera_hf_axi_clk", 1257 .ops = &clk_branch2_ops, 1258 }, 1259 }, 1260 }; 1261 1262 static struct clk_branch gcc_camera_sf_axi_clk = { 1263 .halt_reg = 0xb034, 1264 .halt_check = BRANCH_HALT, 1265 .clkr = { 1266 .enable_reg = 0xb034, 1267 .enable_mask = BIT(0), 1268 .hw.init = &(struct clk_init_data){ 1269 .name = "gcc_camera_sf_axi_clk", 1270 .ops = &clk_branch2_ops, 1271 }, 1272 }, 1273 }; 1274 1275 /* XO critical input to camss, so no need to poll */ 1276 static struct clk_branch gcc_camera_xo_clk = { 1277 .halt_reg = 0xb044, 1278 .halt_check = BRANCH_HALT_DELAY, 1279 .clkr = { 1280 .enable_reg = 0xb044, 1281 .enable_mask = BIT(0), 1282 .hw.init = &(struct clk_init_data){ 1283 .name = "gcc_camera_xo_clk", 1284 .flags = CLK_IS_CRITICAL, 1285 .ops = &clk_branch2_ops, 1286 }, 1287 }, 1288 }; 1289 1290 static struct clk_branch gcc_cfg_noc_usb3_prim_axi_clk = { 1291 .halt_reg = 0xf078, 1292 .halt_check = BRANCH_HALT, 1293 .clkr = { 1294 .enable_reg = 0xf078, 1295 .enable_mask = BIT(0), 1296 .hw.init = &(struct clk_init_data){ 1297 .name = "gcc_cfg_noc_usb3_prim_axi_clk", 1298 .parent_hws = (const struct clk_hw *[]){ 1299 &gcc_usb30_prim_master_clk_src.clkr.hw }, 1300 .num_parents = 1, 1301 .flags = CLK_SET_RATE_PARENT, 1302 .ops = &clk_branch2_ops, 1303 }, 1304 }, 1305 }; 1306 1307 static struct clk_branch gcc_cfg_noc_usb3_sec_axi_clk = { 1308 .halt_reg = 0x10078, 1309 .halt_check = BRANCH_HALT, 1310 .clkr = { 1311 .enable_reg = 0x10078, 1312 .enable_mask = BIT(0), 1313 .hw.init = &(struct clk_init_data){ 1314 .name = "gcc_cfg_noc_usb3_sec_axi_clk", 1315 .parent_hws = (const struct clk_hw *[]){ 1316 &gcc_usb30_sec_master_clk_src.clkr.hw }, 1317 .num_parents = 1, 1318 .flags = CLK_SET_RATE_PARENT, 1319 .ops = &clk_branch2_ops, 1320 }, 1321 }, 1322 }; 1323 1324 static struct clk_branch gcc_cpuss_ahb_clk = { 1325 .halt_reg = 0x48000, 1326 .halt_check = BRANCH_HALT_VOTED, 1327 .clkr = { 1328 .enable_reg = 0x52004, 1329 .enable_mask = BIT(21), 1330 .hw.init = &(struct clk_init_data){ 1331 .name = "gcc_cpuss_ahb_clk", 1332 .parent_hws = (const struct clk_hw *[]){ 1333 &gcc_cpuss_ahb_clk_src.clkr.hw }, 1334 .num_parents = 1, 1335 /* required for cpuss */ 1336 .flags = CLK_IS_CRITICAL | CLK_SET_RATE_PARENT, 1337 .ops = &clk_branch2_ops, 1338 }, 1339 }, 1340 }; 1341 1342 static struct clk_branch gcc_cpuss_dvm_bus_clk = { 1343 .halt_reg = 0x48190, 1344 .halt_check = BRANCH_HALT, 1345 .clkr = { 1346 .enable_reg = 0x48190, 1347 .enable_mask = BIT(0), 1348 .hw.init = &(struct clk_init_data){ 1349 .name = "gcc_cpuss_dvm_bus_clk", 1350 /* required for cpuss */ 1351 .flags = CLK_IS_CRITICAL, 1352 .ops = &clk_branch2_ops, 1353 }, 1354 }, 1355 }; 1356 1357 static struct clk_branch gcc_cpuss_gnoc_clk = { 1358 .halt_reg = 0x48004, 1359 .halt_check = BRANCH_HALT_VOTED, 1360 .hwcg_reg = 0x48004, 1361 .hwcg_bit = 1, 1362 .clkr = { 1363 .enable_reg = 0x52004, 1364 .enable_mask = BIT(22), 1365 .hw.init = &(struct clk_init_data){ 1366 .name = "gcc_cpuss_gnoc_clk", 1367 /* required for cpuss */ 1368 .flags = CLK_IS_CRITICAL, 1369 .ops = &clk_branch2_ops, 1370 }, 1371 }, 1372 }; 1373 1374 static struct clk_branch gcc_cpuss_rbcpr_clk = { 1375 .halt_reg = 0x48008, 1376 .halt_check = BRANCH_HALT, 1377 .clkr = { 1378 .enable_reg = 0x48008, 1379 .enable_mask = BIT(0), 1380 .hw.init = &(struct clk_init_data){ 1381 .name = "gcc_cpuss_rbcpr_clk", 1382 .ops = &clk_branch2_ops, 1383 }, 1384 }, 1385 }; 1386 1387 static struct clk_branch gcc_ddrss_gpu_axi_clk = { 1388 .halt_reg = 0x71154, 1389 .halt_check = BRANCH_VOTED, 1390 .clkr = { 1391 .enable_reg = 0x71154, 1392 .enable_mask = BIT(0), 1393 .hw.init = &(struct clk_init_data){ 1394 .name = "gcc_ddrss_gpu_axi_clk", 1395 .ops = &clk_branch2_ops, 1396 }, 1397 }, 1398 }; 1399 1400 /* 1401 * Clock ON depends on external parent 'config noc', so cant poll 1402 * delay and also mark as crtitical for disp boot 1403 */ 1404 static struct clk_branch gcc_disp_ahb_clk = { 1405 .halt_reg = 0xb00c, 1406 .halt_check = BRANCH_HALT_DELAY, 1407 .hwcg_reg = 0xb00c, 1408 .hwcg_bit = 1, 1409 .clkr = { 1410 .enable_reg = 0xb00c, 1411 .enable_mask = BIT(0), 1412 .hw.init = &(struct clk_init_data){ 1413 .name = "gcc_disp_ahb_clk", 1414 .flags = CLK_IS_CRITICAL, 1415 .ops = &clk_branch2_ops, 1416 }, 1417 }, 1418 }; 1419 1420 static struct clk_branch gcc_disp_hf_axi_clk = { 1421 .halt_reg = 0xb038, 1422 .halt_check = BRANCH_HALT, 1423 .clkr = { 1424 .enable_reg = 0xb038, 1425 .enable_mask = BIT(0), 1426 .hw.init = &(struct clk_init_data){ 1427 .name = "gcc_disp_hf_axi_clk", 1428 .ops = &clk_branch2_ops, 1429 }, 1430 }, 1431 }; 1432 1433 static struct clk_branch gcc_disp_sf_axi_clk = { 1434 .halt_reg = 0xb03c, 1435 .halt_check = BRANCH_HALT, 1436 .clkr = { 1437 .enable_reg = 0xb03c, 1438 .enable_mask = BIT(0), 1439 .hw.init = &(struct clk_init_data){ 1440 .name = "gcc_disp_sf_axi_clk", 1441 .ops = &clk_branch2_ops, 1442 }, 1443 }, 1444 }; 1445 1446 /* XO critical input to disp, so no need to poll */ 1447 static struct clk_branch gcc_disp_xo_clk = { 1448 .halt_reg = 0xb048, 1449 .halt_check = BRANCH_HALT_DELAY, 1450 .clkr = { 1451 .enable_reg = 0xb048, 1452 .enable_mask = BIT(0), 1453 .hw.init = &(struct clk_init_data){ 1454 .name = "gcc_disp_xo_clk", 1455 .flags = CLK_IS_CRITICAL, 1456 .ops = &clk_branch2_ops, 1457 }, 1458 }, 1459 }; 1460 1461 static struct clk_branch gcc_emac_axi_clk = { 1462 .halt_reg = 0x6010, 1463 .halt_check = BRANCH_HALT, 1464 .clkr = { 1465 .enable_reg = 0x6010, 1466 .enable_mask = BIT(0), 1467 .hw.init = &(struct clk_init_data){ 1468 .name = "gcc_emac_axi_clk", 1469 .ops = &clk_branch2_ops, 1470 }, 1471 }, 1472 }; 1473 1474 static struct clk_branch gcc_emac_ptp_clk = { 1475 .halt_reg = 0x6034, 1476 .halt_check = BRANCH_HALT, 1477 .clkr = { 1478 .enable_reg = 0x6034, 1479 .enable_mask = BIT(0), 1480 .hw.init = &(struct clk_init_data){ 1481 .name = "gcc_emac_ptp_clk", 1482 .parent_hws = (const struct clk_hw *[]){ 1483 &gcc_emac_ptp_clk_src.clkr.hw }, 1484 .num_parents = 1, 1485 .flags = CLK_SET_RATE_PARENT, 1486 .ops = &clk_branch2_ops, 1487 }, 1488 }, 1489 }; 1490 1491 static struct clk_branch gcc_emac_rgmii_clk = { 1492 .halt_reg = 0x6018, 1493 .halt_check = BRANCH_HALT, 1494 .clkr = { 1495 .enable_reg = 0x6018, 1496 .enable_mask = BIT(0), 1497 .hw.init = &(struct clk_init_data){ 1498 .name = "gcc_emac_rgmii_clk", 1499 .parent_hws = (const struct clk_hw *[]){ 1500 &gcc_emac_rgmii_clk_src.clkr.hw }, 1501 .num_parents = 1, 1502 .flags = CLK_SET_RATE_PARENT, 1503 .ops = &clk_branch2_ops, 1504 }, 1505 }, 1506 }; 1507 1508 static struct clk_branch gcc_emac_slv_ahb_clk = { 1509 .halt_reg = 0x6014, 1510 .halt_check = BRANCH_HALT, 1511 .hwcg_reg = 0x6014, 1512 .hwcg_bit = 1, 1513 .clkr = { 1514 .enable_reg = 0x6014, 1515 .enable_mask = BIT(0), 1516 .hw.init = &(struct clk_init_data){ 1517 .name = "gcc_emac_slv_ahb_clk", 1518 .ops = &clk_branch2_ops, 1519 }, 1520 }, 1521 }; 1522 1523 static struct clk_branch gcc_gp1_clk = { 1524 .halt_reg = 0x64000, 1525 .halt_check = BRANCH_HALT, 1526 .clkr = { 1527 .enable_reg = 0x64000, 1528 .enable_mask = BIT(0), 1529 .hw.init = &(struct clk_init_data){ 1530 .name = "gcc_gp1_clk", 1531 .parent_hws = (const struct clk_hw *[]){ 1532 &gcc_gp1_clk_src.clkr.hw }, 1533 .num_parents = 1, 1534 .flags = CLK_SET_RATE_PARENT, 1535 .ops = &clk_branch2_ops, 1536 }, 1537 }, 1538 }; 1539 1540 static struct clk_branch gcc_gp2_clk = { 1541 .halt_reg = 0x65000, 1542 .halt_check = BRANCH_HALT, 1543 .clkr = { 1544 .enable_reg = 0x65000, 1545 .enable_mask = BIT(0), 1546 .hw.init = &(struct clk_init_data){ 1547 .name = "gcc_gp2_clk", 1548 .parent_hws = (const struct clk_hw *[]){ 1549 &gcc_gp2_clk_src.clkr.hw }, 1550 .num_parents = 1, 1551 .flags = CLK_SET_RATE_PARENT, 1552 .ops = &clk_branch2_ops, 1553 }, 1554 }, 1555 }; 1556 1557 static struct clk_branch gcc_gp3_clk = { 1558 .halt_reg = 0x66000, 1559 .halt_check = BRANCH_HALT, 1560 .clkr = { 1561 .enable_reg = 0x66000, 1562 .enable_mask = BIT(0), 1563 .hw.init = &(struct clk_init_data){ 1564 .name = "gcc_gp3_clk", 1565 .parent_hws = (const struct clk_hw *[]){ 1566 &gcc_gp3_clk_src.clkr.hw }, 1567 .num_parents = 1, 1568 .flags = CLK_SET_RATE_PARENT, 1569 .ops = &clk_branch2_ops, 1570 }, 1571 }, 1572 }; 1573 1574 static struct clk_branch gcc_gpu_cfg_ahb_clk = { 1575 .halt_reg = 0x71004, 1576 .halt_check = BRANCH_HALT, 1577 .hwcg_reg = 0x71004, 1578 .hwcg_bit = 1, 1579 .clkr = { 1580 .enable_reg = 0x71004, 1581 .enable_mask = BIT(0), 1582 .hw.init = &(struct clk_init_data){ 1583 .name = "gcc_gpu_cfg_ahb_clk", 1584 /* required for gpu */ 1585 .flags = CLK_IS_CRITICAL, 1586 .ops = &clk_branch2_ops, 1587 }, 1588 }, 1589 }; 1590 1591 static struct clk_branch gcc_gpu_gpll0_clk_src = { 1592 .halt_check = BRANCH_HALT_SKIP, 1593 .clkr = { 1594 .enable_reg = 0x52004, 1595 .enable_mask = BIT(15), 1596 .hw.init = &(struct clk_init_data){ 1597 .name = "gcc_gpu_gpll0_clk_src", 1598 .parent_hws = (const struct clk_hw *[]){ 1599 &gpll0.clkr.hw }, 1600 .num_parents = 1, 1601 .flags = CLK_SET_RATE_PARENT, 1602 .ops = &clk_branch2_ops, 1603 }, 1604 }, 1605 }; 1606 1607 static struct clk_branch gcc_gpu_gpll0_div_clk_src = { 1608 .halt_check = BRANCH_HALT_SKIP, 1609 .clkr = { 1610 .enable_reg = 0x52004, 1611 .enable_mask = BIT(16), 1612 .hw.init = &(struct clk_init_data){ 1613 .name = "gcc_gpu_gpll0_div_clk_src", 1614 .parent_hws = (const struct clk_hw *[]){ 1615 &gpll0_out_even.clkr.hw }, 1616 .num_parents = 1, 1617 .flags = CLK_SET_RATE_PARENT, 1618 .ops = &clk_branch2_ops, 1619 }, 1620 }, 1621 }; 1622 1623 static struct clk_branch gcc_gpu_iref_clk = { 1624 .halt_reg = 0x8c010, 1625 .halt_check = BRANCH_HALT, 1626 .clkr = { 1627 .enable_reg = 0x8c010, 1628 .enable_mask = BIT(0), 1629 .hw.init = &(struct clk_init_data){ 1630 .name = "gcc_gpu_iref_clk", 1631 .ops = &clk_branch2_ops, 1632 }, 1633 }, 1634 }; 1635 1636 static struct clk_branch gcc_gpu_memnoc_gfx_clk = { 1637 .halt_reg = 0x7100c, 1638 .halt_check = BRANCH_VOTED, 1639 .clkr = { 1640 .enable_reg = 0x7100c, 1641 .enable_mask = BIT(0), 1642 .hw.init = &(struct clk_init_data){ 1643 .name = "gcc_gpu_memnoc_gfx_clk", 1644 .ops = &clk_branch2_ops, 1645 }, 1646 }, 1647 }; 1648 1649 static struct clk_branch gcc_gpu_snoc_dvm_gfx_clk = { 1650 .halt_reg = 0x71018, 1651 .halt_check = BRANCH_HALT, 1652 .clkr = { 1653 .enable_reg = 0x71018, 1654 .enable_mask = BIT(0), 1655 .hw.init = &(struct clk_init_data){ 1656 .name = "gcc_gpu_snoc_dvm_gfx_clk", 1657 .ops = &clk_branch2_ops, 1658 }, 1659 }, 1660 }; 1661 1662 static struct clk_branch gcc_npu_at_clk = { 1663 .halt_reg = 0x4d010, 1664 .halt_check = BRANCH_VOTED, 1665 .clkr = { 1666 .enable_reg = 0x4d010, 1667 .enable_mask = BIT(0), 1668 .hw.init = &(struct clk_init_data){ 1669 .name = "gcc_npu_at_clk", 1670 .ops = &clk_branch2_ops, 1671 }, 1672 }, 1673 }; 1674 1675 static struct clk_branch gcc_npu_axi_clk = { 1676 .halt_reg = 0x4d008, 1677 .halt_check = BRANCH_VOTED, 1678 .clkr = { 1679 .enable_reg = 0x4d008, 1680 .enable_mask = BIT(0), 1681 .hw.init = &(struct clk_init_data){ 1682 .name = "gcc_npu_axi_clk", 1683 .ops = &clk_branch2_ops, 1684 }, 1685 }, 1686 }; 1687 1688 static struct clk_branch gcc_npu_cfg_ahb_clk = { 1689 .halt_reg = 0x4d004, 1690 .halt_check = BRANCH_HALT, 1691 .hwcg_reg = 0x4d004, 1692 .hwcg_bit = 1, 1693 .clkr = { 1694 .enable_reg = 0x4d004, 1695 .enable_mask = BIT(0), 1696 .hw.init = &(struct clk_init_data){ 1697 .name = "gcc_npu_cfg_ahb_clk", 1698 /* required for npu */ 1699 .flags = CLK_IS_CRITICAL, 1700 .ops = &clk_branch2_ops, 1701 }, 1702 }, 1703 }; 1704 1705 static struct clk_branch gcc_npu_gpll0_clk_src = { 1706 .halt_check = BRANCH_HALT_SKIP, 1707 .clkr = { 1708 .enable_reg = 0x52004, 1709 .enable_mask = BIT(18), 1710 .hw.init = &(struct clk_init_data){ 1711 .name = "gcc_npu_gpll0_clk_src", 1712 .parent_hws = (const struct clk_hw *[]){ 1713 &gpll0.clkr.hw }, 1714 .num_parents = 1, 1715 .flags = CLK_SET_RATE_PARENT, 1716 .ops = &clk_branch2_ops, 1717 }, 1718 }, 1719 }; 1720 1721 static struct clk_branch gcc_npu_gpll0_div_clk_src = { 1722 .halt_check = BRANCH_HALT_SKIP, 1723 .clkr = { 1724 .enable_reg = 0x52004, 1725 .enable_mask = BIT(19), 1726 .hw.init = &(struct clk_init_data){ 1727 .name = "gcc_npu_gpll0_div_clk_src", 1728 .parent_hws = (const struct clk_hw *[]){ 1729 &gpll0_out_even.clkr.hw }, 1730 .num_parents = 1, 1731 .flags = CLK_SET_RATE_PARENT, 1732 .ops = &clk_branch2_ops, 1733 }, 1734 }, 1735 }; 1736 1737 static struct clk_branch gcc_npu_trig_clk = { 1738 .halt_reg = 0x4d00c, 1739 .halt_check = BRANCH_VOTED, 1740 .clkr = { 1741 .enable_reg = 0x4d00c, 1742 .enable_mask = BIT(0), 1743 .hw.init = &(struct clk_init_data){ 1744 .name = "gcc_npu_trig_clk", 1745 .ops = &clk_branch2_ops, 1746 }, 1747 }, 1748 }; 1749 1750 static struct clk_branch gcc_pcie0_phy_refgen_clk = { 1751 .halt_reg = 0x6f02c, 1752 .halt_check = BRANCH_HALT, 1753 .clkr = { 1754 .enable_reg = 0x6f02c, 1755 .enable_mask = BIT(0), 1756 .hw.init = &(struct clk_init_data){ 1757 .name = "gcc_pcie0_phy_refgen_clk", 1758 .parent_hws = (const struct clk_hw *[]){ 1759 &gcc_pcie_phy_refgen_clk_src.clkr.hw }, 1760 .num_parents = 1, 1761 .flags = CLK_SET_RATE_PARENT, 1762 .ops = &clk_branch2_ops, 1763 }, 1764 }, 1765 }; 1766 1767 static struct clk_branch gcc_pcie1_phy_refgen_clk = { 1768 .halt_reg = 0x6f030, 1769 .halt_check = BRANCH_HALT, 1770 .clkr = { 1771 .enable_reg = 0x6f030, 1772 .enable_mask = BIT(0), 1773 .hw.init = &(struct clk_init_data){ 1774 .name = "gcc_pcie1_phy_refgen_clk", 1775 .parent_hws = (const struct clk_hw *[]){ 1776 &gcc_pcie_phy_refgen_clk_src.clkr.hw }, 1777 .num_parents = 1, 1778 .flags = CLK_SET_RATE_PARENT, 1779 .ops = &clk_branch2_ops, 1780 }, 1781 }, 1782 }; 1783 1784 static struct clk_branch gcc_pcie_0_aux_clk = { 1785 .halt_reg = 0x6b020, 1786 .halt_check = BRANCH_HALT_VOTED, 1787 .clkr = { 1788 .enable_reg = 0x5200c, 1789 .enable_mask = BIT(3), 1790 .hw.init = &(struct clk_init_data){ 1791 .name = "gcc_pcie_0_aux_clk", 1792 .parent_hws = (const struct clk_hw *[]){ 1793 &gcc_pcie_0_aux_clk_src.clkr.hw }, 1794 .num_parents = 1, 1795 .flags = CLK_SET_RATE_PARENT, 1796 .ops = &clk_branch2_ops, 1797 }, 1798 }, 1799 }; 1800 1801 static struct clk_branch gcc_pcie_0_cfg_ahb_clk = { 1802 .halt_reg = 0x6b01c, 1803 .halt_check = BRANCH_HALT_VOTED, 1804 .hwcg_reg = 0x6b01c, 1805 .hwcg_bit = 1, 1806 .clkr = { 1807 .enable_reg = 0x5200c, 1808 .enable_mask = BIT(2), 1809 .hw.init = &(struct clk_init_data){ 1810 .name = "gcc_pcie_0_cfg_ahb_clk", 1811 .ops = &clk_branch2_ops, 1812 }, 1813 }, 1814 }; 1815 1816 static struct clk_branch gcc_pcie_0_clkref_clk = { 1817 .halt_reg = 0x8c00c, 1818 .halt_check = BRANCH_HALT, 1819 .clkr = { 1820 .enable_reg = 0x8c00c, 1821 .enable_mask = BIT(0), 1822 .hw.init = &(struct clk_init_data){ 1823 .name = "gcc_pcie_0_clkref_clk", 1824 .ops = &clk_branch2_ops, 1825 }, 1826 }, 1827 }; 1828 1829 static struct clk_branch gcc_pcie_0_mstr_axi_clk = { 1830 .halt_reg = 0x6b018, 1831 .halt_check = BRANCH_HALT_VOTED, 1832 .clkr = { 1833 .enable_reg = 0x5200c, 1834 .enable_mask = BIT(1), 1835 .hw.init = &(struct clk_init_data){ 1836 .name = "gcc_pcie_0_mstr_axi_clk", 1837 .ops = &clk_branch2_ops, 1838 }, 1839 }, 1840 }; 1841 1842 /* Clock ON depends on external parent 'PIPE' clock, so dont poll */ 1843 static struct clk_branch gcc_pcie_0_pipe_clk = { 1844 .halt_reg = 0x6b024, 1845 .halt_check = BRANCH_HALT_DELAY, 1846 .clkr = { 1847 .enable_reg = 0x5200c, 1848 .enable_mask = BIT(4), 1849 .hw.init = &(struct clk_init_data){ 1850 .name = "gcc_pcie_0_pipe_clk", 1851 .ops = &clk_branch2_ops, 1852 }, 1853 }, 1854 }; 1855 1856 static struct clk_branch gcc_pcie_0_slv_axi_clk = { 1857 .halt_reg = 0x6b014, 1858 .halt_check = BRANCH_HALT_VOTED, 1859 .hwcg_reg = 0x6b014, 1860 .hwcg_bit = 1, 1861 .clkr = { 1862 .enable_reg = 0x5200c, 1863 .enable_mask = BIT(0), 1864 .hw.init = &(struct clk_init_data){ 1865 .name = "gcc_pcie_0_slv_axi_clk", 1866 .ops = &clk_branch2_ops, 1867 }, 1868 }, 1869 }; 1870 1871 static struct clk_branch gcc_pcie_0_slv_q2a_axi_clk = { 1872 .halt_reg = 0x6b010, 1873 .halt_check = BRANCH_HALT_VOTED, 1874 .clkr = { 1875 .enable_reg = 0x5200c, 1876 .enable_mask = BIT(5), 1877 .hw.init = &(struct clk_init_data){ 1878 .name = "gcc_pcie_0_slv_q2a_axi_clk", 1879 .ops = &clk_branch2_ops, 1880 }, 1881 }, 1882 }; 1883 1884 static struct clk_branch gcc_pcie_1_aux_clk = { 1885 .halt_reg = 0x8d020, 1886 .halt_check = BRANCH_HALT_VOTED, 1887 .clkr = { 1888 .enable_reg = 0x52004, 1889 .enable_mask = BIT(29), 1890 .hw.init = &(struct clk_init_data){ 1891 .name = "gcc_pcie_1_aux_clk", 1892 .parent_hws = (const struct clk_hw *[]){ 1893 &gcc_pcie_1_aux_clk_src.clkr.hw }, 1894 .num_parents = 1, 1895 .flags = CLK_SET_RATE_PARENT, 1896 .ops = &clk_branch2_ops, 1897 }, 1898 }, 1899 }; 1900 1901 static struct clk_branch gcc_pcie_1_cfg_ahb_clk = { 1902 .halt_reg = 0x8d01c, 1903 .halt_check = BRANCH_HALT_VOTED, 1904 .hwcg_reg = 0x8d01c, 1905 .hwcg_bit = 1, 1906 .clkr = { 1907 .enable_reg = 0x52004, 1908 .enable_mask = BIT(28), 1909 .hw.init = &(struct clk_init_data){ 1910 .name = "gcc_pcie_1_cfg_ahb_clk", 1911 .ops = &clk_branch2_ops, 1912 }, 1913 }, 1914 }; 1915 1916 static struct clk_branch gcc_pcie_1_clkref_clk = { 1917 .halt_reg = 0x8c02c, 1918 .halt_check = BRANCH_HALT, 1919 .clkr = { 1920 .enable_reg = 0x8c02c, 1921 .enable_mask = BIT(0), 1922 .hw.init = &(struct clk_init_data){ 1923 .name = "gcc_pcie_1_clkref_clk", 1924 .ops = &clk_branch2_ops, 1925 }, 1926 }, 1927 }; 1928 1929 static struct clk_branch gcc_pcie_1_mstr_axi_clk = { 1930 .halt_reg = 0x8d018, 1931 .halt_check = BRANCH_HALT_VOTED, 1932 .clkr = { 1933 .enable_reg = 0x52004, 1934 .enable_mask = BIT(27), 1935 .hw.init = &(struct clk_init_data){ 1936 .name = "gcc_pcie_1_mstr_axi_clk", 1937 .ops = &clk_branch2_ops, 1938 }, 1939 }, 1940 }; 1941 1942 /* Clock ON depends on external parent 'PIPE' clock, so dont poll */ 1943 static struct clk_branch gcc_pcie_1_pipe_clk = { 1944 .halt_reg = 0x8d024, 1945 .halt_check = BRANCH_HALT_DELAY, 1946 .clkr = { 1947 .enable_reg = 0x52004, 1948 .enable_mask = BIT(30), 1949 .hw.init = &(struct clk_init_data){ 1950 .name = "gcc_pcie_1_pipe_clk", 1951 .ops = &clk_branch2_ops, 1952 }, 1953 }, 1954 }; 1955 1956 static struct clk_branch gcc_pcie_1_slv_axi_clk = { 1957 .halt_reg = 0x8d014, 1958 .halt_check = BRANCH_HALT_VOTED, 1959 .hwcg_reg = 0x8d014, 1960 .hwcg_bit = 1, 1961 .clkr = { 1962 .enable_reg = 0x52004, 1963 .enable_mask = BIT(26), 1964 .hw.init = &(struct clk_init_data){ 1965 .name = "gcc_pcie_1_slv_axi_clk", 1966 .ops = &clk_branch2_ops, 1967 }, 1968 }, 1969 }; 1970 1971 static struct clk_branch gcc_pcie_1_slv_q2a_axi_clk = { 1972 .halt_reg = 0x8d010, 1973 .halt_check = BRANCH_HALT_VOTED, 1974 .clkr = { 1975 .enable_reg = 0x52004, 1976 .enable_mask = BIT(25), 1977 .hw.init = &(struct clk_init_data){ 1978 .name = "gcc_pcie_1_slv_q2a_axi_clk", 1979 .ops = &clk_branch2_ops, 1980 }, 1981 }, 1982 }; 1983 1984 static struct clk_branch gcc_pcie_phy_aux_clk = { 1985 .halt_reg = 0x6f004, 1986 .halt_check = BRANCH_HALT, 1987 .clkr = { 1988 .enable_reg = 0x6f004, 1989 .enable_mask = BIT(0), 1990 .hw.init = &(struct clk_init_data){ 1991 .name = "gcc_pcie_phy_aux_clk", 1992 .parent_hws = (const struct clk_hw *[]){ 1993 &gcc_pcie_0_aux_clk_src.clkr.hw }, 1994 .num_parents = 1, 1995 .flags = CLK_SET_RATE_PARENT, 1996 .ops = &clk_branch2_ops, 1997 }, 1998 }, 1999 }; 2000 2001 static struct clk_branch gcc_pdm2_clk = { 2002 .halt_reg = 0x3300c, 2003 .halt_check = BRANCH_HALT, 2004 .clkr = { 2005 .enable_reg = 0x3300c, 2006 .enable_mask = BIT(0), 2007 .hw.init = &(struct clk_init_data){ 2008 .name = "gcc_pdm2_clk", 2009 .parent_hws = (const struct clk_hw *[]){ 2010 &gcc_pdm2_clk_src.clkr.hw }, 2011 .num_parents = 1, 2012 .flags = CLK_SET_RATE_PARENT, 2013 .ops = &clk_branch2_ops, 2014 }, 2015 }, 2016 }; 2017 2018 static struct clk_branch gcc_pdm_ahb_clk = { 2019 .halt_reg = 0x33004, 2020 .halt_check = BRANCH_HALT, 2021 .hwcg_reg = 0x33004, 2022 .hwcg_bit = 1, 2023 .clkr = { 2024 .enable_reg = 0x33004, 2025 .enable_mask = BIT(0), 2026 .hw.init = &(struct clk_init_data){ 2027 .name = "gcc_pdm_ahb_clk", 2028 .ops = &clk_branch2_ops, 2029 }, 2030 }, 2031 }; 2032 2033 static struct clk_branch gcc_pdm_xo4_clk = { 2034 .halt_reg = 0x33008, 2035 .halt_check = BRANCH_HALT, 2036 .clkr = { 2037 .enable_reg = 0x33008, 2038 .enable_mask = BIT(0), 2039 .hw.init = &(struct clk_init_data){ 2040 .name = "gcc_pdm_xo4_clk", 2041 .ops = &clk_branch2_ops, 2042 }, 2043 }, 2044 }; 2045 2046 static struct clk_branch gcc_prng_ahb_clk = { 2047 .halt_reg = 0x34004, 2048 .halt_check = BRANCH_HALT_VOTED, 2049 .clkr = { 2050 .enable_reg = 0x52004, 2051 .enable_mask = BIT(13), 2052 .hw.init = &(struct clk_init_data){ 2053 .name = "gcc_prng_ahb_clk", 2054 .ops = &clk_branch2_ops, 2055 }, 2056 }, 2057 }; 2058 2059 static struct clk_branch gcc_qmip_camera_nrt_ahb_clk = { 2060 .halt_reg = 0xb018, 2061 .halt_check = BRANCH_HALT, 2062 .hwcg_reg = 0xb018, 2063 .hwcg_bit = 1, 2064 .clkr = { 2065 .enable_reg = 0xb018, 2066 .enable_mask = BIT(0), 2067 .hw.init = &(struct clk_init_data){ 2068 .name = "gcc_qmip_camera_nrt_ahb_clk", 2069 .ops = &clk_branch2_ops, 2070 }, 2071 }, 2072 }; 2073 2074 static struct clk_branch gcc_qmip_camera_rt_ahb_clk = { 2075 .halt_reg = 0xb01c, 2076 .halt_check = BRANCH_HALT, 2077 .hwcg_reg = 0xb01c, 2078 .hwcg_bit = 1, 2079 .clkr = { 2080 .enable_reg = 0xb01c, 2081 .enable_mask = BIT(0), 2082 .hw.init = &(struct clk_init_data){ 2083 .name = "gcc_qmip_camera_rt_ahb_clk", 2084 .ops = &clk_branch2_ops, 2085 }, 2086 }, 2087 }; 2088 2089 static struct clk_branch gcc_qmip_disp_ahb_clk = { 2090 .halt_reg = 0xb020, 2091 .halt_check = BRANCH_HALT, 2092 .hwcg_reg = 0xb020, 2093 .hwcg_bit = 1, 2094 .clkr = { 2095 .enable_reg = 0xb020, 2096 .enable_mask = BIT(0), 2097 .hw.init = &(struct clk_init_data){ 2098 .name = "gcc_qmip_disp_ahb_clk", 2099 .ops = &clk_branch2_ops, 2100 }, 2101 }, 2102 }; 2103 2104 static struct clk_branch gcc_qmip_video_cvp_ahb_clk = { 2105 .halt_reg = 0xb010, 2106 .halt_check = BRANCH_HALT, 2107 .hwcg_reg = 0xb010, 2108 .hwcg_bit = 1, 2109 .clkr = { 2110 .enable_reg = 0xb010, 2111 .enable_mask = BIT(0), 2112 .hw.init = &(struct clk_init_data){ 2113 .name = "gcc_qmip_video_cvp_ahb_clk", 2114 .ops = &clk_branch2_ops, 2115 }, 2116 }, 2117 }; 2118 2119 static struct clk_branch gcc_qmip_video_vcodec_ahb_clk = { 2120 .halt_reg = 0xb014, 2121 .halt_check = BRANCH_HALT, 2122 .hwcg_reg = 0xb014, 2123 .hwcg_bit = 1, 2124 .clkr = { 2125 .enable_reg = 0xb014, 2126 .enable_mask = BIT(0), 2127 .hw.init = &(struct clk_init_data){ 2128 .name = "gcc_qmip_video_vcodec_ahb_clk", 2129 .ops = &clk_branch2_ops, 2130 }, 2131 }, 2132 }; 2133 2134 static struct clk_branch gcc_qspi_cnoc_periph_ahb_clk = { 2135 .halt_reg = 0x4b000, 2136 .halt_check = BRANCH_HALT, 2137 .clkr = { 2138 .enable_reg = 0x4b000, 2139 .enable_mask = BIT(0), 2140 .hw.init = &(struct clk_init_data){ 2141 .name = "gcc_qspi_cnoc_periph_ahb_clk", 2142 .ops = &clk_branch2_ops, 2143 }, 2144 }, 2145 }; 2146 2147 static struct clk_branch gcc_qspi_core_clk = { 2148 .halt_reg = 0x4b004, 2149 .halt_check = BRANCH_HALT, 2150 .clkr = { 2151 .enable_reg = 0x4b004, 2152 .enable_mask = BIT(0), 2153 .hw.init = &(struct clk_init_data){ 2154 .name = "gcc_qspi_core_clk", 2155 .parent_hws = (const struct clk_hw *[]){ 2156 &gcc_qspi_core_clk_src.clkr.hw }, 2157 .num_parents = 1, 2158 .flags = CLK_SET_RATE_PARENT, 2159 .ops = &clk_branch2_ops, 2160 }, 2161 }, 2162 }; 2163 2164 static struct clk_branch gcc_qupv3_wrap0_s0_clk = { 2165 .halt_reg = 0x17144, 2166 .halt_check = BRANCH_HALT_VOTED, 2167 .clkr = { 2168 .enable_reg = 0x5200c, 2169 .enable_mask = BIT(10), 2170 .hw.init = &(struct clk_init_data){ 2171 .name = "gcc_qupv3_wrap0_s0_clk", 2172 .parent_hws = (const struct clk_hw *[]){ 2173 &gcc_qupv3_wrap0_s0_clk_src.clkr.hw }, 2174 .num_parents = 1, 2175 .flags = CLK_SET_RATE_PARENT, 2176 .ops = &clk_branch2_ops, 2177 }, 2178 }, 2179 }; 2180 2181 static struct clk_branch gcc_qupv3_wrap0_s1_clk = { 2182 .halt_reg = 0x17274, 2183 .halt_check = BRANCH_HALT_VOTED, 2184 .clkr = { 2185 .enable_reg = 0x5200c, 2186 .enable_mask = BIT(11), 2187 .hw.init = &(struct clk_init_data){ 2188 .name = "gcc_qupv3_wrap0_s1_clk", 2189 .parent_hws = (const struct clk_hw *[]){ 2190 &gcc_qupv3_wrap0_s1_clk_src.clkr.hw }, 2191 .num_parents = 1, 2192 .flags = CLK_SET_RATE_PARENT, 2193 .ops = &clk_branch2_ops, 2194 }, 2195 }, 2196 }; 2197 2198 static struct clk_branch gcc_qupv3_wrap0_s2_clk = { 2199 .halt_reg = 0x173a4, 2200 .halt_check = BRANCH_HALT_VOTED, 2201 .clkr = { 2202 .enable_reg = 0x5200c, 2203 .enable_mask = BIT(12), 2204 .hw.init = &(struct clk_init_data){ 2205 .name = "gcc_qupv3_wrap0_s2_clk", 2206 .parent_hws = (const struct clk_hw *[]){ 2207 &gcc_qupv3_wrap0_s2_clk_src.clkr.hw }, 2208 .num_parents = 1, 2209 .flags = CLK_SET_RATE_PARENT, 2210 .ops = &clk_branch2_ops, 2211 }, 2212 }, 2213 }; 2214 2215 static struct clk_branch gcc_qupv3_wrap0_s3_clk = { 2216 .halt_reg = 0x174d4, 2217 .halt_check = BRANCH_HALT_VOTED, 2218 .clkr = { 2219 .enable_reg = 0x5200c, 2220 .enable_mask = BIT(13), 2221 .hw.init = &(struct clk_init_data){ 2222 .name = "gcc_qupv3_wrap0_s3_clk", 2223 .parent_hws = (const struct clk_hw *[]){ 2224 &gcc_qupv3_wrap0_s3_clk_src.clkr.hw }, 2225 .num_parents = 1, 2226 .flags = CLK_SET_RATE_PARENT, 2227 .ops = &clk_branch2_ops, 2228 }, 2229 }, 2230 }; 2231 2232 static struct clk_branch gcc_qupv3_wrap0_s4_clk = { 2233 .halt_reg = 0x17604, 2234 .halt_check = BRANCH_HALT_VOTED, 2235 .clkr = { 2236 .enable_reg = 0x5200c, 2237 .enable_mask = BIT(14), 2238 .hw.init = &(struct clk_init_data){ 2239 .name = "gcc_qupv3_wrap0_s4_clk", 2240 .parent_hws = (const struct clk_hw *[]){ 2241 &gcc_qupv3_wrap0_s4_clk_src.clkr.hw }, 2242 .num_parents = 1, 2243 .flags = CLK_SET_RATE_PARENT, 2244 .ops = &clk_branch2_ops, 2245 }, 2246 }, 2247 }; 2248 2249 static struct clk_branch gcc_qupv3_wrap0_s5_clk = { 2250 .halt_reg = 0x17734, 2251 .halt_check = BRANCH_HALT_VOTED, 2252 .clkr = { 2253 .enable_reg = 0x5200c, 2254 .enable_mask = BIT(15), 2255 .hw.init = &(struct clk_init_data){ 2256 .name = "gcc_qupv3_wrap0_s5_clk", 2257 .parent_hws = (const struct clk_hw *[]){ 2258 &gcc_qupv3_wrap0_s5_clk_src.clkr.hw }, 2259 .num_parents = 1, 2260 .flags = CLK_SET_RATE_PARENT, 2261 .ops = &clk_branch2_ops, 2262 }, 2263 }, 2264 }; 2265 2266 static struct clk_branch gcc_qupv3_wrap0_s6_clk = { 2267 .halt_reg = 0x17864, 2268 .halt_check = BRANCH_HALT_VOTED, 2269 .clkr = { 2270 .enable_reg = 0x5200c, 2271 .enable_mask = BIT(16), 2272 .hw.init = &(struct clk_init_data){ 2273 .name = "gcc_qupv3_wrap0_s6_clk", 2274 .parent_hws = (const struct clk_hw *[]){ 2275 &gcc_qupv3_wrap0_s6_clk_src.clkr.hw }, 2276 .num_parents = 1, 2277 .flags = CLK_SET_RATE_PARENT, 2278 .ops = &clk_branch2_ops, 2279 }, 2280 }, 2281 }; 2282 2283 static struct clk_branch gcc_qupv3_wrap0_s7_clk = { 2284 .halt_reg = 0x17994, 2285 .halt_check = BRANCH_HALT_VOTED, 2286 .clkr = { 2287 .enable_reg = 0x5200c, 2288 .enable_mask = BIT(17), 2289 .hw.init = &(struct clk_init_data){ 2290 .name = "gcc_qupv3_wrap0_s7_clk", 2291 .parent_hws = (const struct clk_hw *[]){ 2292 &gcc_qupv3_wrap0_s7_clk_src.clkr.hw }, 2293 .num_parents = 1, 2294 .flags = CLK_SET_RATE_PARENT, 2295 .ops = &clk_branch2_ops, 2296 }, 2297 }, 2298 }; 2299 2300 static struct clk_branch gcc_qupv3_wrap1_s0_clk = { 2301 .halt_reg = 0x18144, 2302 .halt_check = BRANCH_HALT_VOTED, 2303 .clkr = { 2304 .enable_reg = 0x5200c, 2305 .enable_mask = BIT(22), 2306 .hw.init = &(struct clk_init_data){ 2307 .name = "gcc_qupv3_wrap1_s0_clk", 2308 .parent_hws = (const struct clk_hw *[]){ 2309 &gcc_qupv3_wrap1_s0_clk_src.clkr.hw }, 2310 .num_parents = 1, 2311 .flags = CLK_SET_RATE_PARENT, 2312 .ops = &clk_branch2_ops, 2313 }, 2314 }, 2315 }; 2316 2317 static struct clk_branch gcc_qupv3_wrap1_s1_clk = { 2318 .halt_reg = 0x18274, 2319 .halt_check = BRANCH_HALT_VOTED, 2320 .clkr = { 2321 .enable_reg = 0x5200c, 2322 .enable_mask = BIT(23), 2323 .hw.init = &(struct clk_init_data){ 2324 .name = "gcc_qupv3_wrap1_s1_clk", 2325 .parent_hws = (const struct clk_hw *[]){ 2326 &gcc_qupv3_wrap1_s1_clk_src.clkr.hw }, 2327 .num_parents = 1, 2328 .flags = CLK_SET_RATE_PARENT, 2329 .ops = &clk_branch2_ops, 2330 }, 2331 }, 2332 }; 2333 2334 static struct clk_branch gcc_qupv3_wrap1_s2_clk = { 2335 .halt_reg = 0x183a4, 2336 .halt_check = BRANCH_HALT_VOTED, 2337 .clkr = { 2338 .enable_reg = 0x5200c, 2339 .enable_mask = BIT(24), 2340 .hw.init = &(struct clk_init_data){ 2341 .name = "gcc_qupv3_wrap1_s2_clk", 2342 .parent_hws = (const struct clk_hw *[]){ 2343 &gcc_qupv3_wrap1_s2_clk_src.clkr.hw }, 2344 .num_parents = 1, 2345 .flags = CLK_SET_RATE_PARENT, 2346 .ops = &clk_branch2_ops, 2347 }, 2348 }, 2349 }; 2350 2351 static struct clk_branch gcc_qupv3_wrap1_s3_clk = { 2352 .halt_reg = 0x184d4, 2353 .halt_check = BRANCH_HALT_VOTED, 2354 .clkr = { 2355 .enable_reg = 0x5200c, 2356 .enable_mask = BIT(25), 2357 .hw.init = &(struct clk_init_data){ 2358 .name = "gcc_qupv3_wrap1_s3_clk", 2359 .parent_hws = (const struct clk_hw *[]){ 2360 &gcc_qupv3_wrap1_s3_clk_src.clkr.hw }, 2361 .num_parents = 1, 2362 .flags = CLK_SET_RATE_PARENT, 2363 .ops = &clk_branch2_ops, 2364 }, 2365 }, 2366 }; 2367 2368 static struct clk_branch gcc_qupv3_wrap1_s4_clk = { 2369 .halt_reg = 0x18604, 2370 .halt_check = BRANCH_HALT_VOTED, 2371 .clkr = { 2372 .enable_reg = 0x5200c, 2373 .enable_mask = BIT(26), 2374 .hw.init = &(struct clk_init_data){ 2375 .name = "gcc_qupv3_wrap1_s4_clk", 2376 .parent_hws = (const struct clk_hw *[]){ 2377 &gcc_qupv3_wrap1_s4_clk_src.clkr.hw }, 2378 .num_parents = 1, 2379 .flags = CLK_SET_RATE_PARENT, 2380 .ops = &clk_branch2_ops, 2381 }, 2382 }, 2383 }; 2384 2385 static struct clk_branch gcc_qupv3_wrap1_s5_clk = { 2386 .halt_reg = 0x18734, 2387 .halt_check = BRANCH_HALT_VOTED, 2388 .clkr = { 2389 .enable_reg = 0x5200c, 2390 .enable_mask = BIT(27), 2391 .hw.init = &(struct clk_init_data){ 2392 .name = "gcc_qupv3_wrap1_s5_clk", 2393 .parent_hws = (const struct clk_hw *[]){ 2394 &gcc_qupv3_wrap1_s5_clk_src.clkr.hw }, 2395 .num_parents = 1, 2396 .flags = CLK_SET_RATE_PARENT, 2397 .ops = &clk_branch2_ops, 2398 }, 2399 }, 2400 }; 2401 2402 static struct clk_branch gcc_qupv3_wrap2_s0_clk = { 2403 .halt_reg = 0x1e144, 2404 .halt_check = BRANCH_HALT_VOTED, 2405 .clkr = { 2406 .enable_reg = 0x52014, 2407 .enable_mask = BIT(4), 2408 .hw.init = &(struct clk_init_data){ 2409 .name = "gcc_qupv3_wrap2_s0_clk", 2410 .parent_hws = (const struct clk_hw *[]){ 2411 &gcc_qupv3_wrap2_s0_clk_src.clkr.hw }, 2412 .num_parents = 1, 2413 .flags = CLK_SET_RATE_PARENT, 2414 .ops = &clk_branch2_ops, 2415 }, 2416 }, 2417 }; 2418 2419 static struct clk_branch gcc_qupv3_wrap2_s1_clk = { 2420 .halt_reg = 0x1e274, 2421 .halt_check = BRANCH_HALT_VOTED, 2422 .clkr = { 2423 .enable_reg = 0x52014, 2424 .enable_mask = BIT(5), 2425 .hw.init = &(struct clk_init_data){ 2426 .name = "gcc_qupv3_wrap2_s1_clk", 2427 .parent_hws = (const struct clk_hw *[]){ 2428 &gcc_qupv3_wrap2_s1_clk_src.clkr.hw }, 2429 .num_parents = 1, 2430 .flags = CLK_SET_RATE_PARENT, 2431 .ops = &clk_branch2_ops, 2432 }, 2433 }, 2434 }; 2435 2436 static struct clk_branch gcc_qupv3_wrap2_s2_clk = { 2437 .halt_reg = 0x1e3a4, 2438 .halt_check = BRANCH_HALT_VOTED, 2439 .clkr = { 2440 .enable_reg = 0x52014, 2441 .enable_mask = BIT(6), 2442 .hw.init = &(struct clk_init_data){ 2443 .name = "gcc_qupv3_wrap2_s2_clk", 2444 .parent_hws = (const struct clk_hw *[]){ 2445 &gcc_qupv3_wrap2_s2_clk_src.clkr.hw }, 2446 .num_parents = 1, 2447 .flags = CLK_SET_RATE_PARENT, 2448 .ops = &clk_branch2_ops, 2449 }, 2450 }, 2451 }; 2452 2453 static struct clk_branch gcc_qupv3_wrap2_s3_clk = { 2454 .halt_reg = 0x1e4d4, 2455 .halt_check = BRANCH_HALT_VOTED, 2456 .clkr = { 2457 .enable_reg = 0x52014, 2458 .enable_mask = BIT(7), 2459 .hw.init = &(struct clk_init_data){ 2460 .name = "gcc_qupv3_wrap2_s3_clk", 2461 .parent_hws = (const struct clk_hw *[]){ 2462 &gcc_qupv3_wrap2_s3_clk_src.clkr.hw }, 2463 .num_parents = 1, 2464 .flags = CLK_SET_RATE_PARENT, 2465 .ops = &clk_branch2_ops, 2466 }, 2467 }, 2468 }; 2469 2470 static struct clk_branch gcc_qupv3_wrap2_s4_clk = { 2471 .halt_reg = 0x1e604, 2472 .halt_check = BRANCH_HALT_VOTED, 2473 .clkr = { 2474 .enable_reg = 0x52014, 2475 .enable_mask = BIT(8), 2476 .hw.init = &(struct clk_init_data){ 2477 .name = "gcc_qupv3_wrap2_s4_clk", 2478 .parent_hws = (const struct clk_hw *[]){ 2479 &gcc_qupv3_wrap2_s4_clk_src.clkr.hw }, 2480 .num_parents = 1, 2481 .flags = CLK_SET_RATE_PARENT, 2482 .ops = &clk_branch2_ops, 2483 }, 2484 }, 2485 }; 2486 2487 static struct clk_branch gcc_qupv3_wrap2_s5_clk = { 2488 .halt_reg = 0x1e734, 2489 .halt_check = BRANCH_HALT_VOTED, 2490 .clkr = { 2491 .enable_reg = 0x52014, 2492 .enable_mask = BIT(9), 2493 .hw.init = &(struct clk_init_data){ 2494 .name = "gcc_qupv3_wrap2_s5_clk", 2495 .parent_hws = (const struct clk_hw *[]){ 2496 &gcc_qupv3_wrap2_s5_clk_src.clkr.hw }, 2497 .num_parents = 1, 2498 .flags = CLK_SET_RATE_PARENT, 2499 .ops = &clk_branch2_ops, 2500 }, 2501 }, 2502 }; 2503 2504 static struct clk_branch gcc_qupv3_wrap_0_m_ahb_clk = { 2505 .halt_reg = 0x17004, 2506 .halt_check = BRANCH_HALT_VOTED, 2507 .clkr = { 2508 .enable_reg = 0x5200c, 2509 .enable_mask = BIT(6), 2510 .hw.init = &(struct clk_init_data){ 2511 .name = "gcc_qupv3_wrap_0_m_ahb_clk", 2512 .ops = &clk_branch2_ops, 2513 }, 2514 }, 2515 }; 2516 2517 static struct clk_branch gcc_qupv3_wrap_0_s_ahb_clk = { 2518 .halt_reg = 0x17008, 2519 .halt_check = BRANCH_HALT_VOTED, 2520 .hwcg_reg = 0x17008, 2521 .hwcg_bit = 1, 2522 .clkr = { 2523 .enable_reg = 0x5200c, 2524 .enable_mask = BIT(7), 2525 .hw.init = &(struct clk_init_data){ 2526 .name = "gcc_qupv3_wrap_0_s_ahb_clk", 2527 .ops = &clk_branch2_ops, 2528 }, 2529 }, 2530 }; 2531 2532 static struct clk_branch gcc_qupv3_wrap_1_m_ahb_clk = { 2533 .halt_reg = 0x18004, 2534 .halt_check = BRANCH_HALT_VOTED, 2535 .clkr = { 2536 .enable_reg = 0x5200c, 2537 .enable_mask = BIT(20), 2538 .hw.init = &(struct clk_init_data){ 2539 .name = "gcc_qupv3_wrap_1_m_ahb_clk", 2540 .ops = &clk_branch2_ops, 2541 }, 2542 }, 2543 }; 2544 2545 static struct clk_branch gcc_qupv3_wrap_1_s_ahb_clk = { 2546 .halt_reg = 0x18008, 2547 .halt_check = BRANCH_HALT_VOTED, 2548 .hwcg_reg = 0x18008, 2549 .hwcg_bit = 1, 2550 .clkr = { 2551 .enable_reg = 0x5200c, 2552 .enable_mask = BIT(21), 2553 .hw.init = &(struct clk_init_data){ 2554 .name = "gcc_qupv3_wrap_1_s_ahb_clk", 2555 .ops = &clk_branch2_ops, 2556 }, 2557 }, 2558 }; 2559 2560 static struct clk_branch gcc_qupv3_wrap_2_m_ahb_clk = { 2561 .halt_reg = 0x1e004, 2562 .halt_check = BRANCH_HALT_VOTED, 2563 .clkr = { 2564 .enable_reg = 0x52014, 2565 .enable_mask = BIT(2), 2566 .hw.init = &(struct clk_init_data){ 2567 .name = "gcc_qupv3_wrap_2_m_ahb_clk", 2568 .ops = &clk_branch2_ops, 2569 }, 2570 }, 2571 }; 2572 2573 static struct clk_branch gcc_qupv3_wrap_2_s_ahb_clk = { 2574 .halt_reg = 0x1e008, 2575 .halt_check = BRANCH_HALT_VOTED, 2576 .hwcg_reg = 0x1e008, 2577 .hwcg_bit = 1, 2578 .clkr = { 2579 .enable_reg = 0x52014, 2580 .enable_mask = BIT(1), 2581 .hw.init = &(struct clk_init_data){ 2582 .name = "gcc_qupv3_wrap_2_s_ahb_clk", 2583 .ops = &clk_branch2_ops, 2584 }, 2585 }, 2586 }; 2587 2588 static struct clk_branch gcc_sdcc2_ahb_clk = { 2589 .halt_reg = 0x14008, 2590 .halt_check = BRANCH_HALT, 2591 .clkr = { 2592 .enable_reg = 0x14008, 2593 .enable_mask = BIT(0), 2594 .hw.init = &(struct clk_init_data){ 2595 .name = "gcc_sdcc2_ahb_clk", 2596 .ops = &clk_branch2_ops, 2597 }, 2598 }, 2599 }; 2600 2601 static struct clk_branch gcc_sdcc2_apps_clk = { 2602 .halt_reg = 0x14004, 2603 .halt_check = BRANCH_HALT, 2604 .clkr = { 2605 .enable_reg = 0x14004, 2606 .enable_mask = BIT(0), 2607 .hw.init = &(struct clk_init_data){ 2608 .name = "gcc_sdcc2_apps_clk", 2609 .parent_hws = (const struct clk_hw *[]){ 2610 &gcc_sdcc2_apps_clk_src.clkr.hw }, 2611 .num_parents = 1, 2612 .flags = CLK_SET_RATE_PARENT, 2613 .ops = &clk_branch2_ops, 2614 }, 2615 }, 2616 }; 2617 2618 static struct clk_branch gcc_sdcc4_ahb_clk = { 2619 .halt_reg = 0x16008, 2620 .halt_check = BRANCH_HALT, 2621 .clkr = { 2622 .enable_reg = 0x16008, 2623 .enable_mask = BIT(0), 2624 .hw.init = &(struct clk_init_data){ 2625 .name = "gcc_sdcc4_ahb_clk", 2626 .ops = &clk_branch2_ops, 2627 }, 2628 }, 2629 }; 2630 2631 static struct clk_branch gcc_sdcc4_apps_clk = { 2632 .halt_reg = 0x16004, 2633 .halt_check = BRANCH_HALT, 2634 .clkr = { 2635 .enable_reg = 0x16004, 2636 .enable_mask = BIT(0), 2637 .hw.init = &(struct clk_init_data){ 2638 .name = "gcc_sdcc4_apps_clk", 2639 .parent_hws = (const struct clk_hw *[]){ 2640 &gcc_sdcc4_apps_clk_src.clkr.hw }, 2641 .num_parents = 1, 2642 .flags = CLK_SET_RATE_PARENT, 2643 .ops = &clk_branch2_ops, 2644 }, 2645 }, 2646 }; 2647 2648 static struct clk_branch gcc_sys_noc_cpuss_ahb_clk = { 2649 .halt_reg = 0x4819c, 2650 .halt_check = BRANCH_HALT_VOTED, 2651 .clkr = { 2652 .enable_reg = 0x52004, 2653 .enable_mask = BIT(0), 2654 .hw.init = &(struct clk_init_data){ 2655 .name = "gcc_sys_noc_cpuss_ahb_clk", 2656 .parent_hws = (const struct clk_hw *[]){ 2657 &gcc_cpuss_ahb_clk_src.clkr.hw }, 2658 .num_parents = 1, 2659 /* required for cpuss */ 2660 .flags = CLK_IS_CRITICAL | CLK_SET_RATE_PARENT, 2661 .ops = &clk_branch2_ops, 2662 }, 2663 }, 2664 }; 2665 2666 static struct clk_branch gcc_tsif_ahb_clk = { 2667 .halt_reg = 0x36004, 2668 .halt_check = BRANCH_HALT, 2669 .clkr = { 2670 .enable_reg = 0x36004, 2671 .enable_mask = BIT(0), 2672 .hw.init = &(struct clk_init_data){ 2673 .name = "gcc_tsif_ahb_clk", 2674 .ops = &clk_branch2_ops, 2675 }, 2676 }, 2677 }; 2678 2679 static struct clk_branch gcc_tsif_inactivity_timers_clk = { 2680 .halt_reg = 0x3600c, 2681 .halt_check = BRANCH_HALT, 2682 .clkr = { 2683 .enable_reg = 0x3600c, 2684 .enable_mask = BIT(0), 2685 .hw.init = &(struct clk_init_data){ 2686 .name = "gcc_tsif_inactivity_timers_clk", 2687 .ops = &clk_branch2_ops, 2688 }, 2689 }, 2690 }; 2691 2692 static struct clk_branch gcc_tsif_ref_clk = { 2693 .halt_reg = 0x36008, 2694 .halt_check = BRANCH_HALT, 2695 .clkr = { 2696 .enable_reg = 0x36008, 2697 .enable_mask = BIT(0), 2698 .hw.init = &(struct clk_init_data){ 2699 .name = "gcc_tsif_ref_clk", 2700 .parent_hws = (const struct clk_hw *[]){ 2701 &gcc_tsif_ref_clk_src.clkr.hw }, 2702 .num_parents = 1, 2703 .flags = CLK_SET_RATE_PARENT, 2704 .ops = &clk_branch2_ops, 2705 }, 2706 }, 2707 }; 2708 2709 static struct clk_branch gcc_ufs_card_ahb_clk = { 2710 .halt_reg = 0x75014, 2711 .halt_check = BRANCH_HALT, 2712 .hwcg_reg = 0x75014, 2713 .hwcg_bit = 1, 2714 .clkr = { 2715 .enable_reg = 0x75014, 2716 .enable_mask = BIT(0), 2717 .hw.init = &(struct clk_init_data){ 2718 .name = "gcc_ufs_card_ahb_clk", 2719 .ops = &clk_branch2_ops, 2720 }, 2721 }, 2722 }; 2723 2724 static struct clk_branch gcc_ufs_card_axi_clk = { 2725 .halt_reg = 0x75010, 2726 .halt_check = BRANCH_HALT, 2727 .hwcg_reg = 0x75010, 2728 .hwcg_bit = 1, 2729 .clkr = { 2730 .enable_reg = 0x75010, 2731 .enable_mask = BIT(0), 2732 .hw.init = &(struct clk_init_data){ 2733 .name = "gcc_ufs_card_axi_clk", 2734 .parent_hws = (const struct clk_hw *[]){ 2735 &gcc_ufs_card_axi_clk_src.clkr.hw }, 2736 .num_parents = 1, 2737 .flags = CLK_SET_RATE_PARENT, 2738 .ops = &clk_branch2_ops, 2739 }, 2740 }, 2741 }; 2742 2743 static struct clk_branch gcc_ufs_card_axi_hw_ctl_clk = { 2744 .halt_reg = 0x75010, 2745 .halt_check = BRANCH_HALT, 2746 .hwcg_reg = 0x75010, 2747 .hwcg_bit = 1, 2748 .clkr = { 2749 .enable_reg = 0x75010, 2750 .enable_mask = BIT(1), 2751 .hw.init = &(struct clk_init_data){ 2752 .name = "gcc_ufs_card_axi_hw_ctl_clk", 2753 .parent_hws = (const struct clk_hw *[]){ 2754 &gcc_ufs_card_axi_clk.clkr.hw }, 2755 .num_parents = 1, 2756 .flags = CLK_SET_RATE_PARENT, 2757 .ops = &clk_branch_simple_ops, 2758 }, 2759 }, 2760 }; 2761 2762 static struct clk_branch gcc_ufs_card_clkref_clk = { 2763 .halt_reg = 0x8c004, 2764 .halt_check = BRANCH_HALT, 2765 .clkr = { 2766 .enable_reg = 0x8c004, 2767 .enable_mask = BIT(0), 2768 .hw.init = &(struct clk_init_data){ 2769 .name = "gcc_ufs_card_clkref_clk", 2770 .ops = &clk_branch2_ops, 2771 }, 2772 }, 2773 }; 2774 2775 static struct clk_branch gcc_ufs_card_ice_core_clk = { 2776 .halt_reg = 0x7505c, 2777 .halt_check = BRANCH_HALT, 2778 .hwcg_reg = 0x7505c, 2779 .hwcg_bit = 1, 2780 .clkr = { 2781 .enable_reg = 0x7505c, 2782 .enable_mask = BIT(0), 2783 .hw.init = &(struct clk_init_data){ 2784 .name = "gcc_ufs_card_ice_core_clk", 2785 .parent_hws = (const struct clk_hw *[]){ 2786 &gcc_ufs_card_ice_core_clk_src.clkr.hw }, 2787 .num_parents = 1, 2788 .flags = CLK_SET_RATE_PARENT, 2789 .ops = &clk_branch2_ops, 2790 }, 2791 }, 2792 }; 2793 2794 static struct clk_branch gcc_ufs_card_ice_core_hw_ctl_clk = { 2795 .halt_reg = 0x7505c, 2796 .halt_check = BRANCH_HALT, 2797 .hwcg_reg = 0x7505c, 2798 .hwcg_bit = 1, 2799 .clkr = { 2800 .enable_reg = 0x7505c, 2801 .enable_mask = BIT(1), 2802 .hw.init = &(struct clk_init_data){ 2803 .name = "gcc_ufs_card_ice_core_hw_ctl_clk", 2804 .parent_hws = (const struct clk_hw *[]){ 2805 &gcc_ufs_card_ice_core_clk.clkr.hw }, 2806 .num_parents = 1, 2807 .flags = CLK_SET_RATE_PARENT, 2808 .ops = &clk_branch_simple_ops, 2809 }, 2810 }, 2811 }; 2812 2813 static struct clk_branch gcc_ufs_card_phy_aux_clk = { 2814 .halt_reg = 0x75090, 2815 .halt_check = BRANCH_HALT, 2816 .hwcg_reg = 0x75090, 2817 .hwcg_bit = 1, 2818 .clkr = { 2819 .enable_reg = 0x75090, 2820 .enable_mask = BIT(0), 2821 .hw.init = &(struct clk_init_data){ 2822 .name = "gcc_ufs_card_phy_aux_clk", 2823 .parent_hws = (const struct clk_hw *[]){ 2824 &gcc_ufs_card_phy_aux_clk_src.clkr.hw }, 2825 .num_parents = 1, 2826 .flags = CLK_SET_RATE_PARENT, 2827 .ops = &clk_branch2_ops, 2828 }, 2829 }, 2830 }; 2831 2832 static struct clk_branch gcc_ufs_card_phy_aux_hw_ctl_clk = { 2833 .halt_reg = 0x75090, 2834 .halt_check = BRANCH_HALT, 2835 .hwcg_reg = 0x75090, 2836 .hwcg_bit = 1, 2837 .clkr = { 2838 .enable_reg = 0x75090, 2839 .enable_mask = BIT(1), 2840 .hw.init = &(struct clk_init_data){ 2841 .name = "gcc_ufs_card_phy_aux_hw_ctl_clk", 2842 .parent_hws = (const struct clk_hw *[]){ 2843 &gcc_ufs_card_phy_aux_clk.clkr.hw }, 2844 .num_parents = 1, 2845 .flags = CLK_SET_RATE_PARENT, 2846 .ops = &clk_branch_simple_ops, 2847 }, 2848 }, 2849 }; 2850 2851 /* external clocks so add BRANCH_HALT_SKIP */ 2852 static struct clk_branch gcc_ufs_card_rx_symbol_0_clk = { 2853 .halt_check = BRANCH_HALT_SKIP, 2854 .clkr = { 2855 .enable_reg = 0x7501c, 2856 .enable_mask = BIT(0), 2857 .hw.init = &(struct clk_init_data){ 2858 .name = "gcc_ufs_card_rx_symbol_0_clk", 2859 .ops = &clk_branch2_ops, 2860 }, 2861 }, 2862 }; 2863 2864 /* external clocks so add BRANCH_HALT_SKIP */ 2865 static struct clk_branch gcc_ufs_card_rx_symbol_1_clk = { 2866 .halt_check = BRANCH_HALT_SKIP, 2867 .clkr = { 2868 .enable_reg = 0x750ac, 2869 .enable_mask = BIT(0), 2870 .hw.init = &(struct clk_init_data){ 2871 .name = "gcc_ufs_card_rx_symbol_1_clk", 2872 .ops = &clk_branch2_ops, 2873 }, 2874 }, 2875 }; 2876 2877 /* external clocks so add BRANCH_HALT_SKIP */ 2878 static struct clk_branch gcc_ufs_card_tx_symbol_0_clk = { 2879 .halt_check = BRANCH_HALT_SKIP, 2880 .clkr = { 2881 .enable_reg = 0x75018, 2882 .enable_mask = BIT(0), 2883 .hw.init = &(struct clk_init_data){ 2884 .name = "gcc_ufs_card_tx_symbol_0_clk", 2885 .ops = &clk_branch2_ops, 2886 }, 2887 }, 2888 }; 2889 2890 static struct clk_branch gcc_ufs_card_unipro_core_clk = { 2891 .halt_reg = 0x75058, 2892 .halt_check = BRANCH_HALT, 2893 .hwcg_reg = 0x75058, 2894 .hwcg_bit = 1, 2895 .clkr = { 2896 .enable_reg = 0x75058, 2897 .enable_mask = BIT(0), 2898 .hw.init = &(struct clk_init_data){ 2899 .name = "gcc_ufs_card_unipro_core_clk", 2900 .parent_hws = (const struct clk_hw *[]){ 2901 &gcc_ufs_card_unipro_core_clk_src.clkr.hw }, 2902 .num_parents = 1, 2903 .flags = CLK_SET_RATE_PARENT, 2904 .ops = &clk_branch2_ops, 2905 }, 2906 }, 2907 }; 2908 2909 static struct clk_branch gcc_ufs_card_unipro_core_hw_ctl_clk = { 2910 .halt_reg = 0x75058, 2911 .halt_check = BRANCH_HALT, 2912 .hwcg_reg = 0x75058, 2913 .hwcg_bit = 1, 2914 .clkr = { 2915 .enable_reg = 0x75058, 2916 .enable_mask = BIT(1), 2917 .hw.init = &(struct clk_init_data){ 2918 .name = "gcc_ufs_card_unipro_core_hw_ctl_clk", 2919 .parent_hws = (const struct clk_hw *[]){ 2920 &gcc_ufs_card_unipro_core_clk.clkr.hw }, 2921 .num_parents = 1, 2922 .flags = CLK_SET_RATE_PARENT, 2923 .ops = &clk_branch_simple_ops, 2924 }, 2925 }, 2926 }; 2927 2928 static struct clk_branch gcc_ufs_mem_clkref_clk = { 2929 .halt_reg = 0x8c000, 2930 .halt_check = BRANCH_HALT, 2931 .clkr = { 2932 .enable_reg = 0x8c000, 2933 .enable_mask = BIT(0), 2934 .hw.init = &(struct clk_init_data){ 2935 .name = "gcc_ufs_mem_clkref_clk", 2936 .ops = &clk_branch2_ops, 2937 }, 2938 }, 2939 }; 2940 2941 static struct clk_branch gcc_ufs_phy_ahb_clk = { 2942 .halt_reg = 0x77014, 2943 .halt_check = BRANCH_HALT, 2944 .hwcg_reg = 0x77014, 2945 .hwcg_bit = 1, 2946 .clkr = { 2947 .enable_reg = 0x77014, 2948 .enable_mask = BIT(0), 2949 .hw.init = &(struct clk_init_data){ 2950 .name = "gcc_ufs_phy_ahb_clk", 2951 .ops = &clk_branch2_ops, 2952 }, 2953 }, 2954 }; 2955 2956 static struct clk_branch gcc_ufs_phy_axi_clk = { 2957 .halt_reg = 0x77010, 2958 .halt_check = BRANCH_HALT, 2959 .hwcg_reg = 0x77010, 2960 .hwcg_bit = 1, 2961 .clkr = { 2962 .enable_reg = 0x77010, 2963 .enable_mask = BIT(0), 2964 .hw.init = &(struct clk_init_data){ 2965 .name = "gcc_ufs_phy_axi_clk", 2966 .parent_hws = (const struct clk_hw *[]){ 2967 &gcc_ufs_phy_axi_clk_src.clkr.hw }, 2968 .num_parents = 1, 2969 .flags = CLK_SET_RATE_PARENT, 2970 .ops = &clk_branch2_ops, 2971 }, 2972 }, 2973 }; 2974 2975 static struct clk_branch gcc_ufs_phy_axi_hw_ctl_clk = { 2976 .halt_reg = 0x77010, 2977 .halt_check = BRANCH_HALT, 2978 .hwcg_reg = 0x77010, 2979 .hwcg_bit = 1, 2980 .clkr = { 2981 .enable_reg = 0x77010, 2982 .enable_mask = BIT(1), 2983 .hw.init = &(struct clk_init_data){ 2984 .name = "gcc_ufs_phy_axi_hw_ctl_clk", 2985 .parent_hws = (const struct clk_hw *[]){ 2986 &gcc_ufs_phy_axi_clk.clkr.hw }, 2987 .num_parents = 1, 2988 .flags = CLK_SET_RATE_PARENT, 2989 .ops = &clk_branch_simple_ops, 2990 }, 2991 }, 2992 }; 2993 2994 static struct clk_branch gcc_ufs_phy_ice_core_clk = { 2995 .halt_reg = 0x7705c, 2996 .halt_check = BRANCH_HALT, 2997 .hwcg_reg = 0x7705c, 2998 .hwcg_bit = 1, 2999 .clkr = { 3000 .enable_reg = 0x7705c, 3001 .enable_mask = BIT(0), 3002 .hw.init = &(struct clk_init_data){ 3003 .name = "gcc_ufs_phy_ice_core_clk", 3004 .parent_hws = (const struct clk_hw *[]){ 3005 &gcc_ufs_phy_ice_core_clk_src.clkr.hw }, 3006 .num_parents = 1, 3007 .flags = CLK_SET_RATE_PARENT, 3008 .ops = &clk_branch2_ops, 3009 }, 3010 }, 3011 }; 3012 3013 static struct clk_branch gcc_ufs_phy_ice_core_hw_ctl_clk = { 3014 .halt_reg = 0x7705c, 3015 .halt_check = BRANCH_HALT, 3016 .hwcg_reg = 0x7705c, 3017 .hwcg_bit = 1, 3018 .clkr = { 3019 .enable_reg = 0x7705c, 3020 .enable_mask = BIT(1), 3021 .hw.init = &(struct clk_init_data){ 3022 .name = "gcc_ufs_phy_ice_core_hw_ctl_clk", 3023 .parent_hws = (const struct clk_hw *[]){ 3024 &gcc_ufs_phy_ice_core_clk.clkr.hw }, 3025 .num_parents = 1, 3026 .flags = CLK_SET_RATE_PARENT, 3027 .ops = &clk_branch_simple_ops, 3028 }, 3029 }, 3030 }; 3031 3032 static struct clk_branch gcc_ufs_phy_phy_aux_clk = { 3033 .halt_reg = 0x77090, 3034 .halt_check = BRANCH_HALT, 3035 .hwcg_reg = 0x77090, 3036 .hwcg_bit = 1, 3037 .clkr = { 3038 .enable_reg = 0x77090, 3039 .enable_mask = BIT(0), 3040 .hw.init = &(struct clk_init_data){ 3041 .name = "gcc_ufs_phy_phy_aux_clk", 3042 .parent_hws = (const struct clk_hw *[]){ 3043 &gcc_ufs_phy_phy_aux_clk_src.clkr.hw }, 3044 .num_parents = 1, 3045 .flags = CLK_SET_RATE_PARENT, 3046 .ops = &clk_branch2_ops, 3047 }, 3048 }, 3049 }; 3050 3051 static struct clk_branch gcc_ufs_phy_phy_aux_hw_ctl_clk = { 3052 .halt_reg = 0x77090, 3053 .halt_check = BRANCH_HALT, 3054 .hwcg_reg = 0x77090, 3055 .hwcg_bit = 1, 3056 .clkr = { 3057 .enable_reg = 0x77090, 3058 .enable_mask = BIT(1), 3059 .hw.init = &(struct clk_init_data){ 3060 .name = "gcc_ufs_phy_phy_aux_hw_ctl_clk", 3061 .parent_hws = (const struct clk_hw *[]){ 3062 &gcc_ufs_phy_phy_aux_clk.clkr.hw }, 3063 .num_parents = 1, 3064 .flags = CLK_SET_RATE_PARENT, 3065 .ops = &clk_branch_simple_ops, 3066 }, 3067 }, 3068 }; 3069 3070 /* external clocks so add BRANCH_HALT_SKIP */ 3071 static struct clk_branch gcc_ufs_phy_rx_symbol_0_clk = { 3072 .halt_check = BRANCH_HALT_SKIP, 3073 .clkr = { 3074 .enable_reg = 0x7701c, 3075 .enable_mask = BIT(0), 3076 .hw.init = &(struct clk_init_data){ 3077 .name = "gcc_ufs_phy_rx_symbol_0_clk", 3078 .ops = &clk_branch2_ops, 3079 }, 3080 }, 3081 }; 3082 3083 /* external clocks so add BRANCH_HALT_SKIP */ 3084 static struct clk_branch gcc_ufs_phy_rx_symbol_1_clk = { 3085 .halt_check = BRANCH_HALT_SKIP, 3086 .clkr = { 3087 .enable_reg = 0x770ac, 3088 .enable_mask = BIT(0), 3089 .hw.init = &(struct clk_init_data){ 3090 .name = "gcc_ufs_phy_rx_symbol_1_clk", 3091 .ops = &clk_branch2_ops, 3092 }, 3093 }, 3094 }; 3095 3096 /* external clocks so add BRANCH_HALT_SKIP */ 3097 static struct clk_branch gcc_ufs_phy_tx_symbol_0_clk = { 3098 .halt_check = BRANCH_HALT_SKIP, 3099 .clkr = { 3100 .enable_reg = 0x77018, 3101 .enable_mask = BIT(0), 3102 .hw.init = &(struct clk_init_data){ 3103 .name = "gcc_ufs_phy_tx_symbol_0_clk", 3104 .ops = &clk_branch2_ops, 3105 }, 3106 }, 3107 }; 3108 3109 static struct clk_branch gcc_ufs_phy_unipro_core_clk = { 3110 .halt_reg = 0x77058, 3111 .halt_check = BRANCH_HALT, 3112 .hwcg_reg = 0x77058, 3113 .hwcg_bit = 1, 3114 .clkr = { 3115 .enable_reg = 0x77058, 3116 .enable_mask = BIT(0), 3117 .hw.init = &(struct clk_init_data){ 3118 .name = "gcc_ufs_phy_unipro_core_clk", 3119 .parent_hws = (const struct clk_hw *[]){ 3120 &gcc_ufs_phy_unipro_core_clk_src.clkr.hw }, 3121 .num_parents = 1, 3122 .flags = CLK_SET_RATE_PARENT, 3123 .ops = &clk_branch2_ops, 3124 }, 3125 }, 3126 }; 3127 3128 static struct clk_branch gcc_ufs_phy_unipro_core_hw_ctl_clk = { 3129 .halt_reg = 0x77058, 3130 .halt_check = BRANCH_HALT, 3131 .hwcg_reg = 0x77058, 3132 .hwcg_bit = 1, 3133 .clkr = { 3134 .enable_reg = 0x77058, 3135 .enable_mask = BIT(1), 3136 .hw.init = &(struct clk_init_data){ 3137 .name = "gcc_ufs_phy_unipro_core_hw_ctl_clk", 3138 .parent_hws = (const struct clk_hw *[]){ 3139 &gcc_ufs_phy_unipro_core_clk.clkr.hw }, 3140 .num_parents = 1, 3141 .flags = CLK_SET_RATE_PARENT, 3142 .ops = &clk_branch_simple_ops, 3143 }, 3144 }, 3145 }; 3146 3147 static struct clk_branch gcc_usb30_prim_master_clk = { 3148 .halt_reg = 0xf010, 3149 .halt_check = BRANCH_HALT, 3150 .clkr = { 3151 .enable_reg = 0xf010, 3152 .enable_mask = BIT(0), 3153 .hw.init = &(struct clk_init_data){ 3154 .name = "gcc_usb30_prim_master_clk", 3155 .parent_hws = (const struct clk_hw *[]){ 3156 &gcc_usb30_prim_master_clk_src.clkr.hw }, 3157 .num_parents = 1, 3158 .flags = CLK_SET_RATE_PARENT, 3159 .ops = &clk_branch2_ops, 3160 }, 3161 }, 3162 }; 3163 3164 static struct clk_branch gcc_usb30_prim_mock_utmi_clk = { 3165 .halt_reg = 0xf018, 3166 .halt_check = BRANCH_HALT, 3167 .clkr = { 3168 .enable_reg = 0xf018, 3169 .enable_mask = BIT(0), 3170 .hw.init = &(struct clk_init_data){ 3171 .name = "gcc_usb30_prim_mock_utmi_clk", 3172 .parent_hws = (const struct clk_hw *[]){ 3173 &gcc_usb30_prim_mock_utmi_clk_src.clkr.hw }, 3174 .num_parents = 1, 3175 .flags = CLK_SET_RATE_PARENT, 3176 .ops = &clk_branch2_ops, 3177 }, 3178 }, 3179 }; 3180 3181 static struct clk_branch gcc_usb30_prim_sleep_clk = { 3182 .halt_reg = 0xf014, 3183 .halt_check = BRANCH_HALT, 3184 .clkr = { 3185 .enable_reg = 0xf014, 3186 .enable_mask = BIT(0), 3187 .hw.init = &(struct clk_init_data){ 3188 .name = "gcc_usb30_prim_sleep_clk", 3189 .ops = &clk_branch2_ops, 3190 }, 3191 }, 3192 }; 3193 3194 static struct clk_branch gcc_usb30_sec_master_clk = { 3195 .halt_reg = 0x10010, 3196 .halt_check = BRANCH_HALT, 3197 .clkr = { 3198 .enable_reg = 0x10010, 3199 .enable_mask = BIT(0), 3200 .hw.init = &(struct clk_init_data){ 3201 .name = "gcc_usb30_sec_master_clk", 3202 .parent_hws = (const struct clk_hw *[]){ 3203 &gcc_usb30_sec_master_clk_src.clkr.hw }, 3204 .num_parents = 1, 3205 .flags = CLK_SET_RATE_PARENT, 3206 .ops = &clk_branch2_ops, 3207 }, 3208 }, 3209 }; 3210 3211 static struct clk_branch gcc_usb30_sec_mock_utmi_clk = { 3212 .halt_reg = 0x10018, 3213 .halt_check = BRANCH_HALT, 3214 .clkr = { 3215 .enable_reg = 0x10018, 3216 .enable_mask = BIT(0), 3217 .hw.init = &(struct clk_init_data){ 3218 .name = "gcc_usb30_sec_mock_utmi_clk", 3219 .parent_hws = (const struct clk_hw *[]){ 3220 &gcc_usb30_sec_mock_utmi_clk_src.clkr.hw }, 3221 .num_parents = 1, 3222 .flags = CLK_SET_RATE_PARENT, 3223 .ops = &clk_branch2_ops, 3224 }, 3225 }, 3226 }; 3227 3228 static struct clk_branch gcc_usb30_sec_sleep_clk = { 3229 .halt_reg = 0x10014, 3230 .halt_check = BRANCH_HALT, 3231 .clkr = { 3232 .enable_reg = 0x10014, 3233 .enable_mask = BIT(0), 3234 .hw.init = &(struct clk_init_data){ 3235 .name = "gcc_usb30_sec_sleep_clk", 3236 .ops = &clk_branch2_ops, 3237 }, 3238 }, 3239 }; 3240 3241 static struct clk_branch gcc_usb3_prim_clkref_clk = { 3242 .halt_reg = 0x8c008, 3243 .halt_check = BRANCH_HALT, 3244 .clkr = { 3245 .enable_reg = 0x8c008, 3246 .enable_mask = BIT(0), 3247 .hw.init = &(struct clk_init_data){ 3248 .name = "gcc_usb3_prim_clkref_clk", 3249 .ops = &clk_branch2_ops, 3250 }, 3251 }, 3252 }; 3253 3254 static struct clk_branch gcc_usb3_prim_phy_aux_clk = { 3255 .halt_reg = 0xf050, 3256 .halt_check = BRANCH_HALT, 3257 .clkr = { 3258 .enable_reg = 0xf050, 3259 .enable_mask = BIT(0), 3260 .hw.init = &(struct clk_init_data){ 3261 .name = "gcc_usb3_prim_phy_aux_clk", 3262 .parent_hws = (const struct clk_hw *[]){ 3263 &gcc_usb3_prim_phy_aux_clk_src.clkr.hw }, 3264 .num_parents = 1, 3265 .flags = CLK_SET_RATE_PARENT, 3266 .ops = &clk_branch2_ops, 3267 }, 3268 }, 3269 }; 3270 3271 static struct clk_branch gcc_usb3_prim_phy_com_aux_clk = { 3272 .halt_reg = 0xf054, 3273 .halt_check = BRANCH_HALT, 3274 .clkr = { 3275 .enable_reg = 0xf054, 3276 .enable_mask = BIT(0), 3277 .hw.init = &(struct clk_init_data){ 3278 .name = "gcc_usb3_prim_phy_com_aux_clk", 3279 .parent_hws = (const struct clk_hw *[]){ 3280 &gcc_usb3_prim_phy_aux_clk_src.clkr.hw }, 3281 .num_parents = 1, 3282 .flags = CLK_SET_RATE_PARENT, 3283 .ops = &clk_branch2_ops, 3284 }, 3285 }, 3286 }; 3287 3288 static struct clk_branch gcc_usb3_prim_phy_pipe_clk = { 3289 .halt_check = BRANCH_HALT_SKIP, 3290 .clkr = { 3291 .enable_reg = 0xf058, 3292 .enable_mask = BIT(0), 3293 .hw.init = &(struct clk_init_data){ 3294 .name = "gcc_usb3_prim_phy_pipe_clk", 3295 .ops = &clk_branch2_ops, 3296 }, 3297 }, 3298 }; 3299 3300 static struct clk_branch gcc_usb3_sec_clkref_clk = { 3301 .halt_reg = 0x8c028, 3302 .halt_check = BRANCH_HALT, 3303 .clkr = { 3304 .enable_reg = 0x8c028, 3305 .enable_mask = BIT(0), 3306 .hw.init = &(struct clk_init_data){ 3307 .name = "gcc_usb3_sec_clkref_clk", 3308 .ops = &clk_branch2_ops, 3309 }, 3310 }, 3311 }; 3312 3313 static struct clk_branch gcc_usb3_sec_phy_aux_clk = { 3314 .halt_reg = 0x10050, 3315 .halt_check = BRANCH_HALT, 3316 .clkr = { 3317 .enable_reg = 0x10050, 3318 .enable_mask = BIT(0), 3319 .hw.init = &(struct clk_init_data){ 3320 .name = "gcc_usb3_sec_phy_aux_clk", 3321 .parent_hws = (const struct clk_hw *[]){ 3322 &gcc_usb3_sec_phy_aux_clk_src.clkr.hw }, 3323 .num_parents = 1, 3324 .flags = CLK_SET_RATE_PARENT, 3325 .ops = &clk_branch2_ops, 3326 }, 3327 }, 3328 }; 3329 3330 static struct clk_branch gcc_usb3_sec_phy_com_aux_clk = { 3331 .halt_reg = 0x10054, 3332 .halt_check = BRANCH_HALT, 3333 .clkr = { 3334 .enable_reg = 0x10054, 3335 .enable_mask = BIT(0), 3336 .hw.init = &(struct clk_init_data){ 3337 .name = "gcc_usb3_sec_phy_com_aux_clk", 3338 .parent_hws = (const struct clk_hw *[]){ 3339 &gcc_usb3_sec_phy_aux_clk_src.clkr.hw }, 3340 .num_parents = 1, 3341 .flags = CLK_SET_RATE_PARENT, 3342 .ops = &clk_branch2_ops, 3343 }, 3344 }, 3345 }; 3346 3347 static struct clk_branch gcc_usb3_sec_phy_pipe_clk = { 3348 .halt_check = BRANCH_HALT_SKIP, 3349 .clkr = { 3350 .enable_reg = 0x10058, 3351 .enable_mask = BIT(0), 3352 .hw.init = &(struct clk_init_data){ 3353 .name = "gcc_usb3_sec_phy_pipe_clk", 3354 .ops = &clk_branch2_ops, 3355 }, 3356 }, 3357 }; 3358 3359 /* 3360 * Clock ON depends on external parent 'config noc', so cant poll 3361 * delay and also mark as crtitical for video boot 3362 */ 3363 static struct clk_branch gcc_video_ahb_clk = { 3364 .halt_reg = 0xb004, 3365 .halt_check = BRANCH_HALT_DELAY, 3366 .hwcg_reg = 0xb004, 3367 .hwcg_bit = 1, 3368 .clkr = { 3369 .enable_reg = 0xb004, 3370 .enable_mask = BIT(0), 3371 .hw.init = &(struct clk_init_data){ 3372 .name = "gcc_video_ahb_clk", 3373 .flags = CLK_IS_CRITICAL, 3374 .ops = &clk_branch2_ops, 3375 }, 3376 }, 3377 }; 3378 3379 static struct clk_branch gcc_video_axi0_clk = { 3380 .halt_reg = 0xb024, 3381 .halt_check = BRANCH_HALT, 3382 .clkr = { 3383 .enable_reg = 0xb024, 3384 .enable_mask = BIT(0), 3385 .hw.init = &(struct clk_init_data){ 3386 .name = "gcc_video_axi0_clk", 3387 .ops = &clk_branch2_ops, 3388 }, 3389 }, 3390 }; 3391 3392 static struct clk_branch gcc_video_axi1_clk = { 3393 .halt_reg = 0xb028, 3394 .halt_check = BRANCH_HALT, 3395 .clkr = { 3396 .enable_reg = 0xb028, 3397 .enable_mask = BIT(0), 3398 .hw.init = &(struct clk_init_data){ 3399 .name = "gcc_video_axi1_clk", 3400 .ops = &clk_branch2_ops, 3401 }, 3402 }, 3403 }; 3404 3405 static struct clk_branch gcc_video_axic_clk = { 3406 .halt_reg = 0xb02c, 3407 .halt_check = BRANCH_HALT, 3408 .clkr = { 3409 .enable_reg = 0xb02c, 3410 .enable_mask = BIT(0), 3411 .hw.init = &(struct clk_init_data){ 3412 .name = "gcc_video_axic_clk", 3413 .ops = &clk_branch2_ops, 3414 }, 3415 }, 3416 }; 3417 3418 /* XO critical input to video, so no need to poll */ 3419 static struct clk_branch gcc_video_xo_clk = { 3420 .halt_reg = 0xb040, 3421 .halt_check = BRANCH_HALT_DELAY, 3422 .clkr = { 3423 .enable_reg = 0xb040, 3424 .enable_mask = BIT(0), 3425 .hw.init = &(struct clk_init_data){ 3426 .name = "gcc_video_xo_clk", 3427 .flags = CLK_IS_CRITICAL, 3428 .ops = &clk_branch2_ops, 3429 }, 3430 }, 3431 }; 3432 3433 static struct gdsc pcie_0_gdsc = { 3434 .gdscr = 0x6b004, 3435 .pd = { 3436 .name = "pcie_0_gdsc", 3437 }, 3438 .pwrsts = PWRSTS_OFF_ON, 3439 .flags = POLL_CFG_GDSCR, 3440 }; 3441 3442 static struct gdsc pcie_1_gdsc = { 3443 .gdscr = 0x8d004, 3444 .pd = { 3445 .name = "pcie_1_gdsc", 3446 }, 3447 .pwrsts = PWRSTS_OFF_ON, 3448 .flags = POLL_CFG_GDSCR, 3449 }; 3450 3451 static struct gdsc ufs_card_gdsc = { 3452 .gdscr = 0x75004, 3453 .pd = { 3454 .name = "ufs_card_gdsc", 3455 }, 3456 .pwrsts = PWRSTS_OFF_ON, 3457 .flags = POLL_CFG_GDSCR, 3458 }; 3459 3460 static struct gdsc ufs_phy_gdsc = { 3461 .gdscr = 0x77004, 3462 .pd = { 3463 .name = "ufs_phy_gdsc", 3464 }, 3465 .pwrsts = PWRSTS_OFF_ON, 3466 .flags = POLL_CFG_GDSCR, 3467 }; 3468 3469 static struct gdsc emac_gdsc = { 3470 .gdscr = 0x6004, 3471 .pd = { 3472 .name = "emac_gdsc", 3473 }, 3474 .pwrsts = PWRSTS_OFF_ON, 3475 .flags = POLL_CFG_GDSCR, 3476 }; 3477 3478 static struct gdsc usb30_prim_gdsc = { 3479 .gdscr = 0xf004, 3480 .pd = { 3481 .name = "usb30_prim_gdsc", 3482 }, 3483 .pwrsts = PWRSTS_OFF_ON, 3484 .flags = POLL_CFG_GDSCR, 3485 }; 3486 3487 static struct gdsc usb30_sec_gdsc = { 3488 .gdscr = 0x10004, 3489 .pd = { 3490 .name = "usb30_sec_gdsc", 3491 }, 3492 .pwrsts = PWRSTS_OFF_ON, 3493 .flags = POLL_CFG_GDSCR, 3494 }; 3495 3496 static struct clk_regmap *gcc_sm8150_clocks[] = { 3497 [GCC_AGGRE_NOC_PCIE_TBU_CLK] = &gcc_aggre_noc_pcie_tbu_clk.clkr, 3498 [GCC_AGGRE_UFS_CARD_AXI_CLK] = &gcc_aggre_ufs_card_axi_clk.clkr, 3499 [GCC_AGGRE_UFS_CARD_AXI_HW_CTL_CLK] = 3500 &gcc_aggre_ufs_card_axi_hw_ctl_clk.clkr, 3501 [GCC_AGGRE_UFS_PHY_AXI_CLK] = &gcc_aggre_ufs_phy_axi_clk.clkr, 3502 [GCC_AGGRE_UFS_PHY_AXI_HW_CTL_CLK] = 3503 &gcc_aggre_ufs_phy_axi_hw_ctl_clk.clkr, 3504 [GCC_AGGRE_USB3_PRIM_AXI_CLK] = &gcc_aggre_usb3_prim_axi_clk.clkr, 3505 [GCC_AGGRE_USB3_SEC_AXI_CLK] = &gcc_aggre_usb3_sec_axi_clk.clkr, 3506 [GCC_BOOT_ROM_AHB_CLK] = &gcc_boot_rom_ahb_clk.clkr, 3507 [GCC_CAMERA_AHB_CLK] = &gcc_camera_ahb_clk.clkr, 3508 [GCC_CAMERA_HF_AXI_CLK] = &gcc_camera_hf_axi_clk.clkr, 3509 [GCC_CAMERA_SF_AXI_CLK] = &gcc_camera_sf_axi_clk.clkr, 3510 [GCC_CAMERA_XO_CLK] = &gcc_camera_xo_clk.clkr, 3511 [GCC_CFG_NOC_USB3_PRIM_AXI_CLK] = &gcc_cfg_noc_usb3_prim_axi_clk.clkr, 3512 [GCC_CFG_NOC_USB3_SEC_AXI_CLK] = &gcc_cfg_noc_usb3_sec_axi_clk.clkr, 3513 [GCC_CPUSS_AHB_CLK] = &gcc_cpuss_ahb_clk.clkr, 3514 [GCC_CPUSS_AHB_CLK_SRC] = &gcc_cpuss_ahb_clk_src.clkr, 3515 [GCC_CPUSS_DVM_BUS_CLK] = &gcc_cpuss_dvm_bus_clk.clkr, 3516 [GCC_CPUSS_GNOC_CLK] = &gcc_cpuss_gnoc_clk.clkr, 3517 [GCC_CPUSS_RBCPR_CLK] = &gcc_cpuss_rbcpr_clk.clkr, 3518 [GCC_DDRSS_GPU_AXI_CLK] = &gcc_ddrss_gpu_axi_clk.clkr, 3519 [GCC_DISP_AHB_CLK] = &gcc_disp_ahb_clk.clkr, 3520 [GCC_DISP_HF_AXI_CLK] = &gcc_disp_hf_axi_clk.clkr, 3521 [GCC_DISP_SF_AXI_CLK] = &gcc_disp_sf_axi_clk.clkr, 3522 [GCC_DISP_XO_CLK] = &gcc_disp_xo_clk.clkr, 3523 [GCC_EMAC_AXI_CLK] = &gcc_emac_axi_clk.clkr, 3524 [GCC_EMAC_PTP_CLK] = &gcc_emac_ptp_clk.clkr, 3525 [GCC_EMAC_PTP_CLK_SRC] = &gcc_emac_ptp_clk_src.clkr, 3526 [GCC_EMAC_RGMII_CLK] = &gcc_emac_rgmii_clk.clkr, 3527 [GCC_EMAC_RGMII_CLK_SRC] = &gcc_emac_rgmii_clk_src.clkr, 3528 [GCC_EMAC_SLV_AHB_CLK] = &gcc_emac_slv_ahb_clk.clkr, 3529 [GCC_GP1_CLK] = &gcc_gp1_clk.clkr, 3530 [GCC_GP1_CLK_SRC] = &gcc_gp1_clk_src.clkr, 3531 [GCC_GP2_CLK] = &gcc_gp2_clk.clkr, 3532 [GCC_GP2_CLK_SRC] = &gcc_gp2_clk_src.clkr, 3533 [GCC_GP3_CLK] = &gcc_gp3_clk.clkr, 3534 [GCC_GP3_CLK_SRC] = &gcc_gp3_clk_src.clkr, 3535 [GCC_GPU_CFG_AHB_CLK] = &gcc_gpu_cfg_ahb_clk.clkr, 3536 [GCC_GPU_GPLL0_CLK_SRC] = &gcc_gpu_gpll0_clk_src.clkr, 3537 [GCC_GPU_GPLL0_DIV_CLK_SRC] = &gcc_gpu_gpll0_div_clk_src.clkr, 3538 [GCC_GPU_IREF_CLK] = &gcc_gpu_iref_clk.clkr, 3539 [GCC_GPU_MEMNOC_GFX_CLK] = &gcc_gpu_memnoc_gfx_clk.clkr, 3540 [GCC_GPU_SNOC_DVM_GFX_CLK] = &gcc_gpu_snoc_dvm_gfx_clk.clkr, 3541 [GCC_NPU_AT_CLK] = &gcc_npu_at_clk.clkr, 3542 [GCC_NPU_AXI_CLK] = &gcc_npu_axi_clk.clkr, 3543 [GCC_NPU_CFG_AHB_CLK] = &gcc_npu_cfg_ahb_clk.clkr, 3544 [GCC_NPU_GPLL0_CLK_SRC] = &gcc_npu_gpll0_clk_src.clkr, 3545 [GCC_NPU_GPLL0_DIV_CLK_SRC] = &gcc_npu_gpll0_div_clk_src.clkr, 3546 [GCC_NPU_TRIG_CLK] = &gcc_npu_trig_clk.clkr, 3547 [GCC_PCIE0_PHY_REFGEN_CLK] = &gcc_pcie0_phy_refgen_clk.clkr, 3548 [GCC_PCIE1_PHY_REFGEN_CLK] = &gcc_pcie1_phy_refgen_clk.clkr, 3549 [GCC_PCIE_0_AUX_CLK] = &gcc_pcie_0_aux_clk.clkr, 3550 [GCC_PCIE_0_AUX_CLK_SRC] = &gcc_pcie_0_aux_clk_src.clkr, 3551 [GCC_PCIE_0_CFG_AHB_CLK] = &gcc_pcie_0_cfg_ahb_clk.clkr, 3552 [GCC_PCIE_0_CLKREF_CLK] = &gcc_pcie_0_clkref_clk.clkr, 3553 [GCC_PCIE_0_MSTR_AXI_CLK] = &gcc_pcie_0_mstr_axi_clk.clkr, 3554 [GCC_PCIE_0_PIPE_CLK] = &gcc_pcie_0_pipe_clk.clkr, 3555 [GCC_PCIE_0_SLV_AXI_CLK] = &gcc_pcie_0_slv_axi_clk.clkr, 3556 [GCC_PCIE_0_SLV_Q2A_AXI_CLK] = &gcc_pcie_0_slv_q2a_axi_clk.clkr, 3557 [GCC_PCIE_1_AUX_CLK] = &gcc_pcie_1_aux_clk.clkr, 3558 [GCC_PCIE_1_AUX_CLK_SRC] = &gcc_pcie_1_aux_clk_src.clkr, 3559 [GCC_PCIE_1_CFG_AHB_CLK] = &gcc_pcie_1_cfg_ahb_clk.clkr, 3560 [GCC_PCIE_1_CLKREF_CLK] = &gcc_pcie_1_clkref_clk.clkr, 3561 [GCC_PCIE_1_MSTR_AXI_CLK] = &gcc_pcie_1_mstr_axi_clk.clkr, 3562 [GCC_PCIE_1_PIPE_CLK] = &gcc_pcie_1_pipe_clk.clkr, 3563 [GCC_PCIE_1_SLV_AXI_CLK] = &gcc_pcie_1_slv_axi_clk.clkr, 3564 [GCC_PCIE_1_SLV_Q2A_AXI_CLK] = &gcc_pcie_1_slv_q2a_axi_clk.clkr, 3565 [GCC_PCIE_PHY_AUX_CLK] = &gcc_pcie_phy_aux_clk.clkr, 3566 [GCC_PCIE_PHY_REFGEN_CLK_SRC] = &gcc_pcie_phy_refgen_clk_src.clkr, 3567 [GCC_PDM2_CLK] = &gcc_pdm2_clk.clkr, 3568 [GCC_PDM2_CLK_SRC] = &gcc_pdm2_clk_src.clkr, 3569 [GCC_PDM_AHB_CLK] = &gcc_pdm_ahb_clk.clkr, 3570 [GCC_PDM_XO4_CLK] = &gcc_pdm_xo4_clk.clkr, 3571 [GCC_PRNG_AHB_CLK] = &gcc_prng_ahb_clk.clkr, 3572 [GCC_QMIP_CAMERA_NRT_AHB_CLK] = &gcc_qmip_camera_nrt_ahb_clk.clkr, 3573 [GCC_QMIP_CAMERA_RT_AHB_CLK] = &gcc_qmip_camera_rt_ahb_clk.clkr, 3574 [GCC_QMIP_DISP_AHB_CLK] = &gcc_qmip_disp_ahb_clk.clkr, 3575 [GCC_QMIP_VIDEO_CVP_AHB_CLK] = &gcc_qmip_video_cvp_ahb_clk.clkr, 3576 [GCC_QMIP_VIDEO_VCODEC_AHB_CLK] = &gcc_qmip_video_vcodec_ahb_clk.clkr, 3577 [GCC_QSPI_CNOC_PERIPH_AHB_CLK] = &gcc_qspi_cnoc_periph_ahb_clk.clkr, 3578 [GCC_QSPI_CORE_CLK] = &gcc_qspi_core_clk.clkr, 3579 [GCC_QSPI_CORE_CLK_SRC] = &gcc_qspi_core_clk_src.clkr, 3580 [GCC_QUPV3_WRAP0_S0_CLK] = &gcc_qupv3_wrap0_s0_clk.clkr, 3581 [GCC_QUPV3_WRAP0_S0_CLK_SRC] = &gcc_qupv3_wrap0_s0_clk_src.clkr, 3582 [GCC_QUPV3_WRAP0_S1_CLK] = &gcc_qupv3_wrap0_s1_clk.clkr, 3583 [GCC_QUPV3_WRAP0_S1_CLK_SRC] = &gcc_qupv3_wrap0_s1_clk_src.clkr, 3584 [GCC_QUPV3_WRAP0_S2_CLK] = &gcc_qupv3_wrap0_s2_clk.clkr, 3585 [GCC_QUPV3_WRAP0_S2_CLK_SRC] = &gcc_qupv3_wrap0_s2_clk_src.clkr, 3586 [GCC_QUPV3_WRAP0_S3_CLK] = &gcc_qupv3_wrap0_s3_clk.clkr, 3587 [GCC_QUPV3_WRAP0_S3_CLK_SRC] = &gcc_qupv3_wrap0_s3_clk_src.clkr, 3588 [GCC_QUPV3_WRAP0_S4_CLK] = &gcc_qupv3_wrap0_s4_clk.clkr, 3589 [GCC_QUPV3_WRAP0_S4_CLK_SRC] = &gcc_qupv3_wrap0_s4_clk_src.clkr, 3590 [GCC_QUPV3_WRAP0_S5_CLK] = &gcc_qupv3_wrap0_s5_clk.clkr, 3591 [GCC_QUPV3_WRAP0_S5_CLK_SRC] = &gcc_qupv3_wrap0_s5_clk_src.clkr, 3592 [GCC_QUPV3_WRAP0_S6_CLK] = &gcc_qupv3_wrap0_s6_clk.clkr, 3593 [GCC_QUPV3_WRAP0_S6_CLK_SRC] = &gcc_qupv3_wrap0_s6_clk_src.clkr, 3594 [GCC_QUPV3_WRAP0_S7_CLK] = &gcc_qupv3_wrap0_s7_clk.clkr, 3595 [GCC_QUPV3_WRAP0_S7_CLK_SRC] = &gcc_qupv3_wrap0_s7_clk_src.clkr, 3596 [GCC_QUPV3_WRAP1_S0_CLK] = &gcc_qupv3_wrap1_s0_clk.clkr, 3597 [GCC_QUPV3_WRAP1_S0_CLK_SRC] = &gcc_qupv3_wrap1_s0_clk_src.clkr, 3598 [GCC_QUPV3_WRAP1_S1_CLK] = &gcc_qupv3_wrap1_s1_clk.clkr, 3599 [GCC_QUPV3_WRAP1_S1_CLK_SRC] = &gcc_qupv3_wrap1_s1_clk_src.clkr, 3600 [GCC_QUPV3_WRAP1_S2_CLK] = &gcc_qupv3_wrap1_s2_clk.clkr, 3601 [GCC_QUPV3_WRAP1_S2_CLK_SRC] = &gcc_qupv3_wrap1_s2_clk_src.clkr, 3602 [GCC_QUPV3_WRAP1_S3_CLK] = &gcc_qupv3_wrap1_s3_clk.clkr, 3603 [GCC_QUPV3_WRAP1_S3_CLK_SRC] = &gcc_qupv3_wrap1_s3_clk_src.clkr, 3604 [GCC_QUPV3_WRAP1_S4_CLK] = &gcc_qupv3_wrap1_s4_clk.clkr, 3605 [GCC_QUPV3_WRAP1_S4_CLK_SRC] = &gcc_qupv3_wrap1_s4_clk_src.clkr, 3606 [GCC_QUPV3_WRAP1_S5_CLK] = &gcc_qupv3_wrap1_s5_clk.clkr, 3607 [GCC_QUPV3_WRAP1_S5_CLK_SRC] = &gcc_qupv3_wrap1_s5_clk_src.clkr, 3608 [GCC_QUPV3_WRAP2_S0_CLK] = &gcc_qupv3_wrap2_s0_clk.clkr, 3609 [GCC_QUPV3_WRAP2_S0_CLK_SRC] = &gcc_qupv3_wrap2_s0_clk_src.clkr, 3610 [GCC_QUPV3_WRAP2_S1_CLK] = &gcc_qupv3_wrap2_s1_clk.clkr, 3611 [GCC_QUPV3_WRAP2_S1_CLK_SRC] = &gcc_qupv3_wrap2_s1_clk_src.clkr, 3612 [GCC_QUPV3_WRAP2_S2_CLK] = &gcc_qupv3_wrap2_s2_clk.clkr, 3613 [GCC_QUPV3_WRAP2_S2_CLK_SRC] = &gcc_qupv3_wrap2_s2_clk_src.clkr, 3614 [GCC_QUPV3_WRAP2_S3_CLK] = &gcc_qupv3_wrap2_s3_clk.clkr, 3615 [GCC_QUPV3_WRAP2_S3_CLK_SRC] = &gcc_qupv3_wrap2_s3_clk_src.clkr, 3616 [GCC_QUPV3_WRAP2_S4_CLK] = &gcc_qupv3_wrap2_s4_clk.clkr, 3617 [GCC_QUPV3_WRAP2_S4_CLK_SRC] = &gcc_qupv3_wrap2_s4_clk_src.clkr, 3618 [GCC_QUPV3_WRAP2_S5_CLK] = &gcc_qupv3_wrap2_s5_clk.clkr, 3619 [GCC_QUPV3_WRAP2_S5_CLK_SRC] = &gcc_qupv3_wrap2_s5_clk_src.clkr, 3620 [GCC_QUPV3_WRAP_0_M_AHB_CLK] = &gcc_qupv3_wrap_0_m_ahb_clk.clkr, 3621 [GCC_QUPV3_WRAP_0_S_AHB_CLK] = &gcc_qupv3_wrap_0_s_ahb_clk.clkr, 3622 [GCC_QUPV3_WRAP_1_M_AHB_CLK] = &gcc_qupv3_wrap_1_m_ahb_clk.clkr, 3623 [GCC_QUPV3_WRAP_1_S_AHB_CLK] = &gcc_qupv3_wrap_1_s_ahb_clk.clkr, 3624 [GCC_QUPV3_WRAP_2_M_AHB_CLK] = &gcc_qupv3_wrap_2_m_ahb_clk.clkr, 3625 [GCC_QUPV3_WRAP_2_S_AHB_CLK] = &gcc_qupv3_wrap_2_s_ahb_clk.clkr, 3626 [GCC_SDCC2_AHB_CLK] = &gcc_sdcc2_ahb_clk.clkr, 3627 [GCC_SDCC2_APPS_CLK] = &gcc_sdcc2_apps_clk.clkr, 3628 [GCC_SDCC2_APPS_CLK_SRC] = &gcc_sdcc2_apps_clk_src.clkr, 3629 [GCC_SDCC4_AHB_CLK] = &gcc_sdcc4_ahb_clk.clkr, 3630 [GCC_SDCC4_APPS_CLK] = &gcc_sdcc4_apps_clk.clkr, 3631 [GCC_SDCC4_APPS_CLK_SRC] = &gcc_sdcc4_apps_clk_src.clkr, 3632 [GCC_SYS_NOC_CPUSS_AHB_CLK] = &gcc_sys_noc_cpuss_ahb_clk.clkr, 3633 [GCC_TSIF_AHB_CLK] = &gcc_tsif_ahb_clk.clkr, 3634 [GCC_TSIF_INACTIVITY_TIMERS_CLK] = &gcc_tsif_inactivity_timers_clk.clkr, 3635 [GCC_TSIF_REF_CLK] = &gcc_tsif_ref_clk.clkr, 3636 [GCC_TSIF_REF_CLK_SRC] = &gcc_tsif_ref_clk_src.clkr, 3637 [GCC_UFS_CARD_AHB_CLK] = &gcc_ufs_card_ahb_clk.clkr, 3638 [GCC_UFS_CARD_AXI_CLK] = &gcc_ufs_card_axi_clk.clkr, 3639 [GCC_UFS_CARD_AXI_CLK_SRC] = &gcc_ufs_card_axi_clk_src.clkr, 3640 [GCC_UFS_CARD_AXI_HW_CTL_CLK] = &gcc_ufs_card_axi_hw_ctl_clk.clkr, 3641 [GCC_UFS_CARD_CLKREF_CLK] = &gcc_ufs_card_clkref_clk.clkr, 3642 [GCC_UFS_CARD_ICE_CORE_CLK] = &gcc_ufs_card_ice_core_clk.clkr, 3643 [GCC_UFS_CARD_ICE_CORE_CLK_SRC] = &gcc_ufs_card_ice_core_clk_src.clkr, 3644 [GCC_UFS_CARD_ICE_CORE_HW_CTL_CLK] = 3645 &gcc_ufs_card_ice_core_hw_ctl_clk.clkr, 3646 [GCC_UFS_CARD_PHY_AUX_CLK] = &gcc_ufs_card_phy_aux_clk.clkr, 3647 [GCC_UFS_CARD_PHY_AUX_CLK_SRC] = &gcc_ufs_card_phy_aux_clk_src.clkr, 3648 [GCC_UFS_CARD_PHY_AUX_HW_CTL_CLK] = 3649 &gcc_ufs_card_phy_aux_hw_ctl_clk.clkr, 3650 [GCC_UFS_CARD_RX_SYMBOL_0_CLK] = &gcc_ufs_card_rx_symbol_0_clk.clkr, 3651 [GCC_UFS_CARD_RX_SYMBOL_1_CLK] = &gcc_ufs_card_rx_symbol_1_clk.clkr, 3652 [GCC_UFS_CARD_TX_SYMBOL_0_CLK] = &gcc_ufs_card_tx_symbol_0_clk.clkr, 3653 [GCC_UFS_CARD_UNIPRO_CORE_CLK] = &gcc_ufs_card_unipro_core_clk.clkr, 3654 [GCC_UFS_CARD_UNIPRO_CORE_CLK_SRC] = 3655 &gcc_ufs_card_unipro_core_clk_src.clkr, 3656 [GCC_UFS_CARD_UNIPRO_CORE_HW_CTL_CLK] = 3657 &gcc_ufs_card_unipro_core_hw_ctl_clk.clkr, 3658 [GCC_UFS_MEM_CLKREF_CLK] = &gcc_ufs_mem_clkref_clk.clkr, 3659 [GCC_UFS_PHY_AHB_CLK] = &gcc_ufs_phy_ahb_clk.clkr, 3660 [GCC_UFS_PHY_AXI_CLK] = &gcc_ufs_phy_axi_clk.clkr, 3661 [GCC_UFS_PHY_AXI_CLK_SRC] = &gcc_ufs_phy_axi_clk_src.clkr, 3662 [GCC_UFS_PHY_AXI_HW_CTL_CLK] = &gcc_ufs_phy_axi_hw_ctl_clk.clkr, 3663 [GCC_UFS_PHY_ICE_CORE_CLK] = &gcc_ufs_phy_ice_core_clk.clkr, 3664 [GCC_UFS_PHY_ICE_CORE_CLK_SRC] = &gcc_ufs_phy_ice_core_clk_src.clkr, 3665 [GCC_UFS_PHY_ICE_CORE_HW_CTL_CLK] = 3666 &gcc_ufs_phy_ice_core_hw_ctl_clk.clkr, 3667 [GCC_UFS_PHY_PHY_AUX_CLK] = &gcc_ufs_phy_phy_aux_clk.clkr, 3668 [GCC_UFS_PHY_PHY_AUX_CLK_SRC] = &gcc_ufs_phy_phy_aux_clk_src.clkr, 3669 [GCC_UFS_PHY_PHY_AUX_HW_CTL_CLK] = &gcc_ufs_phy_phy_aux_hw_ctl_clk.clkr, 3670 [GCC_UFS_PHY_RX_SYMBOL_0_CLK] = &gcc_ufs_phy_rx_symbol_0_clk.clkr, 3671 [GCC_UFS_PHY_RX_SYMBOL_1_CLK] = &gcc_ufs_phy_rx_symbol_1_clk.clkr, 3672 [GCC_UFS_PHY_TX_SYMBOL_0_CLK] = &gcc_ufs_phy_tx_symbol_0_clk.clkr, 3673 [GCC_UFS_PHY_UNIPRO_CORE_CLK] = &gcc_ufs_phy_unipro_core_clk.clkr, 3674 [GCC_UFS_PHY_UNIPRO_CORE_CLK_SRC] = 3675 &gcc_ufs_phy_unipro_core_clk_src.clkr, 3676 [GCC_UFS_PHY_UNIPRO_CORE_HW_CTL_CLK] = 3677 &gcc_ufs_phy_unipro_core_hw_ctl_clk.clkr, 3678 [GCC_USB30_PRIM_MASTER_CLK] = &gcc_usb30_prim_master_clk.clkr, 3679 [GCC_USB30_PRIM_MASTER_CLK_SRC] = &gcc_usb30_prim_master_clk_src.clkr, 3680 [GCC_USB30_PRIM_MOCK_UTMI_CLK] = &gcc_usb30_prim_mock_utmi_clk.clkr, 3681 [GCC_USB30_PRIM_MOCK_UTMI_CLK_SRC] = 3682 &gcc_usb30_prim_mock_utmi_clk_src.clkr, 3683 [GCC_USB30_PRIM_SLEEP_CLK] = &gcc_usb30_prim_sleep_clk.clkr, 3684 [GCC_USB30_SEC_MASTER_CLK] = &gcc_usb30_sec_master_clk.clkr, 3685 [GCC_USB30_SEC_MASTER_CLK_SRC] = &gcc_usb30_sec_master_clk_src.clkr, 3686 [GCC_USB30_SEC_MOCK_UTMI_CLK] = &gcc_usb30_sec_mock_utmi_clk.clkr, 3687 [GCC_USB30_SEC_MOCK_UTMI_CLK_SRC] = 3688 &gcc_usb30_sec_mock_utmi_clk_src.clkr, 3689 [GCC_USB30_SEC_SLEEP_CLK] = &gcc_usb30_sec_sleep_clk.clkr, 3690 [GCC_USB3_PRIM_CLKREF_CLK] = &gcc_usb3_prim_clkref_clk.clkr, 3691 [GCC_USB3_PRIM_PHY_AUX_CLK] = &gcc_usb3_prim_phy_aux_clk.clkr, 3692 [GCC_USB3_PRIM_PHY_AUX_CLK_SRC] = &gcc_usb3_prim_phy_aux_clk_src.clkr, 3693 [GCC_USB3_PRIM_PHY_COM_AUX_CLK] = &gcc_usb3_prim_phy_com_aux_clk.clkr, 3694 [GCC_USB3_PRIM_PHY_PIPE_CLK] = &gcc_usb3_prim_phy_pipe_clk.clkr, 3695 [GCC_USB3_SEC_CLKREF_CLK] = &gcc_usb3_sec_clkref_clk.clkr, 3696 [GCC_USB3_SEC_PHY_AUX_CLK] = &gcc_usb3_sec_phy_aux_clk.clkr, 3697 [GCC_USB3_SEC_PHY_AUX_CLK_SRC] = &gcc_usb3_sec_phy_aux_clk_src.clkr, 3698 [GCC_USB3_SEC_PHY_COM_AUX_CLK] = &gcc_usb3_sec_phy_com_aux_clk.clkr, 3699 [GCC_USB3_SEC_PHY_PIPE_CLK] = &gcc_usb3_sec_phy_pipe_clk.clkr, 3700 [GCC_VIDEO_AHB_CLK] = &gcc_video_ahb_clk.clkr, 3701 [GCC_VIDEO_AXI0_CLK] = &gcc_video_axi0_clk.clkr, 3702 [GCC_VIDEO_AXI1_CLK] = &gcc_video_axi1_clk.clkr, 3703 [GCC_VIDEO_AXIC_CLK] = &gcc_video_axic_clk.clkr, 3704 [GCC_VIDEO_XO_CLK] = &gcc_video_xo_clk.clkr, 3705 [GPLL0] = &gpll0.clkr, 3706 [GPLL0_OUT_EVEN] = &gpll0_out_even.clkr, 3707 [GPLL7] = &gpll7.clkr, 3708 [GPLL9] = &gpll9.clkr, 3709 }; 3710 3711 static const struct qcom_reset_map gcc_sm8150_resets[] = { 3712 [GCC_EMAC_BCR] = { 0x6000 }, 3713 [GCC_GPU_BCR] = { 0x71000 }, 3714 [GCC_MMSS_BCR] = { 0xb000 }, 3715 [GCC_NPU_BCR] = { 0x4d000 }, 3716 [GCC_PCIE_0_BCR] = { 0x6b000 }, 3717 [GCC_PCIE_0_PHY_BCR] = { 0x6c01c }, 3718 [GCC_PCIE_1_BCR] = { 0x8d000 }, 3719 [GCC_PCIE_1_PHY_BCR] = { 0x8e01c }, 3720 [GCC_PCIE_PHY_BCR] = { 0x6f000 }, 3721 [GCC_PDM_BCR] = { 0x33000 }, 3722 [GCC_PRNG_BCR] = { 0x34000 }, 3723 [GCC_QSPI_BCR] = { 0x24008 }, 3724 [GCC_QUPV3_WRAPPER_0_BCR] = { 0x17000 }, 3725 [GCC_QUPV3_WRAPPER_1_BCR] = { 0x18000 }, 3726 [GCC_QUPV3_WRAPPER_2_BCR] = { 0x1e000 }, 3727 [GCC_QUSB2PHY_PRIM_BCR] = { 0x12000 }, 3728 [GCC_QUSB2PHY_SEC_BCR] = { 0x12004 }, 3729 [GCC_USB3_PHY_PRIM_BCR] = { 0x50000 }, 3730 [GCC_USB3_DP_PHY_PRIM_BCR] = { 0x50008 }, 3731 [GCC_USB3_PHY_SEC_BCR] = { 0x5000c }, 3732 [GCC_USB3PHY_PHY_SEC_BCR] = { 0x50010 }, 3733 [GCC_SDCC2_BCR] = { 0x14000 }, 3734 [GCC_SDCC4_BCR] = { 0x16000 }, 3735 [GCC_TSIF_BCR] = { 0x36000 }, 3736 [GCC_UFS_CARD_BCR] = { 0x75000 }, 3737 [GCC_UFS_PHY_BCR] = { 0x77000 }, 3738 [GCC_USB30_PRIM_BCR] = { 0xf000 }, 3739 [GCC_USB30_SEC_BCR] = { 0x10000 }, 3740 [GCC_USB_PHY_CFG_AHB2PHY_BCR] = { 0x6a000 }, 3741 }; 3742 3743 static struct gdsc *gcc_sm8150_gdscs[] = { 3744 [EMAC_GDSC] = &emac_gdsc, 3745 [PCIE_0_GDSC] = &pcie_0_gdsc, 3746 [PCIE_1_GDSC] = &pcie_1_gdsc, 3747 [UFS_CARD_GDSC] = &ufs_card_gdsc, 3748 [UFS_PHY_GDSC] = &ufs_phy_gdsc, 3749 [USB30_PRIM_GDSC] = &usb30_prim_gdsc, 3750 [USB30_SEC_GDSC] = &usb30_sec_gdsc, 3751 }; 3752 3753 static const struct regmap_config gcc_sm8150_regmap_config = { 3754 .reg_bits = 32, 3755 .reg_stride = 4, 3756 .val_bits = 32, 3757 .max_register = 0x9c040, 3758 .fast_io = true, 3759 }; 3760 3761 static const struct qcom_cc_desc gcc_sm8150_desc = { 3762 .config = &gcc_sm8150_regmap_config, 3763 .clks = gcc_sm8150_clocks, 3764 .num_clks = ARRAY_SIZE(gcc_sm8150_clocks), 3765 .resets = gcc_sm8150_resets, 3766 .num_resets = ARRAY_SIZE(gcc_sm8150_resets), 3767 .gdscs = gcc_sm8150_gdscs, 3768 .num_gdscs = ARRAY_SIZE(gcc_sm8150_gdscs), 3769 }; 3770 3771 static const struct of_device_id gcc_sm8150_match_table[] = { 3772 { .compatible = "qcom,gcc-sm8150" }, 3773 { } 3774 }; 3775 MODULE_DEVICE_TABLE(of, gcc_sm8150_match_table); 3776 3777 static int gcc_sm8150_probe(struct platform_device *pdev) 3778 { 3779 struct regmap *regmap; 3780 3781 regmap = qcom_cc_map(pdev, &gcc_sm8150_desc); 3782 if (IS_ERR(regmap)) 3783 return PTR_ERR(regmap); 3784 3785 /* Disable the GPLL0 active input to NPU and GPU via MISC registers */ 3786 regmap_update_bits(regmap, 0x4d110, 0x3, 0x3); 3787 regmap_update_bits(regmap, 0x71028, 0x3, 0x3); 3788 3789 return qcom_cc_really_probe(pdev, &gcc_sm8150_desc, regmap); 3790 } 3791 3792 static struct platform_driver gcc_sm8150_driver = { 3793 .probe = gcc_sm8150_probe, 3794 .driver = { 3795 .name = "gcc-sm8150", 3796 .of_match_table = gcc_sm8150_match_table, 3797 }, 3798 }; 3799 3800 static int __init gcc_sm8150_init(void) 3801 { 3802 return platform_driver_register(&gcc_sm8150_driver); 3803 } 3804 subsys_initcall(gcc_sm8150_init); 3805 3806 static void __exit gcc_sm8150_exit(void) 3807 { 3808 platform_driver_unregister(&gcc_sm8150_driver); 3809 } 3810 module_exit(gcc_sm8150_exit); 3811 3812 MODULE_DESCRIPTION("QTI GCC SM8150 Driver"); 3813 MODULE_LICENSE("GPL v2"); 3814