Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

clk: qcom: convert SDM845 Global Clock Controller to parent_data

Convert the clock driver to specify parent data rather than parent
names, to actually bind using 'clock-names' specified in the DTS rather
than global clock names.

Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org>
Reviewed-by: Bjorn Andersson <bjorn.andersson@linaro.org>
Link: https://lore.kernel.org/r/20210409183004.1617777-3-dmitry.baryshkov@linaro.org
Signed-off-by: Stephen Boyd <sboyd@kernel.org>

authored by

Dmitry Baryshkov and committed by
Stephen Boyd
ea434d7a ca22cac2

+349 -338
+349 -338
drivers/clk/qcom/gcc-sdm845.c
··· 35 35 P_SLEEP_CLK, 36 36 }; 37 37 38 - static const struct parent_map gcc_parent_map_0[] = { 39 - { P_BI_TCXO, 0 }, 40 - { P_GPLL0_OUT_MAIN, 1 }, 41 - { P_GPLL0_OUT_EVEN, 6 }, 42 - { P_CORE_BI_PLL_TEST_SE, 7 }, 43 - }; 44 - 45 - static const char * const gcc_parent_names_0[] = { 46 - "bi_tcxo", 47 - "gpll0", 48 - "gpll0_out_even", 49 - "core_bi_pll_test_se", 50 - }; 51 - 52 - static const struct parent_map gcc_parent_map_1[] = { 53 - { P_BI_TCXO, 0 }, 54 - { P_GPLL0_OUT_MAIN, 1 }, 55 - { P_SLEEP_CLK, 5 }, 56 - { P_GPLL0_OUT_EVEN, 6 }, 57 - { P_CORE_BI_PLL_TEST_SE, 7 }, 58 - }; 59 - 60 - static const char * const gcc_parent_names_1[] = { 61 - "bi_tcxo", 62 - "gpll0", 63 - "core_pi_sleep_clk", 64 - "gpll0_out_even", 65 - "core_bi_pll_test_se", 66 - }; 67 - 68 - static const struct parent_map gcc_parent_map_2[] = { 69 - { P_BI_TCXO, 0 }, 70 - { P_SLEEP_CLK, 5 }, 71 - { P_CORE_BI_PLL_TEST_SE, 7 }, 72 - }; 73 - 74 - static const char * const gcc_parent_names_2[] = { 75 - "bi_tcxo", 76 - "core_pi_sleep_clk", 77 - "core_bi_pll_test_se", 78 - }; 79 - 80 - static const struct parent_map gcc_parent_map_3[] = { 81 - { P_BI_TCXO, 0 }, 82 - { P_GPLL0_OUT_MAIN, 1 }, 83 - { P_CORE_BI_PLL_TEST_SE, 7 }, 84 - }; 85 - 86 - static const char * const gcc_parent_names_3[] = { 87 - "bi_tcxo", 88 - "gpll0", 89 - "core_bi_pll_test_se", 90 - }; 91 - 92 - static const struct parent_map gcc_parent_map_4[] = { 93 - { P_BI_TCXO, 0 }, 94 - { P_CORE_BI_PLL_TEST_SE, 7 }, 95 - }; 96 - 97 - static const char * const gcc_parent_names_4[] = { 98 - "bi_tcxo", 99 - "core_bi_pll_test_se", 100 - }; 101 - 102 - static const struct parent_map gcc_parent_map_6[] = { 103 - { P_BI_TCXO, 0 }, 104 - { P_GPLL0_OUT_MAIN, 1 }, 105 - { P_AUD_REF_CLK, 2 }, 106 - { P_GPLL0_OUT_EVEN, 6 }, 107 - { P_CORE_BI_PLL_TEST_SE, 7 }, 108 - }; 109 - 110 - static const char * const gcc_parent_names_6[] = { 111 - "bi_tcxo", 112 - "gpll0", 113 - "aud_ref_clk", 114 - "gpll0_out_even", 115 - "core_bi_pll_test_se", 116 - }; 117 - 118 - static const char * const gcc_parent_names_7_ao[] = { 119 - "bi_tcxo_ao", 120 - "gpll0", 121 - "gpll0_out_even", 122 - "core_bi_pll_test_se", 123 - }; 124 - 125 - static const char * const gcc_parent_names_8[] = { 126 - "bi_tcxo", 127 - "gpll0", 128 - "core_bi_pll_test_se", 129 - }; 130 - 131 - static const char * const gcc_parent_names_8_ao[] = { 132 - "bi_tcxo_ao", 133 - "gpll0", 134 - "core_bi_pll_test_se", 135 - }; 136 - 137 - static const struct parent_map gcc_parent_map_10[] = { 138 - { P_BI_TCXO, 0 }, 139 - { P_GPLL0_OUT_MAIN, 1 }, 140 - { P_GPLL4_OUT_MAIN, 5 }, 141 - { P_GPLL0_OUT_EVEN, 6 }, 142 - { P_CORE_BI_PLL_TEST_SE, 7 }, 143 - }; 144 - 145 - static const char * const gcc_parent_names_10[] = { 146 - "bi_tcxo", 147 - "gpll0", 148 - "gpll4", 149 - "gpll0_out_even", 150 - "core_bi_pll_test_se", 151 - }; 152 - 153 38 static struct clk_alpha_pll gpll0 = { 154 39 .offset = 0x0, 155 40 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], ··· 43 158 .enable_mask = BIT(0), 44 159 .hw.init = &(struct clk_init_data){ 45 160 .name = "gpll0", 46 - .parent_names = (const char *[]){ "bi_tcxo" }, 161 + .parent_data = &(const struct clk_parent_data){ 162 + .fw_name = "bi_tcxo", .name = "bi_tcxo", 163 + }, 47 164 .num_parents = 1, 48 165 .ops = &clk_alpha_pll_fixed_fabia_ops, 49 166 }, ··· 60 173 .enable_mask = BIT(4), 61 174 .hw.init = &(struct clk_init_data){ 62 175 .name = "gpll4", 63 - .parent_names = (const char *[]){ "bi_tcxo" }, 176 + .parent_data = &(const struct clk_parent_data){ 177 + .fw_name = "bi_tcxo", .name = "bi_tcxo", 178 + }, 64 179 .num_parents = 1, 65 180 .ops = &clk_alpha_pll_fixed_fabia_ops, 66 181 }, ··· 86 197 .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_FABIA], 87 198 .clkr.hw.init = &(struct clk_init_data){ 88 199 .name = "gpll0_out_even", 89 - .parent_names = (const char *[]){ "gpll0" }, 200 + .parent_hws = (const struct clk_hw*[]){ 201 + &gpll0.clkr.hw, 202 + }, 90 203 .num_parents = 1, 91 204 .ops = &clk_alpha_pll_postdiv_fabia_ops, 92 205 }, 93 206 }; 207 + 208 + static const struct parent_map gcc_parent_map_0[] = { 209 + { P_BI_TCXO, 0 }, 210 + { P_GPLL0_OUT_MAIN, 1 }, 211 + { P_GPLL0_OUT_EVEN, 6 }, 212 + { P_CORE_BI_PLL_TEST_SE, 7 }, 213 + }; 214 + 215 + static const struct clk_parent_data gcc_parent_data_0[] = { 216 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 217 + { .hw = &gpll0.clkr.hw }, 218 + { .hw = &gpll0_out_even.clkr.hw }, 219 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 220 + }; 221 + 222 + static const struct parent_map gcc_parent_map_1[] = { 223 + { P_BI_TCXO, 0 }, 224 + { P_GPLL0_OUT_MAIN, 1 }, 225 + { P_SLEEP_CLK, 5 }, 226 + { P_GPLL0_OUT_EVEN, 6 }, 227 + { P_CORE_BI_PLL_TEST_SE, 7 }, 228 + }; 229 + 230 + static const struct clk_parent_data gcc_parent_data_1[] = { 231 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 232 + { .hw = &gpll0.clkr.hw }, 233 + { .fw_name = "sleep_clk", .name = "core_pi_sleep_clk" }, 234 + { .hw = &gpll0_out_even.clkr.hw }, 235 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 236 + }; 237 + 238 + static const struct parent_map gcc_parent_map_2[] = { 239 + { P_BI_TCXO, 0 }, 240 + { P_SLEEP_CLK, 5 }, 241 + { P_CORE_BI_PLL_TEST_SE, 7 }, 242 + }; 243 + 244 + static const struct clk_parent_data gcc_parent_data_2[] = { 245 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 246 + { .fw_name = "sleep_clk", .name = "core_pi_sleep_clk" }, 247 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 248 + }; 249 + 250 + static const struct parent_map gcc_parent_map_3[] = { 251 + { P_BI_TCXO, 0 }, 252 + { P_GPLL0_OUT_MAIN, 1 }, 253 + { P_CORE_BI_PLL_TEST_SE, 7 }, 254 + }; 255 + 256 + static const struct clk_parent_data gcc_parent_data_3[] = { 257 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 258 + { .hw = &gpll0.clkr.hw }, 259 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 260 + }; 261 + 262 + static const struct parent_map gcc_parent_map_4[] = { 263 + { P_BI_TCXO, 0 }, 264 + { P_CORE_BI_PLL_TEST_SE, 7 }, 265 + }; 266 + 267 + static const struct clk_parent_data gcc_parent_data_4[] = { 268 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 269 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 270 + }; 271 + 272 + static const struct parent_map gcc_parent_map_6[] = { 273 + { P_BI_TCXO, 0 }, 274 + { P_GPLL0_OUT_MAIN, 1 }, 275 + { P_AUD_REF_CLK, 2 }, 276 + { P_GPLL0_OUT_EVEN, 6 }, 277 + { P_CORE_BI_PLL_TEST_SE, 7 }, 278 + }; 279 + 280 + static const struct clk_parent_data gcc_parent_data_6[] = { 281 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 282 + { .hw = &gpll0.clkr.hw }, 283 + { .fw_name = "aud_ref_clk", .name = "aud_ref_clk" }, 284 + { .hw = &gpll0_out_even.clkr.hw }, 285 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 286 + }; 287 + 288 + static const struct clk_parent_data gcc_parent_data_7_ao[] = { 289 + { .fw_name = "bi_tcxo_ao", .name = "bi_tcxo_ao" }, 290 + { .hw = &gpll0.clkr.hw }, 291 + { .hw = &gpll0_out_even.clkr.hw }, 292 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 293 + }; 294 + 295 + static const struct clk_parent_data gcc_parent_data_8[] = { 296 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 297 + { .hw = &gpll0.clkr.hw }, 298 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 299 + }; 300 + 301 + static const struct clk_parent_data gcc_parent_data_8_ao[] = { 302 + { .fw_name = "bi_tcxo_ao", .name = "bi_tcxo_ao" }, 303 + { .hw = &gpll0.clkr.hw }, 304 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 305 + }; 306 + 307 + static const struct parent_map gcc_parent_map_10[] = { 308 + { P_BI_TCXO, 0 }, 309 + { P_GPLL0_OUT_MAIN, 1 }, 310 + { P_GPLL4_OUT_MAIN, 5 }, 311 + { P_GPLL0_OUT_EVEN, 6 }, 312 + { P_CORE_BI_PLL_TEST_SE, 7 }, 313 + }; 314 + 315 + static const struct clk_parent_data gcc_parent_data_10[] = { 316 + { .fw_name = "bi_tcxo", .name = "bi_tcxo" }, 317 + { .hw = &gpll0.clkr.hw }, 318 + { .hw = &gpll4.clkr.hw }, 319 + { .hw = &gpll0_out_even.clkr.hw }, 320 + { .fw_name = "core_bi_pll_test_se", .name = "core_bi_pll_test_se" }, 321 + }; 322 + 94 323 95 324 static const struct freq_tbl ftbl_gcc_cpuss_ahb_clk_src[] = { 96 325 F(19200000, P_BI_TCXO, 1, 0, 0), ··· 223 216 .freq_tbl = ftbl_gcc_cpuss_ahb_clk_src, 224 217 .clkr.hw.init = &(struct clk_init_data){ 225 218 .name = "gcc_cpuss_ahb_clk_src", 226 - .parent_names = gcc_parent_names_7_ao, 227 - .num_parents = 4, 219 + .parent_data = gcc_parent_data_7_ao, 220 + .num_parents = ARRAY_SIZE(gcc_parent_data_7_ao), 228 221 .ops = &clk_rcg2_ops, 229 222 }, 230 223 }; ··· 242 235 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src, 243 236 .clkr.hw.init = &(struct clk_init_data){ 244 237 .name = "gcc_cpuss_rbcpr_clk_src", 245 - .parent_names = gcc_parent_names_8_ao, 246 - .num_parents = 3, 238 + .parent_data = gcc_parent_data_8_ao, 239 + .num_parents = ARRAY_SIZE(gcc_parent_data_8_ao), 247 240 .ops = &clk_rcg2_ops, 248 241 }, 249 242 }; ··· 265 258 .freq_tbl = ftbl_gcc_gp1_clk_src, 266 259 .clkr.hw.init = &(struct clk_init_data){ 267 260 .name = "gcc_gp1_clk_src", 268 - .parent_names = gcc_parent_names_1, 269 - .num_parents = 5, 261 + .parent_data = gcc_parent_data_1, 262 + .num_parents = ARRAY_SIZE(gcc_parent_data_1), 270 263 .ops = &clk_rcg2_ops, 271 264 }, 272 265 }; ··· 279 272 .freq_tbl = ftbl_gcc_gp1_clk_src, 280 273 .clkr.hw.init = &(struct clk_init_data){ 281 274 .name = "gcc_gp2_clk_src", 282 - .parent_names = gcc_parent_names_1, 283 - .num_parents = 5, 275 + .parent_data = gcc_parent_data_1, 276 + .num_parents = ARRAY_SIZE(gcc_parent_data_1), 284 277 .ops = &clk_rcg2_ops, 285 278 }, 286 279 }; ··· 293 286 .freq_tbl = ftbl_gcc_gp1_clk_src, 294 287 .clkr.hw.init = &(struct clk_init_data){ 295 288 .name = "gcc_gp3_clk_src", 296 - .parent_names = gcc_parent_names_1, 297 - .num_parents = 5, 289 + .parent_data = gcc_parent_data_1, 290 + .num_parents = ARRAY_SIZE(gcc_parent_data_1), 298 291 .ops = &clk_rcg2_ops, 299 292 }, 300 293 }; ··· 313 306 .freq_tbl = ftbl_gcc_pcie_0_aux_clk_src, 314 307 .clkr.hw.init = &(struct clk_init_data){ 315 308 .name = "gcc_pcie_0_aux_clk_src", 316 - .parent_names = gcc_parent_names_2, 317 - .num_parents = 3, 309 + .parent_data = gcc_parent_data_2, 310 + .num_parents = ARRAY_SIZE(gcc_parent_data_2), 318 311 .ops = &clk_rcg2_ops, 319 312 }, 320 313 }; ··· 327 320 .freq_tbl = ftbl_gcc_pcie_0_aux_clk_src, 328 321 .clkr.hw.init = &(struct clk_init_data){ 329 322 .name = "gcc_pcie_1_aux_clk_src", 330 - .parent_names = gcc_parent_names_2, 331 - .num_parents = 3, 323 + .parent_data = gcc_parent_data_2, 324 + .num_parents = ARRAY_SIZE(gcc_parent_data_2), 332 325 .ops = &clk_rcg2_ops, 333 326 }, 334 327 }; ··· 347 340 .freq_tbl = ftbl_gcc_pcie_phy_refgen_clk_src, 348 341 .clkr.hw.init = &(struct clk_init_data){ 349 342 .name = "gcc_pcie_phy_refgen_clk_src", 350 - .parent_names = gcc_parent_names_0, 351 - .num_parents = 4, 343 + .parent_data = gcc_parent_data_0, 344 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 352 345 .ops = &clk_rcg2_ops, 353 346 }, 354 347 }; ··· 369 362 .freq_tbl = ftbl_gcc_qspi_core_clk_src, 370 363 .clkr.hw.init = &(struct clk_init_data){ 371 364 .name = "gcc_qspi_core_clk_src", 372 - .parent_names = gcc_parent_names_0, 373 - .num_parents = 4, 365 + .parent_data = gcc_parent_data_0, 366 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 374 367 .ops = &clk_rcg2_floor_ops, 375 368 }, 376 369 }; ··· 390 383 .freq_tbl = ftbl_gcc_pdm2_clk_src, 391 384 .clkr.hw.init = &(struct clk_init_data){ 392 385 .name = "gcc_pdm2_clk_src", 393 - .parent_names = gcc_parent_names_0, 394 - .num_parents = 4, 386 + .parent_data = gcc_parent_data_0, 387 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 395 388 .ops = &clk_rcg2_ops, 396 389 }, 397 390 }; ··· 417 410 418 411 static struct clk_init_data gcc_qupv3_wrap0_s0_clk_src_init = { 419 412 .name = "gcc_qupv3_wrap0_s0_clk_src", 420 - .parent_names = gcc_parent_names_0, 421 - .num_parents = 4, 413 + .parent_data = gcc_parent_data_0, 414 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 422 415 .ops = &clk_rcg2_shared_ops, 423 416 }; 424 417 ··· 433 426 434 427 static struct clk_init_data gcc_qupv3_wrap0_s1_clk_src_init = { 435 428 .name = "gcc_qupv3_wrap0_s1_clk_src", 436 - .parent_names = gcc_parent_names_0, 437 - .num_parents = 4, 429 + .parent_data = gcc_parent_data_0, 430 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 438 431 .ops = &clk_rcg2_shared_ops, 439 432 }; 440 433 ··· 449 442 450 443 static struct clk_init_data gcc_qupv3_wrap0_s2_clk_src_init = { 451 444 .name = "gcc_qupv3_wrap0_s2_clk_src", 452 - .parent_names = gcc_parent_names_0, 453 - .num_parents = 4, 445 + .parent_data = gcc_parent_data_0, 446 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 454 447 .ops = &clk_rcg2_shared_ops, 455 448 }; 456 449 ··· 465 458 466 459 static struct clk_init_data gcc_qupv3_wrap0_s3_clk_src_init = { 467 460 .name = "gcc_qupv3_wrap0_s3_clk_src", 468 - .parent_names = gcc_parent_names_0, 469 - .num_parents = 4, 461 + .parent_data = gcc_parent_data_0, 462 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 470 463 .ops = &clk_rcg2_shared_ops, 471 464 }; 472 465 ··· 481 474 482 475 static struct clk_init_data gcc_qupv3_wrap0_s4_clk_src_init = { 483 476 .name = "gcc_qupv3_wrap0_s4_clk_src", 484 - .parent_names = gcc_parent_names_0, 485 - .num_parents = 4, 477 + .parent_data = gcc_parent_data_0, 478 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 486 479 .ops = &clk_rcg2_shared_ops, 487 480 }; 488 481 ··· 497 490 498 491 static struct clk_init_data gcc_qupv3_wrap0_s5_clk_src_init = { 499 492 .name = "gcc_qupv3_wrap0_s5_clk_src", 500 - .parent_names = gcc_parent_names_0, 501 - .num_parents = 4, 493 + .parent_data = gcc_parent_data_0, 494 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 502 495 .ops = &clk_rcg2_shared_ops, 503 496 }; 504 497 ··· 513 506 514 507 static struct clk_init_data gcc_qupv3_wrap0_s6_clk_src_init = { 515 508 .name = "gcc_qupv3_wrap0_s6_clk_src", 516 - .parent_names = gcc_parent_names_0, 517 - .num_parents = 4, 509 + .parent_data = gcc_parent_data_0, 510 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 518 511 .ops = &clk_rcg2_shared_ops, 519 512 }; 520 513 ··· 529 522 530 523 static struct clk_init_data gcc_qupv3_wrap0_s7_clk_src_init = { 531 524 .name = "gcc_qupv3_wrap0_s7_clk_src", 532 - .parent_names = gcc_parent_names_0, 533 - .num_parents = 4, 525 + .parent_data = gcc_parent_data_0, 526 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 534 527 .ops = &clk_rcg2_shared_ops, 535 528 }; 536 529 ··· 545 538 546 539 static struct clk_init_data gcc_qupv3_wrap1_s0_clk_src_init = { 547 540 .name = "gcc_qupv3_wrap1_s0_clk_src", 548 - .parent_names = gcc_parent_names_0, 549 - .num_parents = 4, 541 + .parent_data = gcc_parent_data_0, 542 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 550 543 .ops = &clk_rcg2_shared_ops, 551 544 }; 552 545 ··· 561 554 562 555 static struct clk_init_data gcc_qupv3_wrap1_s1_clk_src_init = { 563 556 .name = "gcc_qupv3_wrap1_s1_clk_src", 564 - .parent_names = gcc_parent_names_0, 565 - .num_parents = 4, 557 + .parent_data = gcc_parent_data_0, 558 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 566 559 .ops = &clk_rcg2_shared_ops, 567 560 }; 568 561 ··· 577 570 578 571 static struct clk_init_data gcc_qupv3_wrap1_s2_clk_src_init = { 579 572 .name = "gcc_qupv3_wrap1_s2_clk_src", 580 - .parent_names = gcc_parent_names_0, 581 - .num_parents = 4, 573 + .parent_data = gcc_parent_data_0, 574 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 582 575 .ops = &clk_rcg2_shared_ops, 583 576 }; 584 577 ··· 593 586 594 587 static struct clk_init_data gcc_qupv3_wrap1_s3_clk_src_init = { 595 588 .name = "gcc_qupv3_wrap1_s3_clk_src", 596 - .parent_names = gcc_parent_names_0, 597 - .num_parents = 4, 589 + .parent_data = gcc_parent_data_0, 590 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 598 591 .ops = &clk_rcg2_shared_ops, 599 592 }; 600 593 ··· 609 602 610 603 static struct clk_init_data gcc_qupv3_wrap1_s4_clk_src_init = { 611 604 .name = "gcc_qupv3_wrap1_s4_clk_src", 612 - .parent_names = gcc_parent_names_0, 613 - .num_parents = 4, 605 + .parent_data = gcc_parent_data_0, 606 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 614 607 .ops = &clk_rcg2_shared_ops, 615 608 }; 616 609 ··· 625 618 626 619 static struct clk_init_data gcc_qupv3_wrap1_s5_clk_src_init = { 627 620 .name = "gcc_qupv3_wrap1_s5_clk_src", 628 - .parent_names = gcc_parent_names_0, 629 - .num_parents = 4, 621 + .parent_data = gcc_parent_data_0, 622 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 630 623 .ops = &clk_rcg2_shared_ops, 631 624 }; 632 625 ··· 641 634 642 635 static struct clk_init_data gcc_qupv3_wrap1_s6_clk_src_init = { 643 636 .name = "gcc_qupv3_wrap1_s6_clk_src", 644 - .parent_names = gcc_parent_names_0, 645 - .num_parents = 4, 637 + .parent_data = gcc_parent_data_0, 638 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 646 639 .ops = &clk_rcg2_shared_ops, 647 640 }; 648 641 ··· 657 650 658 651 static struct clk_init_data gcc_qupv3_wrap1_s7_clk_src_init = { 659 652 .name = "gcc_qupv3_wrap1_s7_clk_src", 660 - .parent_names = gcc_parent_names_0, 661 - .num_parents = 4, 653 + .parent_data = gcc_parent_data_0, 654 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 662 655 .ops = &clk_rcg2_shared_ops, 663 656 }; 664 657 ··· 690 683 .freq_tbl = ftbl_gcc_sdcc2_apps_clk_src, 691 684 .clkr.hw.init = &(struct clk_init_data){ 692 685 .name = "gcc_sdcc2_apps_clk_src", 693 - .parent_names = gcc_parent_names_10, 694 - .num_parents = 5, 686 + .parent_data = gcc_parent_data_10, 687 + .num_parents = ARRAY_SIZE(gcc_parent_data_10), 695 688 .ops = &clk_rcg2_floor_ops, 696 689 }, 697 690 }; ··· 714 707 .freq_tbl = ftbl_gcc_sdcc4_apps_clk_src, 715 708 .clkr.hw.init = &(struct clk_init_data){ 716 709 .name = "gcc_sdcc4_apps_clk_src", 717 - .parent_names = gcc_parent_names_0, 718 - .num_parents = 4, 710 + .parent_data = gcc_parent_data_0, 711 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 719 712 .ops = &clk_rcg2_floor_ops, 720 713 }, 721 714 }; ··· 733 726 .freq_tbl = ftbl_gcc_tsif_ref_clk_src, 734 727 .clkr.hw.init = &(struct clk_init_data){ 735 728 .name = "gcc_tsif_ref_clk_src", 736 - .parent_names = gcc_parent_names_6, 737 - .num_parents = 5, 729 + .parent_data = gcc_parent_data_6, 730 + .num_parents = ARRAY_SIZE(gcc_parent_data_6), 738 731 .ops = &clk_rcg2_ops, 739 732 }, 740 733 }; ··· 756 749 .freq_tbl = ftbl_gcc_ufs_card_axi_clk_src, 757 750 .clkr.hw.init = &(struct clk_init_data){ 758 751 .name = "gcc_ufs_card_axi_clk_src", 759 - .parent_names = gcc_parent_names_0, 760 - .num_parents = 4, 752 + .parent_data = gcc_parent_data_0, 753 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 761 754 .ops = &clk_rcg2_shared_ops, 762 755 }, 763 756 }; ··· 778 771 .freq_tbl = ftbl_gcc_ufs_card_ice_core_clk_src, 779 772 .clkr.hw.init = &(struct clk_init_data){ 780 773 .name = "gcc_ufs_card_ice_core_clk_src", 781 - .parent_names = gcc_parent_names_0, 782 - .num_parents = 4, 774 + .parent_data = gcc_parent_data_0, 775 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 783 776 .ops = &clk_rcg2_shared_ops, 784 777 }, 785 778 }; ··· 792 785 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src, 793 786 .clkr.hw.init = &(struct clk_init_data){ 794 787 .name = "gcc_ufs_card_phy_aux_clk_src", 795 - .parent_names = gcc_parent_names_4, 796 - .num_parents = 2, 788 + .parent_data = gcc_parent_data_4, 789 + .num_parents = ARRAY_SIZE(gcc_parent_data_4), 797 790 .ops = &clk_rcg2_ops, 798 791 }, 799 792 }; ··· 813 806 .freq_tbl = ftbl_gcc_ufs_card_unipro_core_clk_src, 814 807 .clkr.hw.init = &(struct clk_init_data){ 815 808 .name = "gcc_ufs_card_unipro_core_clk_src", 816 - .parent_names = gcc_parent_names_0, 817 - .num_parents = 4, 809 + .parent_data = gcc_parent_data_0, 810 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 818 811 .ops = &clk_rcg2_shared_ops, 819 812 }, 820 813 }; ··· 836 829 .freq_tbl = ftbl_gcc_ufs_phy_axi_clk_src, 837 830 .clkr.hw.init = &(struct clk_init_data){ 838 831 .name = "gcc_ufs_phy_axi_clk_src", 839 - .parent_names = gcc_parent_names_0, 840 - .num_parents = 4, 832 + .parent_data = gcc_parent_data_0, 833 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 841 834 .ops = &clk_rcg2_shared_ops, 842 835 }, 843 836 }; ··· 850 843 .freq_tbl = ftbl_gcc_ufs_card_ice_core_clk_src, 851 844 .clkr.hw.init = &(struct clk_init_data){ 852 845 .name = "gcc_ufs_phy_ice_core_clk_src", 853 - .parent_names = gcc_parent_names_0, 854 - .num_parents = 4, 846 + .parent_data = gcc_parent_data_0, 847 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 855 848 .ops = &clk_rcg2_shared_ops, 856 849 }, 857 850 }; ··· 864 857 .freq_tbl = ftbl_gcc_pcie_0_aux_clk_src, 865 858 .clkr.hw.init = &(struct clk_init_data){ 866 859 .name = "gcc_ufs_phy_phy_aux_clk_src", 867 - .parent_names = gcc_parent_names_4, 868 - .num_parents = 2, 860 + .parent_data = gcc_parent_data_4, 861 + .num_parents = ARRAY_SIZE(gcc_parent_data_4), 869 862 .ops = &clk_rcg2_shared_ops, 870 863 }, 871 864 }; ··· 878 871 .freq_tbl = ftbl_gcc_ufs_card_unipro_core_clk_src, 879 872 .clkr.hw.init = &(struct clk_init_data){ 880 873 .name = "gcc_ufs_phy_unipro_core_clk_src", 881 - .parent_names = gcc_parent_names_0, 882 - .num_parents = 4, 874 + .parent_data = gcc_parent_data_0, 875 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 883 876 .ops = &clk_rcg2_shared_ops, 884 877 }, 885 878 }; ··· 901 894 .freq_tbl = ftbl_gcc_usb30_prim_master_clk_src, 902 895 .clkr.hw.init = &(struct clk_init_data){ 903 896 .name = "gcc_usb30_prim_master_clk_src", 904 - .parent_names = gcc_parent_names_0, 905 - .num_parents = 4, 897 + .parent_data = gcc_parent_data_0, 898 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 906 899 .ops = &clk_rcg2_shared_ops, 907 900 }, 908 901 }; ··· 923 916 .freq_tbl = ftbl_gcc_usb30_prim_mock_utmi_clk_src, 924 917 .clkr.hw.init = &(struct clk_init_data){ 925 918 .name = "gcc_usb30_prim_mock_utmi_clk_src", 926 - .parent_names = gcc_parent_names_0, 927 - .num_parents = 4, 919 + .parent_data = gcc_parent_data_0, 920 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 928 921 .ops = &clk_rcg2_shared_ops, 929 922 }, 930 923 }; ··· 937 930 .freq_tbl = ftbl_gcc_usb30_prim_master_clk_src, 938 931 .clkr.hw.init = &(struct clk_init_data){ 939 932 .name = "gcc_usb30_sec_master_clk_src", 940 - .parent_names = gcc_parent_names_0, 941 - .num_parents = 4, 933 + .parent_data = gcc_parent_data_0, 934 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 942 935 .ops = &clk_rcg2_ops, 943 936 }, 944 937 }; ··· 951 944 .freq_tbl = ftbl_gcc_usb30_prim_mock_utmi_clk_src, 952 945 .clkr.hw.init = &(struct clk_init_data){ 953 946 .name = "gcc_usb30_sec_mock_utmi_clk_src", 954 - .parent_names = gcc_parent_names_0, 955 - .num_parents = 4, 947 + .parent_data = gcc_parent_data_0, 948 + .num_parents = ARRAY_SIZE(gcc_parent_data_0), 956 949 .ops = &clk_rcg2_ops, 957 950 }, 958 951 }; ··· 965 958 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src, 966 959 .clkr.hw.init = &(struct clk_init_data){ 967 960 .name = "gcc_usb3_prim_phy_aux_clk_src", 968 - .parent_names = gcc_parent_names_2, 969 - .num_parents = 3, 961 + .parent_data = gcc_parent_data_2, 962 + .num_parents = ARRAY_SIZE(gcc_parent_data_2), 970 963 .ops = &clk_rcg2_ops, 971 964 }, 972 965 }; ··· 979 972 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src, 980 973 .clkr.hw.init = &(struct clk_init_data){ 981 974 .name = "gcc_usb3_sec_phy_aux_clk_src", 982 - .parent_names = gcc_parent_names_2, 983 - .num_parents = 3, 975 + .parent_data = gcc_parent_data_2, 976 + .num_parents = ARRAY_SIZE(gcc_parent_data_2), 984 977 .ops = &clk_rcg2_shared_ops, 985 978 }, 986 979 }; ··· 993 986 .freq_tbl = ftbl_gcc_cpuss_rbcpr_clk_src, 994 987 .clkr.hw.init = &(struct clk_init_data){ 995 988 .name = "gcc_vs_ctrl_clk_src", 996 - .parent_names = gcc_parent_names_3, 997 - .num_parents = 3, 989 + .parent_data = gcc_parent_data_3, 990 + .num_parents = ARRAY_SIZE(gcc_parent_data_3), 998 991 .ops = &clk_rcg2_ops, 999 992 }, 1000 993 }; ··· 1014 1007 .freq_tbl = ftbl_gcc_vsensor_clk_src, 1015 1008 .clkr.hw.init = &(struct clk_init_data){ 1016 1009 .name = "gcc_vsensor_clk_src", 1017 - .parent_names = gcc_parent_names_8, 1018 - .num_parents = 3, 1010 + .parent_data = gcc_parent_data_8, 1011 + .num_parents = ARRAY_SIZE(gcc_parent_data_8), 1019 1012 .ops = &clk_rcg2_ops, 1020 1013 }, 1021 1014 }; ··· 1043 1036 .enable_mask = BIT(0), 1044 1037 .hw.init = &(struct clk_init_data){ 1045 1038 .name = "gcc_aggre_ufs_card_axi_clk", 1046 - .parent_names = (const char *[]){ 1047 - "gcc_ufs_card_axi_clk_src", 1039 + .parent_hws = (const struct clk_hw*[]){ 1040 + &gcc_ufs_card_axi_clk_src.clkr.hw, 1048 1041 }, 1049 1042 .num_parents = 1, 1050 1043 .flags = CLK_SET_RATE_PARENT, ··· 1063 1056 .enable_mask = BIT(0), 1064 1057 .hw.init = &(struct clk_init_data){ 1065 1058 .name = "gcc_aggre_ufs_phy_axi_clk", 1066 - .parent_names = (const char *[]){ 1067 - "gcc_ufs_phy_axi_clk_src", 1059 + .parent_hws = (const struct clk_hw*[]){ 1060 + &gcc_ufs_phy_axi_clk_src.clkr.hw, 1068 1061 }, 1069 1062 .num_parents = 1, 1070 1063 .flags = CLK_SET_RATE_PARENT, ··· 1081 1074 .enable_mask = BIT(0), 1082 1075 .hw.init = &(struct clk_init_data){ 1083 1076 .name = "gcc_aggre_usb3_prim_axi_clk", 1084 - .parent_names = (const char *[]){ 1085 - "gcc_usb30_prim_master_clk_src", 1077 + .parent_hws = (const struct clk_hw*[]){ 1078 + &gcc_usb30_prim_master_clk_src.clkr.hw, 1086 1079 }, 1087 1080 .num_parents = 1, 1088 1081 .flags = CLK_SET_RATE_PARENT, ··· 1099 1092 .enable_mask = BIT(0), 1100 1093 .hw.init = &(struct clk_init_data){ 1101 1094 .name = "gcc_aggre_usb3_sec_axi_clk", 1102 - .parent_names = (const char *[]){ 1103 - "gcc_usb30_sec_master_clk_src", 1095 + .parent_hws = (const struct clk_hw*[]){ 1096 + &gcc_usb30_sec_master_clk_src.clkr.hw, 1104 1097 }, 1105 1098 .num_parents = 1, 1106 1099 .flags = CLK_SET_RATE_PARENT, ··· 1117 1110 .enable_mask = BIT(0), 1118 1111 .hw.init = &(struct clk_init_data){ 1119 1112 .name = "gcc_apc_vs_clk", 1120 - .parent_names = (const char *[]){ 1121 - "gcc_vsensor_clk_src", 1113 + .parent_hws = (const struct clk_hw*[]){ 1114 + &gcc_vsensor_clk_src.clkr.hw, 1122 1115 }, 1123 1116 .num_parents = 1, 1124 1117 .flags = CLK_SET_RATE_PARENT, ··· 1234 1227 .enable_mask = BIT(0), 1235 1228 .hw.init = &(struct clk_init_data){ 1236 1229 .name = "gcc_cfg_noc_usb3_prim_axi_clk", 1237 - .parent_names = (const char *[]){ 1238 - "gcc_usb30_prim_master_clk_src", 1230 + .parent_hws = (const struct clk_hw*[]){ 1231 + &gcc_usb30_prim_master_clk_src.clkr.hw, 1239 1232 }, 1240 1233 .num_parents = 1, 1241 1234 .flags = CLK_SET_RATE_PARENT, ··· 1252 1245 .enable_mask = BIT(0), 1253 1246 .hw.init = &(struct clk_init_data){ 1254 1247 .name = "gcc_cfg_noc_usb3_sec_axi_clk", 1255 - .parent_names = (const char *[]){ 1256 - "gcc_usb30_sec_master_clk_src", 1248 + .parent_hws = (const struct clk_hw*[]){ 1249 + &gcc_usb30_sec_master_clk_src.clkr.hw, 1257 1250 }, 1258 1251 .num_parents = 1, 1259 1252 .flags = CLK_SET_RATE_PARENT, ··· 1270 1263 .enable_mask = BIT(21), 1271 1264 .hw.init = &(struct clk_init_data){ 1272 1265 .name = "gcc_cpuss_ahb_clk", 1273 - .parent_names = (const char *[]){ 1274 - "gcc_cpuss_ahb_clk_src", 1266 + .parent_hws = (const struct clk_hw*[]){ 1267 + &gcc_cpuss_ahb_clk_src.clkr.hw, 1275 1268 }, 1276 1269 .num_parents = 1, 1277 1270 .flags = CLK_SET_RATE_PARENT | CLK_IS_CRITICAL, ··· 1288 1281 .enable_mask = BIT(0), 1289 1282 .hw.init = &(struct clk_init_data){ 1290 1283 .name = "gcc_cpuss_rbcpr_clk", 1291 - .parent_names = (const char *[]){ 1292 - "gcc_cpuss_rbcpr_clk_src", 1284 + .parent_hws = (const struct clk_hw*[]){ 1285 + &gcc_cpuss_rbcpr_clk_src.clkr.hw, 1293 1286 }, 1294 1287 .num_parents = 1, 1295 1288 .flags = CLK_SET_RATE_PARENT, ··· 1347 1340 .enable_mask = BIT(18), 1348 1341 .hw.init = &(struct clk_init_data){ 1349 1342 .name = "gcc_disp_gpll0_clk_src", 1350 - .parent_names = (const char *[]){ 1351 - "gpll0", 1343 + .parent_hws = (const struct clk_hw*[]){ 1344 + &gpll0.clkr.hw, 1352 1345 }, 1353 1346 .num_parents = 1, 1354 1347 .ops = &clk_branch2_aon_ops, ··· 1363 1356 .enable_mask = BIT(19), 1364 1357 .hw.init = &(struct clk_init_data){ 1365 1358 .name = "gcc_disp_gpll0_div_clk_src", 1366 - .parent_names = (const char *[]){ 1367 - "gpll0_out_even", 1359 + .parent_hws = (const struct clk_hw*[]){ 1360 + &gpll0_out_even.clkr.hw, 1368 1361 }, 1369 1362 .num_parents = 1, 1370 1363 .ops = &clk_branch2_ops, ··· 1394 1387 .enable_mask = BIT(0), 1395 1388 .hw.init = &(struct clk_init_data){ 1396 1389 .name = "gcc_gp1_clk", 1397 - .parent_names = (const char *[]){ 1398 - "gcc_gp1_clk_src", 1390 + .parent_hws = (const struct clk_hw*[]){ 1391 + &gcc_gp1_clk_src.clkr.hw, 1399 1392 }, 1400 1393 .num_parents = 1, 1401 1394 .flags = CLK_SET_RATE_PARENT, ··· 1412 1405 .enable_mask = BIT(0), 1413 1406 .hw.init = &(struct clk_init_data){ 1414 1407 .name = "gcc_gp2_clk", 1415 - .parent_names = (const char *[]){ 1416 - "gcc_gp2_clk_src", 1408 + .parent_hws = (const struct clk_hw*[]){ 1409 + &gcc_gp2_clk_src.clkr.hw, 1417 1410 }, 1418 1411 .num_parents = 1, 1419 1412 .flags = CLK_SET_RATE_PARENT, ··· 1430 1423 .enable_mask = BIT(0), 1431 1424 .hw.init = &(struct clk_init_data){ 1432 1425 .name = "gcc_gp3_clk", 1433 - .parent_names = (const char *[]){ 1434 - "gcc_gp3_clk_src", 1426 + .parent_hws = (const struct clk_hw*[]){ 1427 + &gcc_gp3_clk_src.clkr.hw, 1435 1428 }, 1436 1429 .num_parents = 1, 1437 1430 .flags = CLK_SET_RATE_PARENT, ··· 1463 1456 .enable_mask = BIT(15), 1464 1457 .hw.init = &(struct clk_init_data){ 1465 1458 .name = "gcc_gpu_gpll0_clk_src", 1466 - .parent_names = (const char *[]){ 1467 - "gpll0", 1459 + .parent_hws = (const struct clk_hw*[]){ 1460 + &gpll0.clkr.hw, 1468 1461 }, 1469 1462 .num_parents = 1, 1470 1463 .ops = &clk_branch2_ops, ··· 1479 1472 .enable_mask = BIT(16), 1480 1473 .hw.init = &(struct clk_init_data){ 1481 1474 .name = "gcc_gpu_gpll0_div_clk_src", 1482 - .parent_names = (const char *[]){ 1483 - "gpll0_out_even", 1475 + .parent_hws = (const struct clk_hw*[]){ 1476 + &gpll0_out_even.clkr.hw, 1484 1477 }, 1485 1478 .num_parents = 1, 1486 1479 .ops = &clk_branch2_ops, ··· 1535 1528 .enable_mask = BIT(0), 1536 1529 .hw.init = &(struct clk_init_data){ 1537 1530 .name = "gcc_gpu_vs_clk", 1538 - .parent_names = (const char *[]){ 1539 - "gcc_vsensor_clk_src", 1531 + .parent_hws = (const struct clk_hw*[]){ 1532 + &gcc_vsensor_clk_src.clkr.hw, 1540 1533 }, 1541 1534 .num_parents = 1, 1542 1535 .flags = CLK_SET_RATE_PARENT, ··· 1634 1627 .enable_mask = BIT(0), 1635 1628 .hw.init = &(struct clk_init_data){ 1636 1629 .name = "gcc_mss_vs_clk", 1637 - .parent_names = (const char *[]){ 1638 - "gcc_vsensor_clk_src", 1630 + .parent_hws = (const struct clk_hw*[]){ 1631 + &gcc_vsensor_clk_src.clkr.hw, 1639 1632 }, 1640 1633 .num_parents = 1, 1641 1634 .flags = CLK_SET_RATE_PARENT, ··· 1652 1645 .enable_mask = BIT(3), 1653 1646 .hw.init = &(struct clk_init_data){ 1654 1647 .name = "gcc_pcie_0_aux_clk", 1655 - .parent_names = (const char *[]){ 1656 - "gcc_pcie_0_aux_clk_src", 1648 + .parent_hws = (const struct clk_hw*[]){ 1649 + &gcc_pcie_0_aux_clk_src.clkr.hw, 1657 1650 }, 1658 1651 .num_parents = 1, 1659 1652 .flags = CLK_SET_RATE_PARENT, ··· 1710 1703 .enable_mask = BIT(4), 1711 1704 .hw.init = &(struct clk_init_data){ 1712 1705 .name = "gcc_pcie_0_pipe_clk", 1713 - .parent_names = (const char *[]){ "pcie_0_pipe_clk" }, 1706 + .parent_data = &(const struct clk_parent_data){ 1707 + .fw_name = "pcie_0_pipe_clk", .name = "pcie_0_pipe_clk", 1708 + }, 1714 1709 .num_parents = 1, 1715 1710 .flags = CLK_SET_RATE_PARENT, 1716 1711 .ops = &clk_branch2_ops, ··· 1756 1747 .enable_mask = BIT(29), 1757 1748 .hw.init = &(struct clk_init_data){ 1758 1749 .name = "gcc_pcie_1_aux_clk", 1759 - .parent_names = (const char *[]){ 1760 - "gcc_pcie_1_aux_clk_src", 1750 + .parent_hws = (const struct clk_hw*[]){ 1751 + &gcc_pcie_1_aux_clk_src.clkr.hw, 1761 1752 }, 1762 1753 .num_parents = 1, 1763 1754 .flags = CLK_SET_RATE_PARENT, ··· 1814 1805 .enable_mask = BIT(30), 1815 1806 .hw.init = &(struct clk_init_data){ 1816 1807 .name = "gcc_pcie_1_pipe_clk", 1817 - .parent_names = (const char *[]){ "pcie_1_pipe_clk" }, 1808 + .parent_data = &(const struct clk_parent_data){ 1809 + .fw_name = "pcie_1_pipe_clk", .name = "pcie_1_pipe_clk", 1810 + }, 1818 1811 .num_parents = 1, 1819 1812 .ops = &clk_branch2_ops, 1820 1813 }, ··· 1859 1848 .enable_mask = BIT(0), 1860 1849 .hw.init = &(struct clk_init_data){ 1861 1850 .name = "gcc_pcie_phy_aux_clk", 1862 - .parent_names = (const char *[]){ 1863 - "gcc_pcie_0_aux_clk_src", 1851 + .parent_hws = (const struct clk_hw*[]){ 1852 + &gcc_pcie_0_aux_clk_src.clkr.hw, 1864 1853 }, 1865 1854 .num_parents = 1, 1866 1855 .flags = CLK_SET_RATE_PARENT, ··· 1877 1866 .enable_mask = BIT(0), 1878 1867 .hw.init = &(struct clk_init_data){ 1879 1868 .name = "gcc_pcie_phy_refgen_clk", 1880 - .parent_names = (const char *[]){ 1881 - "gcc_pcie_phy_refgen_clk_src", 1869 + .parent_hws = (const struct clk_hw*[]){ 1870 + &gcc_pcie_phy_refgen_clk_src.clkr.hw, 1882 1871 }, 1883 1872 .num_parents = 1, 1884 1873 .flags = CLK_SET_RATE_PARENT, ··· 1895 1884 .enable_mask = BIT(0), 1896 1885 .hw.init = &(struct clk_init_data){ 1897 1886 .name = "gcc_pdm2_clk", 1898 - .parent_names = (const char *[]){ 1899 - "gcc_pdm2_clk_src", 1887 + .parent_hws = (const struct clk_hw*[]){ 1888 + &gcc_pdm2_clk_src.clkr.hw, 1900 1889 }, 1901 1890 .num_parents = 1, 1902 1891 .flags = CLK_SET_RATE_PARENT, ··· 2014 2003 .enable_mask = BIT(0), 2015 2004 .hw.init = &(struct clk_init_data){ 2016 2005 .name = "gcc_qspi_core_clk", 2017 - .parent_names = (const char *[]){ 2018 - "gcc_qspi_core_clk_src", 2006 + .parent_hws = (const struct clk_hw*[]){ 2007 + &gcc_qspi_core_clk_src.clkr.hw, 2019 2008 }, 2020 2009 .num_parents = 1, 2021 2010 .flags = CLK_SET_RATE_PARENT, ··· 2032 2021 .enable_mask = BIT(10), 2033 2022 .hw.init = &(struct clk_init_data){ 2034 2023 .name = "gcc_qupv3_wrap0_s0_clk", 2035 - .parent_names = (const char *[]){ 2036 - "gcc_qupv3_wrap0_s0_clk_src", 2024 + .parent_hws = (const struct clk_hw*[]){ 2025 + &gcc_qupv3_wrap0_s0_clk_src.clkr.hw, 2037 2026 }, 2038 2027 .num_parents = 1, 2039 2028 .flags = CLK_SET_RATE_PARENT, ··· 2050 2039 .enable_mask = BIT(11), 2051 2040 .hw.init = &(struct clk_init_data){ 2052 2041 .name = "gcc_qupv3_wrap0_s1_clk", 2053 - .parent_names = (const char *[]){ 2054 - "gcc_qupv3_wrap0_s1_clk_src", 2042 + .parent_hws = (const struct clk_hw*[]){ 2043 + &gcc_qupv3_wrap0_s1_clk_src.clkr.hw, 2055 2044 }, 2056 2045 .num_parents = 1, 2057 2046 .flags = CLK_SET_RATE_PARENT, ··· 2068 2057 .enable_mask = BIT(12), 2069 2058 .hw.init = &(struct clk_init_data){ 2070 2059 .name = "gcc_qupv3_wrap0_s2_clk", 2071 - .parent_names = (const char *[]){ 2072 - "gcc_qupv3_wrap0_s2_clk_src", 2060 + .parent_hws = (const struct clk_hw*[]){ 2061 + &gcc_qupv3_wrap0_s2_clk_src.clkr.hw, 2073 2062 }, 2074 2063 .num_parents = 1, 2075 2064 .flags = CLK_SET_RATE_PARENT, ··· 2086 2075 .enable_mask = BIT(13), 2087 2076 .hw.init = &(struct clk_init_data){ 2088 2077 .name = "gcc_qupv3_wrap0_s3_clk", 2089 - .parent_names = (const char *[]){ 2090 - "gcc_qupv3_wrap0_s3_clk_src", 2078 + .parent_hws = (const struct clk_hw*[]){ 2079 + &gcc_qupv3_wrap0_s3_clk_src.clkr.hw, 2091 2080 }, 2092 2081 .num_parents = 1, 2093 2082 .flags = CLK_SET_RATE_PARENT, ··· 2104 2093 .enable_mask = BIT(14), 2105 2094 .hw.init = &(struct clk_init_data){ 2106 2095 .name = "gcc_qupv3_wrap0_s4_clk", 2107 - .parent_names = (const char *[]){ 2108 - "gcc_qupv3_wrap0_s4_clk_src", 2096 + .parent_hws = (const struct clk_hw*[]){ 2097 + &gcc_qupv3_wrap0_s4_clk_src.clkr.hw, 2109 2098 }, 2110 2099 .num_parents = 1, 2111 2100 .flags = CLK_SET_RATE_PARENT, ··· 2122 2111 .enable_mask = BIT(15), 2123 2112 .hw.init = &(struct clk_init_data){ 2124 2113 .name = "gcc_qupv3_wrap0_s5_clk", 2125 - .parent_names = (const char *[]){ 2126 - "gcc_qupv3_wrap0_s5_clk_src", 2114 + .parent_hws = (const struct clk_hw*[]){ 2115 + &gcc_qupv3_wrap0_s5_clk_src.clkr.hw, 2127 2116 }, 2128 2117 .num_parents = 1, 2129 2118 .flags = CLK_SET_RATE_PARENT, ··· 2140 2129 .enable_mask = BIT(16), 2141 2130 .hw.init = &(struct clk_init_data){ 2142 2131 .name = "gcc_qupv3_wrap0_s6_clk", 2143 - .parent_names = (const char *[]){ 2144 - "gcc_qupv3_wrap0_s6_clk_src", 2132 + .parent_hws = (const struct clk_hw*[]){ 2133 + &gcc_qupv3_wrap0_s6_clk_src.clkr.hw, 2145 2134 }, 2146 2135 .num_parents = 1, 2147 2136 .flags = CLK_SET_RATE_PARENT, ··· 2158 2147 .enable_mask = BIT(17), 2159 2148 .hw.init = &(struct clk_init_data){ 2160 2149 .name = "gcc_qupv3_wrap0_s7_clk", 2161 - .parent_names = (const char *[]){ 2162 - "gcc_qupv3_wrap0_s7_clk_src", 2150 + .parent_hws = (const struct clk_hw*[]){ 2151 + &gcc_qupv3_wrap0_s7_clk_src.clkr.hw, 2163 2152 }, 2164 2153 .num_parents = 1, 2165 2154 .flags = CLK_SET_RATE_PARENT, ··· 2176 2165 .enable_mask = BIT(22), 2177 2166 .hw.init = &(struct clk_init_data){ 2178 2167 .name = "gcc_qupv3_wrap1_s0_clk", 2179 - .parent_names = (const char *[]){ 2180 - "gcc_qupv3_wrap1_s0_clk_src", 2168 + .parent_hws = (const struct clk_hw*[]){ 2169 + &gcc_qupv3_wrap1_s0_clk_src.clkr.hw, 2181 2170 }, 2182 2171 .num_parents = 1, 2183 2172 .flags = CLK_SET_RATE_PARENT, ··· 2194 2183 .enable_mask = BIT(23), 2195 2184 .hw.init = &(struct clk_init_data){ 2196 2185 .name = "gcc_qupv3_wrap1_s1_clk", 2197 - .parent_names = (const char *[]){ 2198 - "gcc_qupv3_wrap1_s1_clk_src", 2186 + .parent_hws = (const struct clk_hw*[]){ 2187 + &gcc_qupv3_wrap1_s1_clk_src.clkr.hw, 2199 2188 }, 2200 2189 .num_parents = 1, 2201 2190 .flags = CLK_SET_RATE_PARENT, ··· 2212 2201 .enable_mask = BIT(24), 2213 2202 .hw.init = &(struct clk_init_data){ 2214 2203 .name = "gcc_qupv3_wrap1_s2_clk", 2215 - .parent_names = (const char *[]){ 2216 - "gcc_qupv3_wrap1_s2_clk_src", 2204 + .parent_hws = (const struct clk_hw*[]){ 2205 + &gcc_qupv3_wrap1_s2_clk_src.clkr.hw, 2217 2206 }, 2218 2207 .num_parents = 1, 2219 2208 .flags = CLK_SET_RATE_PARENT, ··· 2230 2219 .enable_mask = BIT(25), 2231 2220 .hw.init = &(struct clk_init_data){ 2232 2221 .name = "gcc_qupv3_wrap1_s3_clk", 2233 - .parent_names = (const char *[]){ 2234 - "gcc_qupv3_wrap1_s3_clk_src", 2222 + .parent_hws = (const struct clk_hw*[]){ 2223 + &gcc_qupv3_wrap1_s3_clk_src.clkr.hw, 2235 2224 }, 2236 2225 .num_parents = 1, 2237 2226 .flags = CLK_SET_RATE_PARENT, ··· 2248 2237 .enable_mask = BIT(26), 2249 2238 .hw.init = &(struct clk_init_data){ 2250 2239 .name = "gcc_qupv3_wrap1_s4_clk", 2251 - .parent_names = (const char *[]){ 2252 - "gcc_qupv3_wrap1_s4_clk_src", 2240 + .parent_hws = (const struct clk_hw*[]){ 2241 + &gcc_qupv3_wrap1_s4_clk_src.clkr.hw, 2253 2242 }, 2254 2243 .num_parents = 1, 2255 2244 .flags = CLK_SET_RATE_PARENT, ··· 2266 2255 .enable_mask = BIT(27), 2267 2256 .hw.init = &(struct clk_init_data){ 2268 2257 .name = "gcc_qupv3_wrap1_s5_clk", 2269 - .parent_names = (const char *[]){ 2270 - "gcc_qupv3_wrap1_s5_clk_src", 2258 + .parent_hws = (const struct clk_hw*[]){ 2259 + &gcc_qupv3_wrap1_s5_clk_src.clkr.hw, 2271 2260 }, 2272 2261 .num_parents = 1, 2273 2262 .flags = CLK_SET_RATE_PARENT, ··· 2284 2273 .enable_mask = BIT(28), 2285 2274 .hw.init = &(struct clk_init_data){ 2286 2275 .name = "gcc_qupv3_wrap1_s6_clk", 2287 - .parent_names = (const char *[]){ 2288 - "gcc_qupv3_wrap1_s6_clk_src", 2276 + .parent_hws = (const struct clk_hw*[]){ 2277 + &gcc_qupv3_wrap1_s6_clk_src.clkr.hw, 2289 2278 }, 2290 2279 .num_parents = 1, 2291 2280 .flags = CLK_SET_RATE_PARENT, ··· 2302 2291 .enable_mask = BIT(29), 2303 2292 .hw.init = &(struct clk_init_data){ 2304 2293 .name = "gcc_qupv3_wrap1_s7_clk", 2305 - .parent_names = (const char *[]){ 2306 - "gcc_qupv3_wrap1_s7_clk_src", 2294 + .parent_hws = (const struct clk_hw*[]){ 2295 + &gcc_qupv3_wrap1_s7_clk_src.clkr.hw, 2307 2296 }, 2308 2297 .num_parents = 1, 2309 2298 .flags = CLK_SET_RATE_PARENT, ··· 2389 2378 .enable_mask = BIT(0), 2390 2379 .hw.init = &(struct clk_init_data){ 2391 2380 .name = "gcc_sdcc2_apps_clk", 2392 - .parent_names = (const char *[]){ 2393 - "gcc_sdcc2_apps_clk_src", 2381 + .parent_hws = (const struct clk_hw*[]){ 2382 + &gcc_sdcc2_apps_clk_src.clkr.hw, 2394 2383 }, 2395 2384 .num_parents = 1, 2396 2385 .flags = CLK_SET_RATE_PARENT, ··· 2420 2409 .enable_mask = BIT(0), 2421 2410 .hw.init = &(struct clk_init_data){ 2422 2411 .name = "gcc_sdcc4_apps_clk", 2423 - .parent_names = (const char *[]){ 2424 - "gcc_sdcc4_apps_clk_src", 2412 + .parent_hws = (const struct clk_hw*[]){ 2413 + &gcc_sdcc4_apps_clk_src.clkr.hw, 2425 2414 }, 2426 2415 .num_parents = 1, 2427 2416 .flags = CLK_SET_RATE_PARENT, ··· 2438 2427 .enable_mask = BIT(0), 2439 2428 .hw.init = &(struct clk_init_data){ 2440 2429 .name = "gcc_sys_noc_cpuss_ahb_clk", 2441 - .parent_names = (const char *[]){ 2442 - "gcc_cpuss_ahb_clk_src", 2430 + .parent_hws = (const struct clk_hw*[]){ 2431 + &gcc_cpuss_ahb_clk_src.clkr.hw, 2443 2432 }, 2444 2433 .num_parents = 1, 2445 2434 .flags = CLK_SET_RATE_PARENT | CLK_IS_CRITICAL, ··· 2482 2471 .enable_mask = BIT(0), 2483 2472 .hw.init = &(struct clk_init_data){ 2484 2473 .name = "gcc_tsif_ref_clk", 2485 - .parent_names = (const char *[]){ 2486 - "gcc_tsif_ref_clk_src", 2474 + .parent_hws = (const struct clk_hw*[]){ 2475 + &gcc_tsif_ref_clk_src.clkr.hw, 2487 2476 }, 2488 2477 .num_parents = 1, 2489 2478 .flags = CLK_SET_RATE_PARENT, ··· 2517 2506 .enable_mask = BIT(0), 2518 2507 .hw.init = &(struct clk_init_data){ 2519 2508 .name = "gcc_ufs_card_axi_clk", 2520 - .parent_names = (const char *[]){ 2521 - "gcc_ufs_card_axi_clk_src", 2509 + .parent_hws = (const struct clk_hw*[]){ 2510 + &gcc_ufs_card_axi_clk_src.clkr.hw, 2522 2511 }, 2523 2512 .num_parents = 1, 2524 2513 .flags = CLK_SET_RATE_PARENT, ··· 2550 2539 .enable_mask = BIT(0), 2551 2540 .hw.init = &(struct clk_init_data){ 2552 2541 .name = "gcc_ufs_card_ice_core_clk", 2553 - .parent_names = (const char *[]){ 2554 - "gcc_ufs_card_ice_core_clk_src", 2542 + .parent_hws = (const struct clk_hw*[]){ 2543 + &gcc_ufs_card_ice_core_clk_src.clkr.hw, 2555 2544 }, 2556 2545 .num_parents = 1, 2557 2546 .flags = CLK_SET_RATE_PARENT, ··· 2570 2559 .enable_mask = BIT(0), 2571 2560 .hw.init = &(struct clk_init_data){ 2572 2561 .name = "gcc_ufs_card_phy_aux_clk", 2573 - .parent_names = (const char *[]){ 2574 - "gcc_ufs_card_phy_aux_clk_src", 2562 + .parent_hws = (const struct clk_hw*[]){ 2563 + &gcc_ufs_card_phy_aux_clk_src.clkr.hw, 2575 2564 }, 2576 2565 .num_parents = 1, 2577 2566 .flags = CLK_SET_RATE_PARENT, ··· 2626 2615 .enable_mask = BIT(0), 2627 2616 .hw.init = &(struct clk_init_data){ 2628 2617 .name = "gcc_ufs_card_unipro_core_clk", 2629 - .parent_names = (const char *[]){ 2630 - "gcc_ufs_card_unipro_core_clk_src", 2618 + .parent_hws = (const struct clk_hw*[]){ 2619 + &gcc_ufs_card_unipro_core_clk_src.clkr.hw, 2631 2620 }, 2632 2621 .num_parents = 1, 2633 2622 .flags = CLK_SET_RATE_PARENT, ··· 2674 2663 .enable_mask = BIT(0), 2675 2664 .hw.init = &(struct clk_init_data){ 2676 2665 .name = "gcc_ufs_phy_axi_clk", 2677 - .parent_names = (const char *[]){ 2678 - "gcc_ufs_phy_axi_clk_src", 2666 + .parent_hws = (const struct clk_hw*[]){ 2667 + &gcc_ufs_phy_axi_clk_src.clkr.hw, 2679 2668 }, 2680 2669 .num_parents = 1, 2681 2670 .flags = CLK_SET_RATE_PARENT, ··· 2694 2683 .enable_mask = BIT(0), 2695 2684 .hw.init = &(struct clk_init_data){ 2696 2685 .name = "gcc_ufs_phy_ice_core_clk", 2697 - .parent_names = (const char *[]){ 2698 - "gcc_ufs_phy_ice_core_clk_src", 2686 + .parent_hws = (const struct clk_hw*[]){ 2687 + &gcc_ufs_phy_ice_core_clk_src.clkr.hw, 2699 2688 }, 2700 2689 .num_parents = 1, 2701 2690 .flags = CLK_SET_RATE_PARENT, ··· 2714 2703 .enable_mask = BIT(0), 2715 2704 .hw.init = &(struct clk_init_data){ 2716 2705 .name = "gcc_ufs_phy_phy_aux_clk", 2717 - .parent_names = (const char *[]){ 2718 - "gcc_ufs_phy_phy_aux_clk_src", 2706 + .parent_hws = (const struct clk_hw*[]){ 2707 + &gcc_ufs_phy_phy_aux_clk_src.clkr.hw, 2719 2708 }, 2720 2709 .num_parents = 1, 2721 2710 .flags = CLK_SET_RATE_PARENT, ··· 2770 2759 .enable_mask = BIT(0), 2771 2760 .hw.init = &(struct clk_init_data){ 2772 2761 .name = "gcc_ufs_phy_unipro_core_clk", 2773 - .parent_names = (const char *[]){ 2774 - "gcc_ufs_phy_unipro_core_clk_src", 2762 + .parent_hws = (const struct clk_hw*[]){ 2763 + &gcc_ufs_phy_unipro_core_clk_src.clkr.hw, 2775 2764 }, 2776 2765 .num_parents = 1, 2777 2766 .flags = CLK_SET_RATE_PARENT, ··· 2788 2777 .enable_mask = BIT(0), 2789 2778 .hw.init = &(struct clk_init_data){ 2790 2779 .name = "gcc_usb30_prim_master_clk", 2791 - .parent_names = (const char *[]){ 2792 - "gcc_usb30_prim_master_clk_src", 2780 + .parent_hws = (const struct clk_hw*[]){ 2781 + &gcc_usb30_prim_master_clk_src.clkr.hw, 2793 2782 }, 2794 2783 .num_parents = 1, 2795 2784 .flags = CLK_SET_RATE_PARENT, ··· 2806 2795 .enable_mask = BIT(0), 2807 2796 .hw.init = &(struct clk_init_data){ 2808 2797 .name = "gcc_usb30_prim_mock_utmi_clk", 2809 - .parent_names = (const char *[]){ 2810 - "gcc_usb30_prim_mock_utmi_clk_src", 2798 + .parent_hws = (const struct clk_hw*[]){ 2799 + &gcc_usb30_prim_mock_utmi_clk_src.clkr.hw, 2811 2800 }, 2812 2801 .num_parents = 1, 2813 2802 .flags = CLK_SET_RATE_PARENT, ··· 2837 2826 .enable_mask = BIT(0), 2838 2827 .hw.init = &(struct clk_init_data){ 2839 2828 .name = "gcc_usb30_sec_master_clk", 2840 - .parent_names = (const char *[]){ 2841 - "gcc_usb30_sec_master_clk_src", 2829 + .parent_hws = (const struct clk_hw*[]){ 2830 + &gcc_usb30_sec_master_clk_src.clkr.hw, 2842 2831 }, 2843 2832 .num_parents = 1, 2844 2833 .flags = CLK_SET_RATE_PARENT, ··· 2855 2844 .enable_mask = BIT(0), 2856 2845 .hw.init = &(struct clk_init_data){ 2857 2846 .name = "gcc_usb30_sec_mock_utmi_clk", 2858 - .parent_names = (const char *[]){ 2859 - "gcc_usb30_sec_mock_utmi_clk_src", 2847 + .parent_hws = (const struct clk_hw*[]){ 2848 + &gcc_usb30_sec_mock_utmi_clk_src.clkr.hw, 2860 2849 }, 2861 2850 .num_parents = 1, 2862 2851 .flags = CLK_SET_RATE_PARENT, ··· 2899 2888 .enable_mask = BIT(0), 2900 2889 .hw.init = &(struct clk_init_data){ 2901 2890 .name = "gcc_usb3_prim_phy_aux_clk", 2902 - .parent_names = (const char *[]){ 2903 - "gcc_usb3_prim_phy_aux_clk_src", 2891 + .parent_hws = (const struct clk_hw*[]){ 2892 + &gcc_usb3_prim_phy_aux_clk_src.clkr.hw, 2904 2893 }, 2905 2894 .num_parents = 1, 2906 2895 .flags = CLK_SET_RATE_PARENT, ··· 2917 2906 .enable_mask = BIT(0), 2918 2907 .hw.init = &(struct clk_init_data){ 2919 2908 .name = "gcc_usb3_prim_phy_com_aux_clk", 2920 - .parent_names = (const char *[]){ 2921 - "gcc_usb3_prim_phy_aux_clk_src", 2909 + .parent_hws = (const struct clk_hw*[]){ 2910 + &gcc_usb3_prim_phy_aux_clk_src.clkr.hw, 2922 2911 }, 2923 2912 .num_parents = 1, 2924 2913 .flags = CLK_SET_RATE_PARENT, ··· 2960 2949 .enable_mask = BIT(0), 2961 2950 .hw.init = &(struct clk_init_data){ 2962 2951 .name = "gcc_usb3_sec_phy_aux_clk", 2963 - .parent_names = (const char *[]){ 2964 - "gcc_usb3_sec_phy_aux_clk_src", 2952 + .parent_hws = (const struct clk_hw*[]){ 2953 + &gcc_usb3_sec_phy_aux_clk_src.clkr.hw, 2965 2954 }, 2966 2955 .num_parents = 1, 2967 2956 .flags = CLK_SET_RATE_PARENT, ··· 2978 2967 .enable_mask = BIT(0), 2979 2968 .hw.init = &(struct clk_init_data){ 2980 2969 .name = "gcc_usb3_sec_phy_com_aux_clk", 2981 - .parent_names = (const char *[]){ 2982 - "gcc_usb3_sec_phy_aux_clk_src", 2970 + .parent_hws = (const struct clk_hw*[]){ 2971 + &gcc_usb3_sec_phy_aux_clk_src.clkr.hw, 2983 2972 }, 2984 2973 .num_parents = 1, 2985 2974 .flags = CLK_SET_RATE_PARENT, ··· 3023 3012 .enable_mask = BIT(0), 3024 3013 .hw.init = &(struct clk_init_data){ 3025 3014 .name = "gcc_vdda_vs_clk", 3026 - .parent_names = (const char *[]){ 3027 - "gcc_vsensor_clk_src", 3015 + .parent_hws = (const struct clk_hw*[]){ 3016 + &gcc_vsensor_clk_src.clkr.hw, 3028 3017 }, 3029 3018 .num_parents = 1, 3030 3019 .flags = CLK_SET_RATE_PARENT, ··· 3041 3030 .enable_mask = BIT(0), 3042 3031 .hw.init = &(struct clk_init_data){ 3043 3032 .name = "gcc_vddcx_vs_clk", 3044 - .parent_names = (const char *[]){ 3045 - "gcc_vsensor_clk_src", 3033 + .parent_hws = (const struct clk_hw*[]){ 3034 + &gcc_vsensor_clk_src.clkr.hw, 3046 3035 }, 3047 3036 .num_parents = 1, 3048 3037 .flags = CLK_SET_RATE_PARENT, ··· 3059 3048 .enable_mask = BIT(0), 3060 3049 .hw.init = &(struct clk_init_data){ 3061 3050 .name = "gcc_vddmx_vs_clk", 3062 - .parent_names = (const char *[]){ 3063 - "gcc_vsensor_clk_src", 3051 + .parent_hws = (const struct clk_hw*[]){ 3052 + &gcc_vsensor_clk_src.clkr.hw, 3064 3053 }, 3065 3054 .num_parents = 1, 3066 3055 .flags = CLK_SET_RATE_PARENT, ··· 3135 3124 .enable_mask = BIT(0), 3136 3125 .hw.init = &(struct clk_init_data){ 3137 3126 .name = "gcc_vs_ctrl_clk", 3138 - .parent_names = (const char *[]){ 3139 - "gcc_vs_ctrl_clk_src", 3127 + .parent_hws = (const struct clk_hw*[]){ 3128 + &gcc_vs_ctrl_clk_src.clkr.hw, 3140 3129 }, 3141 3130 .num_parents = 1, 3142 3131 .flags = CLK_SET_RATE_PARENT,