drivers/clk/qcom/gcc-sc7180.c

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