drivers/clk/qcom/gcc-sdx55.c

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