]> www.infradead.org Git - users/jedix/linux-maple.git/commitdiff
Merge tag 'soc-dt-6.11' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc
authorLinus Torvalds <torvalds@linux-foundation.org>
Tue, 16 Jul 2024 18:43:51 +0000 (11:43 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 16 Jul 2024 18:43:51 +0000 (11:43 -0700)
Pull SoC dt updates from Arnd Bergmann:
 "The devicetree updates are fairly well spread out across platforms,
  with Qualcomm making up about a third of the total.

  There are three new SoCs in existing product families this:

   - NXP i.MX95 is a variant of i.MX93, now with six Cortex-A55 cores
     instead of just two as well as a GPU and more high-speed I/O
     devices.

   - Qualcomm QCS8550 is a variant of SM8550 for IOT devices

   - Airoha EN7581 is a 10G-PON network chip and related to the MT7981
     Wireless router chip from its parent Mediatek.

  In total there are 58 new machines, including four riscv boards and
  eight for 32-bit arm.

  The most exciting new addition is probably a pair of laptops based on
  the Qualcomm x1e80100 (Snapdragon X1 Elite) chip, the Asus Vivobook
  S15 and the Lenovo Yoga Slim7x.

  Other noteworthy new additions are:

   - A total of 20 Qualcomm based machines, mostly Android devices from
     Samsung, Motorola and LG, as well as a wireless router and some
     reference designs

   - Six NXP i.MX based machines, mostly industrial boards along with
     some reference designs

   - Mediatek sees some interesting Filogic based routers including the
     "OpenWRT One", a few new Chromebooks as well as single-board
     computers.

   - Four machines from Solidrun based on Marvell cn913x, replacing the
     older Armada 8000 based counterparts

   - The four Amlogic machines are all set top boxes or reference
     designs for them

   - The nine new Rockchips machines are mostly single-board computers
     including some interesting ones based on the rk3588 chip like the
     ROCK 5 ITX board and the CM3588 with its four NVMe slots

   - The RISC-V boards are all single-board computers based on Starfive
     JH7110, Microchip MPFS and Allwinner D1, which all had similar
     boards already

  There are also a lot of updates to already supported machines, notably
  for the TI K3, Rockchips, Freescale and of course Qualcomm platforms"

* tag 'soc-dt-6.11' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc: (846 commits)
  arm64: dts: allwinner: h616: add crypto engine node
  riscv: dts: add clock generator for Sophgo SG2042 SoC
  arm64: dts: rockchip: Add Xunlong Orange Pi 3B
  dt-bindings: arm: rockchip: Add Xunlong Orange Pi 3B
  arm64: dts: rockchip: Add Radxa ROCK 3B
  dt-bindings: arm: rockchip: Add Radxa ROCK 3B
  mailmap: Update Luca Weiss's email address
  ARM: dts: ixp4xx: nslu2: beeper uses PWM
  arm64: dts: rockchip: add ROCK 5 ITX board
  dt-bindings: arm: rockchip: Add ROCK 5 ITX board
  arm64: dts: rockchip: Add dma-names to uart1 on Pine64 rk3566 devices
  arm64: dts: rockchip: Add avdd supplies to hdmi on rock64
  arm64: dts: qcom: msm8916-lg-c50: add initial dts for LG Leon LTE
  arm64: dts: qcom: msm8916-lg-m216: Add initial device tree
  dt-bindings: arm: qcom: Add msm8916 based LG devices
  ARM: dts: qcom: msm8960: correct memory base
  arm64: dts: qcom: ipq9574: Add icc provider ability to gcc
  dt-bindings: interconnect: Add Qualcomm IPQ9574 support
  arm64: dts: qcom: sm8150: Add video clock controller node
  arm64: dts: qcom: pm6150: Add vibrator
  ...

16 files changed:
1  2 
.mailmap
MAINTAINERS
arch/arm/boot/dts/rockchip/rk3066a.dtsi
arch/arm64/boot/dts/qcom/qdu1000.dtsi
arch/arm64/boot/dts/qcom/sc8280xp-crd.dts
arch/arm64/boot/dts/qcom/sc8280xp-lenovo-thinkpad-x13s.dts
arch/arm64/boot/dts/qcom/sm6115.dtsi
arch/arm64/boot/dts/qcom/x1e80100-crd.dts
arch/arm64/boot/dts/rockchip/rk3308-rock-pi-s.dts
arch/arm64/boot/dts/rockchip/rk3308.dtsi
arch/arm64/boot/dts/rockchip/rk3566-quartz64-b.dts
arch/arm64/boot/dts/rockchip/rk3588-quartzpro64.dts
arch/arm64/boot/dts/rockchip/rk3588-rock-5b.dts
arch/arm64/boot/dts/rockchip/rk3588s-rock-5a.dts
arch/riscv/boot/dts/starfive/jh7110-common.dtsi
drivers/clk/qcom/camcc-sm8650.c

diff --cc .mailmap
index 29a5fedee49ca56ab89b7117dab2549d83007736,e169a99ce7c70f2f627facb0532e81f0f6bd2a51..38f8bed507a22cc621f75f5cd6ebbcdcb374b8d5
+++ b/.mailmap
@@@ -384,8 -384,8 +384,9 @@@ Li Yang <leoyang.li@nxp.com> <leoli@fre
  Li Yang <leoyang.li@nxp.com> <leo@zh-kernel.org>
  Lior David <quic_liord@quicinc.com> <liord@codeaurora.org>
  Lorenzo Pieralisi <lpieralisi@kernel.org> <lorenzo.pieralisi@arm.com>
 +Lorenzo Stoakes <lorenzo.stoakes@oracle.com> <lstoakes@gmail.com>
  Luca Ceresoli <luca.ceresoli@bootlin.com> <luca@lucaceresoli.net>
+ Luca Weiss <luca@lucaweiss.eu> <luca@z3ntu.xyz>
  Lukasz Luba <lukasz.luba@arm.com> <l.luba@partner.samsung.com>
  Luo Jie <quic_luoj@quicinc.com> <luoj@codeaurora.org>
  Maciej W. Rozycki <macro@mips.com> <macro@imgtec.com>
diff --cc MAINTAINERS
index 542edd473de85e857d71eb253fb33de757c36298,ff9104c932c3b09c6f05d03bce3851176cb2c20d..ee3a3bbae1c194224e9168c5a3406783a932a9b9
@@@ -2190,8 -2228,8 +2208,9 @@@ F:      Documentation/ABI/testing/sysfs-bus-
  F:    Documentation/ABI/testing/sysfs-firmware-turris-mox-rwtm
  F:    Documentation/devicetree/bindings/bus/moxtet.txt
  F:    Documentation/devicetree/bindings/firmware/cznic,turris-mox-rwtm.txt
 +F:    Documentation/devicetree/bindings/firmware/cznic,turris-omnia-mcu.yaml
  F:    Documentation/devicetree/bindings/gpio/gpio-moxtet.txt
+ F:    Documentation/devicetree/bindings/interrupt-controller/marvell,mpic.yaml
  F:    Documentation/devicetree/bindings/leds/cznic,turris-omnia-leds.yaml
  F:    Documentation/devicetree/bindings/watchdog/armada-37xx-wdt.txt
  F:    drivers/bus/moxtet.c
index f90f03fa6a24fc0a8159c9b36635c32b7ef69495,31329cbe0976e954b827712217aec83b7aee140f..642ca8f0236b3944c5962e5b12b5959cd349812f
  
                system-cache-controller@19200000 {
                        compatible = "qcom,qdu1000-llcc";
 -                      reg = <0 0x19200000 0 0xd80000>,
 +                      reg = <0 0x19200000 0 0x80000>,
 +                            <0 0x19300000 0 0x80000>,
 +                            <0 0x19600000 0 0x80000>,
 +                            <0 0x19700000 0 0x80000>,
 +                            <0 0x19a00000 0 0x80000>,
 +                            <0 0x19b00000 0 0x80000>,
 +                            <0 0x19e00000 0 0x80000>,
 +                            <0 0x19f00000 0 0x80000>,
                              <0 0x1a200000 0 0x80000>;
                        reg-names = "llcc0_base",
 +                                  "llcc1_base",
 +                                  "llcc2_base",
 +                                  "llcc3_base",
 +                                  "llcc4_base",
 +                                  "llcc5_base",
 +                                  "llcc6_base",
 +                                  "llcc7_base",
                                    "llcc_broadcast_base";
                        interrupts = <GIC_SPI 266 IRQ_TYPE_LEVEL_HIGH>;
+                       nvmem-cells = <&multi_chan_ddr>;
+                       nvmem-cell-names = "multi-chan-ddr";
+               };
+               sec_qfprom: efuse@221c8000 {
+                       compatible = "qcom,qdu1000-sec-qfprom", "qcom,sec-qfprom";
+                       reg = <0 0x221c8000 0 0x1000>;
+                       #address-cells = <1>;
+                       #size-cells = <1>;
+                       multi_chan_ddr: multi-chan-ddr@12b {
+                               reg = <0x12b 0x1>;
+                               bits = <0 2>;
+                       };
                };
        };
  
