drivers/clk/qcom/gcc-mdm9615.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
   4  * Copyright (c) BayLibre, SAS.
   5  * Author : Neil Armstrong <narmstrong@baylibre.com>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/bitops.h>
  10 #include <linux/err.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/clk-provider.h>
  15 #include <linux/regmap.h>
  16 #include <linux/reset-controller.h>
  17
  18 #include <dt-bindings/clock/qcom,gcc-mdm9615.h>
  19 #include <dt-bindings/reset/qcom,gcc-mdm9615.h>
  20
  21 #include "common.h"
  22 #include "clk-regmap.h"
  23 #include "clk-pll.h"
  24 #include "clk-rcg.h"
  25 #include "clk-branch.h"
  26 #include "reset.h"
  27
  28 enum {
  29         DT_CXO,
  30         DT_PLL4,
  31 };
  32
  33 enum {
  34         P_CXO,
  35         P_PLL8,
  36         P_PLL14,
  37 };
  38
  39 static const struct parent_map gcc_cxo_map[] = {
  40         { P_CXO, 0 },
  41 };
  42
  43 static const struct clk_parent_data gcc_cxo[] = {
  44         { .index = DT_CXO, .name = "cxo_board" },
  45 };
  46
  47 static struct clk_pll pll0 = {
  48         .l_reg = 0x30c4,
  49         .m_reg = 0x30c8,
  50         .n_reg = 0x30cc,
  51         .config_reg = 0x30d4,
  52         .mode_reg = 0x30c0,
  53         .status_reg = 0x30d8,
  54         .status_bit = 16,
  55         .clkr.hw.init = &(struct clk_init_data){
  56                 .name = "pll0",
  57                 .parent_data = gcc_cxo,
  58                 .num_parents = ARRAY_SIZE(gcc_cxo),
  59                 .ops = &clk_pll_ops,
  60         },
  61 };
  62
  63 static struct clk_regmap pll0_vote = {
  64         .enable_reg = 0x34c0,
  65         .enable_mask = BIT(0),
  66         .hw.init = &(struct clk_init_data){
  67                 .name = "pll0_vote",
  68                 .parent_hws = (const struct clk_hw*[]) {
  69                         &pll0.clkr.hw,
  70                 },
  71                 .num_parents = 1,
  72                 .ops = &clk_pll_vote_ops,
  73         },
  74 };
  75
  76 static struct clk_regmap pll4_vote = {
  77         .enable_reg = 0x34c0,
  78         .enable_mask = BIT(4),
  79         .hw.init = &(struct clk_init_data){
  80                 .name = "pll4_vote",
  81                 .parent_data = &(const struct clk_parent_data) {
  82                         .index = DT_PLL4, .name = "pll4",
  83                 },
  84                 .num_parents = 1,
  85                 .ops = &clk_pll_vote_ops,
  86         },
  87 };
  88
  89 static struct clk_pll pll8 = {
  90         .l_reg = 0x3144,
  91         .m_reg = 0x3148,
  92         .n_reg = 0x314c,
  93         .config_reg = 0x3154,
  94         .mode_reg = 0x3140,
  95         .status_reg = 0x3158,
  96         .status_bit = 16,
  97         .clkr.hw.init = &(struct clk_init_data){
  98                 .name = "pll8",
  99                 .parent_data = gcc_cxo,
 100                 .num_parents = ARRAY_SIZE(gcc_cxo),
 101                 .ops = &clk_pll_ops,
 102         },
 103 };
 104
 105 static struct clk_regmap pll8_vote = {
 106         .enable_reg = 0x34c0,
 107         .enable_mask = BIT(8),
 108         .hw.init = &(struct clk_init_data){
 109                 .name = "pll8_vote",
 110                 .parent_hws = (const struct clk_hw*[]) {
 111                         &pll8.clkr.hw,
 112                 },
 113                 .num_parents = 1,
 114                 .ops = &clk_pll_vote_ops,
 115         },
 116 };
 117
 118 static struct clk_pll pll14 = {
 119         .l_reg = 0x31c4,
 120         .m_reg = 0x31c8,
 121         .n_reg = 0x31cc,
 122         .config_reg = 0x31d4,
 123         .mode_reg = 0x31c0,
 124         .status_reg = 0x31d8,
 125         .status_bit = 16,
 126         .clkr.hw.init = &(struct clk_init_data){
 127                 .name = "pll14",
 128                 .parent_data = gcc_cxo,
 129                 .num_parents = ARRAY_SIZE(gcc_cxo),
 130                 .ops = &clk_pll_ops,
 131         },
 132 };
 133
 134 static struct clk_regmap pll14_vote = {
 135         .enable_reg = 0x34c0,
 136         .enable_mask = BIT(11),
 137         .hw.init = &(struct clk_init_data){
 138                 .name = "pll14_vote",
 139                 .parent_hws = (const struct clk_hw*[]) {
 140                         &pll14.clkr.hw,
 141                 },
 142                 .num_parents = 1,
 143                 .ops = &clk_pll_vote_ops,
 144         },
 145 };
 146
 147 static const struct parent_map gcc_cxo_pll8_map[] = {
 148         { P_CXO, 0 },
 149         { P_PLL8, 3 }
 150 };
 151
 152 static const struct clk_parent_data gcc_cxo_pll8[] = {
 153         { .index = DT_CXO, .name = "cxo_board" },
 154         { .hw = &pll8_vote.hw },
 155 };
 156
 157 static const struct parent_map gcc_cxo_pll14_map[] = {
 158         { P_CXO, 0 },
 159         { P_PLL14, 4 }
 160 };
 161
 162 static const struct clk_parent_data gcc_cxo_pll14[] = {
 163         { .index = DT_CXO, .name = "cxo_board" },
 164         { .hw = &pll14_vote.hw },
 165 };
 166
 167 static const struct freq_tbl clk_tbl_gsbi_uart[] = {
 168         {  1843200, P_PLL8, 2,  6, 625 },
 169         {  3686400, P_PLL8, 2, 12, 625 },
 170         {  7372800, P_PLL8, 2, 24, 625 },
 171         { 14745600, P_PLL8, 2, 48, 625 },
 172         { 16000000, P_PLL8, 4,  1,   6 },
 173         { 24000000, P_PLL8, 4,  1,   4 },
 174         { 32000000, P_PLL8, 4,  1,   3 },
 175         { 40000000, P_PLL8, 1,  5,  48 },
 176         { 46400000, P_PLL8, 1, 29, 240 },
 177         { 48000000, P_PLL8, 4,  1,   2 },
 178         { 51200000, P_PLL8, 1,  2,  15 },
 179         { 56000000, P_PLL8, 1,  7,  48 },
 180         { 58982400, P_PLL8, 1, 96, 625 },
 181         { 64000000, P_PLL8, 2,  1,   3 },
 182         { }
 183 };
 184
 185 static struct clk_rcg gsbi1_uart_src = {
 186         .ns_reg = 0x29d4,
 187         .md_reg = 0x29d0,
 188         .mn = {
 189                 .mnctr_en_bit = 8,
 190                 .mnctr_reset_bit = 7,
 191                 .mnctr_mode_shift = 5,
 192                 .n_val_shift = 16,
 193                 .m_val_shift = 16,
 194                 .width = 16,
 195         },
 196         .p = {
 197                 .pre_div_shift = 3,
 198                 .pre_div_width = 2,
 199         },
 200         .s = {
 201                 .src_sel_shift = 0,
 202                 .parent_map = gcc_cxo_pll8_map,
 203         },
 204         .freq_tbl = clk_tbl_gsbi_uart,
 205         .clkr = {
 206                 .enable_reg = 0x29d4,
 207                 .enable_mask = BIT(11),
 208                 .hw.init = &(struct clk_init_data){
 209                         .name = "gsbi1_uart_src",
 210                         .parent_data = gcc_cxo_pll8,
 211                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 212                         .ops = &clk_rcg_ops,
 213                         .flags = CLK_SET_PARENT_GATE,
 214                 },
 215         },
 216 };
 217
 218 static struct clk_branch gsbi1_uart_clk = {
 219         .halt_reg = 0x2fcc,
 220         .halt_bit = 10,
 221         .clkr = {
 222                 .enable_reg = 0x29d4,
 223                 .enable_mask = BIT(9),
 224                 .hw.init = &(struct clk_init_data){
 225                         .name = "gsbi1_uart_clk",
 226                         .parent_hws = (const struct clk_hw*[]) {
 227                                 &gsbi1_uart_src.clkr.hw,
 228                         },
 229                         .num_parents = 1,
 230                         .ops = &clk_branch_ops,
 231                         .flags = CLK_SET_RATE_PARENT,
 232                 },
 233         },
 234 };
 235
 236 static struct clk_rcg gsbi2_uart_src = {
 237         .ns_reg = 0x29f4,
 238         .md_reg = 0x29f0,
 239         .mn = {
 240                 .mnctr_en_bit = 8,
 241                 .mnctr_reset_bit = 7,
 242                 .mnctr_mode_shift = 5,
 243                 .n_val_shift = 16,
 244                 .m_val_shift = 16,
 245                 .width = 16,
 246         },
 247         .p = {
 248                 .pre_div_shift = 3,
 249                 .pre_div_width = 2,
 250         },
 251         .s = {
 252                 .src_sel_shift = 0,
 253                 .parent_map = gcc_cxo_pll8_map,
 254         },
 255         .freq_tbl = clk_tbl_gsbi_uart,
 256         .clkr = {
 257                 .enable_reg = 0x29f4,
 258                 .enable_mask = BIT(11),
 259                 .hw.init = &(struct clk_init_data){
 260                         .name = "gsbi2_uart_src",
 261                         .parent_data = gcc_cxo_pll8,
 262                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 263                         .ops = &clk_rcg_ops,
 264                         .flags = CLK_SET_PARENT_GATE,
 265                 },
 266         },
 267 };
 268
 269 static struct clk_branch gsbi2_uart_clk = {
 270         .halt_reg = 0x2fcc,
 271         .halt_bit = 6,
 272         .clkr = {
 273                 .enable_reg = 0x29f4,
 274                 .enable_mask = BIT(9),
 275                 .hw.init = &(struct clk_init_data){
 276                         .name = "gsbi2_uart_clk",
 277                         .parent_hws = (const struct clk_hw*[]) {
 278                                 &gsbi2_uart_src.clkr.hw,
 279                         },
 280                         .num_parents = 1,
 281                         .ops = &clk_branch_ops,
 282                         .flags = CLK_SET_RATE_PARENT,
 283                 },
 284         },
 285 };
 286
 287 static struct clk_rcg gsbi3_uart_src = {
 288         .ns_reg = 0x2a14,
 289         .md_reg = 0x2a10,
 290         .mn = {
 291                 .mnctr_en_bit = 8,
 292                 .mnctr_reset_bit = 7,
 293                 .mnctr_mode_shift = 5,
 294                 .n_val_shift = 16,
 295                 .m_val_shift = 16,
 296                 .width = 16,
 297         },
 298         .p = {
 299                 .pre_div_shift = 3,
 300                 .pre_div_width = 2,
 301         },
 302         .s = {
 303                 .src_sel_shift = 0,
 304                 .parent_map = gcc_cxo_pll8_map,
 305         },
 306         .freq_tbl = clk_tbl_gsbi_uart,
 307         .clkr = {
 308                 .enable_reg = 0x2a14,
 309                 .enable_mask = BIT(11),
 310                 .hw.init = &(struct clk_init_data){
 311                         .name = "gsbi3_uart_src",
 312                         .parent_data = gcc_cxo_pll8,
 313                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 314                         .ops = &clk_rcg_ops,
 315                         .flags = CLK_SET_PARENT_GATE,
 316                 },
 317         },
 318 };
 319
 320 static struct clk_branch gsbi3_uart_clk = {
 321         .halt_reg = 0x2fcc,
 322         .halt_bit = 2,
 323         .clkr = {
 324                 .enable_reg = 0x2a14,
 325                 .enable_mask = BIT(9),
 326                 .hw.init = &(struct clk_init_data){
 327                         .name = "gsbi3_uart_clk",
 328                         .parent_hws = (const struct clk_hw*[]) {
 329                                 &gsbi3_uart_src.clkr.hw,
 330                         },
 331                         .num_parents = 1,
 332                         .ops = &clk_branch_ops,
 333                         .flags = CLK_SET_RATE_PARENT,
 334                 },
 335         },
 336 };
 337
 338 static struct clk_rcg gsbi4_uart_src = {
 339         .ns_reg = 0x2a34,
 340         .md_reg = 0x2a30,
 341         .mn = {
 342                 .mnctr_en_bit = 8,
 343                 .mnctr_reset_bit = 7,
 344                 .mnctr_mode_shift = 5,
 345                 .n_val_shift = 16,
 346                 .m_val_shift = 16,
 347                 .width = 16,
 348         },
 349         .p = {
 350                 .pre_div_shift = 3,
 351                 .pre_div_width = 2,
 352         },
 353         .s = {
 354                 .src_sel_shift = 0,
 355                 .parent_map = gcc_cxo_pll8_map,
 356         },
 357         .freq_tbl = clk_tbl_gsbi_uart,
 358         .clkr = {
 359                 .enable_reg = 0x2a34,
 360                 .enable_mask = BIT(11),
 361                 .hw.init = &(struct clk_init_data){
 362                         .name = "gsbi4_uart_src",
 363                         .parent_data = gcc_cxo_pll8,
 364                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 365                         .ops = &clk_rcg_ops,
 366                         .flags = CLK_SET_PARENT_GATE,
 367                 },
 368         },
 369 };
 370
 371 static struct clk_branch gsbi4_uart_clk = {
 372         .halt_reg = 0x2fd0,
 373         .halt_bit = 26,
 374         .clkr = {
 375                 .enable_reg = 0x2a34,
 376                 .enable_mask = BIT(9),
 377                 .hw.init = &(struct clk_init_data){
 378                         .name = "gsbi4_uart_clk",
 379                         .parent_hws = (const struct clk_hw*[]) {
 380                                 &gsbi4_uart_src.clkr.hw,
 381                         },
 382                         .num_parents = 1,
 383                         .ops = &clk_branch_ops,
 384                         .flags = CLK_SET_RATE_PARENT,
 385                 },
 386         },
 387 };
 388
 389 static struct clk_rcg gsbi5_uart_src = {
 390         .ns_reg = 0x2a54,
 391         .md_reg = 0x2a50,
 392         .mn = {
 393                 .mnctr_en_bit = 8,
 394                 .mnctr_reset_bit = 7,
 395                 .mnctr_mode_shift = 5,
 396                 .n_val_shift = 16,
 397                 .m_val_shift = 16,
 398                 .width = 16,
 399         },
 400         .p = {
 401                 .pre_div_shift = 3,
 402                 .pre_div_width = 2,
 403         },
 404         .s = {
 405                 .src_sel_shift = 0,
 406                 .parent_map = gcc_cxo_pll8_map,
 407         },
 408         .freq_tbl = clk_tbl_gsbi_uart,
 409         .clkr = {
 410                 .enable_reg = 0x2a54,
 411                 .enable_mask = BIT(11),
 412                 .hw.init = &(struct clk_init_data){
 413                         .name = "gsbi5_uart_src",
 414                         .parent_data = gcc_cxo_pll8,
 415                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 416                         .ops = &clk_rcg_ops,
 417                         .flags = CLK_SET_PARENT_GATE,
 418                 },
 419         },
 420 };
 421
 422 static struct clk_branch gsbi5_uart_clk = {
 423         .halt_reg = 0x2fd0,
 424         .halt_bit = 22,
 425         .clkr = {
 426                 .enable_reg = 0x2a54,
 427                 .enable_mask = BIT(9),
 428                 .hw.init = &(struct clk_init_data){
 429                         .name = "gsbi5_uart_clk",
 430                         .parent_hws = (const struct clk_hw*[]) {
 431                                 &gsbi5_uart_src.clkr.hw,
 432                         },
 433                         .num_parents = 1,
 434                         .ops = &clk_branch_ops,
 435                         .flags = CLK_SET_RATE_PARENT,
 436                 },
 437         },
 438 };
 439
 440 static const struct freq_tbl clk_tbl_gsbi_qup[] = {
 441         {   960000, P_CXO,  4, 1,  5 },
 442         {  4800000, P_CXO,  4, 0,  1 },
 443         {  9600000, P_CXO,  2, 0,  1 },
 444         { 15060000, P_PLL8, 1, 2, 51 },
 445         { 24000000, P_PLL8, 4, 1,  4 },
 446         { 25600000, P_PLL8, 1, 1, 15 },
 447         { 48000000, P_PLL8, 4, 1,  2 },
 448         { 51200000, P_PLL8, 1, 2, 15 },
 449         { }
 450 };
 451
 452 static struct clk_rcg gsbi1_qup_src = {
 453         .ns_reg = 0x29cc,
 454         .md_reg = 0x29c8,
 455         .mn = {
 456                 .mnctr_en_bit = 8,
 457                 .mnctr_reset_bit = 7,
 458                 .mnctr_mode_shift = 5,
 459                 .n_val_shift = 16,
 460                 .m_val_shift = 16,
 461                 .width = 8,
 462         },
 463         .p = {
 464                 .pre_div_shift = 3,
 465                 .pre_div_width = 2,
 466         },
 467         .s = {
 468                 .src_sel_shift = 0,
 469                 .parent_map = gcc_cxo_pll8_map,
 470         },
 471         .freq_tbl = clk_tbl_gsbi_qup,
 472         .clkr = {
 473                 .enable_reg = 0x29cc,
 474                 .enable_mask = BIT(11),
 475                 .hw.init = &(struct clk_init_data){
 476                         .name = "gsbi1_qup_src",
 477                         .parent_data = gcc_cxo_pll8,
 478                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 479                         .ops = &clk_rcg_ops,
 480                         .flags = CLK_SET_PARENT_GATE,
 481                 },
 482         },
 483 };
 484
 485 static struct clk_branch gsbi1_qup_clk = {
 486         .halt_reg = 0x2fcc,
 487         .halt_bit = 9,
 488         .clkr = {
 489                 .enable_reg = 0x29cc,
 490                 .enable_mask = BIT(9),
 491                 .hw.init = &(struct clk_init_data){
 492                         .name = "gsbi1_qup_clk",
 493                         .parent_hws = (const struct clk_hw*[]) {
 494                                 &gsbi1_qup_src.clkr.hw,
 495                         },
 496                         .num_parents = 1,
 497                         .ops = &clk_branch_ops,
 498                         .flags = CLK_SET_RATE_PARENT,
 499                 },
 500         },
 501 };
 502
 503 static struct clk_rcg gsbi2_qup_src = {
 504         .ns_reg = 0x29ec,
 505         .md_reg = 0x29e8,
 506         .mn = {
 507                 .mnctr_en_bit = 8,
 508                 .mnctr_reset_bit = 7,
 509                 .mnctr_mode_shift = 5,
 510                 .n_val_shift = 16,
 511                 .m_val_shift = 16,
 512                 .width = 8,
 513         },
 514         .p = {
 515                 .pre_div_shift = 3,
 516                 .pre_div_width = 2,
 517         },
 518         .s = {
 519                 .src_sel_shift = 0,
 520                 .parent_map = gcc_cxo_pll8_map,
 521         },
 522         .freq_tbl = clk_tbl_gsbi_qup,
 523         .clkr = {
 524                 .enable_reg = 0x29ec,
 525                 .enable_mask = BIT(11),
 526                 .hw.init = &(struct clk_init_data){
 527                         .name = "gsbi2_qup_src",
 528                         .parent_data = gcc_cxo_pll8,
 529                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 530                         .ops = &clk_rcg_ops,
 531                         .flags = CLK_SET_PARENT_GATE,
 532                 },
 533         },
 534 };
 535
 536 static struct clk_branch gsbi2_qup_clk = {
 537         .halt_reg = 0x2fcc,
 538         .halt_bit = 4,
 539         .clkr = {
 540                 .enable_reg = 0x29ec,
 541                 .enable_mask = BIT(9),
 542                 .hw.init = &(struct clk_init_data){
 543                         .name = "gsbi2_qup_clk",
 544                         .parent_hws = (const struct clk_hw*[]) {
 545                                 &gsbi2_qup_src.clkr.hw,
 546                         },
 547                         .num_parents = 1,
 548                         .ops = &clk_branch_ops,
 549                         .flags = CLK_SET_RATE_PARENT,
 550                 },
 551         },
 552 };
 553
 554 static struct clk_rcg gsbi3_qup_src = {
 555         .ns_reg = 0x2a0c,
 556         .md_reg = 0x2a08,
 557         .mn = {
 558                 .mnctr_en_bit = 8,
 559                 .mnctr_reset_bit = 7,
 560                 .mnctr_mode_shift = 5,
 561                 .n_val_shift = 16,
 562                 .m_val_shift = 16,
 563                 .width = 8,
 564         },
 565         .p = {
 566                 .pre_div_shift = 3,
 567                 .pre_div_width = 2,
 568         },
 569         .s = {
 570                 .src_sel_shift = 0,
 571                 .parent_map = gcc_cxo_pll8_map,
 572         },
 573         .freq_tbl = clk_tbl_gsbi_qup,
 574         .clkr = {
 575                 .enable_reg = 0x2a0c,
 576                 .enable_mask = BIT(11),
 577                 .hw.init = &(struct clk_init_data){
 578                         .name = "gsbi3_qup_src",
 579                         .parent_data = gcc_cxo_pll8,
 580                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 581                         .ops = &clk_rcg_ops,
 582                         .flags = CLK_SET_PARENT_GATE,
 583                 },
 584         },
 585 };
 586
 587 static struct clk_branch gsbi3_qup_clk = {
 588         .halt_reg = 0x2fcc,
 589         .halt_bit = 0,
 590         .clkr = {
 591                 .enable_reg = 0x2a0c,
 592                 .enable_mask = BIT(9),
 593                 .hw.init = &(struct clk_init_data){
 594                         .name = "gsbi3_qup_clk",
 595                         .parent_hws = (const struct clk_hw*[]) {
 596                                 &gsbi3_qup_src.clkr.hw,
 597                         },
 598                         .num_parents = 1,
 599                         .ops = &clk_branch_ops,
 600                         .flags = CLK_SET_RATE_PARENT,
 601                 },
 602         },
 603 };
 604
 605 static struct clk_rcg gsbi4_qup_src = {
 606         .ns_reg = 0x2a2c,
 607         .md_reg = 0x2a28,
 608         .mn = {
 609                 .mnctr_en_bit = 8,
 610                 .mnctr_reset_bit = 7,
 611                 .mnctr_mode_shift = 5,
 612                 .n_val_shift = 16,
 613                 .m_val_shift = 16,
 614                 .width = 8,
 615         },
 616         .p = {
 617                 .pre_div_shift = 3,
 618                 .pre_div_width = 2,
 619         },
 620         .s = {
 621                 .src_sel_shift = 0,
 622                 .parent_map = gcc_cxo_pll8_map,
 623         },
 624         .freq_tbl = clk_tbl_gsbi_qup,
 625         .clkr = {
 626                 .enable_reg = 0x2a2c,
 627                 .enable_mask = BIT(11),
 628                 .hw.init = &(struct clk_init_data){
 629                         .name = "gsbi4_qup_src",
 630                         .parent_data = gcc_cxo_pll8,
 631                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 632                         .ops = &clk_rcg_ops,
 633                         .flags = CLK_SET_PARENT_GATE,
 634                 },
 635         },
 636 };
 637
 638 static struct clk_branch gsbi4_qup_clk = {
 639         .halt_reg = 0x2fd0,
 640         .halt_bit = 24,
 641         .clkr = {
 642                 .enable_reg = 0x2a2c,
 643                 .enable_mask = BIT(9),
 644                 .hw.init = &(struct clk_init_data){
 645                         .name = "gsbi4_qup_clk",
 646                         .parent_hws = (const struct clk_hw*[]) {
 647                                 &gsbi4_qup_src.clkr.hw,
 648                         },
 649                         .num_parents = 1,
 650                         .ops = &clk_branch_ops,
 651                         .flags = CLK_SET_RATE_PARENT,
 652                 },
 653         },
 654 };
 655
 656 static struct clk_rcg gsbi5_qup_src = {
 657         .ns_reg = 0x2a4c,
 658         .md_reg = 0x2a48,
 659         .mn = {
 660                 .mnctr_en_bit = 8,
 661                 .mnctr_reset_bit = 7,
 662                 .mnctr_mode_shift = 5,
 663                 .n_val_shift = 16,
 664                 .m_val_shift = 16,
 665                 .width = 8,
 666         },
 667         .p = {
 668                 .pre_div_shift = 3,
 669                 .pre_div_width = 2,
 670         },
 671         .s = {
 672                 .src_sel_shift = 0,
 673                 .parent_map = gcc_cxo_pll8_map,
 674         },
 675         .freq_tbl = clk_tbl_gsbi_qup,
 676         .clkr = {
 677                 .enable_reg = 0x2a4c,
 678                 .enable_mask = BIT(11),
 679                 .hw.init = &(struct clk_init_data){
 680                         .name = "gsbi5_qup_src",
 681                         .parent_data = gcc_cxo_pll8,
 682                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 683                         .ops = &clk_rcg_ops,
 684                         .flags = CLK_SET_PARENT_GATE,
 685                 },
 686         },
 687 };
 688
 689 static struct clk_branch gsbi5_qup_clk = {
 690         .halt_reg = 0x2fd0,
 691         .halt_bit = 20,
 692         .clkr = {
 693                 .enable_reg = 0x2a4c,
 694                 .enable_mask = BIT(9),
 695                 .hw.init = &(struct clk_init_data){
 696                         .name = "gsbi5_qup_clk",
 697                         .parent_hws = (const struct clk_hw*[]) {
 698                                 &gsbi5_qup_src.clkr.hw,
 699                         },
 700                         .num_parents = 1,
 701                         .ops = &clk_branch_ops,
 702                         .flags = CLK_SET_RATE_PARENT,
 703                 },
 704         },
 705 };
 706
 707 static const struct freq_tbl clk_tbl_gp[] = {
 708         { 9600000, P_CXO,  2, 0, 0 },
 709         { 19200000, P_CXO,  1, 0, 0 },
 710         { }
 711 };
 712
 713 static struct clk_rcg gp0_src = {
 714         .ns_reg = 0x2d24,
 715         .md_reg = 0x2d00,
 716         .mn = {
 717                 .mnctr_en_bit = 8,
 718                 .mnctr_reset_bit = 7,
 719                 .mnctr_mode_shift = 5,
 720                 .n_val_shift = 16,
 721                 .m_val_shift = 16,
 722                 .width = 8,
 723         },
 724         .p = {
 725                 .pre_div_shift = 3,
 726                 .pre_div_width = 2,
 727         },
 728         .s = {
 729                 .src_sel_shift = 0,
 730                 .parent_map = gcc_cxo_map,
 731         },
 732         .freq_tbl = clk_tbl_gp,
 733         .clkr = {
 734                 .enable_reg = 0x2d24,
 735                 .enable_mask = BIT(11),
 736                 .hw.init = &(struct clk_init_data){
 737                         .name = "gp0_src",
 738                         .parent_data = gcc_cxo,
 739                         .num_parents = ARRAY_SIZE(gcc_cxo),
 740                         .ops = &clk_rcg_ops,
 741                         .flags = CLK_SET_PARENT_GATE,
 742                 },
 743         }
 744 };
 745
 746 static struct clk_branch gp0_clk = {
 747         .halt_reg = 0x2fd8,
 748         .halt_bit = 7,
 749         .clkr = {
 750                 .enable_reg = 0x2d24,
 751                 .enable_mask = BIT(9),
 752                 .hw.init = &(struct clk_init_data){
 753                         .name = "gp0_clk",
 754                         .parent_hws = (const struct clk_hw*[]) {
 755                                 &gp0_src.clkr.hw,
 756                         },
 757                         .num_parents = 1,
 758                         .ops = &clk_branch_ops,
 759                         .flags = CLK_SET_RATE_PARENT,
 760                 },
 761         },
 762 };
 763
 764 static struct clk_rcg gp1_src = {
 765         .ns_reg = 0x2d44,
 766         .md_reg = 0x2d40,
 767         .mn = {
 768                 .mnctr_en_bit = 8,
 769                 .mnctr_reset_bit = 7,
 770                 .mnctr_mode_shift = 5,
 771                 .n_val_shift = 16,
 772                 .m_val_shift = 16,
 773                 .width = 8,
 774         },
 775         .p = {
 776                 .pre_div_shift = 3,
 777                 .pre_div_width = 2,
 778         },
 779         .s = {
 780                 .src_sel_shift = 0,
 781                 .parent_map = gcc_cxo_map,
 782         },
 783         .freq_tbl = clk_tbl_gp,
 784         .clkr = {
 785                 .enable_reg = 0x2d44,
 786                 .enable_mask = BIT(11),
 787                 .hw.init = &(struct clk_init_data){
 788                         .name = "gp1_src",
 789                         .parent_data = gcc_cxo,
 790                         .num_parents = ARRAY_SIZE(gcc_cxo),
 791                         .ops = &clk_rcg_ops,
 792                         .flags = CLK_SET_RATE_GATE,
 793                 },
 794         }
 795 };
 796
 797 static struct clk_branch gp1_clk = {
 798         .halt_reg = 0x2fd8,
 799         .halt_bit = 6,
 800         .clkr = {
 801                 .enable_reg = 0x2d44,
 802                 .enable_mask = BIT(9),
 803                 .hw.init = &(struct clk_init_data){
 804                         .name = "gp1_clk",
 805                         .parent_hws = (const struct clk_hw*[]) {
 806                                 &gp1_src.clkr.hw,
 807                         },
 808                         .num_parents = 1,
 809                         .ops = &clk_branch_ops,
 810                         .flags = CLK_SET_RATE_PARENT,
 811                 },
 812         },
 813 };
 814
 815 static struct clk_rcg gp2_src = {
 816         .ns_reg = 0x2d64,
 817         .md_reg = 0x2d60,
 818         .mn = {
 819                 .mnctr_en_bit = 8,
 820                 .mnctr_reset_bit = 7,
 821                 .mnctr_mode_shift = 5,
 822                 .n_val_shift = 16,
 823                 .m_val_shift = 16,
 824                 .width = 8,
 825         },
 826         .p = {
 827                 .pre_div_shift = 3,
 828                 .pre_div_width = 2,
 829         },
 830         .s = {
 831                 .src_sel_shift = 0,
 832                 .parent_map = gcc_cxo_map,
 833         },
 834         .freq_tbl = clk_tbl_gp,
 835         .clkr = {
 836                 .enable_reg = 0x2d64,
 837                 .enable_mask = BIT(11),
 838                 .hw.init = &(struct clk_init_data){
 839                         .name = "gp2_src",
 840                         .parent_data = gcc_cxo,
 841                         .num_parents = ARRAY_SIZE(gcc_cxo),
 842                         .ops = &clk_rcg_ops,
 843                         .flags = CLK_SET_RATE_GATE,
 844                 },
 845         }
 846 };
 847
 848 static struct clk_branch gp2_clk = {
 849         .halt_reg = 0x2fd8,
 850         .halt_bit = 5,
 851         .clkr = {
 852                 .enable_reg = 0x2d64,
 853                 .enable_mask = BIT(9),
 854                 .hw.init = &(struct clk_init_data){
 855                         .name = "gp2_clk",
 856                         .parent_hws = (const struct clk_hw*[]) {
 857                                 &gp2_src.clkr.hw,
 858                         },
 859                         .num_parents = 1,
 860                         .ops = &clk_branch_ops,
 861                         .flags = CLK_SET_RATE_PARENT,
 862                 },
 863         },
 864 };
 865
 866 static struct clk_branch pmem_clk = {
 867         .hwcg_reg = 0x25a0,
 868         .hwcg_bit = 6,
 869         .halt_reg = 0x2fc8,
 870         .halt_bit = 20,
 871         .clkr = {
 872                 .enable_reg = 0x25a0,
 873                 .enable_mask = BIT(4),
 874                 .hw.init = &(struct clk_init_data){
 875                         .name = "pmem_clk",
 876                         .ops = &clk_branch_ops,
 877                 },
 878         },
 879 };
 880
 881 static struct clk_rcg prng_src = {
 882         .ns_reg = 0x2e80,
 883         .p = {
 884                 .pre_div_shift = 3,
 885                 .pre_div_width = 4,
 886         },
 887         .s = {
 888                 .src_sel_shift = 0,
 889                 .parent_map = gcc_cxo_pll8_map,
 890         },
 891         .clkr = {
 892                 .hw.init = &(struct clk_init_data){
 893                         .name = "prng_src",
 894                         .parent_data = gcc_cxo_pll8,
 895                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 896                         .ops = &clk_rcg_ops,
 897                 },
 898         },
 899 };
 900
 901 static struct clk_branch prng_clk = {
 902         .halt_reg = 0x2fd8,
 903         .halt_check = BRANCH_HALT_VOTED,
 904         .halt_bit = 10,
 905         .clkr = {
 906                 .enable_reg = 0x3080,
 907                 .enable_mask = BIT(10),
 908                 .hw.init = &(struct clk_init_data){
 909                         .name = "prng_clk",
 910                         .parent_hws = (const struct clk_hw*[]) {
 911                                 &prng_src.clkr.hw,
 912                         },
 913                         .num_parents = 1,
 914                         .ops = &clk_branch_ops,
 915                 },
 916         },
 917 };
 918
 919 static const struct freq_tbl clk_tbl_sdc[] = {
 920         {    144000, P_CXO,   1, 1, 133 },
 921         {    400000, P_PLL8,  4, 1, 240 },
 922         {  16000000, P_PLL8,  4, 1,   6 },
 923         {  17070000, P_PLL8,  1, 2,  45 },
 924         {  20210000, P_PLL8,  1, 1,  19 },
 925         {  24000000, P_PLL8,  4, 1,   4 },
 926         {  38400000, P_PLL8,  2, 1,   5 },
 927         {  48000000, P_PLL8,  4, 1,   2 },
 928         {  64000000, P_PLL8,  3, 1,   2 },
 929         {  76800000, P_PLL8,  1, 1,   5 },
 930         { }
 931 };
 932
 933 static struct clk_rcg sdc1_src = {
 934         .ns_reg = 0x282c,
 935         .md_reg = 0x2828,
 936         .mn = {
 937                 .mnctr_en_bit = 8,
 938                 .mnctr_reset_bit = 7,
 939                 .mnctr_mode_shift = 5,
 940                 .n_val_shift = 16,
 941                 .m_val_shift = 16,
 942                 .width = 8,
 943         },
 944         .p = {
 945                 .pre_div_shift = 3,
 946                 .pre_div_width = 2,
 947         },
 948         .s = {
 949                 .src_sel_shift = 0,
 950                 .parent_map = gcc_cxo_pll8_map,
 951         },
 952         .freq_tbl = clk_tbl_sdc,
 953         .clkr = {
 954                 .enable_reg = 0x282c,
 955                 .enable_mask = BIT(11),
 956                 .hw.init = &(struct clk_init_data){
 957                         .name = "sdc1_src",
 958                         .parent_data = gcc_cxo_pll8,
 959                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
 960                         .ops = &clk_rcg_ops,
 961                 },
 962         }
 963 };
 964
 965 static struct clk_branch sdc1_clk = {
 966         .halt_reg = 0x2fc8,
 967         .halt_bit = 6,
 968         .clkr = {
 969                 .enable_reg = 0x282c,
 970                 .enable_mask = BIT(9),
 971                 .hw.init = &(struct clk_init_data){
 972                         .name = "sdc1_clk",
 973                         .parent_hws = (const struct clk_hw*[]) {
 974                                 &sdc1_src.clkr.hw,
 975                         },
 976                         .num_parents = 1,
 977                         .ops = &clk_branch_ops,
 978                         .flags = CLK_SET_RATE_PARENT,
 979                 },
 980         },
 981 };
 982
 983 static struct clk_rcg sdc2_src = {
 984         .ns_reg = 0x284c,
 985         .md_reg = 0x2848,
 986         .mn = {
 987                 .mnctr_en_bit = 8,
 988                 .mnctr_reset_bit = 7,
 989                 .mnctr_mode_shift = 5,
 990                 .n_val_shift = 16,
 991                 .m_val_shift = 16,
 992                 .width = 8,
 993         },
 994         .p = {
 995                 .pre_div_shift = 3,
 996                 .pre_div_width = 2,
 997         },
 998         .s = {
 999                 .src_sel_shift = 0,
1000                 .parent_map = gcc_cxo_pll8_map,
1001         },
1002         .freq_tbl = clk_tbl_sdc,
1003         .clkr = {
1004                 .enable_reg = 0x284c,
1005                 .enable_mask = BIT(11),
1006                 .hw.init = &(struct clk_init_data){
1007                         .name = "sdc2_src",
1008                         .parent_data = gcc_cxo_pll8,
1009                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
1010                         .ops = &clk_rcg_ops,
1011                 },
1012         }
1013 };
1014
1015 static struct clk_branch sdc2_clk = {
1016         .halt_reg = 0x2fc8,
1017         .halt_bit = 5,
1018         .clkr = {
1019                 .enable_reg = 0x284c,
1020                 .enable_mask = BIT(9),
1021                 .hw.init = &(struct clk_init_data){
1022                         .name = "sdc2_clk",
1023                         .parent_hws = (const struct clk_hw*[]) {
1024                                 &sdc2_src.clkr.hw,
1025                         },
1026                         .num_parents = 1,
1027                         .ops = &clk_branch_ops,
1028                         .flags = CLK_SET_RATE_PARENT,
1029                 },
1030         },
1031 };
1032
1033 static const struct freq_tbl clk_tbl_usb[] = {
1034         { 60000000, P_PLL8, 1, 5, 32 },
1035         { }
1036 };
1037
1038 static struct clk_rcg usb_hs1_xcvr_src = {
1039         .ns_reg = 0x290c,
1040         .md_reg = 0x2908,
1041         .mn = {
1042                 .mnctr_en_bit = 8,
1043                 .mnctr_reset_bit = 7,
1044                 .mnctr_mode_shift = 5,
1045                 .n_val_shift = 16,
1046                 .m_val_shift = 16,
1047                 .width = 8,
1048         },
1049         .p = {
1050                 .pre_div_shift = 3,
1051                 .pre_div_width = 2,
1052         },
1053         .s = {
1054                 .src_sel_shift = 0,
1055                 .parent_map = gcc_cxo_pll8_map,
1056         },
1057         .freq_tbl = clk_tbl_usb,
1058         .clkr = {
1059                 .enable_reg = 0x290c,
1060                 .enable_mask = BIT(11),
1061                 .hw.init = &(struct clk_init_data){
1062                         .name = "usb_hs1_xcvr_src",
1063                         .parent_data = gcc_cxo_pll8,
1064                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
1065                         .ops = &clk_rcg_ops,
1066                         .flags = CLK_SET_RATE_GATE,
1067                 },
1068         }
1069 };
1070
1071 static struct clk_branch usb_hs1_xcvr_clk = {
1072         .halt_reg = 0x2fc8,
1073         .halt_bit = 0,
1074         .clkr = {
1075                 .enable_reg = 0x290c,
1076                 .enable_mask = BIT(9),
1077                 .hw.init = &(struct clk_init_data){
1078                         .name = "usb_hs1_xcvr_clk",
1079                         .parent_hws = (const struct clk_hw*[]) {
1080                                 &usb_hs1_xcvr_src.clkr.hw,
1081                         },
1082                         .num_parents = 1,
1083                         .ops = &clk_branch_ops,
1084                         .flags = CLK_SET_RATE_PARENT,
1085                 },
1086         },
1087 };
1088
1089 static struct clk_rcg usb_hsic_xcvr_fs_src = {
1090         .ns_reg = 0x2928,
1091         .md_reg = 0x2924,
1092         .mn = {
1093                 .mnctr_en_bit = 8,
1094                 .mnctr_reset_bit = 7,
1095                 .mnctr_mode_shift = 5,
1096                 .n_val_shift = 16,
1097                 .m_val_shift = 16,
1098                 .width = 8,
1099         },
1100         .p = {
1101                 .pre_div_shift = 3,
1102                 .pre_div_width = 2,
1103         },
1104         .s = {
1105                 .src_sel_shift = 0,
1106                 .parent_map = gcc_cxo_pll8_map,
1107         },
1108         .freq_tbl = clk_tbl_usb,
1109         .clkr = {
1110                 .enable_reg = 0x2928,
1111                 .enable_mask = BIT(11),
1112                 .hw.init = &(struct clk_init_data){
1113                         .name = "usb_hsic_xcvr_fs_src",
1114                         .parent_data = gcc_cxo_pll8,
1115                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
1116                         .ops = &clk_rcg_ops,
1117                         .flags = CLK_SET_RATE_GATE,
1118                 },
1119         }
1120 };
1121
1122 static struct clk_branch usb_hsic_xcvr_fs_clk = {
1123         .halt_reg = 0x2fc8,
1124         .halt_bit = 9,
1125         .clkr = {
1126                 .enable_reg = 0x2928,
1127                 .enable_mask = BIT(9),
1128                 .hw.init = &(struct clk_init_data){
1129                         .name = "usb_hsic_xcvr_fs_clk",
1130                         .parent_hws = (const struct clk_hw*[]) {
1131                                 &usb_hsic_xcvr_fs_src.clkr.hw,
1132                         },
1133                         .num_parents = 1,
1134                         .ops = &clk_branch_ops,
1135                         .flags = CLK_SET_RATE_PARENT,
1136                 },
1137         },
1138 };
1139
1140 static const struct freq_tbl clk_tbl_usb_hs1_system[] = {
1141         { 60000000, P_PLL8, 1, 5, 32 },
1142         { }
1143 };
1144
1145 static struct clk_rcg usb_hs1_system_src = {
1146         .ns_reg = 0x36a4,
1147         .md_reg = 0x36a0,
1148         .mn = {
1149                 .mnctr_en_bit = 8,
1150                 .mnctr_reset_bit = 7,
1151                 .mnctr_mode_shift = 5,
1152                 .n_val_shift = 16,
1153                 .m_val_shift = 16,
1154                 .width = 8,
1155         },
1156         .p = {
1157                 .pre_div_shift = 3,
1158                 .pre_div_width = 2,
1159         },
1160         .s = {
1161                 .src_sel_shift = 0,
1162                 .parent_map = gcc_cxo_pll8_map,
1163         },
1164         .freq_tbl = clk_tbl_usb_hs1_system,
1165         .clkr = {
1166                 .enable_reg = 0x36a4,
1167                 .enable_mask = BIT(11),
1168                 .hw.init = &(struct clk_init_data){
1169                         .name = "usb_hs1_system_src",
1170                         .parent_data = gcc_cxo_pll8,
1171                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
1172                         .ops = &clk_rcg_ops,
1173                         .flags = CLK_SET_RATE_GATE,
1174                 },
1175         }
1176 };
1177
1178 static struct clk_branch usb_hs1_system_clk = {
1179         .halt_reg = 0x2fc8,
1180         .halt_bit = 4,
1181         .clkr = {
1182                 .enable_reg = 0x36a4,
1183                 .enable_mask = BIT(9),
1184                 .hw.init = &(struct clk_init_data){
1185                         .parent_hws = (const struct clk_hw*[]) {
1186                                 &usb_hs1_system_src.clkr.hw,
1187                         },
1188                         .num_parents = 1,
1189                         .name = "usb_hs1_system_clk",
1190                         .ops = &clk_branch_ops,
1191                         .flags = CLK_SET_RATE_PARENT | CLK_IGNORE_UNUSED,
1192                 },
1193         },
1194 };
1195
1196 static const struct freq_tbl clk_tbl_usb_hsic_system[] = {
1197         { 64000000, P_PLL8, 1, 1, 6 },
1198         { }
1199 };
1200
1201 static struct clk_rcg usb_hsic_system_src = {
1202         .ns_reg = 0x2b58,
1203         .md_reg = 0x2b54,
1204         .mn = {
1205                 .mnctr_en_bit = 8,
1206                 .mnctr_reset_bit = 7,
1207                 .mnctr_mode_shift = 5,
1208                 .n_val_shift = 16,
1209                 .m_val_shift = 16,
1210                 .width = 8,
1211         },
1212         .p = {
1213                 .pre_div_shift = 3,
1214                 .pre_div_width = 2,
1215         },
1216         .s = {
1217                 .src_sel_shift = 0,
1218                 .parent_map = gcc_cxo_pll8_map,
1219         },
1220         .freq_tbl = clk_tbl_usb_hsic_system,
1221         .clkr = {
1222                 .enable_reg = 0x2b58,
1223                 .enable_mask = BIT(11),
1224                 .hw.init = &(struct clk_init_data){
1225                         .name = "usb_hsic_system_src",
1226                         .parent_data = gcc_cxo_pll8,
1227                         .num_parents = ARRAY_SIZE(gcc_cxo_pll8),
1228                         .ops = &clk_rcg_ops,
1229                         .flags = CLK_SET_RATE_GATE,
1230                 },
1231         }
1232 };
1233
1234 static struct clk_branch usb_hsic_system_clk = {
1235         .halt_reg = 0x2fc8,
1236         .halt_bit = 7,
1237         .clkr = {
1238                 .enable_reg = 0x2b58,
1239                 .enable_mask = BIT(9),
1240                 .hw.init = &(struct clk_init_data){
1241                         .parent_hws = (const struct clk_hw*[]) {
1242                                 &usb_hsic_system_src.clkr.hw,
1243                         },
1244                         .num_parents = 1,
1245                         .name = "usb_hsic_system_clk",
1246                         .ops = &clk_branch_ops,
1247                         .flags = CLK_SET_RATE_PARENT,
1248                 },
1249         },
1250 };
1251
1252 static const struct freq_tbl clk_tbl_usb_hsic_hsic[] = {
1253         { 48000000, P_PLL14, 1, 0, 0 },
1254         { }
1255 };
1256
1257 static struct clk_rcg usb_hsic_hsic_src = {
1258         .ns_reg = 0x2b50,
1259         .md_reg = 0x2b4c,
1260         .mn = {
1261                 .mnctr_en_bit = 8,
1262                 .mnctr_reset_bit = 7,
1263                 .mnctr_mode_shift = 5,
1264                 .n_val_shift = 16,
1265                 .m_val_shift = 16,
1266                 .width = 8,
1267         },
1268         .p = {
1269                 .pre_div_shift = 3,
1270                 .pre_div_width = 2,
1271         },
1272         .s = {
1273                 .src_sel_shift = 0,
1274                 .parent_map = gcc_cxo_pll14_map,
1275         },
1276         .freq_tbl = clk_tbl_usb_hsic_hsic,
1277         .clkr = {
1278                 .enable_reg = 0x2b50,
1279                 .enable_mask = BIT(11),
1280                 .hw.init = &(struct clk_init_data){
1281                         .name = "usb_hsic_hsic_src",
1282                         .parent_data = gcc_cxo_pll14,
1283                         .num_parents = ARRAY_SIZE(gcc_cxo_pll14),
1284                         .ops = &clk_rcg_ops,
1285                         .flags = CLK_SET_RATE_GATE,
1286                 },
1287         }
1288 };
1289
1290 static struct clk_branch usb_hsic_hsic_clk = {
1291         .halt_check = BRANCH_HALT_DELAY,
1292         .clkr = {
1293                 .enable_reg = 0x2b50,
1294                 .enable_mask = BIT(9),
1295                 .hw.init = &(struct clk_init_data){
1296                         .parent_hws = (const struct clk_hw*[]) {
1297                                 &usb_hsic_hsic_src.clkr.hw,
1298                         },
1299                         .num_parents = 1,
1300                         .name = "usb_hsic_hsic_clk",
1301                         .ops = &clk_branch_ops,
1302                         .flags = CLK_SET_RATE_PARENT,
1303                 },
1304         },
1305 };
1306
1307 static struct clk_branch usb_hsic_hsio_cal_clk = {
1308         .halt_reg = 0x2fc8,
1309         .halt_bit = 8,
1310         .clkr = {
1311                 .enable_reg = 0x2b48,
1312                 .enable_mask = BIT(0),
1313                 .hw.init = &(struct clk_init_data){
1314                         .parent_data = gcc_cxo,
1315                         .num_parents = ARRAY_SIZE(gcc_cxo),
1316                         .name = "usb_hsic_hsio_cal_clk",
1317                         .ops = &clk_branch_ops,
1318                 },
1319         },
1320 };
1321
1322 static struct clk_branch ce1_core_clk = {
1323         .hwcg_reg = 0x2724,
1324         .hwcg_bit = 6,
1325         .halt_reg = 0x2fd4,
1326         .halt_bit = 27,
1327         .clkr = {
1328                 .enable_reg = 0x2724,
1329                 .enable_mask = BIT(4),
1330                 .hw.init = &(struct clk_init_data){
1331                         .name = "ce1_core_clk",
1332                         .ops = &clk_branch_ops,
1333                 },
1334         },
1335 };
1336
1337 static struct clk_branch ce1_h_clk = {
1338         .halt_reg = 0x2fd4,
1339         .halt_bit = 1,
1340         .clkr = {
1341                 .enable_reg = 0x2720,
1342                 .enable_mask = BIT(4),
1343                 .hw.init = &(struct clk_init_data){
1344                         .name = "ce1_h_clk",
1345                         .ops = &clk_branch_ops,
1346                 },
1347         },
1348 };
1349
1350 static struct clk_branch dma_bam_h_clk = {
1351         .hwcg_reg = 0x25c0,
1352         .hwcg_bit = 6,
1353         .halt_reg = 0x2fc8,
1354         .halt_bit = 12,
1355         .clkr = {
1356                 .enable_reg = 0x25c0,
1357                 .enable_mask = BIT(4),
1358                 .hw.init = &(struct clk_init_data){
1359                         .name = "dma_bam_h_clk",
1360                         .ops = &clk_branch_ops,
1361                 },
1362         },
1363 };
1364
1365 static struct clk_branch gsbi1_h_clk = {
1366         .hwcg_reg = 0x29c0,
1367         .hwcg_bit = 6,
1368         .halt_reg = 0x2fcc,
1369         .halt_bit = 11,
1370         .clkr = {
1371                 .enable_reg = 0x29c0,
1372                 .enable_mask = BIT(4),
1373                 .hw.init = &(struct clk_init_data){
1374                         .name = "gsbi1_h_clk",
1375                         .ops = &clk_branch_ops,
1376                 },
1377         },
1378 };
1379
1380 static struct clk_branch gsbi2_h_clk = {
1381         .hwcg_reg = 0x29e0,
1382         .hwcg_bit = 6,
1383         .halt_reg = 0x2fcc,
1384         .halt_bit = 7,
1385         .clkr = {
1386                 .enable_reg = 0x29e0,
1387                 .enable_mask = BIT(4),
1388                 .hw.init = &(struct clk_init_data){
1389                         .name = "gsbi2_h_clk",
1390                         .ops = &clk_branch_ops,
1391                 },
1392         },
1393 };
1394
1395 static struct clk_branch gsbi3_h_clk = {
1396         .hwcg_reg = 0x2a00,
1397         .hwcg_bit = 6,
1398         .halt_reg = 0x2fcc,
1399         .halt_bit = 3,
1400         .clkr = {
1401                 .enable_reg = 0x2a00,
1402                 .enable_mask = BIT(4),
1403                 .hw.init = &(struct clk_init_data){
1404                         .name = "gsbi3_h_clk",
1405                         .ops = &clk_branch_ops,
1406                 },
1407         },
1408 };
1409
1410 static struct clk_branch gsbi4_h_clk = {
1411         .hwcg_reg = 0x2a20,
1412         .hwcg_bit = 6,
1413         .halt_reg = 0x2fd0,
1414         .halt_bit = 27,
1415         .clkr = {
1416                 .enable_reg = 0x2a20,
1417                 .enable_mask = BIT(4),
1418                 .hw.init = &(struct clk_init_data){
1419                         .name = "gsbi4_h_clk",
1420                         .ops = &clk_branch_ops,
1421                 },
1422         },
1423 };
1424
1425 static struct clk_branch gsbi5_h_clk = {
1426         .hwcg_reg = 0x2a40,
1427         .hwcg_bit = 6,
1428         .halt_reg = 0x2fd0,
1429         .halt_bit = 23,
1430         .clkr = {
1431                 .enable_reg = 0x2a40,
1432                 .enable_mask = BIT(4),
1433                 .hw.init = &(struct clk_init_data){
1434                         .name = "gsbi5_h_clk",
1435                         .ops = &clk_branch_ops,
1436                 },
1437         },
1438 };
1439
1440 static struct clk_branch usb_hs1_h_clk = {
1441         .hwcg_reg = 0x2900,
1442         .hwcg_bit = 6,
1443         .halt_reg = 0x2fc8,
1444         .halt_bit = 1,
1445         .clkr = {
1446                 .enable_reg = 0x2900,
1447                 .enable_mask = BIT(4),
1448                 .hw.init = &(struct clk_init_data){
1449                         .name = "usb_hs1_h_clk",
1450                         .ops = &clk_branch_ops,
1451                 },
1452         },
1453 };
1454
1455 static struct clk_branch usb_hsic_h_clk = {
1456         .halt_reg = 0x2fcc,
1457         .halt_bit = 28,
1458         .clkr = {
1459                 .enable_reg = 0x2920,
1460                 .enable_mask = BIT(4),
1461                 .hw.init = &(struct clk_init_data){
1462                         .name = "usb_hsic_h_clk",
1463                         .ops = &clk_branch_ops,
1464                 },
1465         },
1466 };
1467
1468 static struct clk_branch sdc1_h_clk = {
1469         .hwcg_reg = 0x2820,
1470         .hwcg_bit = 6,
1471         .halt_reg = 0x2fc8,
1472         .halt_bit = 11,
1473         .clkr = {
1474                 .enable_reg = 0x2820,
1475                 .enable_mask = BIT(4),
1476                 .hw.init = &(struct clk_init_data){
1477                         .name = "sdc1_h_clk",
1478                         .ops = &clk_branch_ops,
1479                 },
1480         },
1481 };
1482
1483 static struct clk_branch sdc2_h_clk = {
1484         .hwcg_reg = 0x2840,
1485         .hwcg_bit = 6,
1486         .halt_reg = 0x2fc8,
1487         .halt_bit = 10,
1488         .clkr = {
1489                 .enable_reg = 0x2840,
1490                 .enable_mask = BIT(4),
1491                 .hw.init = &(struct clk_init_data){
1492                         .name = "sdc2_h_clk",
1493                         .ops = &clk_branch_ops,
1494                 },
1495         },
1496 };
1497
1498 static struct clk_branch adm0_clk = {
1499         .halt_reg = 0x2fdc,
1500         .halt_check = BRANCH_HALT_VOTED,
1501         .halt_bit = 14,
1502         .clkr = {
1503                 .enable_reg = 0x3080,
1504                 .enable_mask = BIT(2),
1505                 .hw.init = &(struct clk_init_data){
1506                         .name = "adm0_clk",
1507                         .ops = &clk_branch_ops,
1508                 },
1509         },
1510 };
1511
1512 static struct clk_branch adm0_pbus_clk = {
1513         .hwcg_reg = 0x2208,
1514         .hwcg_bit = 6,
1515         .halt_reg = 0x2fdc,
1516         .halt_check = BRANCH_HALT_VOTED,
1517         .halt_bit = 13,
1518         .clkr = {
1519                 .enable_reg = 0x3080,
1520                 .enable_mask = BIT(3),
1521                 .hw.init = &(struct clk_init_data){
1522                         .name = "adm0_pbus_clk",
1523                         .ops = &clk_branch_ops,
1524                 },
1525         },
1526 };
1527
1528 static struct clk_branch pmic_arb0_h_clk = {
1529         .halt_reg = 0x2fd8,
1530         .halt_check = BRANCH_HALT_VOTED,
1531         .halt_bit = 22,
1532         .clkr = {
1533                 .enable_reg = 0x3080,
1534                 .enable_mask = BIT(8),
1535                 .hw.init = &(struct clk_init_data){
1536                         .name = "pmic_arb0_h_clk",
1537                         .ops = &clk_branch_ops,
1538                 },
1539         },
1540 };
1541
1542 static struct clk_branch pmic_arb1_h_clk = {
1543         .halt_reg = 0x2fd8,
1544         .halt_check = BRANCH_HALT_VOTED,
1545         .halt_bit = 21,
1546         .clkr = {
1547                 .enable_reg = 0x3080,
1548                 .enable_mask = BIT(9),
1549                 .hw.init = &(struct clk_init_data){
1550                         .name = "pmic_arb1_h_clk",
1551                         .ops = &clk_branch_ops,
1552                 },
1553         },
1554 };
1555
1556 static struct clk_branch pmic_ssbi2_clk = {
1557         .halt_reg = 0x2fd8,
1558         .halt_check = BRANCH_HALT_VOTED,
1559         .halt_bit = 23,
1560         .clkr = {
1561                 .enable_reg = 0x3080,
1562                 .enable_mask = BIT(7),
1563                 .hw.init = &(struct clk_init_data){
1564                         .name = "pmic_ssbi2_clk",
1565                         .ops = &clk_branch_ops,
1566                 },
1567         },
1568 };
1569
1570 static struct clk_branch rpm_msg_ram_h_clk = {
1571         .hwcg_reg = 0x27e0,
1572         .hwcg_bit = 6,
1573         .halt_reg = 0x2fd8,
1574         .halt_check = BRANCH_HALT_VOTED,
1575         .halt_bit = 12,
1576         .clkr = {
1577                 .enable_reg = 0x3080,
1578                 .enable_mask = BIT(6),
1579                 .hw.init = &(struct clk_init_data){
1580                         .name = "rpm_msg_ram_h_clk",
1581                         .ops = &clk_branch_ops,
1582                 },
1583         },
1584 };
1585
1586 static struct clk_branch ebi2_clk = {
1587         .hwcg_reg = 0x2664,
1588         .hwcg_bit = 6,
1589         .halt_reg = 0x2fcc,
1590         .halt_bit = 24,
1591         .clkr = {
1592                 .enable_reg = 0x2664,
1593                 .enable_mask = BIT(6) | BIT(4),
1594                 .hw.init = &(struct clk_init_data){
1595                         .name = "ebi2_clk",
1596                         .ops = &clk_branch_ops,
1597                 },
1598         },
1599 };
1600
1601 static struct clk_branch ebi2_aon_clk = {
1602         .halt_reg = 0x2fcc,
1603         .halt_bit = 23,
1604         .clkr = {
1605                 .enable_reg = 0x2664,
1606                 .enable_mask = BIT(8),
1607                 .hw.init = &(struct clk_init_data){
1608                         .name = "ebi2_aon_clk",
1609                         .ops = &clk_branch_ops,
1610                 },
1611         },
1612 };
1613
1614 static struct clk_regmap *gcc_mdm9615_clks[] = {
1615         [PLL0] = &pll0.clkr,
1616         [PLL0_VOTE] = &pll0_vote,
1617         [PLL4_VOTE] = &pll4_vote,
1618         [PLL8] = &pll8.clkr,
1619         [PLL8_VOTE] = &pll8_vote,
1620         [PLL14] = &pll14.clkr,
1621         [PLL14_VOTE] = &pll14_vote,
1622         [GSBI1_UART_SRC] = &gsbi1_uart_src.clkr,
1623         [GSBI1_UART_CLK] = &gsbi1_uart_clk.clkr,
1624         [GSBI2_UART_SRC] = &gsbi2_uart_src.clkr,
1625         [GSBI2_UART_CLK] = &gsbi2_uart_clk.clkr,
1626         [GSBI3_UART_SRC] = &gsbi3_uart_src.clkr,
1627         [GSBI3_UART_CLK] = &gsbi3_uart_clk.clkr,
1628         [GSBI4_UART_SRC] = &gsbi4_uart_src.clkr,
1629         [GSBI4_UART_CLK] = &gsbi4_uart_clk.clkr,
1630         [GSBI5_UART_SRC] = &gsbi5_uart_src.clkr,
1631         [GSBI5_UART_CLK] = &gsbi5_uart_clk.clkr,
1632         [GSBI1_QUP_SRC] = &gsbi1_qup_src.clkr,
1633         [GSBI1_QUP_CLK] = &gsbi1_qup_clk.clkr,
1634         [GSBI2_QUP_SRC] = &gsbi2_qup_src.clkr,
1635         [GSBI2_QUP_CLK] = &gsbi2_qup_clk.clkr,
1636         [GSBI3_QUP_SRC] = &gsbi3_qup_src.clkr,
1637         [GSBI3_QUP_CLK] = &gsbi3_qup_clk.clkr,
1638         [GSBI4_QUP_SRC] = &gsbi4_qup_src.clkr,
1639         [GSBI4_QUP_CLK] = &gsbi4_qup_clk.clkr,
1640         [GSBI5_QUP_SRC] = &gsbi5_qup_src.clkr,
1641         [GSBI5_QUP_CLK] = &gsbi5_qup_clk.clkr,
1642         [GP0_SRC] = &gp0_src.clkr,
1643         [GP0_CLK] = &gp0_clk.clkr,
1644         [GP1_SRC] = &gp1_src.clkr,
1645         [GP1_CLK] = &gp1_clk.clkr,
1646         [GP2_SRC] = &gp2_src.clkr,
1647         [GP2_CLK] = &gp2_clk.clkr,
1648         [PMEM_A_CLK] = &pmem_clk.clkr,
1649         [PRNG_SRC] = &prng_src.clkr,
1650         [PRNG_CLK] = &prng_clk.clkr,
1651         [SDC1_SRC] = &sdc1_src.clkr,
1652         [SDC1_CLK] = &sdc1_clk.clkr,
1653         [SDC2_SRC] = &sdc2_src.clkr,
1654         [SDC2_CLK] = &sdc2_clk.clkr,
1655         [USB_HS1_XCVR_SRC] = &usb_hs1_xcvr_src.clkr,
1656         [USB_HS1_XCVR_CLK] = &usb_hs1_xcvr_clk.clkr,
1657         [USB_HS1_SYSTEM_CLK_SRC] = &usb_hs1_system_src.clkr,
1658         [USB_HS1_SYSTEM_CLK] = &usb_hs1_system_clk.clkr,
1659         [USB_HSIC_XCVR_FS_SRC] = &usb_hsic_xcvr_fs_src.clkr,
1660         [USB_HSIC_XCVR_FS_CLK] = &usb_hsic_xcvr_fs_clk.clkr,
1661         [USB_HSIC_SYSTEM_CLK_SRC] = &usb_hsic_system_src.clkr,
1662         [USB_HSIC_SYSTEM_CLK] = &usb_hsic_system_clk.clkr,
1663         [USB_HSIC_HSIC_CLK_SRC] = &usb_hsic_hsic_src.clkr,
1664         [USB_HSIC_HSIC_CLK] = &usb_hsic_hsic_clk.clkr,
1665         [USB_HSIC_HSIO_CAL_CLK] = &usb_hsic_hsio_cal_clk.clkr,
1666         [CE1_CORE_CLK] = &ce1_core_clk.clkr,
1667         [CE1_H_CLK] = &ce1_h_clk.clkr,
1668         [DMA_BAM_H_CLK] = &dma_bam_h_clk.clkr,
1669         [GSBI1_H_CLK] = &gsbi1_h_clk.clkr,
1670         [GSBI2_H_CLK] = &gsbi2_h_clk.clkr,
1671         [GSBI3_H_CLK] = &gsbi3_h_clk.clkr,
1672         [GSBI4_H_CLK] = &gsbi4_h_clk.clkr,
1673         [GSBI5_H_CLK] = &gsbi5_h_clk.clkr,
1674         [USB_HS1_H_CLK] = &usb_hs1_h_clk.clkr,
1675         [USB_HSIC_H_CLK] = &usb_hsic_h_clk.clkr,
1676         [SDC1_H_CLK] = &sdc1_h_clk.clkr,
1677         [SDC2_H_CLK] = &sdc2_h_clk.clkr,
1678         [ADM0_CLK] = &adm0_clk.clkr,
1679         [ADM0_PBUS_CLK] = &adm0_pbus_clk.clkr,
1680         [PMIC_ARB0_H_CLK] = &pmic_arb0_h_clk.clkr,
1681         [PMIC_ARB1_H_CLK] = &pmic_arb1_h_clk.clkr,
1682         [PMIC_SSBI2_CLK] = &pmic_ssbi2_clk.clkr,
1683         [RPM_MSG_RAM_H_CLK] = &rpm_msg_ram_h_clk.clkr,
1684         [EBI2_CLK] = &ebi2_clk.clkr,
1685         [EBI2_AON_CLK] = &ebi2_aon_clk.clkr,
1686 };
1687
1688 static const struct qcom_reset_map gcc_mdm9615_resets[] = {
1689         [DMA_BAM_RESET] = { 0x25c0, 7 },
1690         [CE1_H_RESET] = { 0x2720, 7 },
1691         [CE1_CORE_RESET] = { 0x2724, 7 },
1692         [SDC1_RESET] = { 0x2830 },
1693         [SDC2_RESET] = { 0x2850 },
1694         [ADM0_C2_RESET] = { 0x220c, 4 },
1695         [ADM0_C1_RESET] = { 0x220c, 3 },
1696         [ADM0_C0_RESET] = { 0x220c, 2 },
1697         [ADM0_PBUS_RESET] = { 0x220c, 1 },
1698         [ADM0_RESET] = { 0x220c },
1699         [USB_HS1_RESET] = { 0x2910 },
1700         [USB_HSIC_RESET] = { 0x2934 },
1701         [GSBI1_RESET] = { 0x29dc },
1702         [GSBI2_RESET] = { 0x29fc },
1703         [GSBI3_RESET] = { 0x2a1c },
1704         [GSBI4_RESET] = { 0x2a3c },
1705         [GSBI5_RESET] = { 0x2a5c },
1706         [PDM_RESET] = { 0x2CC0, 12 },
1707 };
1708
1709 static const struct regmap_config gcc_mdm9615_regmap_config = {
1710         .reg_bits       = 32,
1711         .reg_stride     = 4,
1712         .val_bits       = 32,
1713         .max_register   = 0x3660,
1714         .fast_io        = true,
1715 };
1716
1717 static const struct qcom_cc_desc gcc_mdm9615_desc = {
1718         .config = &gcc_mdm9615_regmap_config,
1719         .clks = gcc_mdm9615_clks,
1720         .num_clks = ARRAY_SIZE(gcc_mdm9615_clks),
1721         .resets = gcc_mdm9615_resets,
1722         .num_resets = ARRAY_SIZE(gcc_mdm9615_resets),
1723 };
1724
1725 static const struct of_device_id gcc_mdm9615_match_table[] = {
1726         { .compatible = "qcom,gcc-mdm9615" },
1727         { }
1728 };
1729 MODULE_DEVICE_TABLE(of, gcc_mdm9615_match_table);
1730
1731 static int gcc_mdm9615_probe(struct platform_device *pdev)
1732 {
1733         struct regmap *regmap;
1734
1735         regmap = qcom_cc_map(pdev, &gcc_mdm9615_desc);
1736         if (IS_ERR(regmap))
1737                 return PTR_ERR(regmap);
1738
1739         return qcom_cc_really_probe(&pdev->dev, &gcc_mdm9615_desc, regmap);
1740 }
1741
1742 static struct platform_driver gcc_mdm9615_driver = {
1743         .probe          = gcc_mdm9615_probe,
1744         .driver         = {
1745                 .name   = "gcc-mdm9615",
1746                 .of_match_table = gcc_mdm9615_match_table,
1747         },
1748 };
1749
1750 static int __init gcc_mdm9615_init(void)
1751 {
1752         return platform_driver_register(&gcc_mdm9615_driver);
1753 }
1754 core_initcall(gcc_mdm9615_init);
1755
1756 static void __exit gcc_mdm9615_exit(void)
1757 {
1758         platform_driver_unregister(&gcc_mdm9615_driver);
1759 }
1760 module_exit(gcc_mdm9615_exit);
1761
1762 MODULE_DESCRIPTION("QCOM GCC MDM9615 Driver");
1763 MODULE_LICENSE("GPL v2");
1764 MODULE_ALIAS("platform:gcc-mdm9615");