drivers/clk/qcom/mmcc-msm8974.c

   1 /*
   2  * Copyright (c) 2013, The Linux Foundation. All rights reserved.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/bitops.h>
  16 #include <linux/err.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/of_device.h>
  21 #include <linux/clk-provider.h>
  22 #include <linux/regmap.h>
  23 #include <linux/reset-controller.h>
  24
  25 #include <dt-bindings/clock/qcom,mmcc-msm8974.h>
  26 #include <dt-bindings/reset/qcom,mmcc-msm8974.h>
  27
  28 #include "common.h"
  29 #include "clk-regmap.h"
  30 #include "clk-pll.h"
  31 #include "clk-rcg.h"
  32 #include "clk-branch.h"
  33 #include "reset.h"
  34 #include "gdsc.h"
  35
  36 enum {
  37         P_XO,
  38         P_MMPLL0,
  39         P_EDPLINK,
  40         P_MMPLL1,
  41         P_HDMIPLL,
  42         P_GPLL0,
  43         P_EDPVCO,
  44         P_GPLL1,
  45         P_DSI0PLL,
  46         P_DSI0PLL_BYTE,
  47         P_MMPLL2,
  48         P_MMPLL3,
  49         P_DSI1PLL,
  50         P_DSI1PLL_BYTE,
  51 };
  52
  53 static const struct parent_map mmcc_xo_mmpll0_mmpll1_gpll0_map[] = {
  54         { P_XO, 0 },
  55         { P_MMPLL0, 1 },
  56         { P_MMPLL1, 2 },
  57         { P_GPLL0, 5 }
  58 };
  59
  60 static const char * const mmcc_xo_mmpll0_mmpll1_gpll0[] = {
  61         "xo",
  62         "mmpll0_vote",
  63         "mmpll1_vote",
  64         "mmss_gpll0_vote",
  65 };
  66
  67 static const struct parent_map mmcc_xo_mmpll0_dsi_hdmi_gpll0_map[] = {
  68         { P_XO, 0 },
  69         { P_MMPLL0, 1 },
  70         { P_HDMIPLL, 4 },
  71         { P_GPLL0, 5 },
  72         { P_DSI0PLL, 2 },
  73         { P_DSI1PLL, 3 }
  74 };
  75
  76 static const char * const mmcc_xo_mmpll0_dsi_hdmi_gpll0[] = {
  77         "xo",
  78         "mmpll0_vote",
  79         "hdmipll",
  80         "mmss_gpll0_vote",
  81         "dsi0pll",
  82         "dsi1pll",
  83 };
  84
  85 static const struct parent_map mmcc_xo_mmpll0_1_2_gpll0_map[] = {
  86         { P_XO, 0 },
  87         { P_MMPLL0, 1 },
  88         { P_MMPLL1, 2 },
  89         { P_GPLL0, 5 },
  90         { P_MMPLL2, 3 }
  91 };
  92
  93 static const char * const mmcc_xo_mmpll0_1_2_gpll0[] = {
  94         "xo",
  95         "mmpll0_vote",
  96         "mmpll1_vote",
  97         "mmss_gpll0_vote",
  98         "mmpll2",
  99 };
 100
 101 static const struct parent_map mmcc_xo_mmpll0_1_3_gpll0_map[] = {
 102         { P_XO, 0 },
 103         { P_MMPLL0, 1 },
 104         { P_MMPLL1, 2 },
 105         { P_GPLL0, 5 },
 106         { P_MMPLL3, 3 }
 107 };
 108
 109 static const char * const mmcc_xo_mmpll0_1_3_gpll0[] = {
 110         "xo",
 111         "mmpll0_vote",
 112         "mmpll1_vote",
 113         "mmss_gpll0_vote",
 114         "mmpll3",
 115 };
 116
 117 static const struct parent_map mmcc_xo_mmpll0_1_gpll1_0_map[] = {
 118         { P_XO, 0 },
 119         { P_MMPLL0, 1 },
 120         { P_MMPLL1, 2 },
 121         { P_GPLL0, 5 },
 122         { P_GPLL1, 4 }
 123 };
 124
 125 static const char * const mmcc_xo_mmpll0_1_gpll1_0[] = {
 126         "xo",
 127         "mmpll0_vote",
 128         "mmpll1_vote",
 129         "mmss_gpll0_vote",
 130         "gpll1_vote",
 131 };
 132
 133 static const struct parent_map mmcc_xo_dsi_hdmi_edp_map[] = {
 134         { P_XO, 0 },
 135         { P_EDPLINK, 4 },
 136         { P_HDMIPLL, 3 },
 137         { P_EDPVCO, 5 },
 138         { P_DSI0PLL, 1 },
 139         { P_DSI1PLL, 2 }
 140 };
 141
 142 static const char * const mmcc_xo_dsi_hdmi_edp[] = {
 143         "xo",
 144         "edp_link_clk",
 145         "hdmipll",
 146         "edp_vco_div",
 147         "dsi0pll",
 148         "dsi1pll",
 149 };
 150
 151 static const struct parent_map mmcc_xo_dsi_hdmi_edp_gpll0_map[] = {
 152         { P_XO, 0 },
 153         { P_EDPLINK, 4 },
 154         { P_HDMIPLL, 3 },
 155         { P_GPLL0, 5 },
 156         { P_DSI0PLL, 1 },
 157         { P_DSI1PLL, 2 }
 158 };
 159
 160 static const char * const mmcc_xo_dsi_hdmi_edp_gpll0[] = {
 161         "xo",
 162         "edp_link_clk",
 163         "hdmipll",
 164         "gpll0_vote",
 165         "dsi0pll",
 166         "dsi1pll",
 167 };
 168
 169 static const struct parent_map mmcc_xo_dsibyte_hdmi_edp_gpll0_map[] = {
 170         { P_XO, 0 },
 171         { P_EDPLINK, 4 },
 172         { P_HDMIPLL, 3 },
 173         { P_GPLL0, 5 },
 174         { P_DSI0PLL_BYTE, 1 },
 175         { P_DSI1PLL_BYTE, 2 }
 176 };
 177
 178 static const char * const mmcc_xo_dsibyte_hdmi_edp_gpll0[] = {
 179         "xo",
 180         "edp_link_clk",
 181         "hdmipll",
 182         "gpll0_vote",
 183         "dsi0pllbyte",
 184         "dsi1pllbyte",
 185 };
 186
 187 #define F(f, s, h, m, n) { (f), (s), (2 * (h) - 1), (m), (n) }
 188
 189 static struct clk_pll mmpll0 = {
 190         .l_reg = 0x0004,
 191         .m_reg = 0x0008,
 192         .n_reg = 0x000c,
 193         .config_reg = 0x0014,
 194         .mode_reg = 0x0000,
 195         .status_reg = 0x001c,
 196         .status_bit = 17,
 197         .clkr.hw.init = &(struct clk_init_data){
 198                 .name = "mmpll0",
 199                 .parent_names = (const char *[]){ "xo" },
 200                 .num_parents = 1,
 201                 .ops = &clk_pll_ops,
 202         },
 203 };
 204
 205 static struct clk_regmap mmpll0_vote = {
 206         .enable_reg = 0x0100,
 207         .enable_mask = BIT(0),
 208         .hw.init = &(struct clk_init_data){
 209                 .name = "mmpll0_vote",
 210                 .parent_names = (const char *[]){ "mmpll0" },
 211                 .num_parents = 1,
 212                 .ops = &clk_pll_vote_ops,
 213         },
 214 };
 215
 216 static struct clk_pll mmpll1 = {
 217         .l_reg = 0x0044,
 218         .m_reg = 0x0048,
 219         .n_reg = 0x004c,
 220         .config_reg = 0x0050,
 221         .mode_reg = 0x0040,
 222         .status_reg = 0x005c,
 223         .status_bit = 17,
 224         .clkr.hw.init = &(struct clk_init_data){
 225                 .name = "mmpll1",
 226                 .parent_names = (const char *[]){ "xo" },
 227                 .num_parents = 1,
 228                 .ops = &clk_pll_ops,
 229         },
 230 };
 231
 232 static struct clk_regmap mmpll1_vote = {
 233         .enable_reg = 0x0100,
 234         .enable_mask = BIT(1),
 235         .hw.init = &(struct clk_init_data){
 236                 .name = "mmpll1_vote",
 237                 .parent_names = (const char *[]){ "mmpll1" },
 238                 .num_parents = 1,
 239                 .ops = &clk_pll_vote_ops,
 240         },
 241 };
 242
 243 static struct clk_pll mmpll2 = {
 244         .l_reg = 0x4104,
 245         .m_reg = 0x4108,
 246         .n_reg = 0x410c,
 247         .config_reg = 0x4110,
 248         .mode_reg = 0x4100,
 249         .status_reg = 0x411c,
 250         .clkr.hw.init = &(struct clk_init_data){
 251                 .name = "mmpll2",
 252                 .parent_names = (const char *[]){ "xo" },
 253                 .num_parents = 1,
 254                 .ops = &clk_pll_ops,
 255         },
 256 };
 257
 258 static struct clk_pll mmpll3 = {
 259         .l_reg = 0x0084,
 260         .m_reg = 0x0088,
 261         .n_reg = 0x008c,
 262         .config_reg = 0x0090,
 263         .mode_reg = 0x0080,
 264         .status_reg = 0x009c,
 265         .status_bit = 17,
 266         .clkr.hw.init = &(struct clk_init_data){
 267                 .name = "mmpll3",
 268                 .parent_names = (const char *[]){ "xo" },
 269                 .num_parents = 1,
 270                 .ops = &clk_pll_ops,
 271         },
 272 };
 273
 274 static struct clk_rcg2 mmss_ahb_clk_src = {
 275         .cmd_rcgr = 0x5000,
 276         .hid_width = 5,
 277         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 278         .clkr.hw.init = &(struct clk_init_data){
 279                 .name = "mmss_ahb_clk_src",
 280                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 281                 .num_parents = 4,
 282                 .ops = &clk_rcg2_ops,
 283         },
 284 };
 285
 286 static struct freq_tbl ftbl_mmss_axi_clk[] = {
 287         F( 19200000, P_XO, 1, 0, 0),
 288         F( 37500000, P_GPLL0, 16, 0, 0),
 289         F( 50000000, P_GPLL0, 12, 0, 0),
 290         F( 75000000, P_GPLL0, 8, 0, 0),
 291         F(100000000, P_GPLL0, 6, 0, 0),
 292         F(150000000, P_GPLL0, 4, 0, 0),
 293         F(291750000, P_MMPLL1, 4, 0, 0),
 294         F(400000000, P_MMPLL0, 2, 0, 0),
 295         F(466800000, P_MMPLL1, 2.5, 0, 0),
 296 };
 297
 298 static struct clk_rcg2 mmss_axi_clk_src = {
 299         .cmd_rcgr = 0x5040,
 300         .hid_width = 5,
 301         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 302         .freq_tbl = ftbl_mmss_axi_clk,
 303         .clkr.hw.init = &(struct clk_init_data){
 304                 .name = "mmss_axi_clk_src",
 305                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 306                 .num_parents = 4,
 307                 .ops = &clk_rcg2_ops,
 308         },
 309 };
 310
 311 static struct freq_tbl ftbl_ocmemnoc_clk[] = {
 312         F( 19200000, P_XO, 1, 0, 0),
 313         F( 37500000, P_GPLL0, 16, 0, 0),
 314         F( 50000000, P_GPLL0, 12, 0, 0),
 315         F( 75000000, P_GPLL0, 8, 0, 0),
 316         F(100000000, P_GPLL0, 6, 0, 0),
 317         F(150000000, P_GPLL0, 4, 0, 0),
 318         F(291750000, P_MMPLL1, 4, 0, 0),
 319         F(400000000, P_MMPLL0, 2, 0, 0),
 320 };
 321
 322 static struct clk_rcg2 ocmemnoc_clk_src = {
 323         .cmd_rcgr = 0x5090,
 324         .hid_width = 5,
 325         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 326         .freq_tbl = ftbl_ocmemnoc_clk,
 327         .clkr.hw.init = &(struct clk_init_data){
 328                 .name = "ocmemnoc_clk_src",
 329                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 330                 .num_parents = 4,
 331                 .ops = &clk_rcg2_ops,
 332         },
 333 };
 334
 335 static struct freq_tbl ftbl_camss_csi0_3_clk[] = {
 336         F(100000000, P_GPLL0, 6, 0, 0),
 337         F(200000000, P_MMPLL0, 4, 0, 0),
 338         { }
 339 };
 340
 341 static struct clk_rcg2 csi0_clk_src = {
 342         .cmd_rcgr = 0x3090,
 343         .hid_width = 5,
 344         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 345         .freq_tbl = ftbl_camss_csi0_3_clk,
 346         .clkr.hw.init = &(struct clk_init_data){
 347                 .name = "csi0_clk_src",
 348                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 349                 .num_parents = 4,
 350                 .ops = &clk_rcg2_ops,
 351         },
 352 };
 353
 354 static struct clk_rcg2 csi1_clk_src = {
 355         .cmd_rcgr = 0x3100,
 356         .hid_width = 5,
 357         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 358         .freq_tbl = ftbl_camss_csi0_3_clk,
 359         .clkr.hw.init = &(struct clk_init_data){
 360                 .name = "csi1_clk_src",
 361                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 362                 .num_parents = 4,
 363                 .ops = &clk_rcg2_ops,
 364         },
 365 };
 366
 367 static struct clk_rcg2 csi2_clk_src = {
 368         .cmd_rcgr = 0x3160,
 369         .hid_width = 5,
 370         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 371         .freq_tbl = ftbl_camss_csi0_3_clk,
 372         .clkr.hw.init = &(struct clk_init_data){
 373                 .name = "csi2_clk_src",
 374                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 375                 .num_parents = 4,
 376                 .ops = &clk_rcg2_ops,
 377         },
 378 };
 379
 380 static struct clk_rcg2 csi3_clk_src = {
 381         .cmd_rcgr = 0x31c0,
 382         .hid_width = 5,
 383         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 384         .freq_tbl = ftbl_camss_csi0_3_clk,
 385         .clkr.hw.init = &(struct clk_init_data){
 386                 .name = "csi3_clk_src",
 387                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 388                 .num_parents = 4,
 389                 .ops = &clk_rcg2_ops,
 390         },
 391 };
 392
 393 static struct freq_tbl ftbl_camss_vfe_vfe0_1_clk[] = {
 394         F(37500000, P_GPLL0, 16, 0, 0),
 395         F(50000000, P_GPLL0, 12, 0, 0),
 396         F(60000000, P_GPLL0, 10, 0, 0),
 397         F(80000000, P_GPLL0, 7.5, 0, 0),
 398         F(100000000, P_GPLL0, 6, 0, 0),
 399         F(109090000, P_GPLL0, 5.5, 0, 0),
 400         F(133330000, P_GPLL0, 4.5, 0, 0),
 401         F(200000000, P_GPLL0, 3, 0, 0),
 402         F(228570000, P_MMPLL0, 3.5, 0, 0),
 403         F(266670000, P_MMPLL0, 3, 0, 0),
 404         F(320000000, P_MMPLL0, 2.5, 0, 0),
 405         F(400000000, P_MMPLL0, 2, 0, 0),
 406         F(465000000, P_MMPLL3, 2, 0, 0),
 407         { }
 408 };
 409
 410 static struct clk_rcg2 vfe0_clk_src = {
 411         .cmd_rcgr = 0x3600,
 412         .hid_width = 5,
 413         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 414         .freq_tbl = ftbl_camss_vfe_vfe0_1_clk,
 415         .clkr.hw.init = &(struct clk_init_data){
 416                 .name = "vfe0_clk_src",
 417                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 418                 .num_parents = 4,
 419                 .ops = &clk_rcg2_ops,
 420         },
 421 };
 422
 423 static struct clk_rcg2 vfe1_clk_src = {
 424         .cmd_rcgr = 0x3620,
 425         .hid_width = 5,
 426         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 427         .freq_tbl = ftbl_camss_vfe_vfe0_1_clk,
 428         .clkr.hw.init = &(struct clk_init_data){
 429                 .name = "vfe1_clk_src",
 430                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 431                 .num_parents = 4,
 432                 .ops = &clk_rcg2_ops,
 433         },
 434 };
 435
 436 static struct freq_tbl ftbl_mdss_mdp_clk[] = {
 437         F(37500000, P_GPLL0, 16, 0, 0),
 438         F(60000000, P_GPLL0, 10, 0, 0),
 439         F(75000000, P_GPLL0, 8, 0, 0),
 440         F(85710000, P_GPLL0, 7, 0, 0),
 441         F(100000000, P_GPLL0, 6, 0, 0),
 442         F(133330000, P_MMPLL0, 6, 0, 0),
 443         F(160000000, P_MMPLL0, 5, 0, 0),
 444         F(200000000, P_MMPLL0, 4, 0, 0),
 445         F(228570000, P_MMPLL0, 3.5, 0, 0),
 446         F(240000000, P_GPLL0, 2.5, 0, 0),
 447         F(266670000, P_MMPLL0, 3, 0, 0),
 448         F(320000000, P_MMPLL0, 2.5, 0, 0),
 449         { }
 450 };
 451
 452 static struct clk_rcg2 mdp_clk_src = {
 453         .cmd_rcgr = 0x2040,
 454         .hid_width = 5,
 455         .parent_map = mmcc_xo_mmpll0_dsi_hdmi_gpll0_map,
 456         .freq_tbl = ftbl_mdss_mdp_clk,
 457         .clkr.hw.init = &(struct clk_init_data){
 458                 .name = "mdp_clk_src",
 459                 .parent_names = mmcc_xo_mmpll0_dsi_hdmi_gpll0,
 460                 .num_parents = 6,
 461                 .ops = &clk_rcg2_ops,
 462         },
 463 };
 464
 465 static struct clk_rcg2 gfx3d_clk_src = {
 466         .cmd_rcgr = 0x4000,
 467         .hid_width = 5,
 468         .parent_map = mmcc_xo_mmpll0_1_2_gpll0_map,
 469         .clkr.hw.init = &(struct clk_init_data){
 470                 .name = "gfx3d_clk_src",
 471                 .parent_names = mmcc_xo_mmpll0_1_2_gpll0,
 472                 .num_parents = 5,
 473                 .ops = &clk_rcg2_ops,
 474         },
 475 };
 476
 477 static struct freq_tbl ftbl_camss_jpeg_jpeg0_2_clk[] = {
 478         F(75000000, P_GPLL0, 8, 0, 0),
 479         F(133330000, P_GPLL0, 4.5, 0, 0),
 480         F(200000000, P_GPLL0, 3, 0, 0),
 481         F(228570000, P_MMPLL0, 3.5, 0, 0),
 482         F(266670000, P_MMPLL0, 3, 0, 0),
 483         F(320000000, P_MMPLL0, 2.5, 0, 0),
 484         { }
 485 };
 486
 487 static struct clk_rcg2 jpeg0_clk_src = {
 488         .cmd_rcgr = 0x3500,
 489         .hid_width = 5,
 490         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 491         .freq_tbl = ftbl_camss_jpeg_jpeg0_2_clk,
 492         .clkr.hw.init = &(struct clk_init_data){
 493                 .name = "jpeg0_clk_src",
 494                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 495                 .num_parents = 4,
 496                 .ops = &clk_rcg2_ops,
 497         },
 498 };
 499
 500 static struct clk_rcg2 jpeg1_clk_src = {
 501         .cmd_rcgr = 0x3520,
 502         .hid_width = 5,
 503         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 504         .freq_tbl = ftbl_camss_jpeg_jpeg0_2_clk,
 505         .clkr.hw.init = &(struct clk_init_data){
 506                 .name = "jpeg1_clk_src",
 507                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 508                 .num_parents = 4,
 509                 .ops = &clk_rcg2_ops,
 510         },
 511 };
 512
 513 static struct clk_rcg2 jpeg2_clk_src = {
 514         .cmd_rcgr = 0x3540,
 515         .hid_width = 5,
 516         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 517         .freq_tbl = ftbl_camss_jpeg_jpeg0_2_clk,
 518         .clkr.hw.init = &(struct clk_init_data){
 519                 .name = "jpeg2_clk_src",
 520                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 521                 .num_parents = 4,
 522                 .ops = &clk_rcg2_ops,
 523         },
 524 };
 525
 526 static struct clk_rcg2 pclk0_clk_src = {
 527         .cmd_rcgr = 0x2000,
 528         .mnd_width = 8,
 529         .hid_width = 5,
 530         .parent_map = mmcc_xo_dsi_hdmi_edp_gpll0_map,
 531         .clkr.hw.init = &(struct clk_init_data){
 532                 .name = "pclk0_clk_src",
 533                 .parent_names = mmcc_xo_dsi_hdmi_edp_gpll0,
 534                 .num_parents = 6,
 535                 .ops = &clk_pixel_ops,
 536                 .flags = CLK_SET_RATE_PARENT,
 537         },
 538 };
 539
 540 static struct clk_rcg2 pclk1_clk_src = {
 541         .cmd_rcgr = 0x2020,
 542         .mnd_width = 8,
 543         .hid_width = 5,
 544         .parent_map = mmcc_xo_dsi_hdmi_edp_gpll0_map,
 545         .clkr.hw.init = &(struct clk_init_data){
 546                 .name = "pclk1_clk_src",
 547                 .parent_names = mmcc_xo_dsi_hdmi_edp_gpll0,
 548                 .num_parents = 6,
 549                 .ops = &clk_pixel_ops,
 550                 .flags = CLK_SET_RATE_PARENT,
 551         },
 552 };
 553
 554 static struct freq_tbl ftbl_venus0_vcodec0_clk[] = {
 555         F(50000000, P_GPLL0, 12, 0, 0),
 556         F(100000000, P_GPLL0, 6, 0, 0),
 557         F(133330000, P_MMPLL0, 6, 0, 0),
 558         F(200000000, P_MMPLL0, 4, 0, 0),
 559         F(266670000, P_MMPLL0, 3, 0, 0),
 560         F(465000000, P_MMPLL3, 2, 0, 0),
 561         { }
 562 };
 563
 564 static struct clk_rcg2 vcodec0_clk_src = {
 565         .cmd_rcgr = 0x1000,
 566         .mnd_width = 8,
 567         .hid_width = 5,
 568         .parent_map = mmcc_xo_mmpll0_1_3_gpll0_map,
 569         .freq_tbl = ftbl_venus0_vcodec0_clk,
 570         .clkr.hw.init = &(struct clk_init_data){
 571                 .name = "vcodec0_clk_src",
 572                 .parent_names = mmcc_xo_mmpll0_1_3_gpll0,
 573                 .num_parents = 5,
 574                 .ops = &clk_rcg2_ops,
 575         },
 576 };
 577
 578 static struct freq_tbl ftbl_camss_cci_cci_clk[] = {
 579         F(19200000, P_XO, 1, 0, 0),
 580         { }
 581 };
 582
 583 static struct clk_rcg2 cci_clk_src = {
 584         .cmd_rcgr = 0x3300,
 585         .hid_width = 5,
 586         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 587         .freq_tbl = ftbl_camss_cci_cci_clk,
 588         .clkr.hw.init = &(struct clk_init_data){
 589                 .name = "cci_clk_src",
 590                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 591                 .num_parents = 4,
 592                 .ops = &clk_rcg2_ops,
 593         },
 594 };
 595
 596 static struct freq_tbl ftbl_camss_gp0_1_clk[] = {
 597         F(10000, P_XO, 16, 1, 120),
 598         F(24000, P_XO, 16, 1, 50),
 599         F(6000000, P_GPLL0, 10, 1, 10),
 600         F(12000000, P_GPLL0, 10, 1, 5),
 601         F(13000000, P_GPLL0, 4, 13, 150),
 602         F(24000000, P_GPLL0, 5, 1, 5),
 603         { }
 604 };
 605
 606 static struct clk_rcg2 camss_gp0_clk_src = {
 607         .cmd_rcgr = 0x3420,
 608         .mnd_width = 8,
 609         .hid_width = 5,
 610         .parent_map = mmcc_xo_mmpll0_1_gpll1_0_map,
 611         .freq_tbl = ftbl_camss_gp0_1_clk,
 612         .clkr.hw.init = &(struct clk_init_data){
 613                 .name = "camss_gp0_clk_src",
 614                 .parent_names = mmcc_xo_mmpll0_1_gpll1_0,
 615                 .num_parents = 5,
 616                 .ops = &clk_rcg2_ops,
 617         },
 618 };
 619
 620 static struct clk_rcg2 camss_gp1_clk_src = {
 621         .cmd_rcgr = 0x3450,
 622         .mnd_width = 8,
 623         .hid_width = 5,
 624         .parent_map = mmcc_xo_mmpll0_1_gpll1_0_map,
 625         .freq_tbl = ftbl_camss_gp0_1_clk,
 626         .clkr.hw.init = &(struct clk_init_data){
 627                 .name = "camss_gp1_clk_src",
 628                 .parent_names = mmcc_xo_mmpll0_1_gpll1_0,
 629                 .num_parents = 5,
 630                 .ops = &clk_rcg2_ops,
 631         },
 632 };
 633
 634 static struct freq_tbl ftbl_camss_mclk0_3_clk[] = {
 635         F(4800000, P_XO, 4, 0, 0),
 636         F(6000000, P_GPLL0, 10, 1, 10),
 637         F(8000000, P_GPLL0, 15, 1, 5),
 638         F(9600000, P_XO, 2, 0, 0),
 639         F(16000000, P_GPLL0, 12.5, 1, 3),
 640         F(19200000, P_XO, 1, 0, 0),
 641         F(24000000, P_GPLL0, 5, 1, 5),
 642         F(32000000, P_MMPLL0, 5, 1, 5),
 643         F(48000000, P_GPLL0, 12.5, 0, 0),
 644         F(64000000, P_MMPLL0, 12.5, 0, 0),
 645         F(66670000, P_GPLL0, 9, 0, 0),
 646         { }
 647 };
 648
 649 static struct clk_rcg2 mclk0_clk_src = {
 650         .cmd_rcgr = 0x3360,
 651         .hid_width = 5,
 652         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 653         .freq_tbl = ftbl_camss_mclk0_3_clk,
 654         .clkr.hw.init = &(struct clk_init_data){
 655                 .name = "mclk0_clk_src",
 656                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 657                 .num_parents = 4,
 658                 .ops = &clk_rcg2_ops,
 659         },
 660 };
 661
 662 static struct clk_rcg2 mclk1_clk_src = {
 663         .cmd_rcgr = 0x3390,
 664         .hid_width = 5,
 665         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 666         .freq_tbl = ftbl_camss_mclk0_3_clk,
 667         .clkr.hw.init = &(struct clk_init_data){
 668                 .name = "mclk1_clk_src",
 669                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 670                 .num_parents = 4,
 671                 .ops = &clk_rcg2_ops,
 672         },
 673 };
 674
 675 static struct clk_rcg2 mclk2_clk_src = {
 676         .cmd_rcgr = 0x33c0,
 677         .hid_width = 5,
 678         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 679         .freq_tbl = ftbl_camss_mclk0_3_clk,
 680         .clkr.hw.init = &(struct clk_init_data){
 681                 .name = "mclk2_clk_src",
 682                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 683                 .num_parents = 4,
 684                 .ops = &clk_rcg2_ops,
 685         },
 686 };
 687
 688 static struct clk_rcg2 mclk3_clk_src = {
 689         .cmd_rcgr = 0x33f0,
 690         .hid_width = 5,
 691         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 692         .freq_tbl = ftbl_camss_mclk0_3_clk,
 693         .clkr.hw.init = &(struct clk_init_data){
 694                 .name = "mclk3_clk_src",
 695                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 696                 .num_parents = 4,
 697                 .ops = &clk_rcg2_ops,
 698         },
 699 };
 700
 701 static struct freq_tbl ftbl_camss_phy0_2_csi0_2phytimer_clk[] = {
 702         F(100000000, P_GPLL0, 6, 0, 0),
 703         F(200000000, P_MMPLL0, 4, 0, 0),
 704         { }
 705 };
 706
 707 static struct clk_rcg2 csi0phytimer_clk_src = {
 708         .cmd_rcgr = 0x3000,
 709         .hid_width = 5,
 710         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 711         .freq_tbl = ftbl_camss_phy0_2_csi0_2phytimer_clk,
 712         .clkr.hw.init = &(struct clk_init_data){
 713                 .name = "csi0phytimer_clk_src",
 714                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 715                 .num_parents = 4,
 716                 .ops = &clk_rcg2_ops,
 717         },
 718 };
 719
 720 static struct clk_rcg2 csi1phytimer_clk_src = {
 721         .cmd_rcgr = 0x3030,
 722         .hid_width = 5,
 723         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 724         .freq_tbl = ftbl_camss_phy0_2_csi0_2phytimer_clk,
 725         .clkr.hw.init = &(struct clk_init_data){
 726                 .name = "csi1phytimer_clk_src",
 727                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 728                 .num_parents = 4,
 729                 .ops = &clk_rcg2_ops,
 730         },
 731 };
 732
 733 static struct clk_rcg2 csi2phytimer_clk_src = {
 734         .cmd_rcgr = 0x3060,
 735         .hid_width = 5,
 736         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 737         .freq_tbl = ftbl_camss_phy0_2_csi0_2phytimer_clk,
 738         .clkr.hw.init = &(struct clk_init_data){
 739                 .name = "csi2phytimer_clk_src",
 740                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 741                 .num_parents = 4,
 742                 .ops = &clk_rcg2_ops,
 743         },
 744 };
 745
 746 static struct freq_tbl ftbl_camss_vfe_cpp_clk[] = {
 747         F(133330000, P_GPLL0, 4.5, 0, 0),
 748         F(266670000, P_MMPLL0, 3, 0, 0),
 749         F(320000000, P_MMPLL0, 2.5, 0, 0),
 750         F(400000000, P_MMPLL0, 2, 0, 0),
 751         F(465000000, P_MMPLL3, 2, 0, 0),
 752         { }
 753 };
 754
 755 static struct clk_rcg2 cpp_clk_src = {
 756         .cmd_rcgr = 0x3640,
 757         .hid_width = 5,
 758         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 759         .freq_tbl = ftbl_camss_vfe_cpp_clk,
 760         .clkr.hw.init = &(struct clk_init_data){
 761                 .name = "cpp_clk_src",
 762                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 763                 .num_parents = 4,
 764                 .ops = &clk_rcg2_ops,
 765         },
 766 };
 767
 768 static struct freq_tbl byte_freq_tbl[] = {
 769         { .src = P_DSI0PLL_BYTE },
 770         { }
 771 };
 772
 773 static struct clk_rcg2 byte0_clk_src = {
 774         .cmd_rcgr = 0x2120,
 775         .hid_width = 5,
 776         .parent_map = mmcc_xo_dsibyte_hdmi_edp_gpll0_map,
 777         .freq_tbl = byte_freq_tbl,
 778         .clkr.hw.init = &(struct clk_init_data){
 779                 .name = "byte0_clk_src",
 780                 .parent_names = mmcc_xo_dsibyte_hdmi_edp_gpll0,
 781                 .num_parents = 6,
 782                 .ops = &clk_byte2_ops,
 783                 .flags = CLK_SET_RATE_PARENT,
 784         },
 785 };
 786
 787 static struct clk_rcg2 byte1_clk_src = {
 788         .cmd_rcgr = 0x2140,
 789         .hid_width = 5,
 790         .parent_map = mmcc_xo_dsibyte_hdmi_edp_gpll0_map,
 791         .freq_tbl = byte_freq_tbl,
 792         .clkr.hw.init = &(struct clk_init_data){
 793                 .name = "byte1_clk_src",
 794                 .parent_names = mmcc_xo_dsibyte_hdmi_edp_gpll0,
 795                 .num_parents = 6,
 796                 .ops = &clk_byte2_ops,
 797                 .flags = CLK_SET_RATE_PARENT,
 798         },
 799 };
 800
 801 static struct freq_tbl ftbl_mdss_edpaux_clk[] = {
 802         F(19200000, P_XO, 1, 0, 0),
 803         { }
 804 };
 805
 806 static struct clk_rcg2 edpaux_clk_src = {
 807         .cmd_rcgr = 0x20e0,
 808         .hid_width = 5,
 809         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 810         .freq_tbl = ftbl_mdss_edpaux_clk,
 811         .clkr.hw.init = &(struct clk_init_data){
 812                 .name = "edpaux_clk_src",
 813                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 814                 .num_parents = 4,
 815                 .ops = &clk_rcg2_ops,
 816         },
 817 };
 818
 819 static struct freq_tbl ftbl_mdss_edplink_clk[] = {
 820         F(135000000, P_EDPLINK, 2, 0, 0),
 821         F(270000000, P_EDPLINK, 11, 0, 0),
 822         { }
 823 };
 824
 825 static struct clk_rcg2 edplink_clk_src = {
 826         .cmd_rcgr = 0x20c0,
 827         .hid_width = 5,
 828         .parent_map = mmcc_xo_dsi_hdmi_edp_gpll0_map,
 829         .freq_tbl = ftbl_mdss_edplink_clk,
 830         .clkr.hw.init = &(struct clk_init_data){
 831                 .name = "edplink_clk_src",
 832                 .parent_names = mmcc_xo_dsi_hdmi_edp_gpll0,
 833                 .num_parents = 6,
 834                 .ops = &clk_rcg2_ops,
 835                 .flags = CLK_SET_RATE_PARENT,
 836         },
 837 };
 838
 839 static struct freq_tbl edp_pixel_freq_tbl[] = {
 840         { .src = P_EDPVCO },
 841         { }
 842 };
 843
 844 static struct clk_rcg2 edppixel_clk_src = {
 845         .cmd_rcgr = 0x20a0,
 846         .mnd_width = 8,
 847         .hid_width = 5,
 848         .parent_map = mmcc_xo_dsi_hdmi_edp_map,
 849         .freq_tbl = edp_pixel_freq_tbl,
 850         .clkr.hw.init = &(struct clk_init_data){
 851                 .name = "edppixel_clk_src",
 852                 .parent_names = mmcc_xo_dsi_hdmi_edp,
 853                 .num_parents = 6,
 854                 .ops = &clk_edp_pixel_ops,
 855         },
 856 };
 857
 858 static struct freq_tbl ftbl_mdss_esc0_1_clk[] = {
 859         F(19200000, P_XO, 1, 0, 0),
 860         { }
 861 };
 862
 863 static struct clk_rcg2 esc0_clk_src = {
 864         .cmd_rcgr = 0x2160,
 865         .hid_width = 5,
 866         .parent_map = mmcc_xo_dsibyte_hdmi_edp_gpll0_map,
 867         .freq_tbl = ftbl_mdss_esc0_1_clk,
 868         .clkr.hw.init = &(struct clk_init_data){
 869                 .name = "esc0_clk_src",
 870                 .parent_names = mmcc_xo_dsibyte_hdmi_edp_gpll0,
 871                 .num_parents = 6,
 872                 .ops = &clk_rcg2_ops,
 873         },
 874 };
 875
 876 static struct clk_rcg2 esc1_clk_src = {
 877         .cmd_rcgr = 0x2180,
 878         .hid_width = 5,
 879         .parent_map = mmcc_xo_dsibyte_hdmi_edp_gpll0_map,
 880         .freq_tbl = ftbl_mdss_esc0_1_clk,
 881         .clkr.hw.init = &(struct clk_init_data){
 882                 .name = "esc1_clk_src",
 883                 .parent_names = mmcc_xo_dsibyte_hdmi_edp_gpll0,
 884                 .num_parents = 6,
 885                 .ops = &clk_rcg2_ops,
 886         },
 887 };
 888
 889 static struct freq_tbl extpclk_freq_tbl[] = {
 890         { .src = P_HDMIPLL },
 891         { }
 892 };
 893
 894 static struct clk_rcg2 extpclk_clk_src = {
 895         .cmd_rcgr = 0x2060,
 896         .hid_width = 5,
 897         .parent_map = mmcc_xo_dsi_hdmi_edp_gpll0_map,
 898         .freq_tbl = extpclk_freq_tbl,
 899         .clkr.hw.init = &(struct clk_init_data){
 900                 .name = "extpclk_clk_src",
 901                 .parent_names = mmcc_xo_dsi_hdmi_edp_gpll0,
 902                 .num_parents = 6,
 903                 .ops = &clk_byte_ops,
 904                 .flags = CLK_SET_RATE_PARENT,
 905         },
 906 };
 907
 908 static struct freq_tbl ftbl_mdss_hdmi_clk[] = {
 909         F(19200000, P_XO, 1, 0, 0),
 910         { }
 911 };
 912
 913 static struct clk_rcg2 hdmi_clk_src = {
 914         .cmd_rcgr = 0x2100,
 915         .hid_width = 5,
 916         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 917         .freq_tbl = ftbl_mdss_hdmi_clk,
 918         .clkr.hw.init = &(struct clk_init_data){
 919                 .name = "hdmi_clk_src",
 920                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 921                 .num_parents = 4,
 922                 .ops = &clk_rcg2_ops,
 923         },
 924 };
 925
 926 static struct freq_tbl ftbl_mdss_vsync_clk[] = {
 927         F(19200000, P_XO, 1, 0, 0),
 928         { }
 929 };
 930
 931 static struct clk_rcg2 vsync_clk_src = {
 932         .cmd_rcgr = 0x2080,
 933         .hid_width = 5,
 934         .parent_map = mmcc_xo_mmpll0_mmpll1_gpll0_map,
 935         .freq_tbl = ftbl_mdss_vsync_clk,
 936         .clkr.hw.init = &(struct clk_init_data){
 937                 .name = "vsync_clk_src",
 938                 .parent_names = mmcc_xo_mmpll0_mmpll1_gpll0,
 939                 .num_parents = 4,
 940                 .ops = &clk_rcg2_ops,
 941         },
 942 };
 943
 944 static struct clk_branch camss_cci_cci_ahb_clk = {
 945         .halt_reg = 0x3348,
 946         .clkr = {
 947                 .enable_reg = 0x3348,
 948                 .enable_mask = BIT(0),
 949                 .hw.init = &(struct clk_init_data){
 950                         .name = "camss_cci_cci_ahb_clk",
 951                         .parent_names = (const char *[]){
 952                                 "mmss_ahb_clk_src",
 953                         },
 954                         .num_parents = 1,
 955                         .ops = &clk_branch2_ops,
 956                 },
 957         },
 958 };
 959
 960 static struct clk_branch camss_cci_cci_clk = {
 961         .halt_reg = 0x3344,
 962         .clkr = {
 963                 .enable_reg = 0x3344,
 964                 .enable_mask = BIT(0),
 965                 .hw.init = &(struct clk_init_data){
 966                         .name = "camss_cci_cci_clk",
 967                         .parent_names = (const char *[]){
 968                                 "cci_clk_src",
 969                         },
 970                         .num_parents = 1,
 971                         .flags = CLK_SET_RATE_PARENT,
 972                         .ops = &clk_branch2_ops,
 973                 },
 974         },
 975 };
 976
 977 static struct clk_branch camss_csi0_ahb_clk = {
 978         .halt_reg = 0x30bc,
 979         .clkr = {
 980                 .enable_reg = 0x30bc,
 981                 .enable_mask = BIT(0),
 982                 .hw.init = &(struct clk_init_data){
 983                         .name = "camss_csi0_ahb_clk",
 984                         .parent_names = (const char *[]){
 985                                 "mmss_ahb_clk_src",
 986                         },
 987                         .num_parents = 1,
 988                         .ops = &clk_branch2_ops,
 989                 },
 990         },
 991 };
 992
 993 static struct clk_branch camss_csi0_clk = {
 994         .halt_reg = 0x30b4,
 995         .clkr = {
 996                 .enable_reg = 0x30b4,
 997                 .enable_mask = BIT(0),
 998                 .hw.init = &(struct clk_init_data){
 999                         .name = "camss_csi0_clk",
1000                         .parent_names = (const char *[]){
1001                                 "csi0_clk_src",
1002                         },
1003                         .num_parents = 1,
1004                         .flags = CLK_SET_RATE_PARENT,
1005                         .ops = &clk_branch2_ops,
1006                 },
1007         },
1008 };
1009
1010 static struct clk_branch camss_csi0phy_clk = {
1011         .halt_reg = 0x30c4,
1012         .clkr = {
1013                 .enable_reg = 0x30c4,
1014                 .enable_mask = BIT(0),
1015                 .hw.init = &(struct clk_init_data){
1016                         .name = "camss_csi0phy_clk",
1017                         .parent_names = (const char *[]){
1018                                 "csi0_clk_src",
1019                         },
1020                         .num_parents = 1,
1021                         .flags = CLK_SET_RATE_PARENT,
1022                         .ops = &clk_branch2_ops,
1023                 },
1024         },
1025 };
1026
1027 static struct clk_branch camss_csi0pix_clk = {
1028         .halt_reg = 0x30e4,
1029         .clkr = {
1030                 .enable_reg = 0x30e4,
1031                 .enable_mask = BIT(0),
1032                 .hw.init = &(struct clk_init_data){
1033                         .name = "camss_csi0pix_clk",
1034                         .parent_names = (const char *[]){
1035                                 "csi0_clk_src",
1036                         },
1037                         .num_parents = 1,
1038                         .flags = CLK_SET_RATE_PARENT,
1039                         .ops = &clk_branch2_ops,
1040                 },
1041         },
1042 };
1043
1044 static struct clk_branch camss_csi0rdi_clk = {
1045         .halt_reg = 0x30d4,
1046         .clkr = {
1047                 .enable_reg = 0x30d4,
1048                 .enable_mask = BIT(0),
1049                 .hw.init = &(struct clk_init_data){
1050                         .name = "camss_csi0rdi_clk",
1051                         .parent_names = (const char *[]){
1052                                 "csi0_clk_src",
1053                         },
1054                         .num_parents = 1,
1055                         .flags = CLK_SET_RATE_PARENT,
1056                         .ops = &clk_branch2_ops,
1057                 },
1058         },
1059 };
1060
1061 static struct clk_branch camss_csi1_ahb_clk = {
1062         .halt_reg = 0x3128,
1063         .clkr = {
1064                 .enable_reg = 0x3128,
1065                 .enable_mask = BIT(0),
1066                 .hw.init = &(struct clk_init_data){
1067                         .name = "camss_csi1_ahb_clk",
1068                         .parent_names = (const char *[]){
1069                                 "mmss_ahb_clk_src",
1070                         },
1071                         .num_parents = 1,
1072                         .ops = &clk_branch2_ops,
1073                 },
1074         },
1075 };
1076
1077 static struct clk_branch camss_csi1_clk = {
1078         .halt_reg = 0x3124,
1079         .clkr = {
1080                 .enable_reg = 0x3124,
1081                 .enable_mask = BIT(0),
1082                 .hw.init = &(struct clk_init_data){
1083                         .name = "camss_csi1_clk",
1084                         .parent_names = (const char *[]){
1085                                 "csi1_clk_src",
1086                         },
1087                         .num_parents = 1,
1088                         .flags = CLK_SET_RATE_PARENT,
1089                         .ops = &clk_branch2_ops,
1090                 },
1091         },
1092 };
1093
1094 static struct clk_branch camss_csi1phy_clk = {
1095         .halt_reg = 0x3134,
1096         .clkr = {
1097                 .enable_reg = 0x3134,
1098                 .enable_mask = BIT(0),
1099                 .hw.init = &(struct clk_init_data){
1100                         .name = "camss_csi1phy_clk",
1101                         .parent_names = (const char *[]){
1102                                 "csi1_clk_src",
1103                         },
1104                         .num_parents = 1,
1105                         .flags = CLK_SET_RATE_PARENT,
1106                         .ops = &clk_branch2_ops,
1107                 },
1108         },
1109 };
1110
1111 static struct clk_branch camss_csi1pix_clk = {
1112         .halt_reg = 0x3154,
1113         .clkr = {
1114                 .enable_reg = 0x3154,
1115                 .enable_mask = BIT(0),
1116                 .hw.init = &(struct clk_init_data){
1117                         .name = "camss_csi1pix_clk",
1118                         .parent_names = (const char *[]){
1119                                 "csi1_clk_src",
1120                         },
1121                         .num_parents = 1,
1122                         .flags = CLK_SET_RATE_PARENT,
1123                         .ops = &clk_branch2_ops,
1124                 },
1125         },
1126 };
1127
1128 static struct clk_branch camss_csi1rdi_clk = {
1129         .halt_reg = 0x3144,
1130         .clkr = {
1131                 .enable_reg = 0x3144,
1132                 .enable_mask = BIT(0),
1133                 .hw.init = &(struct clk_init_data){
1134                         .name = "camss_csi1rdi_clk",
1135                         .parent_names = (const char *[]){
1136                                 "csi1_clk_src",
1137                         },
1138                         .num_parents = 1,
1139                         .flags = CLK_SET_RATE_PARENT,
1140                         .ops = &clk_branch2_ops,
1141                 },
1142         },
1143 };
1144
1145 static struct clk_branch camss_csi2_ahb_clk = {
1146         .halt_reg = 0x3188,
1147         .clkr = {
1148                 .enable_reg = 0x3188,
1149                 .enable_mask = BIT(0),
1150                 .hw.init = &(struct clk_init_data){
1151                         .name = "camss_csi2_ahb_clk",
1152                         .parent_names = (const char *[]){
1153                                 "mmss_ahb_clk_src",
1154                         },
1155                         .num_parents = 1,
1156                         .ops = &clk_branch2_ops,
1157                 },
1158         },
1159 };
1160
1161 static struct clk_branch camss_csi2_clk = {
1162         .halt_reg = 0x3184,
1163         .clkr = {
1164                 .enable_reg = 0x3184,
1165                 .enable_mask = BIT(0),
1166                 .hw.init = &(struct clk_init_data){
1167                         .name = "camss_csi2_clk",
1168                         .parent_names = (const char *[]){
1169                                 "csi2_clk_src",
1170                         },
1171                         .num_parents = 1,
1172                         .flags = CLK_SET_RATE_PARENT,
1173                         .ops = &clk_branch2_ops,
1174                 },
1175         },
1176 };
1177
1178 static struct clk_branch camss_csi2phy_clk = {
1179         .halt_reg = 0x3194,
1180         .clkr = {
1181                 .enable_reg = 0x3194,
1182                 .enable_mask = BIT(0),
1183                 .hw.init = &(struct clk_init_data){
1184                         .name = "camss_csi2phy_clk",
1185                         .parent_names = (const char *[]){
1186                                 "csi2_clk_src",
1187                         },
1188                         .num_parents = 1,
1189                         .flags = CLK_SET_RATE_PARENT,
1190                         .ops = &clk_branch2_ops,
1191                 },
1192         },
1193 };
1194
1195 static struct clk_branch camss_csi2pix_clk = {
1196         .halt_reg = 0x31b4,
1197         .clkr = {
1198                 .enable_reg = 0x31b4,
1199                 .enable_mask = BIT(0),
1200                 .hw.init = &(struct clk_init_data){
1201                         .name = "camss_csi2pix_clk",
1202                         .parent_names = (const char *[]){
1203                                 "csi2_clk_src",
1204                         },
1205                         .num_parents = 1,
1206                         .flags = CLK_SET_RATE_PARENT,
1207                         .ops = &clk_branch2_ops,
1208                 },
1209         },
1210 };
1211
1212 static struct clk_branch camss_csi2rdi_clk = {
1213         .halt_reg = 0x31a4,
1214         .clkr = {
1215                 .enable_reg = 0x31a4,
1216                 .enable_mask = BIT(0),
1217                 .hw.init = &(struct clk_init_data){
1218                         .name = "camss_csi2rdi_clk",
1219                         .parent_names = (const char *[]){
1220                                 "csi2_clk_src",
1221                         },
1222                         .num_parents = 1,
1223                         .flags = CLK_SET_RATE_PARENT,
1224                         .ops = &clk_branch2_ops,
1225                 },
1226         },
1227 };
1228
1229 static struct clk_branch camss_csi3_ahb_clk = {
1230         .halt_reg = 0x31e8,
1231         .clkr = {
1232                 .enable_reg = 0x31e8,
1233                 .enable_mask = BIT(0),
1234                 .hw.init = &(struct clk_init_data){
1235                         .name = "camss_csi3_ahb_clk",
1236                         .parent_names = (const char *[]){
1237                                 "mmss_ahb_clk_src",
1238                         },
1239                         .num_parents = 1,
1240                         .ops = &clk_branch2_ops,
1241                 },
1242         },
1243 };
1244
1245 static struct clk_branch camss_csi3_clk = {
1246         .halt_reg = 0x31e4,
1247         .clkr = {
1248                 .enable_reg = 0x31e4,
1249                 .enable_mask = BIT(0),
1250                 .hw.init = &(struct clk_init_data){
1251                         .name = "camss_csi3_clk",
1252                         .parent_names = (const char *[]){
1253                                 "csi3_clk_src",
1254                         },
1255                         .num_parents = 1,
1256                         .flags = CLK_SET_RATE_PARENT,
1257                         .ops = &clk_branch2_ops,
1258                 },
1259         },
1260 };
1261
1262 static struct clk_branch camss_csi3phy_clk = {
1263         .halt_reg = 0x31f4,
1264         .clkr = {
1265                 .enable_reg = 0x31f4,
1266                 .enable_mask = BIT(0),
1267                 .hw.init = &(struct clk_init_data){
1268                         .name = "camss_csi3phy_clk",
1269                         .parent_names = (const char *[]){
1270                                 "csi3_clk_src",
1271                         },
1272                         .num_parents = 1,
1273                         .flags = CLK_SET_RATE_PARENT,
1274                         .ops = &clk_branch2_ops,
1275                 },
1276         },
1277 };
1278
1279 static struct clk_branch camss_csi3pix_clk = {
1280         .halt_reg = 0x3214,
1281         .clkr = {
1282                 .enable_reg = 0x3214,
1283                 .enable_mask = BIT(0),
1284                 .hw.init = &(struct clk_init_data){
1285                         .name = "camss_csi3pix_clk",
1286                         .parent_names = (const char *[]){
1287                                 "csi3_clk_src",
1288                         },
1289                         .num_parents = 1,
1290                         .flags = CLK_SET_RATE_PARENT,
1291                         .ops = &clk_branch2_ops,
1292                 },
1293         },
1294 };
1295
1296 static struct clk_branch camss_csi3rdi_clk = {
1297         .halt_reg = 0x3204,
1298         .clkr = {
1299                 .enable_reg = 0x3204,
1300                 .enable_mask = BIT(0),
1301                 .hw.init = &(struct clk_init_data){
1302                         .name = "camss_csi3rdi_clk",
1303                         .parent_names = (const char *[]){
1304                                 "csi3_clk_src",
1305                         },
1306                         .num_parents = 1,
1307                         .flags = CLK_SET_RATE_PARENT,
1308                         .ops = &clk_branch2_ops,
1309                 },
1310         },
1311 };
1312
1313 static struct clk_branch camss_csi_vfe0_clk = {
1314         .halt_reg = 0x3704,
1315         .clkr = {
1316                 .enable_reg = 0x3704,
1317                 .enable_mask = BIT(0),
1318                 .hw.init = &(struct clk_init_data){
1319                         .name = "camss_csi_vfe0_clk",
1320                         .parent_names = (const char *[]){
1321                                 "vfe0_clk_src",
1322                         },
1323                         .num_parents = 1,
1324                         .flags = CLK_SET_RATE_PARENT,
1325                         .ops = &clk_branch2_ops,
1326                 },
1327         },
1328 };
1329
1330 static struct clk_branch camss_csi_vfe1_clk = {
1331         .halt_reg = 0x3714,
1332         .clkr = {
1333                 .enable_reg = 0x3714,
1334                 .enable_mask = BIT(0),
1335                 .hw.init = &(struct clk_init_data){
1336                         .name = "camss_csi_vfe1_clk",
1337                         .parent_names = (const char *[]){
1338                                 "vfe1_clk_src",
1339                         },
1340                         .num_parents = 1,
1341                         .flags = CLK_SET_RATE_PARENT,
1342                         .ops = &clk_branch2_ops,
1343                 },
1344         },
1345 };
1346
1347 static struct clk_branch camss_gp0_clk = {
1348         .halt_reg = 0x3444,
1349         .clkr = {
1350                 .enable_reg = 0x3444,
1351                 .enable_mask = BIT(0),
1352                 .hw.init = &(struct clk_init_data){
1353                         .name = "camss_gp0_clk",
1354                         .parent_names = (const char *[]){
1355                                 "camss_gp0_clk_src",
1356                         },
1357                         .num_parents = 1,
1358                         .flags = CLK_SET_RATE_PARENT,
1359                         .ops = &clk_branch2_ops,
1360                 },
1361         },
1362 };
1363
1364 static struct clk_branch camss_gp1_clk = {
1365         .halt_reg = 0x3474,
1366         .clkr = {
1367                 .enable_reg = 0x3474,
1368                 .enable_mask = BIT(0),
1369                 .hw.init = &(struct clk_init_data){
1370                         .name = "camss_gp1_clk",
1371                         .parent_names = (const char *[]){
1372                                 "camss_gp1_clk_src",
1373                         },
1374                         .num_parents = 1,
1375                         .flags = CLK_SET_RATE_PARENT,
1376                         .ops = &clk_branch2_ops,
1377                 },
1378         },
1379 };
1380
1381 static struct clk_branch camss_ispif_ahb_clk = {
1382         .halt_reg = 0x3224,
1383         .clkr = {
1384                 .enable_reg = 0x3224,
1385                 .enable_mask = BIT(0),
1386                 .hw.init = &(struct clk_init_data){
1387                         .name = "camss_ispif_ahb_clk",
1388                         .parent_names = (const char *[]){
1389                                 "mmss_ahb_clk_src",
1390                         },
1391                         .num_parents = 1,
1392                         .ops = &clk_branch2_ops,
1393                 },
1394         },
1395 };
1396
1397 static struct clk_branch camss_jpeg_jpeg0_clk = {
1398         .halt_reg = 0x35a8,
1399         .clkr = {
1400                 .enable_reg = 0x35a8,
1401                 .enable_mask = BIT(0),
1402                 .hw.init = &(struct clk_init_data){
1403                         .name = "camss_jpeg_jpeg0_clk",
1404                         .parent_names = (const char *[]){
1405                                 "jpeg0_clk_src",
1406                         },
1407                         .num_parents = 1,
1408                         .flags = CLK_SET_RATE_PARENT,
1409                         .ops = &clk_branch2_ops,
1410                 },
1411         },
1412 };
1413
1414 static struct clk_branch camss_jpeg_jpeg1_clk = {
1415         .halt_reg = 0x35ac,
1416         .clkr = {
1417                 .enable_reg = 0x35ac,
1418                 .enable_mask = BIT(0),
1419                 .hw.init = &(struct clk_init_data){
1420                         .name = "camss_jpeg_jpeg1_clk",
1421                         .parent_names = (const char *[]){
1422                                 "jpeg1_clk_src",
1423                         },
1424                         .num_parents = 1,
1425                         .flags = CLK_SET_RATE_PARENT,
1426                         .ops = &clk_branch2_ops,
1427                 },
1428         },
1429 };
1430
1431 static struct clk_branch camss_jpeg_jpeg2_clk = {
1432         .halt_reg = 0x35b0,
1433         .clkr = {
1434                 .enable_reg = 0x35b0,
1435                 .enable_mask = BIT(0),
1436                 .hw.init = &(struct clk_init_data){
1437                         .name = "camss_jpeg_jpeg2_clk",
1438                         .parent_names = (const char *[]){
1439                                 "jpeg2_clk_src",
1440                         },
1441                         .num_parents = 1,
1442                         .flags = CLK_SET_RATE_PARENT,
1443                         .ops = &clk_branch2_ops,
1444                 },
1445         },
1446 };
1447
1448 static struct clk_branch camss_jpeg_jpeg_ahb_clk = {
1449         .halt_reg = 0x35b4,
1450         .clkr = {
1451                 .enable_reg = 0x35b4,
1452                 .enable_mask = BIT(0),
1453                 .hw.init = &(struct clk_init_data){
1454                         .name = "camss_jpeg_jpeg_ahb_clk",
1455                         .parent_names = (const char *[]){
1456                                 "mmss_ahb_clk_src",
1457                         },
1458                         .num_parents = 1,
1459                         .ops = &clk_branch2_ops,
1460                 },
1461         },
1462 };
1463
1464 static struct clk_branch camss_jpeg_jpeg_axi_clk = {
1465         .halt_reg = 0x35b8,
1466         .clkr = {
1467                 .enable_reg = 0x35b8,
1468                 .enable_mask = BIT(0),
1469                 .hw.init = &(struct clk_init_data){
1470                         .name = "camss_jpeg_jpeg_axi_clk",
1471                         .parent_names = (const char *[]){
1472                                 "mmss_axi_clk_src",
1473                         },
1474                         .num_parents = 1,
1475                         .ops = &clk_branch2_ops,
1476                 },
1477         },
1478 };
1479
1480 static struct clk_branch camss_jpeg_jpeg_ocmemnoc_clk = {
1481         .halt_reg = 0x35bc,
1482         .clkr = {
1483                 .enable_reg = 0x35bc,
1484                 .enable_mask = BIT(0),
1485                 .hw.init = &(struct clk_init_data){
1486                         .name = "camss_jpeg_jpeg_ocmemnoc_clk",
1487                         .parent_names = (const char *[]){
1488                                 "ocmemnoc_clk_src",
1489                         },
1490                         .num_parents = 1,
1491                         .flags = CLK_SET_RATE_PARENT,
1492                         .ops = &clk_branch2_ops,
1493                 },
1494         },
1495 };
1496
1497 static struct clk_branch camss_mclk0_clk = {
1498         .halt_reg = 0x3384,
1499         .clkr = {
1500                 .enable_reg = 0x3384,
1501                 .enable_mask = BIT(0),
1502                 .hw.init = &(struct clk_init_data){
1503                         .name = "camss_mclk0_clk",
1504                         .parent_names = (const char *[]){
1505                                 "mclk0_clk_src",
1506                         },
1507                         .num_parents = 1,
1508                         .flags = CLK_SET_RATE_PARENT,
1509                         .ops = &clk_branch2_ops,
1510                 },
1511         },
1512 };
1513
1514 static struct clk_branch camss_mclk1_clk = {
1515         .halt_reg = 0x33b4,
1516         .clkr = {
1517                 .enable_reg = 0x33b4,
1518                 .enable_mask = BIT(0),
1519                 .hw.init = &(struct clk_init_data){
1520                         .name = "camss_mclk1_clk",
1521                         .parent_names = (const char *[]){
1522                                 "mclk1_clk_src",
1523                         },
1524                         .num_parents = 1,
1525                         .flags = CLK_SET_RATE_PARENT,
1526                         .ops = &clk_branch2_ops,
1527                 },
1528         },
1529 };
1530
1531 static struct clk_branch camss_mclk2_clk = {
1532         .halt_reg = 0x33e4,
1533         .clkr = {
1534                 .enable_reg = 0x33e4,
1535                 .enable_mask = BIT(0),
1536                 .hw.init = &(struct clk_init_data){
1537                         .name = "camss_mclk2_clk",
1538                         .parent_names = (const char *[]){
1539                                 "mclk2_clk_src",
1540                         },
1541                         .num_parents = 1,
1542                         .flags = CLK_SET_RATE_PARENT,
1543                         .ops = &clk_branch2_ops,
1544                 },
1545         },
1546 };
1547
1548 static struct clk_branch camss_mclk3_clk = {
1549         .halt_reg = 0x3414,
1550         .clkr = {
1551                 .enable_reg = 0x3414,
1552                 .enable_mask = BIT(0),
1553                 .hw.init = &(struct clk_init_data){
1554                         .name = "camss_mclk3_clk",
1555                         .parent_names = (const char *[]){
1556                                 "mclk3_clk_src",
1557                         },
1558                         .num_parents = 1,
1559                         .flags = CLK_SET_RATE_PARENT,
1560                         .ops = &clk_branch2_ops,
1561                 },
1562         },
1563 };
1564
1565 static struct clk_branch camss_micro_ahb_clk = {
1566         .halt_reg = 0x3494,
1567         .clkr = {
1568                 .enable_reg = 0x3494,
1569                 .enable_mask = BIT(0),
1570                 .hw.init = &(struct clk_init_data){
1571                         .name = "camss_micro_ahb_clk",
1572                         .parent_names = (const char *[]){
1573                                 "mmss_ahb_clk_src",
1574                         },
1575                         .num_parents = 1,
1576                         .ops = &clk_branch2_ops,
1577                 },
1578         },
1579 };
1580
1581 static struct clk_branch camss_phy0_csi0phytimer_clk = {
1582         .halt_reg = 0x3024,
1583         .clkr = {
1584                 .enable_reg = 0x3024,
1585                 .enable_mask = BIT(0),
1586                 .hw.init = &(struct clk_init_data){
1587                         .name = "camss_phy0_csi0phytimer_clk",
1588                         .parent_names = (const char *[]){
1589                                 "csi0phytimer_clk_src",
1590                         },
1591                         .num_parents = 1,
1592                         .flags = CLK_SET_RATE_PARENT,
1593                         .ops = &clk_branch2_ops,
1594                 },
1595         },
1596 };
1597
1598 static struct clk_branch camss_phy1_csi1phytimer_clk = {
1599         .halt_reg = 0x3054,
1600         .clkr = {
1601                 .enable_reg = 0x3054,
1602                 .enable_mask = BIT(0),
1603                 .hw.init = &(struct clk_init_data){
1604                         .name = "camss_phy1_csi1phytimer_clk",
1605                         .parent_names = (const char *[]){
1606                                 "csi1phytimer_clk_src",
1607                         },
1608                         .num_parents = 1,
1609                         .flags = CLK_SET_RATE_PARENT,
1610                         .ops = &clk_branch2_ops,
1611                 },
1612         },
1613 };
1614
1615 static struct clk_branch camss_phy2_csi2phytimer_clk = {
1616         .halt_reg = 0x3084,
1617         .clkr = {
1618                 .enable_reg = 0x3084,
1619                 .enable_mask = BIT(0),
1620                 .hw.init = &(struct clk_init_data){
1621                         .name = "camss_phy2_csi2phytimer_clk",
1622                         .parent_names = (const char *[]){
1623                                 "csi2phytimer_clk_src",
1624                         },
1625                         .num_parents = 1,
1626                         .flags = CLK_SET_RATE_PARENT,
1627                         .ops = &clk_branch2_ops,
1628                 },
1629         },
1630 };
1631
1632 static struct clk_branch camss_top_ahb_clk = {
1633         .halt_reg = 0x3484,
1634         .clkr = {
1635                 .enable_reg = 0x3484,
1636                 .enable_mask = BIT(0),
1637                 .hw.init = &(struct clk_init_data){
1638                         .name = "camss_top_ahb_clk",
1639                         .parent_names = (const char *[]){
1640                                 "mmss_ahb_clk_src",
1641                         },
1642                         .num_parents = 1,
1643                         .ops = &clk_branch2_ops,
1644                 },
1645         },
1646 };
1647
1648 static struct clk_branch camss_vfe_cpp_ahb_clk = {
1649         .halt_reg = 0x36b4,
1650         .clkr = {
1651                 .enable_reg = 0x36b4,
1652                 .enable_mask = BIT(0),
1653                 .hw.init = &(struct clk_init_data){
1654                         .name = "camss_vfe_cpp_ahb_clk",
1655                         .parent_names = (const char *[]){
1656                                 "mmss_ahb_clk_src",
1657                         },
1658                         .num_parents = 1,
1659                         .ops = &clk_branch2_ops,
1660                 },
1661         },
1662 };
1663
1664 static struct clk_branch camss_vfe_cpp_clk = {
1665         .halt_reg = 0x36b0,
1666         .clkr = {
1667                 .enable_reg = 0x36b0,
1668                 .enable_mask = BIT(0),
1669                 .hw.init = &(struct clk_init_data){
1670                         .name = "camss_vfe_cpp_clk",
1671                         .parent_names = (const char *[]){
1672                                 "cpp_clk_src",
1673                         },
1674                         .num_parents = 1,
1675                         .flags = CLK_SET_RATE_PARENT,
1676                         .ops = &clk_branch2_ops,
1677                 },
1678         },
1679 };
1680
1681 static struct clk_branch camss_vfe_vfe0_clk = {
1682         .halt_reg = 0x36a8,
1683         .clkr = {
1684                 .enable_reg = 0x36a8,
1685                 .enable_mask = BIT(0),
1686                 .hw.init = &(struct clk_init_data){
1687                         .name = "camss_vfe_vfe0_clk",
1688                         .parent_names = (const char *[]){
1689                                 "vfe0_clk_src",
1690                         },
1691                         .num_parents = 1,
1692                         .flags = CLK_SET_RATE_PARENT,
1693                         .ops = &clk_branch2_ops,
1694                 },
1695         },
1696 };
1697
1698 static struct clk_branch camss_vfe_vfe1_clk = {
1699         .halt_reg = 0x36ac,
1700         .clkr = {
1701                 .enable_reg = 0x36ac,
1702                 .enable_mask = BIT(0),
1703                 .hw.init = &(struct clk_init_data){
1704                         .name = "camss_vfe_vfe1_clk",
1705                         .parent_names = (const char *[]){
1706                                 "vfe1_clk_src",
1707                         },
1708                         .num_parents = 1,
1709                         .flags = CLK_SET_RATE_PARENT,
1710                         .ops = &clk_branch2_ops,
1711                 },
1712         },
1713 };
1714
1715 static struct clk_branch camss_vfe_vfe_ahb_clk = {
1716         .halt_reg = 0x36b8,
1717         .clkr = {
1718                 .enable_reg = 0x36b8,
1719                 .enable_mask = BIT(0),
1720                 .hw.init = &(struct clk_init_data){
1721                         .name = "camss_vfe_vfe_ahb_clk",
1722                         .parent_names = (const char *[]){
1723                                 "mmss_ahb_clk_src",
1724                         },
1725                         .num_parents = 1,
1726                         .ops = &clk_branch2_ops,
1727                 },
1728         },
1729 };
1730
1731 static struct clk_branch camss_vfe_vfe_axi_clk = {
1732         .halt_reg = 0x36bc,
1733         .clkr = {
1734                 .enable_reg = 0x36bc,
1735                 .enable_mask = BIT(0),
1736                 .hw.init = &(struct clk_init_data){
1737                         .name = "camss_vfe_vfe_axi_clk",
1738                         .parent_names = (const char *[]){
1739                                 "mmss_axi_clk_src",
1740                         },
1741                         .num_parents = 1,
1742                         .ops = &clk_branch2_ops,
1743                 },
1744         },
1745 };
1746
1747 static struct clk_branch camss_vfe_vfe_ocmemnoc_clk = {
1748         .halt_reg = 0x36c0,
1749         .clkr = {
1750                 .enable_reg = 0x36c0,
1751                 .enable_mask = BIT(0),
1752                 .hw.init = &(struct clk_init_data){
1753                         .name = "camss_vfe_vfe_ocmemnoc_clk",
1754                         .parent_names = (const char *[]){
1755                                 "ocmemnoc_clk_src",
1756                         },
1757                         .num_parents = 1,
1758                         .flags = CLK_SET_RATE_PARENT,
1759                         .ops = &clk_branch2_ops,
1760                 },
1761         },
1762 };
1763
1764 static struct clk_branch mdss_ahb_clk = {
1765         .halt_reg = 0x2308,
1766         .clkr = {
1767                 .enable_reg = 0x2308,
1768                 .enable_mask = BIT(0),
1769                 .hw.init = &(struct clk_init_data){
1770                         .name = "mdss_ahb_clk",
1771                         .parent_names = (const char *[]){
1772                                 "mmss_ahb_clk_src",
1773                         },
1774                         .num_parents = 1,
1775                         .ops = &clk_branch2_ops,
1776                 },
1777         },
1778 };
1779
1780 static struct clk_branch mdss_axi_clk = {
1781         .halt_reg = 0x2310,
1782         .clkr = {
1783                 .enable_reg = 0x2310,
1784                 .enable_mask = BIT(0),
1785                 .hw.init = &(struct clk_init_data){
1786                         .name = "mdss_axi_clk",
1787                         .parent_names = (const char *[]){
1788                                 "mmss_axi_clk_src",
1789                         },
1790                         .num_parents = 1,
1791                         .flags = CLK_SET_RATE_PARENT,
1792                         .ops = &clk_branch2_ops,
1793                 },
1794         },
1795 };
1796
1797 static struct clk_branch mdss_byte0_clk = {
1798         .halt_reg = 0x233c,
1799         .clkr = {
1800                 .enable_reg = 0x233c,
1801                 .enable_mask = BIT(0),
1802                 .hw.init = &(struct clk_init_data){
1803                         .name = "mdss_byte0_clk",
1804                         .parent_names = (const char *[]){
1805                                 "byte0_clk_src",
1806                         },
1807                         .num_parents = 1,
1808                         .flags = CLK_SET_RATE_PARENT,
1809                         .ops = &clk_branch2_ops,
1810                 },
1811         },
1812 };
1813
1814 static struct clk_branch mdss_byte1_clk = {
1815         .halt_reg = 0x2340,
1816         .clkr = {
1817                 .enable_reg = 0x2340,
1818                 .enable_mask = BIT(0),
1819                 .hw.init = &(struct clk_init_data){
1820                         .name = "mdss_byte1_clk",
1821                         .parent_names = (const char *[]){
1822                                 "byte1_clk_src",
1823                         },
1824                         .num_parents = 1,
1825                         .flags = CLK_SET_RATE_PARENT,
1826                         .ops = &clk_branch2_ops,
1827                 },
1828         },
1829 };
1830
1831 static struct clk_branch mdss_edpaux_clk = {
1832         .halt_reg = 0x2334,
1833         .clkr = {
1834                 .enable_reg = 0x2334,
1835                 .enable_mask = BIT(0),
1836                 .hw.init = &(struct clk_init_data){
1837                         .name = "mdss_edpaux_clk",
1838                         .parent_names = (const char *[]){
1839                                 "edpaux_clk_src",
1840                         },
1841                         .num_parents = 1,
1842                         .flags = CLK_SET_RATE_PARENT,
1843                         .ops = &clk_branch2_ops,
1844                 },
1845         },
1846 };
1847
1848 static struct clk_branch mdss_edplink_clk = {
1849         .halt_reg = 0x2330,
1850         .clkr = {
1851                 .enable_reg = 0x2330,
1852                 .enable_mask = BIT(0),
1853                 .hw.init = &(struct clk_init_data){
1854                         .name = "mdss_edplink_clk",
1855                         .parent_names = (const char *[]){
1856                                 "edplink_clk_src",
1857                         },
1858                         .num_parents = 1,
1859                         .flags = CLK_SET_RATE_PARENT,
1860                         .ops = &clk_branch2_ops,
1861                 },
1862         },
1863 };
1864
1865 static struct clk_branch mdss_edppixel_clk = {
1866         .halt_reg = 0x232c,
1867         .clkr = {
1868                 .enable_reg = 0x232c,
1869                 .enable_mask = BIT(0),
1870                 .hw.init = &(struct clk_init_data){
1871                         .name = "mdss_edppixel_clk",
1872                         .parent_names = (const char *[]){
1873                                 "edppixel_clk_src",
1874                         },
1875                         .num_parents = 1,
1876                         .flags = CLK_SET_RATE_PARENT,
1877                         .ops = &clk_branch2_ops,
1878                 },
1879         },
1880 };
1881
1882 static struct clk_branch mdss_esc0_clk = {
1883         .halt_reg = 0x2344,
1884         .clkr = {
1885                 .enable_reg = 0x2344,
1886                 .enable_mask = BIT(0),
1887                 .hw.init = &(struct clk_init_data){
1888                         .name = "mdss_esc0_clk",
1889                         .parent_names = (const char *[]){
1890                                 "esc0_clk_src",
1891                         },
1892                         .num_parents = 1,
1893                         .flags = CLK_SET_RATE_PARENT,
1894                         .ops = &clk_branch2_ops,
1895                 },
1896         },
1897 };
1898
1899 static struct clk_branch mdss_esc1_clk = {
1900         .halt_reg = 0x2348,
1901         .clkr = {
1902                 .enable_reg = 0x2348,
1903                 .enable_mask = BIT(0),
1904                 .hw.init = &(struct clk_init_data){
1905                         .name = "mdss_esc1_clk",
1906                         .parent_names = (const char *[]){
1907                                 "esc1_clk_src",
1908                         },
1909                         .num_parents = 1,
1910                         .flags = CLK_SET_RATE_PARENT,
1911                         .ops = &clk_branch2_ops,
1912                 },
1913         },
1914 };
1915
1916 static struct clk_branch mdss_extpclk_clk = {
1917         .halt_reg = 0x2324,
1918         .clkr = {
1919                 .enable_reg = 0x2324,
1920                 .enable_mask = BIT(0),
1921                 .hw.init = &(struct clk_init_data){
1922                         .name = "mdss_extpclk_clk",
1923                         .parent_names = (const char *[]){
1924                                 "extpclk_clk_src",
1925                         },
1926                         .num_parents = 1,
1927                         .flags = CLK_SET_RATE_PARENT,
1928                         .ops = &clk_branch2_ops,
1929                 },
1930         },
1931 };
1932
1933 static struct clk_branch mdss_hdmi_ahb_clk = {
1934         .halt_reg = 0x230c,
1935         .clkr = {
1936                 .enable_reg = 0x230c,
1937                 .enable_mask = BIT(0),
1938                 .hw.init = &(struct clk_init_data){
1939                         .name = "mdss_hdmi_ahb_clk",
1940                         .parent_names = (const char *[]){
1941                                 "mmss_ahb_clk_src",
1942                         },
1943                         .num_parents = 1,
1944                         .ops = &clk_branch2_ops,
1945                 },
1946         },
1947 };
1948
1949 static struct clk_branch mdss_hdmi_clk = {
1950         .halt_reg = 0x2338,
1951         .clkr = {
1952                 .enable_reg = 0x2338,
1953                 .enable_mask = BIT(0),
1954                 .hw.init = &(struct clk_init_data){
1955                         .name = "mdss_hdmi_clk",
1956                         .parent_names = (const char *[]){
1957                                 "hdmi_clk_src",
1958                         },
1959                         .num_parents = 1,
1960                         .flags = CLK_SET_RATE_PARENT,
1961                         .ops = &clk_branch2_ops,
1962                 },
1963         },
1964 };
1965
1966 static struct clk_branch mdss_mdp_clk = {
1967         .halt_reg = 0x231c,
1968         .clkr = {
1969                 .enable_reg = 0x231c,
1970                 .enable_mask = BIT(0),
1971                 .hw.init = &(struct clk_init_data){
1972                         .name = "mdss_mdp_clk",
1973                         .parent_names = (const char *[]){
1974                                 "mdp_clk_src",
1975                         },
1976                         .num_parents = 1,
1977                         .flags = CLK_SET_RATE_PARENT,
1978                         .ops = &clk_branch2_ops,
1979                 },
1980         },
1981 };
1982
1983 static struct clk_branch mdss_mdp_lut_clk = {
1984         .halt_reg = 0x2320,
1985         .clkr = {
1986                 .enable_reg = 0x2320,
1987                 .enable_mask = BIT(0),
1988                 .hw.init = &(struct clk_init_data){
1989                         .name = "mdss_mdp_lut_clk",
1990                         .parent_names = (const char *[]){
1991                                 "mdp_clk_src",
1992                         },
1993                         .num_parents = 1,
1994                         .flags = CLK_SET_RATE_PARENT,
1995                         .ops = &clk_branch2_ops,
1996                 },
1997         },
1998 };
1999
2000 static struct clk_branch mdss_pclk0_clk = {
2001         .halt_reg = 0x2314,
2002         .clkr = {
2003                 .enable_reg = 0x2314,
2004                 .enable_mask = BIT(0),
2005                 .hw.init = &(struct clk_init_data){
2006                         .name = "mdss_pclk0_clk",
2007                         .parent_names = (const char *[]){
2008                                 "pclk0_clk_src",
2009                         },
2010                         .num_parents = 1,
2011                         .flags = CLK_SET_RATE_PARENT,
2012                         .ops = &clk_branch2_ops,
2013                 },
2014         },
2015 };
2016
2017 static struct clk_branch mdss_pclk1_clk = {
2018         .halt_reg = 0x2318,
2019         .clkr = {
2020                 .enable_reg = 0x2318,
2021                 .enable_mask = BIT(0),
2022                 .hw.init = &(struct clk_init_data){
2023                         .name = "mdss_pclk1_clk",
2024                         .parent_names = (const char *[]){
2025                                 "pclk1_clk_src",
2026                         },
2027                         .num_parents = 1,
2028                         .flags = CLK_SET_RATE_PARENT,
2029                         .ops = &clk_branch2_ops,
2030                 },
2031         },
2032 };
2033
2034 static struct clk_branch mdss_vsync_clk = {
2035         .halt_reg = 0x2328,
2036         .clkr = {
2037                 .enable_reg = 0x2328,
2038                 .enable_mask = BIT(0),
2039                 .hw.init = &(struct clk_init_data){
2040                         .name = "mdss_vsync_clk",
2041                         .parent_names = (const char *[]){
2042                                 "vsync_clk_src",
2043                         },
2044                         .num_parents = 1,
2045                         .flags = CLK_SET_RATE_PARENT,
2046                         .ops = &clk_branch2_ops,
2047                 },
2048         },
2049 };
2050
2051 static struct clk_branch mmss_misc_ahb_clk = {
2052         .halt_reg = 0x502c,
2053         .clkr = {
2054                 .enable_reg = 0x502c,
2055                 .enable_mask = BIT(0),
2056                 .hw.init = &(struct clk_init_data){
2057                         .name = "mmss_misc_ahb_clk",
2058                         .parent_names = (const char *[]){
2059                                 "mmss_ahb_clk_src",
2060                         },
2061                         .num_parents = 1,
2062                         .ops = &clk_branch2_ops,
2063                 },
2064         },
2065 };
2066
2067 static struct clk_branch mmss_mmssnoc_ahb_clk = {
2068         .halt_reg = 0x5024,
2069         .clkr = {
2070                 .enable_reg = 0x5024,
2071                 .enable_mask = BIT(0),
2072                 .hw.init = &(struct clk_init_data){
2073                         .name = "mmss_mmssnoc_ahb_clk",
2074                         .parent_names = (const char *[]){
2075                                 "mmss_ahb_clk_src",
2076                         },
2077                         .num_parents = 1,
2078                         .ops = &clk_branch2_ops,
2079                         .flags = CLK_IGNORE_UNUSED,
2080                 },
2081         },
2082 };
2083
2084 static struct clk_branch mmss_mmssnoc_bto_ahb_clk = {
2085         .halt_reg = 0x5028,
2086         .clkr = {
2087                 .enable_reg = 0x5028,
2088                 .enable_mask = BIT(0),
2089                 .hw.init = &(struct clk_init_data){
2090                         .name = "mmss_mmssnoc_bto_ahb_clk",
2091                         .parent_names = (const char *[]){
2092                                 "mmss_ahb_clk_src",
2093                         },
2094                         .num_parents = 1,
2095                         .ops = &clk_branch2_ops,
2096                         .flags = CLK_IGNORE_UNUSED,
2097                 },
2098         },
2099 };
2100
2101 static struct clk_branch mmss_mmssnoc_axi_clk = {
2102         .halt_reg = 0x506c,
2103         .clkr = {
2104                 .enable_reg = 0x506c,
2105                 .enable_mask = BIT(0),
2106                 .hw.init = &(struct clk_init_data){
2107                         .name = "mmss_mmssnoc_axi_clk",
2108                         .parent_names = (const char *[]){
2109                                 "mmss_axi_clk_src",
2110                         },
2111                         .num_parents = 1,
2112                         .flags = CLK_SET_RATE_PARENT | CLK_IGNORE_UNUSED,
2113                         .ops = &clk_branch2_ops,
2114                 },
2115         },
2116 };
2117
2118 static struct clk_branch mmss_s0_axi_clk = {
2119         .halt_reg = 0x5064,
2120         .clkr = {
2121                 .enable_reg = 0x5064,
2122                 .enable_mask = BIT(0),
2123                 .hw.init = &(struct clk_init_data){
2124                         .name = "mmss_s0_axi_clk",
2125                         .parent_names = (const char *[]){
2126                                 "mmss_axi_clk_src",
2127                         },
2128                         .num_parents = 1,
2129                         .ops = &clk_branch2_ops,
2130                         .flags = CLK_IGNORE_UNUSED,
2131                 },
2132         },
2133 };
2134
2135 static struct clk_branch ocmemcx_ahb_clk = {
2136         .halt_reg = 0x405c,
2137         .clkr = {
2138                 .enable_reg = 0x405c,
2139                 .enable_mask = BIT(0),
2140                 .hw.init = &(struct clk_init_data){
2141                         .name = "ocmemcx_ahb_clk",
2142                         .parent_names = (const char *[]){
2143                                 "mmss_ahb_clk_src",
2144                         },
2145                         .num_parents = 1,
2146                         .ops = &clk_branch2_ops,
2147                 },
2148         },
2149 };
2150
2151 static struct clk_branch ocmemcx_ocmemnoc_clk = {
2152         .halt_reg = 0x4058,
2153         .clkr = {
2154                 .enable_reg = 0x4058,
2155                 .enable_mask = BIT(0),
2156                 .hw.init = &(struct clk_init_data){
2157                         .name = "ocmemcx_ocmemnoc_clk",
2158                         .parent_names = (const char *[]){
2159                                 "ocmemnoc_clk_src",
2160                         },
2161                         .num_parents = 1,
2162                         .flags = CLK_SET_RATE_PARENT,
2163                         .ops = &clk_branch2_ops,
2164                 },
2165         },
2166 };
2167
2168 static struct clk_branch oxili_ocmemgx_clk = {
2169         .halt_reg = 0x402c,
2170         .clkr = {
2171                 .enable_reg = 0x402c,
2172                 .enable_mask = BIT(0),
2173                 .hw.init = &(struct clk_init_data){
2174                         .name = "oxili_ocmemgx_clk",
2175                         .parent_names = (const char *[]){
2176                                 "gfx3d_clk_src",
2177                         },
2178                         .num_parents = 1,
2179                         .flags = CLK_SET_RATE_PARENT,
2180                         .ops = &clk_branch2_ops,
2181                 },
2182         },
2183 };
2184
2185 static struct clk_branch ocmemnoc_clk = {
2186         .halt_reg = 0x50b4,
2187         .clkr = {
2188                 .enable_reg = 0x50b4,
2189                 .enable_mask = BIT(0),
2190                 .hw.init = &(struct clk_init_data){
2191                         .name = "ocmemnoc_clk",
2192                         .parent_names = (const char *[]){
2193                                 "ocmemnoc_clk_src",
2194                         },
2195                         .num_parents = 1,
2196                         .flags = CLK_SET_RATE_PARENT,
2197                         .ops = &clk_branch2_ops,
2198                 },
2199         },
2200 };
2201
2202 static struct clk_branch oxili_gfx3d_clk = {
2203         .halt_reg = 0x4028,
2204         .clkr = {
2205                 .enable_reg = 0x4028,
2206                 .enable_mask = BIT(0),
2207                 .hw.init = &(struct clk_init_data){
2208                         .name = "oxili_gfx3d_clk",
2209                         .parent_names = (const char *[]){
2210                                 "gfx3d_clk_src",
2211                         },
2212                         .num_parents = 1,
2213                         .flags = CLK_SET_RATE_PARENT,
2214                         .ops = &clk_branch2_ops,
2215                 },
2216         },
2217 };
2218
2219 static struct clk_branch oxilicx_ahb_clk = {
2220         .halt_reg = 0x403c,
2221         .clkr = {
2222                 .enable_reg = 0x403c,
2223                 .enable_mask = BIT(0),
2224                 .hw.init = &(struct clk_init_data){
2225                         .name = "oxilicx_ahb_clk",
2226                         .parent_names = (const char *[]){
2227                                 "mmss_ahb_clk_src",
2228                         },
2229                         .num_parents = 1,
2230                         .ops = &clk_branch2_ops,
2231                 },
2232         },
2233 };
2234
2235 static struct clk_branch oxilicx_axi_clk = {
2236         .halt_reg = 0x4038,
2237         .clkr = {
2238                 .enable_reg = 0x4038,
2239                 .enable_mask = BIT(0),
2240                 .hw.init = &(struct clk_init_data){
2241                         .name = "oxilicx_axi_clk",
2242                         .parent_names = (const char *[]){
2243                                 "mmss_axi_clk_src",
2244                         },
2245                         .num_parents = 1,
2246                         .ops = &clk_branch2_ops,
2247                 },
2248         },
2249 };
2250
2251 static struct clk_branch venus0_ahb_clk = {
2252         .halt_reg = 0x1030,
2253         .clkr = {
2254                 .enable_reg = 0x1030,
2255                 .enable_mask = BIT(0),
2256                 .hw.init = &(struct clk_init_data){
2257                         .name = "venus0_ahb_clk",
2258                         .parent_names = (const char *[]){
2259                                 "mmss_ahb_clk_src",
2260                         },
2261                         .num_parents = 1,
2262                         .ops = &clk_branch2_ops,
2263                 },
2264         },
2265 };
2266
2267 static struct clk_branch venus0_axi_clk = {
2268         .halt_reg = 0x1034,
2269         .clkr = {
2270                 .enable_reg = 0x1034,
2271                 .enable_mask = BIT(0),
2272                 .hw.init = &(struct clk_init_data){
2273                         .name = "venus0_axi_clk",
2274                         .parent_names = (const char *[]){
2275                                 "mmss_axi_clk_src",
2276                         },
2277                         .num_parents = 1,
2278                         .ops = &clk_branch2_ops,
2279                 },
2280         },
2281 };
2282
2283 static struct clk_branch venus0_ocmemnoc_clk = {
2284         .halt_reg = 0x1038,
2285         .clkr = {
2286                 .enable_reg = 0x1038,
2287                 .enable_mask = BIT(0),
2288                 .hw.init = &(struct clk_init_data){
2289                         .name = "venus0_ocmemnoc_clk",
2290                         .parent_names = (const char *[]){
2291                                 "ocmemnoc_clk_src",
2292                         },
2293                         .num_parents = 1,
2294                         .flags = CLK_SET_RATE_PARENT,
2295                         .ops = &clk_branch2_ops,
2296                 },
2297         },
2298 };
2299
2300 static struct clk_branch venus0_vcodec0_clk = {
2301         .halt_reg = 0x1028,
2302         .clkr = {
2303                 .enable_reg = 0x1028,
2304                 .enable_mask = BIT(0),
2305                 .hw.init = &(struct clk_init_data){
2306                         .name = "venus0_vcodec0_clk",
2307                         .parent_names = (const char *[]){
2308                                 "vcodec0_clk_src",
2309                         },
2310                         .num_parents = 1,
2311                         .flags = CLK_SET_RATE_PARENT,
2312                         .ops = &clk_branch2_ops,
2313                 },
2314         },
2315 };
2316
2317 static const struct pll_config mmpll1_config = {
2318         .l = 60,
2319         .m = 25,
2320         .n = 32,
2321         .vco_val = 0x0,
2322         .vco_mask = 0x3 << 20,
2323         .pre_div_val = 0x0,
2324         .pre_div_mask = 0x7 << 12,
2325         .post_div_val = 0x0,
2326         .post_div_mask = 0x3 << 8,
2327         .mn_ena_mask = BIT(24),
2328         .main_output_mask = BIT(0),
2329 };
2330
2331 static struct pll_config mmpll3_config = {
2332         .l = 48,
2333         .m = 7,
2334         .n = 16,
2335         .vco_val = 0x0,
2336         .vco_mask = 0x3 << 20,
2337         .pre_div_val = 0x0,
2338         .pre_div_mask = 0x7 << 12,
2339         .post_div_val = 0x0,
2340         .post_div_mask = 0x3 << 8,
2341         .mn_ena_mask = BIT(24),
2342         .main_output_mask = BIT(0),
2343         .aux_output_mask = BIT(1),
2344 };
2345
2346 static struct gdsc venus0_gdsc = {
2347         .gdscr = 0x1024,
2348         .cxcs = (unsigned int []){ 0x1028 },
2349         .cxc_count = 1,
2350         .resets = (unsigned int []){ VENUS0_RESET },
2351         .reset_count = 1,
2352         .pd = {
2353                 .name = "venus0",
2354         },
2355         .pwrsts = PWRSTS_ON,
2356 };
2357
2358 static struct gdsc mdss_gdsc = {
2359         .gdscr = 0x2304,
2360         .cxcs = (unsigned int []){ 0x231c, 0x2320 },
2361         .cxc_count = 2,
2362         .pd = {
2363                 .name = "mdss",
2364         },
2365         .pwrsts = PWRSTS_RET_ON,
2366 };
2367
2368 static struct gdsc camss_jpeg_gdsc = {
2369         .gdscr = 0x35a4,
2370         .cxcs = (unsigned int []){ 0x35a8, 0x35ac, 0x35b0 },
2371         .cxc_count = 3,
2372         .pd = {
2373                 .name = "camss_jpeg",
2374         },
2375         .pwrsts = PWRSTS_OFF_ON,
2376 };
2377
2378 static struct gdsc camss_vfe_gdsc = {
2379         .gdscr = 0x36a4,
2380         .cxcs = (unsigned int []){ 0x36a8, 0x36ac, 0x3704, 0x3714, 0x36b0 },
2381         .cxc_count = 5,
2382         .pd = {
2383                 .name = "camss_vfe",
2384         },
2385         .pwrsts = PWRSTS_OFF_ON,
2386 };
2387
2388 static struct gdsc oxili_gdsc = {
2389         .gdscr = 0x4024,
2390         .cxcs = (unsigned int []){ 0x4028 },
2391         .cxc_count = 1,
2392         .pd = {
2393                 .name = "oxili",
2394         },
2395         .pwrsts = PWRSTS_OFF_ON,
2396 };
2397
2398 static struct gdsc oxilicx_gdsc = {
2399         .gdscr = 0x4034,
2400         .pd = {
2401                 .name = "oxilicx",
2402         },
2403         .parent = &oxili_gdsc.pd,
2404         .pwrsts = PWRSTS_OFF_ON,
2405 };
2406
2407 static struct clk_regmap *mmcc_msm8974_clocks[] = {
2408         [MMSS_AHB_CLK_SRC] = &mmss_ahb_clk_src.clkr,
2409         [MMSS_AXI_CLK_SRC] = &mmss_axi_clk_src.clkr,
2410         [OCMEMNOC_CLK_SRC] = &ocmemnoc_clk_src.clkr,
2411         [MMPLL0] = &mmpll0.clkr,
2412         [MMPLL0_VOTE] = &mmpll0_vote,
2413         [MMPLL1] = &mmpll1.clkr,
2414         [MMPLL1_VOTE] = &mmpll1_vote,
2415         [MMPLL2] = &mmpll2.clkr,
2416         [MMPLL3] = &mmpll3.clkr,
2417         [CSI0_CLK_SRC] = &csi0_clk_src.clkr,
2418         [CSI1_CLK_SRC] = &csi1_clk_src.clkr,
2419         [CSI2_CLK_SRC] = &csi2_clk_src.clkr,
2420         [CSI3_CLK_SRC] = &csi3_clk_src.clkr,
2421         [VFE0_CLK_SRC] = &vfe0_clk_src.clkr,
2422         [VFE1_CLK_SRC] = &vfe1_clk_src.clkr,
2423         [MDP_CLK_SRC] = &mdp_clk_src.clkr,
2424         [GFX3D_CLK_SRC] = &gfx3d_clk_src.clkr,
2425         [JPEG0_CLK_SRC] = &jpeg0_clk_src.clkr,
2426         [JPEG1_CLK_SRC] = &jpeg1_clk_src.clkr,
2427         [JPEG2_CLK_SRC] = &jpeg2_clk_src.clkr,
2428         [PCLK0_CLK_SRC] = &pclk0_clk_src.clkr,
2429         [PCLK1_CLK_SRC] = &pclk1_clk_src.clkr,
2430         [VCODEC0_CLK_SRC] = &vcodec0_clk_src.clkr,
2431         [CCI_CLK_SRC] = &cci_clk_src.clkr,
2432         [CAMSS_GP0_CLK_SRC] = &camss_gp0_clk_src.clkr,
2433         [CAMSS_GP1_CLK_SRC] = &camss_gp1_clk_src.clkr,
2434         [MCLK0_CLK_SRC] = &mclk0_clk_src.clkr,
2435         [MCLK1_CLK_SRC] = &mclk1_clk_src.clkr,
2436         [MCLK2_CLK_SRC] = &mclk2_clk_src.clkr,
2437         [MCLK3_CLK_SRC] = &mclk3_clk_src.clkr,
2438         [CSI0PHYTIMER_CLK_SRC] = &csi0phytimer_clk_src.clkr,
2439         [CSI1PHYTIMER_CLK_SRC] = &csi1phytimer_clk_src.clkr,
2440         [CSI2PHYTIMER_CLK_SRC] = &csi2phytimer_clk_src.clkr,
2441         [CPP_CLK_SRC] = &cpp_clk_src.clkr,
2442         [BYTE0_CLK_SRC] = &byte0_clk_src.clkr,
2443         [BYTE1_CLK_SRC] = &byte1_clk_src.clkr,
2444         [EDPAUX_CLK_SRC] = &edpaux_clk_src.clkr,
2445         [EDPLINK_CLK_SRC] = &edplink_clk_src.clkr,
2446         [EDPPIXEL_CLK_SRC] = &edppixel_clk_src.clkr,
2447         [ESC0_CLK_SRC] = &esc0_clk_src.clkr,
2448         [ESC1_CLK_SRC] = &esc1_clk_src.clkr,
2449         [EXTPCLK_CLK_SRC] = &extpclk_clk_src.clkr,
2450         [HDMI_CLK_SRC] = &hdmi_clk_src.clkr,
2451         [VSYNC_CLK_SRC] = &vsync_clk_src.clkr,
2452         [CAMSS_CCI_CCI_AHB_CLK] = &camss_cci_cci_ahb_clk.clkr,
2453         [CAMSS_CCI_CCI_CLK] = &camss_cci_cci_clk.clkr,
2454         [CAMSS_CSI0_AHB_CLK] = &camss_csi0_ahb_clk.clkr,
2455         [CAMSS_CSI0_CLK] = &camss_csi0_clk.clkr,
2456         [CAMSS_CSI0PHY_CLK] = &camss_csi0phy_clk.clkr,
2457         [CAMSS_CSI0PIX_CLK] = &camss_csi0pix_clk.clkr,
2458         [CAMSS_CSI0RDI_CLK] = &camss_csi0rdi_clk.clkr,
2459         [CAMSS_CSI1_AHB_CLK] = &camss_csi1_ahb_clk.clkr,
2460         [CAMSS_CSI1_CLK] = &camss_csi1_clk.clkr,
2461         [CAMSS_CSI1PHY_CLK] = &camss_csi1phy_clk.clkr,
2462         [CAMSS_CSI1PIX_CLK] = &camss_csi1pix_clk.clkr,
2463         [CAMSS_CSI1RDI_CLK] = &camss_csi1rdi_clk.clkr,
2464         [CAMSS_CSI2_AHB_CLK] = &camss_csi2_ahb_clk.clkr,
2465         [CAMSS_CSI2_CLK] = &camss_csi2_clk.clkr,
2466         [CAMSS_CSI2PHY_CLK] = &camss_csi2phy_clk.clkr,
2467         [CAMSS_CSI2PIX_CLK] = &camss_csi2pix_clk.clkr,
2468         [CAMSS_CSI2RDI_CLK] = &camss_csi2rdi_clk.clkr,
2469         [CAMSS_CSI3_AHB_CLK] = &camss_csi3_ahb_clk.clkr,
2470         [CAMSS_CSI3_CLK] = &camss_csi3_clk.clkr,
2471         [CAMSS_CSI3PHY_CLK] = &camss_csi3phy_clk.clkr,
2472         [CAMSS_CSI3PIX_CLK] = &camss_csi3pix_clk.clkr,
2473         [CAMSS_CSI3RDI_CLK] = &camss_csi3rdi_clk.clkr,
2474         [CAMSS_CSI_VFE0_CLK] = &camss_csi_vfe0_clk.clkr,
2475         [CAMSS_CSI_VFE1_CLK] = &camss_csi_vfe1_clk.clkr,
2476         [CAMSS_GP0_CLK] = &camss_gp0_clk.clkr,
2477         [CAMSS_GP1_CLK] = &camss_gp1_clk.clkr,
2478         [CAMSS_ISPIF_AHB_CLK] = &camss_ispif_ahb_clk.clkr,
2479         [CAMSS_JPEG_JPEG0_CLK] = &camss_jpeg_jpeg0_clk.clkr,
2480         [CAMSS_JPEG_JPEG1_CLK] = &camss_jpeg_jpeg1_clk.clkr,
2481         [CAMSS_JPEG_JPEG2_CLK] = &camss_jpeg_jpeg2_clk.clkr,
2482         [CAMSS_JPEG_JPEG_AHB_CLK] = &camss_jpeg_jpeg_ahb_clk.clkr,
2483         [CAMSS_JPEG_JPEG_AXI_CLK] = &camss_jpeg_jpeg_axi_clk.clkr,
2484         [CAMSS_JPEG_JPEG_OCMEMNOC_CLK] = &camss_jpeg_jpeg_ocmemnoc_clk.clkr,
2485         [CAMSS_MCLK0_CLK] = &camss_mclk0_clk.clkr,
2486         [CAMSS_MCLK1_CLK] = &camss_mclk1_clk.clkr,
2487         [CAMSS_MCLK2_CLK] = &camss_mclk2_clk.clkr,
2488         [CAMSS_MCLK3_CLK] = &camss_mclk3_clk.clkr,
2489         [CAMSS_MICRO_AHB_CLK] = &camss_micro_ahb_clk.clkr,
2490         [CAMSS_PHY0_CSI0PHYTIMER_CLK] = &camss_phy0_csi0phytimer_clk.clkr,
2491         [CAMSS_PHY1_CSI1PHYTIMER_CLK] = &camss_phy1_csi1phytimer_clk.clkr,
2492         [CAMSS_PHY2_CSI2PHYTIMER_CLK] = &camss_phy2_csi2phytimer_clk.clkr,
2493         [CAMSS_TOP_AHB_CLK] = &camss_top_ahb_clk.clkr,
2494         [CAMSS_VFE_CPP_AHB_CLK] = &camss_vfe_cpp_ahb_clk.clkr,
2495         [CAMSS_VFE_CPP_CLK] = &camss_vfe_cpp_clk.clkr,
2496         [CAMSS_VFE_VFE0_CLK] = &camss_vfe_vfe0_clk.clkr,
2497         [CAMSS_VFE_VFE1_CLK] = &camss_vfe_vfe1_clk.clkr,
2498         [CAMSS_VFE_VFE_AHB_CLK] = &camss_vfe_vfe_ahb_clk.clkr,
2499         [CAMSS_VFE_VFE_AXI_CLK] = &camss_vfe_vfe_axi_clk.clkr,
2500         [CAMSS_VFE_VFE_OCMEMNOC_CLK] = &camss_vfe_vfe_ocmemnoc_clk.clkr,
2501         [MDSS_AHB_CLK] = &mdss_ahb_clk.clkr,
2502         [MDSS_AXI_CLK] = &mdss_axi_clk.clkr,
2503         [MDSS_BYTE0_CLK] = &mdss_byte0_clk.clkr,
2504         [MDSS_BYTE1_CLK] = &mdss_byte1_clk.clkr,
2505         [MDSS_EDPAUX_CLK] = &mdss_edpaux_clk.clkr,
2506         [MDSS_EDPLINK_CLK] = &mdss_edplink_clk.clkr,
2507         [MDSS_EDPPIXEL_CLK] = &mdss_edppixel_clk.clkr,
2508         [MDSS_ESC0_CLK] = &mdss_esc0_clk.clkr,
2509         [MDSS_ESC1_CLK] = &mdss_esc1_clk.clkr,
2510         [MDSS_EXTPCLK_CLK] = &mdss_extpclk_clk.clkr,
2511         [MDSS_HDMI_AHB_CLK] = &mdss_hdmi_ahb_clk.clkr,
2512         [MDSS_HDMI_CLK] = &mdss_hdmi_clk.clkr,
2513         [MDSS_MDP_CLK] = &mdss_mdp_clk.clkr,
2514         [MDSS_MDP_LUT_CLK] = &mdss_mdp_lut_clk.clkr,
2515         [MDSS_PCLK0_CLK] = &mdss_pclk0_clk.clkr,
2516         [MDSS_PCLK1_CLK] = &mdss_pclk1_clk.clkr,
2517         [MDSS_VSYNC_CLK] = &mdss_vsync_clk.clkr,
2518         [MMSS_MISC_AHB_CLK] = &mmss_misc_ahb_clk.clkr,
2519         [MMSS_MMSSNOC_AHB_CLK] = &mmss_mmssnoc_ahb_clk.clkr,
2520         [MMSS_MMSSNOC_BTO_AHB_CLK] = &mmss_mmssnoc_bto_ahb_clk.clkr,
2521         [MMSS_MMSSNOC_AXI_CLK] = &mmss_mmssnoc_axi_clk.clkr,
2522         [MMSS_S0_AXI_CLK] = &mmss_s0_axi_clk.clkr,
2523         [OCMEMCX_AHB_CLK] = &ocmemcx_ahb_clk.clkr,
2524         [OCMEMCX_OCMEMNOC_CLK] = &ocmemcx_ocmemnoc_clk.clkr,
2525         [OXILI_OCMEMGX_CLK] = &oxili_ocmemgx_clk.clkr,
2526         [OCMEMNOC_CLK] = &ocmemnoc_clk.clkr,
2527         [OXILI_GFX3D_CLK] = &oxili_gfx3d_clk.clkr,
2528         [OXILICX_AHB_CLK] = &oxilicx_ahb_clk.clkr,
2529         [OXILICX_AXI_CLK] = &oxilicx_axi_clk.clkr,
2530         [VENUS0_AHB_CLK] = &venus0_ahb_clk.clkr,
2531         [VENUS0_AXI_CLK] = &venus0_axi_clk.clkr,
2532         [VENUS0_OCMEMNOC_CLK] = &venus0_ocmemnoc_clk.clkr,
2533         [VENUS0_VCODEC0_CLK] = &venus0_vcodec0_clk.clkr,
2534 };
2535
2536 static const struct qcom_reset_map mmcc_msm8974_resets[] = {
2537         [SPDM_RESET] = { 0x0200 },
2538         [SPDM_RM_RESET] = { 0x0300 },
2539         [VENUS0_RESET] = { 0x1020 },
2540         [MDSS_RESET] = { 0x2300 },
2541         [CAMSS_PHY0_RESET] = { 0x3020 },
2542         [CAMSS_PHY1_RESET] = { 0x3050 },
2543         [CAMSS_PHY2_RESET] = { 0x3080 },
2544         [CAMSS_CSI0_RESET] = { 0x30b0 },
2545         [CAMSS_CSI0PHY_RESET] = { 0x30c0 },
2546         [CAMSS_CSI0RDI_RESET] = { 0x30d0 },
2547         [CAMSS_CSI0PIX_RESET] = { 0x30e0 },
2548         [CAMSS_CSI1_RESET] = { 0x3120 },
2549         [CAMSS_CSI1PHY_RESET] = { 0x3130 },
2550         [CAMSS_CSI1RDI_RESET] = { 0x3140 },
2551         [CAMSS_CSI1PIX_RESET] = { 0x3150 },
2552         [CAMSS_CSI2_RESET] = { 0x3180 },
2553         [CAMSS_CSI2PHY_RESET] = { 0x3190 },
2554         [CAMSS_CSI2RDI_RESET] = { 0x31a0 },
2555         [CAMSS_CSI2PIX_RESET] = { 0x31b0 },
2556         [CAMSS_CSI3_RESET] = { 0x31e0 },
2557         [CAMSS_CSI3PHY_RESET] = { 0x31f0 },
2558         [CAMSS_CSI3RDI_RESET] = { 0x3200 },
2559         [CAMSS_CSI3PIX_RESET] = { 0x3210 },
2560         [CAMSS_ISPIF_RESET] = { 0x3220 },
2561         [CAMSS_CCI_RESET] = { 0x3340 },
2562         [CAMSS_MCLK0_RESET] = { 0x3380 },
2563         [CAMSS_MCLK1_RESET] = { 0x33b0 },
2564         [CAMSS_MCLK2_RESET] = { 0x33e0 },
2565         [CAMSS_MCLK3_RESET] = { 0x3410 },
2566         [CAMSS_GP0_RESET] = { 0x3440 },
2567         [CAMSS_GP1_RESET] = { 0x3470 },
2568         [CAMSS_TOP_RESET] = { 0x3480 },
2569         [CAMSS_MICRO_RESET] = { 0x3490 },
2570         [CAMSS_JPEG_RESET] = { 0x35a0 },
2571         [CAMSS_VFE_RESET] = { 0x36a0 },
2572         [CAMSS_CSI_VFE0_RESET] = { 0x3700 },
2573         [CAMSS_CSI_VFE1_RESET] = { 0x3710 },
2574         [OXILI_RESET] = { 0x4020 },
2575         [OXILICX_RESET] = { 0x4030 },
2576         [OCMEMCX_RESET] = { 0x4050 },
2577         [MMSS_RBCRP_RESET] = { 0x4080 },
2578         [MMSSNOCAHB_RESET] = { 0x5020 },
2579         [MMSSNOCAXI_RESET] = { 0x5060 },
2580         [OCMEMNOC_RESET] = { 0x50b0 },
2581 };
2582
2583 static struct gdsc *mmcc_msm8974_gdscs[] = {
2584         [VENUS0_GDSC] = &venus0_gdsc,
2585         [MDSS_GDSC] = &mdss_gdsc,
2586         [CAMSS_JPEG_GDSC] = &camss_jpeg_gdsc,
2587         [CAMSS_VFE_GDSC] = &camss_vfe_gdsc,
2588         [OXILI_GDSC] = &oxili_gdsc,
2589         [OXILICX_GDSC] = &oxilicx_gdsc,
2590 };
2591
2592 static const struct regmap_config mmcc_msm8974_regmap_config = {
2593         .reg_bits       = 32,
2594         .reg_stride     = 4,
2595         .val_bits       = 32,
2596         .max_register   = 0x5104,
2597         .fast_io        = true,
2598 };
2599
2600 static const struct qcom_cc_desc mmcc_msm8974_desc = {
2601         .config = &mmcc_msm8974_regmap_config,
2602         .clks = mmcc_msm8974_clocks,
2603         .num_clks = ARRAY_SIZE(mmcc_msm8974_clocks),
2604         .resets = mmcc_msm8974_resets,
2605         .num_resets = ARRAY_SIZE(mmcc_msm8974_resets),
2606         .gdscs = mmcc_msm8974_gdscs,
2607         .num_gdscs = ARRAY_SIZE(mmcc_msm8974_gdscs),
2608 };
2609
2610 static const struct of_device_id mmcc_msm8974_match_table[] = {
2611         { .compatible = "qcom,mmcc-msm8974" },
2612         { }
2613 };
2614 MODULE_DEVICE_TABLE(of, mmcc_msm8974_match_table);
2615
2616 static int mmcc_msm8974_probe(struct platform_device *pdev)
2617 {
2618         struct regmap *regmap;
2619
2620         regmap = qcom_cc_map(pdev, &mmcc_msm8974_desc);
2621         if (IS_ERR(regmap))
2622                 return PTR_ERR(regmap);
2623
2624         clk_pll_configure_sr_hpm_lp(&mmpll1, regmap, &mmpll1_config, true);
2625         clk_pll_configure_sr_hpm_lp(&mmpll3, regmap, &mmpll3_config, false);
2626
2627         return qcom_cc_really_probe(pdev, &mmcc_msm8974_desc, regmap);
2628 }
2629
2630 static struct platform_driver mmcc_msm8974_driver = {
2631         .probe          = mmcc_msm8974_probe,
2632         .driver         = {
2633                 .name   = "mmcc-msm8974",
2634                 .of_match_table = mmcc_msm8974_match_table,
2635         },
2636 };
2637 module_platform_driver(mmcc_msm8974_driver);
2638
2639 MODULE_DESCRIPTION("QCOM MMCC MSM8974 Driver");
2640 MODULE_LICENSE("GPL v2");
2641 MODULE_ALIAS("platform:mmcc-msm8974");