index 9ed062150aaf20dd0a32d049035301f767fb59d0,aec6ca5941c22ef1e13eb68c24eb98a9bff76c09..e374733f3b856eacdc22efd2f698e37d041f5390
                                 <&gcc GCC_SDCC1_ICE_CORE_CLK>;
                        clock-names = "iface", "core", "xo", "ice";
  
+                       resets = <&gcc GCC_SDCC1_BCR>;
                        power-domains = <&rpmpd SM6115_VDDCX>;
                        operating-points-v2 = <&sdhc1_opp_table>;
 +                      iommus = <&apps_smmu 0x00c0 0x0>;
                        interconnects = <&system_noc MASTER_SDCC_1 RPM_ALWAYS_TAG
                                         &bimc SLAVE_EBI_CH0 RPM_ALWAYS_TAG>,
                                        <&bimc MASTER_AMPSS_M0 RPM_ALWAYS_TAG
index 079101cddd65fa102cb1e40c4bbfa2433ce0dbbf,0b973c1a5ef9c15cd67ed83c7c75504be90281ef..62d18ca769a107914273df55cb2fbb9fe13026e7
        pinctrl-names = "default";
        pinctrl-0 = <&rtc_32k>;
  
+       bluetooth {
+               bt_reg_on: bt-reg-on {
+                       rockchip,pins = <4 RK_PB3 RK_FUNC_GPIO &pcfg_pull_none>;
+               };
+               bt_wake_host: bt-wake-host {
+                       rockchip,pins = <4 RK_PB4 RK_FUNC_GPIO &pcfg_pull_down>;
+               };
+               host_wake_bt: host-wake-bt {
+                       rockchip,pins = <4 RK_PB2 RK_FUNC_GPIO &pcfg_pull_none>;
+               };
+       };
+       gmac {
+               mac_rst: mac-rst {
+                       rockchip,pins = <0 RK_PA7 RK_FUNC_GPIO &pcfg_pull_none>;
+               };
+       };
        leds {
 -              green_led_gio: green-led-gpio {
 +              green_led: green-led {
                        rockchip,pins = <0 RK_PA6 RK_FUNC_GPIO &pcfg_pull_none>;
                };
  
index 0000000000000000000000000000000000000000,a37e52a67ed4dde59731598bcd4b8e4d1bf9c546..1b28e086e5199863b219e54745e4afc8d32f284e
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,3591 +1,3591 @@@
 -      ret = qcom_cc_really_probe(&pdev->dev, &cam_cc_sm8650_desc, regmap);
+ // SPDX-License-Identifier: GPL-2.0-only
+ /*
+  * Copyright (c) 2024, Qualcomm Innovation Center, Inc. All rights reserved.
+  */
+ #include <linux/clk-provider.h>
+ #include <linux/mod_devicetable.h>
+ #include <linux/module.h>
+ #include <linux/platform_device.h>
+ #include <linux/pm_runtime.h>
+ #include <linux/regmap.h>
+ #include <dt-bindings/clock/qcom,sm8650-camcc.h>
+ #include "clk-alpha-pll.h"
+ #include "clk-branch.h"
+ #include "clk-rcg.h"
+ #include "clk-regmap.h"
+ #include "common.h"
+ #include "gdsc.h"
+ #include "reset.h"
+ enum {
+       DT_IFACE,
+       DT_BI_TCXO,
+       DT_BI_TCXO_AO,
+       DT_SLEEP_CLK,
+ };
+ enum {
+       P_BI_TCXO,
+       P_BI_TCXO_AO,
+       P_CAM_CC_PLL0_OUT_EVEN,
+       P_CAM_CC_PLL0_OUT_MAIN,
+       P_CAM_CC_PLL0_OUT_ODD,
+       P_CAM_CC_PLL1_OUT_EVEN,
+       P_CAM_CC_PLL2_OUT_EVEN,
+       P_CAM_CC_PLL2_OUT_MAIN,
+       P_CAM_CC_PLL3_OUT_EVEN,
+       P_CAM_CC_PLL4_OUT_EVEN,
+       P_CAM_CC_PLL5_OUT_EVEN,
+       P_CAM_CC_PLL6_OUT_EVEN,
+       P_CAM_CC_PLL7_OUT_EVEN,
+       P_CAM_CC_PLL8_OUT_EVEN,
+       P_CAM_CC_PLL9_OUT_EVEN,
+       P_CAM_CC_PLL9_OUT_ODD,
+       P_CAM_CC_PLL10_OUT_EVEN,
+       P_SLEEP_CLK,
+ };
+ static const struct pll_vco lucid_ole_vco[] = {
+       { 249600000, 2300000000, 0 },
+ };
+ static const struct pll_vco rivian_ole_vco[] = {
+       { 777000000, 1285000000, 0 },
+ };
+ static const struct alpha_pll_config cam_cc_pll0_config = {
+       .l = 0x3e,
+       .alpha = 0x8000,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00008400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll0 = {
+       .offset = 0x0,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll0",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll0_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll0_out_even = {
+       .offset = 0x0,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll0_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll0_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll0_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll0.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll0_out_odd[] = {
+       { 0x2, 3 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll0_out_odd = {
+       .offset = 0x0,
+       .post_div_shift = 14,
+       .post_div_table = post_div_table_cam_cc_pll0_out_odd,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll0_out_odd),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll0_out_odd",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll0.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll1_config = {
+       .l = 0x31,
+       .alpha = 0x7aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll1 = {
+       .offset = 0x1000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll1",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll1_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll1_out_even = {
+       .offset = 0x1000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll1_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll1_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll1_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll1.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll2_config = {
+       .l = 0x32,
+       .alpha = 0x0,
+       .config_ctl_val = 0x10000030,
+       .config_ctl_hi_val = 0x80890263,
+       .config_ctl_hi1_val = 0x00000217,
+       .user_ctl_val = 0x00000001,
+       .user_ctl_hi_val = 0x00000000,
+ };
+ static struct clk_alpha_pll cam_cc_pll2 = {
+       .offset = 0x2000,
+       .vco_table = rivian_ole_vco,
+       .num_vco = ARRAY_SIZE(rivian_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_RIVIAN_EVO],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll2",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_rivian_evo_ops,
+               },
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll3_config = {
+       .l = 0x30,
+       .alpha = 0x8aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll3 = {
+       .offset = 0x3000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll3",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll3_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll3_out_even = {
+       .offset = 0x3000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll3_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll3_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll3_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll3.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll4_config = {
+       .l = 0x30,
+       .alpha = 0x8aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll4 = {
+       .offset = 0x4000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll4",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll4_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll4_out_even = {
+       .offset = 0x4000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll4_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll4_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll4_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll4.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll5_config = {
+       .l = 0x30,
+       .alpha = 0x8aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll5 = {
+       .offset = 0x5000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll5",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll5_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll5_out_even = {
+       .offset = 0x5000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll5_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll5_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll5_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll5.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll6_config = {
+       .l = 0x30,
+       .alpha = 0x8aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll6 = {
+       .offset = 0x6000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll6",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll6_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll6_out_even = {
+       .offset = 0x6000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll6_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll6_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll6_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll6.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll7_config = {
+       .l = 0x30,
+       .alpha = 0x8aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll7 = {
+       .offset = 0x7000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll7",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll7_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll7_out_even = {
+       .offset = 0x7000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll7_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll7_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll7_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll7.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll8_config = {
+       .l = 0x14,
+       .alpha = 0xd555,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll8 = {
+       .offset = 0x8000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll8",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll8_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll8_out_even = {
+       .offset = 0x8000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll8_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll8_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll8_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll8.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll9_config = {
+       .l = 0x32,
+       .alpha = 0x0,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00008400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll9 = {
+       .offset = 0x9000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll9",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll9_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll9_out_even = {
+       .offset = 0x9000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll9_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll9_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll9_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll9.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll9_out_odd[] = {
+       { 0x2, 3 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll9_out_odd = {
+       .offset = 0x9000,
+       .post_div_shift = 14,
+       .post_div_table = post_div_table_cam_cc_pll9_out_odd,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll9_out_odd),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll9_out_odd",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll9.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct alpha_pll_config cam_cc_pll10_config = {
+       .l = 0x30,
+       .alpha = 0x8aaa,
+       .config_ctl_val = 0x20485699,
+       .config_ctl_hi_val = 0x00182261,
+       .config_ctl_hi1_val = 0x82aa299c,
+       .test_ctl_val = 0x00000000,
+       .test_ctl_hi_val = 0x00000003,
+       .test_ctl_hi1_val = 0x00009000,
+       .test_ctl_hi2_val = 0x00000034,
+       .user_ctl_val = 0x00000400,
+       .user_ctl_hi_val = 0x00000005,
+ };
+ static struct clk_alpha_pll cam_cc_pll10 = {
+       .offset = 0xa000,
+       .vco_table = lucid_ole_vco,
+       .num_vco = ARRAY_SIZE(lucid_ole_vco),
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr = {
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_pll10",
+                       .parent_data = &(const struct clk_parent_data) {
+                               .index = DT_BI_TCXO,
+                       },
+                       .num_parents = 1,
+                       .ops = &clk_alpha_pll_lucid_evo_ops,
+               },
+       },
+ };
+ static const struct clk_div_table post_div_table_cam_cc_pll10_out_even[] = {
+       { 0x1, 2 },
+       { }
+ };
+ static struct clk_alpha_pll_postdiv cam_cc_pll10_out_even = {
+       .offset = 0xa000,
+       .post_div_shift = 10,
+       .post_div_table = post_div_table_cam_cc_pll10_out_even,
+       .num_post_div = ARRAY_SIZE(post_div_table_cam_cc_pll10_out_even),
+       .width = 4,
+       .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_LUCID_OLE],
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_pll10_out_even",
+               .parent_hws = (const struct clk_hw*[]) {
+                       &cam_cc_pll10.clkr.hw,
+               },
+               .num_parents = 1,
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_alpha_pll_postdiv_lucid_ole_ops,
+       },
+ };
+ static const struct parent_map cam_cc_parent_map_0[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL0_OUT_MAIN, 1 },
+       { P_CAM_CC_PLL0_OUT_EVEN, 2 },
+       { P_CAM_CC_PLL0_OUT_ODD, 3 },
+       { P_CAM_CC_PLL9_OUT_ODD, 4 },
+       { P_CAM_CC_PLL9_OUT_EVEN, 5 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_0[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll0.clkr.hw },
+       { .hw = &cam_cc_pll0_out_even.clkr.hw },
+       { .hw = &cam_cc_pll0_out_odd.clkr.hw },
+       { .hw = &cam_cc_pll9_out_odd.clkr.hw },
+       { .hw = &cam_cc_pll9_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_1[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL2_OUT_EVEN, 3 },
+       { P_CAM_CC_PLL2_OUT_MAIN, 5 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_1[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll2.clkr.hw },
+       { .hw = &cam_cc_pll2.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_2[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL8_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_2[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll8_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_3[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL3_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_3[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll3_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_4[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL4_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_4[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll4_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_5[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL5_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_5[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll5_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_6[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL1_OUT_EVEN, 4 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_6[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll1_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_7[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL6_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_7[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll6_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_8[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL7_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_8[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll7_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_9[] = {
+       { P_BI_TCXO, 0 },
+       { P_CAM_CC_PLL10_OUT_EVEN, 6 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_9[] = {
+       { .index = DT_BI_TCXO },
+       { .hw = &cam_cc_pll10_out_even.clkr.hw },
+ };
+ static const struct parent_map cam_cc_parent_map_10[] = {
+       { P_SLEEP_CLK, 0 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_10[] = {
+       { .index = DT_SLEEP_CLK },
+ };
+ static const struct parent_map cam_cc_parent_map_11_ao[] = {
+       { P_BI_TCXO_AO, 0 },
+ };
+ static const struct clk_parent_data cam_cc_parent_data_11_ao[] = {
+       { .index = DT_BI_TCXO_AO },
+ };
+ static const struct freq_tbl ftbl_cam_cc_bps_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(200000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
+       F(400000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
+       F(480000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL8_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_bps_clk_src = {
+       .cmd_rcgr = 0x10050,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_2,
+       .freq_tbl = ftbl_cam_cc_bps_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_bps_clk_src",
+               .parent_data = cam_cc_parent_data_2,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_2),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_camnoc_axi_rt_clk_src[] = {
+       F(300000000, P_CAM_CC_PLL0_OUT_EVEN, 2, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_camnoc_axi_rt_clk_src = {
+       .cmd_rcgr = 0x1325c,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_camnoc_axi_rt_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_camnoc_axi_rt_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_cci_0_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(37500000, P_CAM_CC_PLL0_OUT_EVEN, 16, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_cci_0_clk_src = {
+       .cmd_rcgr = 0x131cc,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_cci_0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_cci_0_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_cci_1_clk_src = {
+       .cmd_rcgr = 0x131e8,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_cci_0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_cci_1_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_cci_2_clk_src = {
+       .cmd_rcgr = 0x13204,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_cci_0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_cci_2_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_cphy_rx_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
+       F(480000000, P_CAM_CC_PLL0_OUT_MAIN, 2.5, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_cphy_rx_clk_src = {
+       .cmd_rcgr = 0x1104c,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_cphy_rx_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_cphy_rx_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_cre_clk_src[] = {
+       F(200000000, P_CAM_CC_PLL0_OUT_ODD, 2, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
+       F(480000000, P_CAM_CC_PLL9_OUT_EVEN, 1, 0, 0),
+       F(600000000, P_CAM_CC_PLL0_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_cre_clk_src = {
+       .cmd_rcgr = 0x13144,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_cre_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_cre_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_csi0phytimer_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_csi0phytimer_clk_src = {
+       .cmd_rcgr = 0x150e0,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi0phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi1phytimer_clk_src = {
+       .cmd_rcgr = 0x15104,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi1phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi2phytimer_clk_src = {
+       .cmd_rcgr = 0x15124,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi2phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi3phytimer_clk_src = {
+       .cmd_rcgr = 0x15144,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi3phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi4phytimer_clk_src = {
+       .cmd_rcgr = 0x15164,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi4phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi5phytimer_clk_src = {
+       .cmd_rcgr = 0x15184,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi5phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi6phytimer_clk_src = {
+       .cmd_rcgr = 0x151a4,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi6phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_csi7phytimer_clk_src = {
+       .cmd_rcgr = 0x151c4,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csi0phytimer_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csi7phytimer_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_csid_clk_src[] = {
+       F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
+       F(480000000, P_CAM_CC_PLL0_OUT_MAIN, 2.5, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_csid_clk_src = {
+       .cmd_rcgr = 0x13238,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csid_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_csid_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_fast_ahb_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(300000000, P_CAM_CC_PLL0_OUT_EVEN, 2, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_MAIN, 3, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_fast_ahb_clk_src = {
+       .cmd_rcgr = 0x10018,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_fast_ahb_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_fast_ahb_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_icp_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
+       F(480000000, P_CAM_CC_PLL9_OUT_EVEN, 1, 0, 0),
+       F(600000000, P_CAM_CC_PLL0_OUT_MAIN, 2, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_icp_clk_src = {
+       .cmd_rcgr = 0x131a4,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_icp_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_icp_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_ife_0_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(466000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
+       F(594000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL3_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_ife_0_clk_src = {
+       .cmd_rcgr = 0x11018,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_3,
+       .freq_tbl = ftbl_cam_cc_ife_0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_ife_0_clk_src",
+               .parent_data = cam_cc_parent_data_3,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_3),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_ife_1_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(466000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
+       F(594000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL4_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_ife_1_clk_src = {
+       .cmd_rcgr = 0x12018,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_4,
+       .freq_tbl = ftbl_cam_cc_ife_1_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_ife_1_clk_src",
+               .parent_data = cam_cc_parent_data_4,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_4),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_ife_2_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(466000000, P_CAM_CC_PLL5_OUT_EVEN, 1, 0, 0),
+       F(594000000, P_CAM_CC_PLL5_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL5_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL5_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_ife_2_clk_src = {
+       .cmd_rcgr = 0x12068,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_5,
+       .freq_tbl = ftbl_cam_cc_ife_2_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_ife_2_clk_src",
+               .parent_data = cam_cc_parent_data_5,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_5),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_ife_lite_clk_src = {
+       .cmd_rcgr = 0x13000,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csid_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_ife_lite_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_ife_lite_csid_clk_src = {
+       .cmd_rcgr = 0x13028,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_csid_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_ife_lite_csid_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_ipe_nps_clk_src[] = {
+       F(475000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
+       F(575000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
+       F(825000000, P_CAM_CC_PLL1_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_ipe_nps_clk_src = {
+       .cmd_rcgr = 0x10094,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_6,
+       .freq_tbl = ftbl_cam_cc_ipe_nps_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_ipe_nps_clk_src",
+               .parent_data = cam_cc_parent_data_6,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_6),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_jpeg_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(200000000, P_CAM_CC_PLL0_OUT_ODD, 2, 0, 0),
+       F(400000000, P_CAM_CC_PLL0_OUT_ODD, 1, 0, 0),
+       F(480000000, P_CAM_CC_PLL9_OUT_EVEN, 1, 0, 0),
+       F(600000000, P_CAM_CC_PLL0_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_jpeg_clk_src = {
+       .cmd_rcgr = 0x13168,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_jpeg_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_jpeg_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_mclk0_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(24000000, P_CAM_CC_PLL2_OUT_EVEN, 10, 1, 4),
+       F(68571429, P_CAM_CC_PLL2_OUT_MAIN, 14, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_mclk0_clk_src = {
+       .cmd_rcgr = 0x15000,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk0_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk1_clk_src = {
+       .cmd_rcgr = 0x1501c,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk1_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk2_clk_src = {
+       .cmd_rcgr = 0x15038,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk2_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk3_clk_src = {
+       .cmd_rcgr = 0x15054,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk3_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk4_clk_src = {
+       .cmd_rcgr = 0x15070,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk4_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk5_clk_src = {
+       .cmd_rcgr = 0x1508c,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk5_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk6_clk_src = {
+       .cmd_rcgr = 0x150a8,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk6_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_rcg2 cam_cc_mclk7_clk_src = {
+       .cmd_rcgr = 0x150c4,
+       .mnd_width = 8,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_1,
+       .freq_tbl = ftbl_cam_cc_mclk0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_mclk7_clk_src",
+               .parent_data = cam_cc_parent_data_1,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_1),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_qdss_debug_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(75000000, P_CAM_CC_PLL0_OUT_EVEN, 8, 0, 0),
+       F(150000000, P_CAM_CC_PLL0_OUT_EVEN, 4, 0, 0),
+       F(300000000, P_CAM_CC_PLL0_OUT_MAIN, 4, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_qdss_debug_clk_src = {
+       .cmd_rcgr = 0x1329c,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_qdss_debug_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_qdss_debug_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_sfe_0_clk_src[] = {
+       F(466000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
+       F(594000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL6_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_sfe_0_clk_src = {
+       .cmd_rcgr = 0x1306c,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_7,
+       .freq_tbl = ftbl_cam_cc_sfe_0_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_sfe_0_clk_src",
+               .parent_data = cam_cc_parent_data_7,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_7),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_sfe_1_clk_src[] = {
+       F(466000000, P_CAM_CC_PLL7_OUT_EVEN, 1, 0, 0),
+       F(594000000, P_CAM_CC_PLL7_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL7_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL7_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_sfe_1_clk_src = {
+       .cmd_rcgr = 0x130bc,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_8,
+       .freq_tbl = ftbl_cam_cc_sfe_1_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_sfe_1_clk_src",
+               .parent_data = cam_cc_parent_data_8,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_8),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_sfe_2_clk_src[] = {
+       F(466000000, P_CAM_CC_PLL10_OUT_EVEN, 1, 0, 0),
+       F(594000000, P_CAM_CC_PLL10_OUT_EVEN, 1, 0, 0),
+       F(675000000, P_CAM_CC_PLL10_OUT_EVEN, 1, 0, 0),
+       F(785000000, P_CAM_CC_PLL10_OUT_EVEN, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_sfe_2_clk_src = {
+       .cmd_rcgr = 0x1310c,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_9,
+       .freq_tbl = ftbl_cam_cc_sfe_2_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_sfe_2_clk_src",
+               .parent_data = cam_cc_parent_data_9,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_9),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_sleep_clk_src[] = {
+       F(32000, P_SLEEP_CLK, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_sleep_clk_src = {
+       .cmd_rcgr = 0x132f0,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_10,
+       .freq_tbl = ftbl_cam_cc_sleep_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_sleep_clk_src",
+               .parent_data = cam_cc_parent_data_10,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_10),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_slow_ahb_clk_src[] = {
+       F(19200000, P_BI_TCXO, 1, 0, 0),
+       F(80000000, P_CAM_CC_PLL0_OUT_EVEN, 7.5, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_slow_ahb_clk_src = {
+       .cmd_rcgr = 0x10034,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_0,
+       .freq_tbl = ftbl_cam_cc_slow_ahb_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_slow_ahb_clk_src",
+               .parent_data = cam_cc_parent_data_0,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_0),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static const struct freq_tbl ftbl_cam_cc_xo_clk_src[] = {
+       F(19200000, P_BI_TCXO_AO, 1, 0, 0),
+       { }
+ };
+ static struct clk_rcg2 cam_cc_xo_clk_src = {
+       .cmd_rcgr = 0x132d4,
+       .mnd_width = 0,
+       .hid_width = 5,
+       .parent_map = cam_cc_parent_map_11_ao,
+       .freq_tbl = ftbl_cam_cc_xo_clk_src,
+       .clkr.hw.init = &(const struct clk_init_data) {
+               .name = "cam_cc_xo_clk_src",
+               .parent_data = cam_cc_parent_data_11_ao,
+               .num_parents = ARRAY_SIZE(cam_cc_parent_data_11_ao),
+               .flags = CLK_SET_RATE_PARENT,
+               .ops = &clk_rcg2_shared_ops,
+       },
+ };
+ static struct clk_branch cam_cc_bps_ahb_clk = {
+       .halt_reg = 0x1004c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1004c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_bps_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_bps_clk = {
+       .halt_reg = 0x10068,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x10068,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_bps_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_bps_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_bps_fast_ahb_clk = {
+       .halt_reg = 0x10030,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x10030,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_bps_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_bps_shift_clk = {
+       .halt_reg = 0x10078,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x10078,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_bps_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_camnoc_axi_nrt_clk = {
+       .halt_reg = 0x13284,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13284,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_camnoc_axi_nrt_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_camnoc_axi_rt_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_camnoc_axi_rt_clk = {
+       .halt_reg = 0x13274,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13274,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_camnoc_axi_rt_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_camnoc_axi_rt_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_camnoc_dcd_xo_clk = {
+       .halt_reg = 0x13290,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13290,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_camnoc_dcd_xo_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_camnoc_xo_clk = {
+       .halt_reg = 0x13294,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13294,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_camnoc_xo_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cci_0_clk = {
+       .halt_reg = 0x131e4,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x131e4,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cci_0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cci_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cci_1_clk = {
+       .halt_reg = 0x13200,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13200,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cci_1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cci_1_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cci_2_clk = {
+       .halt_reg = 0x1321c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1321c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cci_2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cci_2_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_core_ahb_clk = {
+       .halt_reg = 0x132d0,
+       .halt_check = BRANCH_HALT_DELAY,
+       .clkr = {
+               .enable_reg = 0x132d0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_core_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_ahb_clk = {
+       .halt_reg = 0x13220,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13220,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_bps_clk = {
+       .halt_reg = 0x10074,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x10074,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_bps_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_bps_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_cre_clk = {
+       .halt_reg = 0x13160,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13160,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_cre_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cre_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_fast_ahb_clk = {
+       .halt_reg = 0x1322c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1322c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_ife_0_clk = {
+       .halt_reg = 0x1103c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1103c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_ife_0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_ife_1_clk = {
+       .halt_reg = 0x1203c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1203c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_ife_1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_1_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_ife_2_clk = {
+       .halt_reg = 0x1208c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1208c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_ife_2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_2_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_ife_lite_clk = {
+       .halt_reg = 0x13024,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13024,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_ife_lite_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_lite_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_ipe_nps_clk = {
+       .halt_reg = 0x100b8,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100b8,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_ipe_nps_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ipe_nps_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_sbi_clk = {
+       .halt_reg = 0x10104,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x10104,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_sbi_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_sfe_0_clk = {
+       .halt_reg = 0x13090,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13090,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_sfe_0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_sfe_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_sfe_1_clk = {
+       .halt_reg = 0x130e0,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x130e0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_sfe_1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_sfe_1_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cpas_sfe_2_clk = {
+       .halt_reg = 0x13130,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13130,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cpas_sfe_2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_sfe_2_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cre_ahb_clk = {
+       .halt_reg = 0x13164,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13164,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cre_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_cre_clk = {
+       .halt_reg = 0x1315c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1315c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_cre_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cre_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi0phytimer_clk = {
+       .halt_reg = 0x150f8,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x150f8,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi0phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi0phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi1phytimer_clk = {
+       .halt_reg = 0x1511c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1511c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi1phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi1phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi2phytimer_clk = {
+       .halt_reg = 0x1513c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1513c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi2phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi2phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi3phytimer_clk = {
+       .halt_reg = 0x1515c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1515c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi3phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi3phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi4phytimer_clk = {
+       .halt_reg = 0x1517c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1517c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi4phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi4phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi5phytimer_clk = {
+       .halt_reg = 0x1519c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1519c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi5phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi5phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi6phytimer_clk = {
+       .halt_reg = 0x151bc,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x151bc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi6phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi6phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csi7phytimer_clk = {
+       .halt_reg = 0x151dc,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x151dc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csi7phytimer_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csi7phytimer_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csid_clk = {
+       .halt_reg = 0x13250,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13250,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csid_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_csid_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csid_csiphy_rx_clk = {
+       .halt_reg = 0x15100,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15100,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csid_csiphy_rx_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy0_clk = {
+       .halt_reg = 0x150fc,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x150fc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy1_clk = {
+       .halt_reg = 0x15120,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15120,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy2_clk = {
+       .halt_reg = 0x15140,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15140,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy3_clk = {
+       .halt_reg = 0x15160,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15160,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy3_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy4_clk = {
+       .halt_reg = 0x15180,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15180,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy4_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy5_clk = {
+       .halt_reg = 0x151a0,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x151a0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy5_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy6_clk = {
+       .halt_reg = 0x151c0,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x151c0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy6_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_csiphy7_clk = {
+       .halt_reg = 0x151e0,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x151e0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_csiphy7_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_icp_ahb_clk = {
+       .halt_reg = 0x131c8,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x131c8,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_icp_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_icp_clk = {
+       .halt_reg = 0x131bc,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x131bc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_icp_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_icp_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_0_clk = {
+       .halt_reg = 0x11030,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x11030,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_0_fast_ahb_clk = {
+       .halt_reg = 0x11048,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x11048,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_0_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_0_shift_clk = {
+       .halt_reg = 0x11064,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x11064,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_0_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_1_clk = {
+       .halt_reg = 0x12030,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x12030,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_1_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_1_fast_ahb_clk = {
+       .halt_reg = 0x12048,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x12048,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_1_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_1_shift_clk = {
+       .halt_reg = 0x1204c,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x1204c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_1_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_2_clk = {
+       .halt_reg = 0x12080,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x12080,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_2_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_2_fast_ahb_clk = {
+       .halt_reg = 0x12098,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x12098,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_2_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_2_shift_clk = {
+       .halt_reg = 0x1209c,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x1209c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_2_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_lite_ahb_clk = {
+       .halt_reg = 0x13050,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13050,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_lite_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_lite_clk = {
+       .halt_reg = 0x13018,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13018,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_lite_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_lite_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_lite_cphy_rx_clk = {
+       .halt_reg = 0x1304c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1304c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_lite_cphy_rx_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_cphy_rx_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ife_lite_csid_clk = {
+       .halt_reg = 0x13040,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13040,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ife_lite_csid_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_lite_csid_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ipe_nps_ahb_clk = {
+       .halt_reg = 0x100d0,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100d0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ipe_nps_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_slow_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ipe_nps_clk = {
+       .halt_reg = 0x100ac,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100ac,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ipe_nps_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ipe_nps_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ipe_nps_fast_ahb_clk = {
+       .halt_reg = 0x100d4,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100d4,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ipe_nps_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ipe_pps_clk = {
+       .halt_reg = 0x100bc,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100bc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ipe_pps_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ipe_nps_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ipe_pps_fast_ahb_clk = {
+       .halt_reg = 0x100d8,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100d8,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ipe_pps_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_ipe_shift_clk = {
+       .halt_reg = 0x100dc,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x100dc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_ipe_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_jpeg_1_clk = {
+       .halt_reg = 0x1318c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1318c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_jpeg_1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_jpeg_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_jpeg_clk = {
+       .halt_reg = 0x13180,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13180,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_jpeg_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_jpeg_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk0_clk = {
+       .halt_reg = 0x15018,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15018,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk1_clk = {
+       .halt_reg = 0x15034,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15034,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk1_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk2_clk = {
+       .halt_reg = 0x15050,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15050,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk2_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk3_clk = {
+       .halt_reg = 0x1506c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1506c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk3_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk3_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk4_clk = {
+       .halt_reg = 0x15088,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x15088,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk4_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk4_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk5_clk = {
+       .halt_reg = 0x150a4,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x150a4,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk5_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk5_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk6_clk = {
+       .halt_reg = 0x150c0,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x150c0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk6_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk6_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_mclk7_clk = {
+       .halt_reg = 0x150dc,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x150dc,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_mclk7_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_mclk7_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_qdss_debug_clk = {
+       .halt_reg = 0x132b4,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x132b4,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_qdss_debug_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_qdss_debug_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_qdss_debug_xo_clk = {
+       .halt_reg = 0x132b8,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x132b8,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_qdss_debug_xo_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sbi_clk = {
+       .halt_reg = 0x100f8,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x100f8,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sbi_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_ife_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sbi_fast_ahb_clk = {
+       .halt_reg = 0x10108,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x10108,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sbi_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sbi_shift_clk = {
+       .halt_reg = 0x1010c,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x1010c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sbi_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_0_clk = {
+       .halt_reg = 0x13084,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13084,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_0_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_sfe_0_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_0_fast_ahb_clk = {
+       .halt_reg = 0x1309c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1309c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_0_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_0_shift_clk = {
+       .halt_reg = 0x130a0,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x130a0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_0_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_1_clk = {
+       .halt_reg = 0x130d4,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x130d4,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_1_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_sfe_1_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_1_fast_ahb_clk = {
+       .halt_reg = 0x130ec,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x130ec,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_1_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_1_shift_clk = {
+       .halt_reg = 0x130f0,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x130f0,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_1_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_2_clk = {
+       .halt_reg = 0x13124,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x13124,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_2_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_sfe_2_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_2_fast_ahb_clk = {
+       .halt_reg = 0x1313c,
+       .halt_check = BRANCH_HALT,
+       .clkr = {
+               .enable_reg = 0x1313c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_2_fast_ahb_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_fast_ahb_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_sfe_2_shift_clk = {
+       .halt_reg = 0x13140,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x13140,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_sfe_2_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct clk_branch cam_cc_titan_top_shift_clk = {
+       .halt_reg = 0x1330c,
+       .halt_check = BRANCH_HALT_VOTED,
+       .clkr = {
+               .enable_reg = 0x1330c,
+               .enable_mask = BIT(0),
+               .hw.init = &(const struct clk_init_data) {
+                       .name = "cam_cc_titan_top_shift_clk",
+                       .parent_hws = (const struct clk_hw*[]) {
+                               &cam_cc_xo_clk_src.clkr.hw,
+                       },
+                       .num_parents = 1,
+                       .flags = CLK_SET_RATE_PARENT,
+                       .ops = &clk_branch2_ops,
+               },
+       },
+ };
+ static struct gdsc cam_cc_titan_top_gdsc = {
+       .gdscr = 0x132bc,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_titan_top_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_bps_gdsc = {
+       .gdscr = 0x10004,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_bps_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_ife_0_gdsc = {
+       .gdscr = 0x11004,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_ife_0_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_ife_1_gdsc = {
+       .gdscr = 0x12004,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_ife_1_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_ife_2_gdsc = {
+       .gdscr = 0x12054,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_ife_2_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_ipe_0_gdsc = {
+       .gdscr = 0x10080,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_ipe_0_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_sbi_gdsc = {
+       .gdscr = 0x100e4,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_sbi_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_sfe_0_gdsc = {
+       .gdscr = 0x13058,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_sfe_0_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_sfe_1_gdsc = {
+       .gdscr = 0x130a8,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_sfe_1_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct gdsc cam_cc_sfe_2_gdsc = {
+       .gdscr = 0x130f8,
+       .en_rest_wait_val = 0x2,
+       .en_few_wait_val = 0x2,
+       .clk_dis_wait_val = 0xf,
+       .pd = {
+               .name = "cam_cc_sfe_2_gdsc",
+       },
+       .pwrsts = PWRSTS_OFF_ON,
+       .parent = &cam_cc_titan_top_gdsc.pd,
+       .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE,
+ };
+ static struct clk_regmap *cam_cc_sm8650_clocks[] = {
+       [CAM_CC_BPS_AHB_CLK] = &cam_cc_bps_ahb_clk.clkr,
+       [CAM_CC_BPS_CLK] = &cam_cc_bps_clk.clkr,
+       [CAM_CC_BPS_CLK_SRC] = &cam_cc_bps_clk_src.clkr,
+       [CAM_CC_BPS_FAST_AHB_CLK] = &cam_cc_bps_fast_ahb_clk.clkr,
+       [CAM_CC_BPS_SHIFT_CLK] = &cam_cc_bps_shift_clk.clkr,
+       [CAM_CC_CAMNOC_AXI_NRT_CLK] = &cam_cc_camnoc_axi_nrt_clk.clkr,
+       [CAM_CC_CAMNOC_AXI_RT_CLK] = &cam_cc_camnoc_axi_rt_clk.clkr,
+       [CAM_CC_CAMNOC_AXI_RT_CLK_SRC] = &cam_cc_camnoc_axi_rt_clk_src.clkr,
+       [CAM_CC_CAMNOC_DCD_XO_CLK] = &cam_cc_camnoc_dcd_xo_clk.clkr,
+       [CAM_CC_CAMNOC_XO_CLK] = &cam_cc_camnoc_xo_clk.clkr,
+       [CAM_CC_CCI_0_CLK] = &cam_cc_cci_0_clk.clkr,
+       [CAM_CC_CCI_0_CLK_SRC] = &cam_cc_cci_0_clk_src.clkr,
+       [CAM_CC_CCI_1_CLK] = &cam_cc_cci_1_clk.clkr,
+       [CAM_CC_CCI_1_CLK_SRC] = &cam_cc_cci_1_clk_src.clkr,
+       [CAM_CC_CCI_2_CLK] = &cam_cc_cci_2_clk.clkr,
+       [CAM_CC_CCI_2_CLK_SRC] = &cam_cc_cci_2_clk_src.clkr,
+       [CAM_CC_CORE_AHB_CLK] = &cam_cc_core_ahb_clk.clkr,
+       [CAM_CC_CPAS_AHB_CLK] = &cam_cc_cpas_ahb_clk.clkr,
+       [CAM_CC_CPAS_BPS_CLK] = &cam_cc_cpas_bps_clk.clkr,
+       [CAM_CC_CPAS_CRE_CLK] = &cam_cc_cpas_cre_clk.clkr,
+       [CAM_CC_CPAS_FAST_AHB_CLK] = &cam_cc_cpas_fast_ahb_clk.clkr,
+       [CAM_CC_CPAS_IFE_0_CLK] = &cam_cc_cpas_ife_0_clk.clkr,
+       [CAM_CC_CPAS_IFE_1_CLK] = &cam_cc_cpas_ife_1_clk.clkr,
+       [CAM_CC_CPAS_IFE_2_CLK] = &cam_cc_cpas_ife_2_clk.clkr,
+       [CAM_CC_CPAS_IFE_LITE_CLK] = &cam_cc_cpas_ife_lite_clk.clkr,
+       [CAM_CC_CPAS_IPE_NPS_CLK] = &cam_cc_cpas_ipe_nps_clk.clkr,
+       [CAM_CC_CPAS_SBI_CLK] = &cam_cc_cpas_sbi_clk.clkr,
+       [CAM_CC_CPAS_SFE_0_CLK] = &cam_cc_cpas_sfe_0_clk.clkr,
+       [CAM_CC_CPAS_SFE_1_CLK] = &cam_cc_cpas_sfe_1_clk.clkr,
+       [CAM_CC_CPAS_SFE_2_CLK] = &cam_cc_cpas_sfe_2_clk.clkr,
+       [CAM_CC_CPHY_RX_CLK_SRC] = &cam_cc_cphy_rx_clk_src.clkr,
+       [CAM_CC_CRE_AHB_CLK] = &cam_cc_cre_ahb_clk.clkr,
+       [CAM_CC_CRE_CLK] = &cam_cc_cre_clk.clkr,
+       [CAM_CC_CRE_CLK_SRC] = &cam_cc_cre_clk_src.clkr,
+       [CAM_CC_CSI0PHYTIMER_CLK] = &cam_cc_csi0phytimer_clk.clkr,
+       [CAM_CC_CSI0PHYTIMER_CLK_SRC] = &cam_cc_csi0phytimer_clk_src.clkr,
+       [CAM_CC_CSI1PHYTIMER_CLK] = &cam_cc_csi1phytimer_clk.clkr,
+       [CAM_CC_CSI1PHYTIMER_CLK_SRC] = &cam_cc_csi1phytimer_clk_src.clkr,
+       [CAM_CC_CSI2PHYTIMER_CLK] = &cam_cc_csi2phytimer_clk.clkr,
+       [CAM_CC_CSI2PHYTIMER_CLK_SRC] = &cam_cc_csi2phytimer_clk_src.clkr,
+       [CAM_CC_CSI3PHYTIMER_CLK] = &cam_cc_csi3phytimer_clk.clkr,
+       [CAM_CC_CSI3PHYTIMER_CLK_SRC] = &cam_cc_csi3phytimer_clk_src.clkr,
+       [CAM_CC_CSI4PHYTIMER_CLK] = &cam_cc_csi4phytimer_clk.clkr,
+       [CAM_CC_CSI4PHYTIMER_CLK_SRC] = &cam_cc_csi4phytimer_clk_src.clkr,
+       [CAM_CC_CSI5PHYTIMER_CLK] = &cam_cc_csi5phytimer_clk.clkr,
+       [CAM_CC_CSI5PHYTIMER_CLK_SRC] = &cam_cc_csi5phytimer_clk_src.clkr,
+       [CAM_CC_CSI6PHYTIMER_CLK] = &cam_cc_csi6phytimer_clk.clkr,
+       [CAM_CC_CSI6PHYTIMER_CLK_SRC] = &cam_cc_csi6phytimer_clk_src.clkr,
+       [CAM_CC_CSI7PHYTIMER_CLK] = &cam_cc_csi7phytimer_clk.clkr,
+       [CAM_CC_CSI7PHYTIMER_CLK_SRC] = &cam_cc_csi7phytimer_clk_src.clkr,
+       [CAM_CC_CSID_CLK] = &cam_cc_csid_clk.clkr,
+       [CAM_CC_CSID_CLK_SRC] = &cam_cc_csid_clk_src.clkr,
+       [CAM_CC_CSID_CSIPHY_RX_CLK] = &cam_cc_csid_csiphy_rx_clk.clkr,
+       [CAM_CC_CSIPHY0_CLK] = &cam_cc_csiphy0_clk.clkr,
+       [CAM_CC_CSIPHY1_CLK] = &cam_cc_csiphy1_clk.clkr,
+       [CAM_CC_CSIPHY2_CLK] = &cam_cc_csiphy2_clk.clkr,
+       [CAM_CC_CSIPHY3_CLK] = &cam_cc_csiphy3_clk.clkr,
+       [CAM_CC_CSIPHY4_CLK] = &cam_cc_csiphy4_clk.clkr,
+       [CAM_CC_CSIPHY5_CLK] = &cam_cc_csiphy5_clk.clkr,
+       [CAM_CC_CSIPHY6_CLK] = &cam_cc_csiphy6_clk.clkr,
+       [CAM_CC_CSIPHY7_CLK] = &cam_cc_csiphy7_clk.clkr,
+       [CAM_CC_FAST_AHB_CLK_SRC] = &cam_cc_fast_ahb_clk_src.clkr,
+       [CAM_CC_ICP_AHB_CLK] = &cam_cc_icp_ahb_clk.clkr,
+       [CAM_CC_ICP_CLK] = &cam_cc_icp_clk.clkr,
+       [CAM_CC_ICP_CLK_SRC] = &cam_cc_icp_clk_src.clkr,
+       [CAM_CC_IFE_0_CLK] = &cam_cc_ife_0_clk.clkr,
+       [CAM_CC_IFE_0_CLK_SRC] = &cam_cc_ife_0_clk_src.clkr,
+       [CAM_CC_IFE_0_FAST_AHB_CLK] = &cam_cc_ife_0_fast_ahb_clk.clkr,
+       [CAM_CC_IFE_0_SHIFT_CLK] = &cam_cc_ife_0_shift_clk.clkr,
+       [CAM_CC_IFE_1_CLK] = &cam_cc_ife_1_clk.clkr,
+       [CAM_CC_IFE_1_CLK_SRC] = &cam_cc_ife_1_clk_src.clkr,
+       [CAM_CC_IFE_1_FAST_AHB_CLK] = &cam_cc_ife_1_fast_ahb_clk.clkr,
+       [CAM_CC_IFE_1_SHIFT_CLK] = &cam_cc_ife_1_shift_clk.clkr,
+       [CAM_CC_IFE_2_CLK] = &cam_cc_ife_2_clk.clkr,
+       [CAM_CC_IFE_2_CLK_SRC] = &cam_cc_ife_2_clk_src.clkr,
+       [CAM_CC_IFE_2_FAST_AHB_CLK] = &cam_cc_ife_2_fast_ahb_clk.clkr,
+       [CAM_CC_IFE_2_SHIFT_CLK] = &cam_cc_ife_2_shift_clk.clkr,
+       [CAM_CC_IFE_LITE_AHB_CLK] = &cam_cc_ife_lite_ahb_clk.clkr,
+       [CAM_CC_IFE_LITE_CLK] = &cam_cc_ife_lite_clk.clkr,
+       [CAM_CC_IFE_LITE_CLK_SRC] = &cam_cc_ife_lite_clk_src.clkr,
+       [CAM_CC_IFE_LITE_CPHY_RX_CLK] = &cam_cc_ife_lite_cphy_rx_clk.clkr,
+       [CAM_CC_IFE_LITE_CSID_CLK] = &cam_cc_ife_lite_csid_clk.clkr,
+       [CAM_CC_IFE_LITE_CSID_CLK_SRC] = &cam_cc_ife_lite_csid_clk_src.clkr,
+       [CAM_CC_IPE_NPS_AHB_CLK] = &cam_cc_ipe_nps_ahb_clk.clkr,
+       [CAM_CC_IPE_NPS_CLK] = &cam_cc_ipe_nps_clk.clkr,
+       [CAM_CC_IPE_NPS_CLK_SRC] = &cam_cc_ipe_nps_clk_src.clkr,
+       [CAM_CC_IPE_NPS_FAST_AHB_CLK] = &cam_cc_ipe_nps_fast_ahb_clk.clkr,
+       [CAM_CC_IPE_PPS_CLK] = &cam_cc_ipe_pps_clk.clkr,
+       [CAM_CC_IPE_PPS_FAST_AHB_CLK] = &cam_cc_ipe_pps_fast_ahb_clk.clkr,
+       [CAM_CC_IPE_SHIFT_CLK] = &cam_cc_ipe_shift_clk.clkr,
+       [CAM_CC_JPEG_1_CLK] = &cam_cc_jpeg_1_clk.clkr,
+       [CAM_CC_JPEG_CLK] = &cam_cc_jpeg_clk.clkr,
+       [CAM_CC_JPEG_CLK_SRC] = &cam_cc_jpeg_clk_src.clkr,
+       [CAM_CC_MCLK0_CLK] = &cam_cc_mclk0_clk.clkr,
+       [CAM_CC_MCLK0_CLK_SRC] = &cam_cc_mclk0_clk_src.clkr,
+       [CAM_CC_MCLK1_CLK] = &cam_cc_mclk1_clk.clkr,
+       [CAM_CC_MCLK1_CLK_SRC] = &cam_cc_mclk1_clk_src.clkr,
+       [CAM_CC_MCLK2_CLK] = &cam_cc_mclk2_clk.clkr,
+       [CAM_CC_MCLK2_CLK_SRC] = &cam_cc_mclk2_clk_src.clkr,
+       [CAM_CC_MCLK3_CLK] = &cam_cc_mclk3_clk.clkr,
+       [CAM_CC_MCLK3_CLK_SRC] = &cam_cc_mclk3_clk_src.clkr,
+       [CAM_CC_MCLK4_CLK] = &cam_cc_mclk4_clk.clkr,
+       [CAM_CC_MCLK4_CLK_SRC] = &cam_cc_mclk4_clk_src.clkr,
+       [CAM_CC_MCLK5_CLK] = &cam_cc_mclk5_clk.clkr,
+       [CAM_CC_MCLK5_CLK_SRC] = &cam_cc_mclk5_clk_src.clkr,
+       [CAM_CC_MCLK6_CLK] = &cam_cc_mclk6_clk.clkr,
+       [CAM_CC_MCLK6_CLK_SRC] = &cam_cc_mclk6_clk_src.clkr,
+       [CAM_CC_MCLK7_CLK] = &cam_cc_mclk7_clk.clkr,
+       [CAM_CC_MCLK7_CLK_SRC] = &cam_cc_mclk7_clk_src.clkr,
+       [CAM_CC_PLL0] = &cam_cc_pll0.clkr,
+       [CAM_CC_PLL0_OUT_EVEN] = &cam_cc_pll0_out_even.clkr,
+       [CAM_CC_PLL0_OUT_ODD] = &cam_cc_pll0_out_odd.clkr,
+       [CAM_CC_PLL1] = &cam_cc_pll1.clkr,
+       [CAM_CC_PLL1_OUT_EVEN] = &cam_cc_pll1_out_even.clkr,
+       [CAM_CC_PLL2] = &cam_cc_pll2.clkr,
+       [CAM_CC_PLL3] = &cam_cc_pll3.clkr,
+       [CAM_CC_PLL3_OUT_EVEN] = &cam_cc_pll3_out_even.clkr,
+       [CAM_CC_PLL4] = &cam_cc_pll4.clkr,
+       [CAM_CC_PLL4_OUT_EVEN] = &cam_cc_pll4_out_even.clkr,
+       [CAM_CC_PLL5] = &cam_cc_pll5.clkr,
+       [CAM_CC_PLL5_OUT_EVEN] = &cam_cc_pll5_out_even.clkr,
+       [CAM_CC_PLL6] = &cam_cc_pll6.clkr,
+       [CAM_CC_PLL6_OUT_EVEN] = &cam_cc_pll6_out_even.clkr,
+       [CAM_CC_PLL7] = &cam_cc_pll7.clkr,
+       [CAM_CC_PLL7_OUT_EVEN] = &cam_cc_pll7_out_even.clkr,
+       [CAM_CC_PLL8] = &cam_cc_pll8.clkr,
+       [CAM_CC_PLL8_OUT_EVEN] = &cam_cc_pll8_out_even.clkr,
+       [CAM_CC_PLL9] = &cam_cc_pll9.clkr,
+       [CAM_CC_PLL9_OUT_EVEN] = &cam_cc_pll9_out_even.clkr,
+       [CAM_CC_PLL9_OUT_ODD] = &cam_cc_pll9_out_odd.clkr,
+       [CAM_CC_PLL10] = &cam_cc_pll10.clkr,
+       [CAM_CC_PLL10_OUT_EVEN] = &cam_cc_pll10_out_even.clkr,
+       [CAM_CC_QDSS_DEBUG_CLK] = &cam_cc_qdss_debug_clk.clkr,
+       [CAM_CC_QDSS_DEBUG_CLK_SRC] = &cam_cc_qdss_debug_clk_src.clkr,
+       [CAM_CC_QDSS_DEBUG_XO_CLK] = &cam_cc_qdss_debug_xo_clk.clkr,
+       [CAM_CC_SBI_CLK] = &cam_cc_sbi_clk.clkr,
+       [CAM_CC_SBI_FAST_AHB_CLK] = &cam_cc_sbi_fast_ahb_clk.clkr,
+       [CAM_CC_SBI_SHIFT_CLK] = &cam_cc_sbi_shift_clk.clkr,
+       [CAM_CC_SFE_0_CLK] = &cam_cc_sfe_0_clk.clkr,
+       [CAM_CC_SFE_0_CLK_SRC] = &cam_cc_sfe_0_clk_src.clkr,
+       [CAM_CC_SFE_0_FAST_AHB_CLK] = &cam_cc_sfe_0_fast_ahb_clk.clkr,
+       [CAM_CC_SFE_0_SHIFT_CLK] = &cam_cc_sfe_0_shift_clk.clkr,
+       [CAM_CC_SFE_1_CLK] = &cam_cc_sfe_1_clk.clkr,
+       [CAM_CC_SFE_1_CLK_SRC] = &cam_cc_sfe_1_clk_src.clkr,
+       [CAM_CC_SFE_1_FAST_AHB_CLK] = &cam_cc_sfe_1_fast_ahb_clk.clkr,
+       [CAM_CC_SFE_1_SHIFT_CLK] = &cam_cc_sfe_1_shift_clk.clkr,
+       [CAM_CC_SFE_2_CLK] = &cam_cc_sfe_2_clk.clkr,
+       [CAM_CC_SFE_2_CLK_SRC] = &cam_cc_sfe_2_clk_src.clkr,
+       [CAM_CC_SFE_2_FAST_AHB_CLK] = &cam_cc_sfe_2_fast_ahb_clk.clkr,
+       [CAM_CC_SFE_2_SHIFT_CLK] = &cam_cc_sfe_2_shift_clk.clkr,
+       [CAM_CC_SLEEP_CLK_SRC] = &cam_cc_sleep_clk_src.clkr,
+       [CAM_CC_SLOW_AHB_CLK_SRC] = &cam_cc_slow_ahb_clk_src.clkr,
+       [CAM_CC_TITAN_TOP_SHIFT_CLK] = &cam_cc_titan_top_shift_clk.clkr,
+       [CAM_CC_XO_CLK_SRC] = &cam_cc_xo_clk_src.clkr,
+ };
+ static struct gdsc *cam_cc_sm8650_gdscs[] = {
+       [CAM_CC_TITAN_TOP_GDSC] = &cam_cc_titan_top_gdsc,
+       [CAM_CC_BPS_GDSC] = &cam_cc_bps_gdsc,
+       [CAM_CC_IFE_0_GDSC] = &cam_cc_ife_0_gdsc,
+       [CAM_CC_IFE_1_GDSC] = &cam_cc_ife_1_gdsc,
+       [CAM_CC_IFE_2_GDSC] = &cam_cc_ife_2_gdsc,
+       [CAM_CC_IPE_0_GDSC] = &cam_cc_ipe_0_gdsc,
+       [CAM_CC_SBI_GDSC] = &cam_cc_sbi_gdsc,
+       [CAM_CC_SFE_0_GDSC] = &cam_cc_sfe_0_gdsc,
+       [CAM_CC_SFE_1_GDSC] = &cam_cc_sfe_1_gdsc,
+       [CAM_CC_SFE_2_GDSC] = &cam_cc_sfe_2_gdsc,
+ };
+ static const struct qcom_reset_map cam_cc_sm8650_resets[] = {
+       [CAM_CC_BPS_BCR] = { 0x10000 },
+       [CAM_CC_DRV_BCR] = { 0x13310 },
+       [CAM_CC_ICP_BCR] = { 0x131a0 },
+       [CAM_CC_IFE_0_BCR] = { 0x11000 },
+       [CAM_CC_IFE_1_BCR] = { 0x12000 },
+       [CAM_CC_IFE_2_BCR] = { 0x12050 },
+       [CAM_CC_IPE_0_BCR] = { 0x1007c },
+       [CAM_CC_QDSS_DEBUG_BCR] = { 0x13298 },
+       [CAM_CC_SBI_BCR] = { 0x100e0 },
+       [CAM_CC_SFE_0_BCR] = { 0x13054 },
+       [CAM_CC_SFE_1_BCR] = { 0x130a4 },
+       [CAM_CC_SFE_2_BCR] = { 0x130f4 },
+ };
+ static const struct regmap_config cam_cc_sm8650_regmap_config = {
+       .reg_bits = 32,
+       .reg_stride = 4,
+       .val_bits = 32,
+       .max_register = 0x1603c,
+       .fast_io = true,
+ };
+ static struct qcom_cc_desc cam_cc_sm8650_desc = {
+       .config = &cam_cc_sm8650_regmap_config,
+       .clks = cam_cc_sm8650_clocks,
+       .num_clks = ARRAY_SIZE(cam_cc_sm8650_clocks),
+       .resets = cam_cc_sm8650_resets,
+       .num_resets = ARRAY_SIZE(cam_cc_sm8650_resets),
+       .gdscs = cam_cc_sm8650_gdscs,
+       .num_gdscs = ARRAY_SIZE(cam_cc_sm8650_gdscs),
+ };
+ static const struct of_device_id cam_cc_sm8650_match_table[] = {
+       { .compatible = "qcom,sm8650-camcc" },
+       { }
+ };
+ MODULE_DEVICE_TABLE(of, cam_cc_sm8650_match_table);
+ static int cam_cc_sm8650_probe(struct platform_device *pdev)
+ {
+       struct regmap *regmap;
+       int ret;
+       ret = devm_pm_runtime_enable(&pdev->dev);
+       if (ret)
+               return ret;
+       ret = pm_runtime_resume_and_get(&pdev->dev);
+       if (ret)
+               return ret;
+       regmap = qcom_cc_map(pdev, &cam_cc_sm8650_desc);
+       if (IS_ERR(regmap)) {
+               pm_runtime_put(&pdev->dev);
+               return PTR_ERR(regmap);
+       }
+       clk_lucid_ole_pll_configure(&cam_cc_pll0, regmap, &cam_cc_pll0_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll1, regmap, &cam_cc_pll1_config);
+       clk_rivian_evo_pll_configure(&cam_cc_pll2, regmap, &cam_cc_pll2_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll3, regmap, &cam_cc_pll3_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll4, regmap, &cam_cc_pll4_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll5, regmap, &cam_cc_pll5_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll6, regmap, &cam_cc_pll6_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll7, regmap, &cam_cc_pll7_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll8, regmap, &cam_cc_pll8_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll9, regmap, &cam_cc_pll9_config);
+       clk_lucid_ole_pll_configure(&cam_cc_pll10, regmap, &cam_cc_pll10_config);
+       /* Keep clocks always enabled */
+       qcom_branch_set_clk_en(regmap, 0x13318); /* CAM_CC_DRV_AHB_CLK */
+       qcom_branch_set_clk_en(regmap, 0x13314); /* CAM_CC_DRV_XO_CLK */
+       qcom_branch_set_clk_en(regmap, 0x132ec); /* CAM_CC_GDSC_CLK */
+       qcom_branch_set_clk_en(regmap, 0x13308); /* CAM_CC_SLEEP_CLK */
++      ret = qcom_cc_really_probe(pdev, &cam_cc_sm8650_desc, regmap);
+       pm_runtime_put(&pdev->dev);
+       return ret;
+ }
+ static struct platform_driver cam_cc_sm8650_driver = {
+       .probe = cam_cc_sm8650_probe,
+       .driver = {
+               .name = "camcc-sm8650",
+               .of_match_table = cam_cc_sm8650_match_table,
+       },
+ };
+ module_platform_driver(cam_cc_sm8650_driver);
+ MODULE_DESCRIPTION("QTI CAMCC SM8650 Driver");
+ MODULE_LICENSE("GPL");