1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2013, The Linux Foundation. All rights reserved. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/bitops.h> 8 #include <linux/err.h> 9 #include <linux/platform_device.h> 10 #include <linux/module.h> 11 #include <linux/of.h> 12 #include <linux/of_device.h> 13 #include <linux/clk-provider.h> 14 #include <linux/regmap.h> 15 #include <linux/reset-controller.h> 16 17 #include <dt-bindings/clock/qcom,gcc-msm8660.h> 18 #include <dt-bindings/reset/qcom,gcc-msm8660.h> 19 20 #include "common.h" 21 #include "clk-regmap.h" 22 #include "clk-pll.h" 23 #include "clk-rcg.h" 24 #include "clk-branch.h" 25 #include "reset.h" 26 27 static struct clk_pll pll8 = { 28 .l_reg = 0x3144, 29 .m_reg = 0x3148, 30 .n_reg = 0x314c, 31 .config_reg = 0x3154, 32 .mode_reg = 0x3140, 33 .status_reg = 0x3158, 34 .status_bit = 16, 35 .clkr.hw.init = &(struct clk_init_data){ 36 .name = "pll8", 37 .parent_names = (const char *[]){ "pxo" }, 38 .num_parents = 1, 39 .ops = &clk_pll_ops, 40 }, 41 }; 42 43 static struct clk_regmap pll8_vote = { 44 .enable_reg = 0x34c0, 45 .enable_mask = BIT(8), 46 .hw.init = &(struct clk_init_data){ 47 .name = "pll8_vote", 48 .parent_names = (const char *[]){ "pll8" }, 49 .num_parents = 1, 50 .ops = &clk_pll_vote_ops, 51 }, 52 }; 53 54 enum { 55 P_PXO, 56 P_PLL8, 57 P_CXO, 58 }; 59 60 static const struct parent_map gcc_pxo_pll8_map[] = { 61 { P_PXO, 0 }, 62 { P_PLL8, 3 } 63 }; 64 65 static const char * const gcc_pxo_pll8[] = { 66 "pxo", 67 "pll8_vote", 68 }; 69 70 static const struct parent_map gcc_pxo_pll8_cxo_map[] = { 71 { P_PXO, 0 }, 72 { P_PLL8, 3 }, 73 { P_CXO, 5 } 74 }; 75 76 static const char * const gcc_pxo_pll8_cxo[] = { 77 "pxo", 78 "pll8_vote", 79 "cxo", 80 }; 81 82 static struct freq_tbl clk_tbl_gsbi_uart[] = { 83 { 1843200, P_PLL8, 2, 6, 625 }, 84 { 3686400, P_PLL8, 2, 12, 625 }, 85 { 7372800, P_PLL8, 2, 24, 625 }, 86 { 14745600, P_PLL8, 2, 48, 625 }, 87 { 16000000, P_PLL8, 4, 1, 6 }, 88 { 24000000, P_PLL8, 4, 1, 4 }, 89 { 32000000, P_PLL8, 4, 1, 3 }, 90 { 40000000, P_PLL8, 1, 5, 48 }, 91 { 46400000, P_PLL8, 1, 29, 240 }, 92 { 48000000, P_PLL8, 4, 1, 2 }, 93 { 51200000, P_PLL8, 1, 2, 15 }, 94 { 56000000, P_PLL8, 1, 7, 48 }, 95 { 58982400, P_PLL8, 1, 96, 625 }, 96 { 64000000, P_PLL8, 2, 1, 3 }, 97 { } 98 }; 99 100 static struct clk_rcg gsbi1_uart_src = { 101 .ns_reg = 0x29d4, 102 .md_reg = 0x29d0, 103 .mn = { 104 .mnctr_en_bit = 8, 105 .mnctr_reset_bit = 7, 106 .mnctr_mode_shift = 5, 107 .n_val_shift = 16, 108 .m_val_shift = 16, 109 .width = 16, 110 }, 111 .p = { 112 .pre_div_shift = 3, 113 .pre_div_width = 2, 114 }, 115 .s = { 116 .src_sel_shift = 0, 117 .parent_map = gcc_pxo_pll8_map, 118 }, 119 .freq_tbl = clk_tbl_gsbi_uart, 120 .clkr = { 121 .enable_reg = 0x29d4, 122 .enable_mask = BIT(11), 123 .hw.init = &(struct clk_init_data){ 124 .name = "gsbi1_uart_src", 125 .parent_names = gcc_pxo_pll8, 126 .num_parents = 2, 127 .ops = &clk_rcg_ops, 128 .flags = CLK_SET_PARENT_GATE, 129 }, 130 }, 131 }; 132 133 static struct clk_branch gsbi1_uart_clk = { 134 .halt_reg = 0x2fcc, 135 .halt_bit = 10, 136 .clkr = { 137 .enable_reg = 0x29d4, 138 .enable_mask = BIT(9), 139 .hw.init = &(struct clk_init_data){ 140 .name = "gsbi1_uart_clk", 141 .parent_names = (const char *[]){ 142 "gsbi1_uart_src", 143 }, 144 .num_parents = 1, 145 .ops = &clk_branch_ops, 146 .flags = CLK_SET_RATE_PARENT, 147 }, 148 }, 149 }; 150 151 static struct clk_rcg gsbi2_uart_src = { 152 .ns_reg = 0x29f4, 153 .md_reg = 0x29f0, 154 .mn = { 155 .mnctr_en_bit = 8, 156 .mnctr_reset_bit = 7, 157 .mnctr_mode_shift = 5, 158 .n_val_shift = 16, 159 .m_val_shift = 16, 160 .width = 16, 161 }, 162 .p = { 163 .pre_div_shift = 3, 164 .pre_div_width = 2, 165 }, 166 .s = { 167 .src_sel_shift = 0, 168 .parent_map = gcc_pxo_pll8_map, 169 }, 170 .freq_tbl = clk_tbl_gsbi_uart, 171 .clkr = { 172 .enable_reg = 0x29f4, 173 .enable_mask = BIT(11), 174 .hw.init = &(struct clk_init_data){ 175 .name = "gsbi2_uart_src", 176 .parent_names = gcc_pxo_pll8, 177 .num_parents = 2, 178 .ops = &clk_rcg_ops, 179 .flags = CLK_SET_PARENT_GATE, 180 }, 181 }, 182 }; 183 184 static struct clk_branch gsbi2_uart_clk = { 185 .halt_reg = 0x2fcc, 186 .halt_bit = 6, 187 .clkr = { 188 .enable_reg = 0x29f4, 189 .enable_mask = BIT(9), 190 .hw.init = &(struct clk_init_data){ 191 .name = "gsbi2_uart_clk", 192 .parent_names = (const char *[]){ 193 "gsbi2_uart_src", 194 }, 195 .num_parents = 1, 196 .ops = &clk_branch_ops, 197 .flags = CLK_SET_RATE_PARENT, 198 }, 199 }, 200 }; 201 202 static struct clk_rcg gsbi3_uart_src = { 203 .ns_reg = 0x2a14, 204 .md_reg = 0x2a10, 205 .mn = { 206 .mnctr_en_bit = 8, 207 .mnctr_reset_bit = 7, 208 .mnctr_mode_shift = 5, 209 .n_val_shift = 16, 210 .m_val_shift = 16, 211 .width = 16, 212 }, 213 .p = { 214 .pre_div_shift = 3, 215 .pre_div_width = 2, 216 }, 217 .s = { 218 .src_sel_shift = 0, 219 .parent_map = gcc_pxo_pll8_map, 220 }, 221 .freq_tbl = clk_tbl_gsbi_uart, 222 .clkr = { 223 .enable_reg = 0x2a14, 224 .enable_mask = BIT(11), 225 .hw.init = &(struct clk_init_data){ 226 .name = "gsbi3_uart_src", 227 .parent_names = gcc_pxo_pll8, 228 .num_parents = 2, 229 .ops = &clk_rcg_ops, 230 .flags = CLK_SET_PARENT_GATE, 231 }, 232 }, 233 }; 234 235 static struct clk_branch gsbi3_uart_clk = { 236 .halt_reg = 0x2fcc, 237 .halt_bit = 2, 238 .clkr = { 239 .enable_reg = 0x2a14, 240 .enable_mask = BIT(9), 241 .hw.init = &(struct clk_init_data){ 242 .name = "gsbi3_uart_clk", 243 .parent_names = (const char *[]){ 244 "gsbi3_uart_src", 245 }, 246 .num_parents = 1, 247 .ops = &clk_branch_ops, 248 .flags = CLK_SET_RATE_PARENT, 249 }, 250 }, 251 }; 252 253 static struct clk_rcg gsbi4_uart_src = { 254 .ns_reg = 0x2a34, 255 .md_reg = 0x2a30, 256 .mn = { 257 .mnctr_en_bit = 8, 258 .mnctr_reset_bit = 7, 259 .mnctr_mode_shift = 5, 260 .n_val_shift = 16, 261 .m_val_shift = 16, 262 .width = 16, 263 }, 264 .p = { 265 .pre_div_shift = 3, 266 .pre_div_width = 2, 267 }, 268 .s = { 269 .src_sel_shift = 0, 270 .parent_map = gcc_pxo_pll8_map, 271 }, 272 .freq_tbl = clk_tbl_gsbi_uart, 273 .clkr = { 274 .enable_reg = 0x2a34, 275 .enable_mask = BIT(11), 276 .hw.init = &(struct clk_init_data){ 277 .name = "gsbi4_uart_src", 278 .parent_names = gcc_pxo_pll8, 279 .num_parents = 2, 280 .ops = &clk_rcg_ops, 281 .flags = CLK_SET_PARENT_GATE, 282 }, 283 }, 284 }; 285 286 static struct clk_branch gsbi4_uart_clk = { 287 .halt_reg = 0x2fd0, 288 .halt_bit = 26, 289 .clkr = { 290 .enable_reg = 0x2a34, 291 .enable_mask = BIT(9), 292 .hw.init = &(struct clk_init_data){ 293 .name = "gsbi4_uart_clk", 294 .parent_names = (const char *[]){ 295 "gsbi4_uart_src", 296 }, 297 .num_parents = 1, 298 .ops = &clk_branch_ops, 299 .flags = CLK_SET_RATE_PARENT, 300 }, 301 }, 302 }; 303 304 static struct clk_rcg gsbi5_uart_src = { 305 .ns_reg = 0x2a54, 306 .md_reg = 0x2a50, 307 .mn = { 308 .mnctr_en_bit = 8, 309 .mnctr_reset_bit = 7, 310 .mnctr_mode_shift = 5, 311 .n_val_shift = 16, 312 .m_val_shift = 16, 313 .width = 16, 314 }, 315 .p = { 316 .pre_div_shift = 3, 317 .pre_div_width = 2, 318 }, 319 .s = { 320 .src_sel_shift = 0, 321 .parent_map = gcc_pxo_pll8_map, 322 }, 323 .freq_tbl = clk_tbl_gsbi_uart, 324 .clkr = { 325 .enable_reg = 0x2a54, 326 .enable_mask = BIT(11), 327 .hw.init = &(struct clk_init_data){ 328 .name = "gsbi5_uart_src", 329 .parent_names = gcc_pxo_pll8, 330 .num_parents = 2, 331 .ops = &clk_rcg_ops, 332 .flags = CLK_SET_PARENT_GATE, 333 }, 334 }, 335 }; 336 337 static struct clk_branch gsbi5_uart_clk = { 338 .halt_reg = 0x2fd0, 339 .halt_bit = 22, 340 .clkr = { 341 .enable_reg = 0x2a54, 342 .enable_mask = BIT(9), 343 .hw.init = &(struct clk_init_data){ 344 .name = "gsbi5_uart_clk", 345 .parent_names = (const char *[]){ 346 "gsbi5_uart_src", 347 }, 348 .num_parents = 1, 349 .ops = &clk_branch_ops, 350 .flags = CLK_SET_RATE_PARENT, 351 }, 352 }, 353 }; 354 355 static struct clk_rcg gsbi6_uart_src = { 356 .ns_reg = 0x2a74, 357 .md_reg = 0x2a70, 358 .mn = { 359 .mnctr_en_bit = 8, 360 .mnctr_reset_bit = 7, 361 .mnctr_mode_shift = 5, 362 .n_val_shift = 16, 363 .m_val_shift = 16, 364 .width = 16, 365 }, 366 .p = { 367 .pre_div_shift = 3, 368 .pre_div_width = 2, 369 }, 370 .s = { 371 .src_sel_shift = 0, 372 .parent_map = gcc_pxo_pll8_map, 373 }, 374 .freq_tbl = clk_tbl_gsbi_uart, 375 .clkr = { 376 .enable_reg = 0x2a74, 377 .enable_mask = BIT(11), 378 .hw.init = &(struct clk_init_data){ 379 .name = "gsbi6_uart_src", 380 .parent_names = gcc_pxo_pll8, 381 .num_parents = 2, 382 .ops = &clk_rcg_ops, 383 .flags = CLK_SET_PARENT_GATE, 384 }, 385 }, 386 }; 387 388 static struct clk_branch gsbi6_uart_clk = { 389 .halt_reg = 0x2fd0, 390 .halt_bit = 18, 391 .clkr = { 392 .enable_reg = 0x2a74, 393 .enable_mask = BIT(9), 394 .hw.init = &(struct clk_init_data){ 395 .name = "gsbi6_uart_clk", 396 .parent_names = (const char *[]){ 397 "gsbi6_uart_src", 398 }, 399 .num_parents = 1, 400 .ops = &clk_branch_ops, 401 .flags = CLK_SET_RATE_PARENT, 402 }, 403 }, 404 }; 405 406 static struct clk_rcg gsbi7_uart_src = { 407 .ns_reg = 0x2a94, 408 .md_reg = 0x2a90, 409 .mn = { 410 .mnctr_en_bit = 8, 411 .mnctr_reset_bit = 7, 412 .mnctr_mode_shift = 5, 413 .n_val_shift = 16, 414 .m_val_shift = 16, 415 .width = 16, 416 }, 417 .p = { 418 .pre_div_shift = 3, 419 .pre_div_width = 2, 420 }, 421 .s = { 422 .src_sel_shift = 0, 423 .parent_map = gcc_pxo_pll8_map, 424 }, 425 .freq_tbl = clk_tbl_gsbi_uart, 426 .clkr = { 427 .enable_reg = 0x2a94, 428 .enable_mask = BIT(11), 429 .hw.init = &(struct clk_init_data){ 430 .name = "gsbi7_uart_src", 431 .parent_names = gcc_pxo_pll8, 432 .num_parents = 2, 433 .ops = &clk_rcg_ops, 434 .flags = CLK_SET_PARENT_GATE, 435 }, 436 }, 437 }; 438 439 static struct clk_branch gsbi7_uart_clk = { 440 .halt_reg = 0x2fd0, 441 .halt_bit = 14, 442 .clkr = { 443 .enable_reg = 0x2a94, 444 .enable_mask = BIT(9), 445 .hw.init = &(struct clk_init_data){ 446 .name = "gsbi7_uart_clk", 447 .parent_names = (const char *[]){ 448 "gsbi7_uart_src", 449 }, 450 .num_parents = 1, 451 .ops = &clk_branch_ops, 452 .flags = CLK_SET_RATE_PARENT, 453 }, 454 }, 455 }; 456 457 static struct clk_rcg gsbi8_uart_src = { 458 .ns_reg = 0x2ab4, 459 .md_reg = 0x2ab0, 460 .mn = { 461 .mnctr_en_bit = 8, 462 .mnctr_reset_bit = 7, 463 .mnctr_mode_shift = 5, 464 .n_val_shift = 16, 465 .m_val_shift = 16, 466 .width = 16, 467 }, 468 .p = { 469 .pre_div_shift = 3, 470 .pre_div_width = 2, 471 }, 472 .s = { 473 .src_sel_shift = 0, 474 .parent_map = gcc_pxo_pll8_map, 475 }, 476 .freq_tbl = clk_tbl_gsbi_uart, 477 .clkr = { 478 .enable_reg = 0x2ab4, 479 .enable_mask = BIT(11), 480 .hw.init = &(struct clk_init_data){ 481 .name = "gsbi8_uart_src", 482 .parent_names = gcc_pxo_pll8, 483 .num_parents = 2, 484 .ops = &clk_rcg_ops, 485 .flags = CLK_SET_PARENT_GATE, 486 }, 487 }, 488 }; 489 490 static struct clk_branch gsbi8_uart_clk = { 491 .halt_reg = 0x2fd0, 492 .halt_bit = 10, 493 .clkr = { 494 .enable_reg = 0x2ab4, 495 .enable_mask = BIT(9), 496 .hw.init = &(struct clk_init_data){ 497 .name = "gsbi8_uart_clk", 498 .parent_names = (const char *[]){ "gsbi8_uart_src" }, 499 .num_parents = 1, 500 .ops = &clk_branch_ops, 501 .flags = CLK_SET_RATE_PARENT, 502 }, 503 }, 504 }; 505 506 static struct clk_rcg gsbi9_uart_src = { 507 .ns_reg = 0x2ad4, 508 .md_reg = 0x2ad0, 509 .mn = { 510 .mnctr_en_bit = 8, 511 .mnctr_reset_bit = 7, 512 .mnctr_mode_shift = 5, 513 .n_val_shift = 16, 514 .m_val_shift = 16, 515 .width = 16, 516 }, 517 .p = { 518 .pre_div_shift = 3, 519 .pre_div_width = 2, 520 }, 521 .s = { 522 .src_sel_shift = 0, 523 .parent_map = gcc_pxo_pll8_map, 524 }, 525 .freq_tbl = clk_tbl_gsbi_uart, 526 .clkr = { 527 .enable_reg = 0x2ad4, 528 .enable_mask = BIT(11), 529 .hw.init = &(struct clk_init_data){ 530 .name = "gsbi9_uart_src", 531 .parent_names = gcc_pxo_pll8, 532 .num_parents = 2, 533 .ops = &clk_rcg_ops, 534 .flags = CLK_SET_PARENT_GATE, 535 }, 536 }, 537 }; 538 539 static struct clk_branch gsbi9_uart_clk = { 540 .halt_reg = 0x2fd0, 541 .halt_bit = 6, 542 .clkr = { 543 .enable_reg = 0x2ad4, 544 .enable_mask = BIT(9), 545 .hw.init = &(struct clk_init_data){ 546 .name = "gsbi9_uart_clk", 547 .parent_names = (const char *[]){ "gsbi9_uart_src" }, 548 .num_parents = 1, 549 .ops = &clk_branch_ops, 550 .flags = CLK_SET_RATE_PARENT, 551 }, 552 }, 553 }; 554 555 static struct clk_rcg gsbi10_uart_src = { 556 .ns_reg = 0x2af4, 557 .md_reg = 0x2af0, 558 .mn = { 559 .mnctr_en_bit = 8, 560 .mnctr_reset_bit = 7, 561 .mnctr_mode_shift = 5, 562 .n_val_shift = 16, 563 .m_val_shift = 16, 564 .width = 16, 565 }, 566 .p = { 567 .pre_div_shift = 3, 568 .pre_div_width = 2, 569 }, 570 .s = { 571 .src_sel_shift = 0, 572 .parent_map = gcc_pxo_pll8_map, 573 }, 574 .freq_tbl = clk_tbl_gsbi_uart, 575 .clkr = { 576 .enable_reg = 0x2af4, 577 .enable_mask = BIT(11), 578 .hw.init = &(struct clk_init_data){ 579 .name = "gsbi10_uart_src", 580 .parent_names = gcc_pxo_pll8, 581 .num_parents = 2, 582 .ops = &clk_rcg_ops, 583 .flags = CLK_SET_PARENT_GATE, 584 }, 585 }, 586 }; 587 588 static struct clk_branch gsbi10_uart_clk = { 589 .halt_reg = 0x2fd0, 590 .halt_bit = 2, 591 .clkr = { 592 .enable_reg = 0x2af4, 593 .enable_mask = BIT(9), 594 .hw.init = &(struct clk_init_data){ 595 .name = "gsbi10_uart_clk", 596 .parent_names = (const char *[]){ "gsbi10_uart_src" }, 597 .num_parents = 1, 598 .ops = &clk_branch_ops, 599 .flags = CLK_SET_RATE_PARENT, 600 }, 601 }, 602 }; 603 604 static struct clk_rcg gsbi11_uart_src = { 605 .ns_reg = 0x2b14, 606 .md_reg = 0x2b10, 607 .mn = { 608 .mnctr_en_bit = 8, 609 .mnctr_reset_bit = 7, 610 .mnctr_mode_shift = 5, 611 .n_val_shift = 16, 612 .m_val_shift = 16, 613 .width = 16, 614 }, 615 .p = { 616 .pre_div_shift = 3, 617 .pre_div_width = 2, 618 }, 619 .s = { 620 .src_sel_shift = 0, 621 .parent_map = gcc_pxo_pll8_map, 622 }, 623 .freq_tbl = clk_tbl_gsbi_uart, 624 .clkr = { 625 .enable_reg = 0x2b14, 626 .enable_mask = BIT(11), 627 .hw.init = &(struct clk_init_data){ 628 .name = "gsbi11_uart_src", 629 .parent_names = gcc_pxo_pll8, 630 .num_parents = 2, 631 .ops = &clk_rcg_ops, 632 .flags = CLK_SET_PARENT_GATE, 633 }, 634 }, 635 }; 636 637 static struct clk_branch gsbi11_uart_clk = { 638 .halt_reg = 0x2fd4, 639 .halt_bit = 17, 640 .clkr = { 641 .enable_reg = 0x2b14, 642 .enable_mask = BIT(9), 643 .hw.init = &(struct clk_init_data){ 644 .name = "gsbi11_uart_clk", 645 .parent_names = (const char *[]){ "gsbi11_uart_src" }, 646 .num_parents = 1, 647 .ops = &clk_branch_ops, 648 .flags = CLK_SET_RATE_PARENT, 649 }, 650 }, 651 }; 652 653 static struct clk_rcg gsbi12_uart_src = { 654 .ns_reg = 0x2b34, 655 .md_reg = 0x2b30, 656 .mn = { 657 .mnctr_en_bit = 8, 658 .mnctr_reset_bit = 7, 659 .mnctr_mode_shift = 5, 660 .n_val_shift = 16, 661 .m_val_shift = 16, 662 .width = 16, 663 }, 664 .p = { 665 .pre_div_shift = 3, 666 .pre_div_width = 2, 667 }, 668 .s = { 669 .src_sel_shift = 0, 670 .parent_map = gcc_pxo_pll8_map, 671 }, 672 .freq_tbl = clk_tbl_gsbi_uart, 673 .clkr = { 674 .enable_reg = 0x2b34, 675 .enable_mask = BIT(11), 676 .hw.init = &(struct clk_init_data){ 677 .name = "gsbi12_uart_src", 678 .parent_names = gcc_pxo_pll8, 679 .num_parents = 2, 680 .ops = &clk_rcg_ops, 681 .flags = CLK_SET_PARENT_GATE, 682 }, 683 }, 684 }; 685 686 static struct clk_branch gsbi12_uart_clk = { 687 .halt_reg = 0x2fd4, 688 .halt_bit = 13, 689 .clkr = { 690 .enable_reg = 0x2b34, 691 .enable_mask = BIT(9), 692 .hw.init = &(struct clk_init_data){ 693 .name = "gsbi12_uart_clk", 694 .parent_names = (const char *[]){ "gsbi12_uart_src" }, 695 .num_parents = 1, 696 .ops = &clk_branch_ops, 697 .flags = CLK_SET_RATE_PARENT, 698 }, 699 }, 700 }; 701 702 static struct freq_tbl clk_tbl_gsbi_qup[] = { 703 { 1100000, P_PXO, 1, 2, 49 }, 704 { 5400000, P_PXO, 1, 1, 5 }, 705 { 10800000, P_PXO, 1, 2, 5 }, 706 { 15060000, P_PLL8, 1, 2, 51 }, 707 { 24000000, P_PLL8, 4, 1, 4 }, 708 { 25600000, P_PLL8, 1, 1, 15 }, 709 { 27000000, P_PXO, 1, 0, 0 }, 710 { 48000000, P_PLL8, 4, 1, 2 }, 711 { 51200000, P_PLL8, 1, 2, 15 }, 712 { } 713 }; 714 715 static struct clk_rcg gsbi1_qup_src = { 716 .ns_reg = 0x29cc, 717 .md_reg = 0x29c8, 718 .mn = { 719 .mnctr_en_bit = 8, 720 .mnctr_reset_bit = 7, 721 .mnctr_mode_shift = 5, 722 .n_val_shift = 16, 723 .m_val_shift = 16, 724 .width = 8, 725 }, 726 .p = { 727 .pre_div_shift = 3, 728 .pre_div_width = 2, 729 }, 730 .s = { 731 .src_sel_shift = 0, 732 .parent_map = gcc_pxo_pll8_map, 733 }, 734 .freq_tbl = clk_tbl_gsbi_qup, 735 .clkr = { 736 .enable_reg = 0x29cc, 737 .enable_mask = BIT(11), 738 .hw.init = &(struct clk_init_data){ 739 .name = "gsbi1_qup_src", 740 .parent_names = gcc_pxo_pll8, 741 .num_parents = 2, 742 .ops = &clk_rcg_ops, 743 .flags = CLK_SET_PARENT_GATE, 744 }, 745 }, 746 }; 747 748 static struct clk_branch gsbi1_qup_clk = { 749 .halt_reg = 0x2fcc, 750 .halt_bit = 9, 751 .clkr = { 752 .enable_reg = 0x29cc, 753 .enable_mask = BIT(9), 754 .hw.init = &(struct clk_init_data){ 755 .name = "gsbi1_qup_clk", 756 .parent_names = (const char *[]){ "gsbi1_qup_src" }, 757 .num_parents = 1, 758 .ops = &clk_branch_ops, 759 .flags = CLK_SET_RATE_PARENT, 760 }, 761 }, 762 }; 763 764 static struct clk_rcg gsbi2_qup_src = { 765 .ns_reg = 0x29ec, 766 .md_reg = 0x29e8, 767 .mn = { 768 .mnctr_en_bit = 8, 769 .mnctr_reset_bit = 7, 770 .mnctr_mode_shift = 5, 771 .n_val_shift = 16, 772 .m_val_shift = 16, 773 .width = 8, 774 }, 775 .p = { 776 .pre_div_shift = 3, 777 .pre_div_width = 2, 778 }, 779 .s = { 780 .src_sel_shift = 0, 781 .parent_map = gcc_pxo_pll8_map, 782 }, 783 .freq_tbl = clk_tbl_gsbi_qup, 784 .clkr = { 785 .enable_reg = 0x29ec, 786 .enable_mask = BIT(11), 787 .hw.init = &(struct clk_init_data){ 788 .name = "gsbi2_qup_src", 789 .parent_names = gcc_pxo_pll8, 790 .num_parents = 2, 791 .ops = &clk_rcg_ops, 792 .flags = CLK_SET_PARENT_GATE, 793 }, 794 }, 795 }; 796 797 static struct clk_branch gsbi2_qup_clk = { 798 .halt_reg = 0x2fcc, 799 .halt_bit = 4, 800 .clkr = { 801 .enable_reg = 0x29ec, 802 .enable_mask = BIT(9), 803 .hw.init = &(struct clk_init_data){ 804 .name = "gsbi2_qup_clk", 805 .parent_names = (const char *[]){ "gsbi2_qup_src" }, 806 .num_parents = 1, 807 .ops = &clk_branch_ops, 808 .flags = CLK_SET_RATE_PARENT, 809 }, 810 }, 811 }; 812 813 static struct clk_rcg gsbi3_qup_src = { 814 .ns_reg = 0x2a0c, 815 .md_reg = 0x2a08, 816 .mn = { 817 .mnctr_en_bit = 8, 818 .mnctr_reset_bit = 7, 819 .mnctr_mode_shift = 5, 820 .n_val_shift = 16, 821 .m_val_shift = 16, 822 .width = 8, 823 }, 824 .p = { 825 .pre_div_shift = 3, 826 .pre_div_width = 2, 827 }, 828 .s = { 829 .src_sel_shift = 0, 830 .parent_map = gcc_pxo_pll8_map, 831 }, 832 .freq_tbl = clk_tbl_gsbi_qup, 833 .clkr = { 834 .enable_reg = 0x2a0c, 835 .enable_mask = BIT(11), 836 .hw.init = &(struct clk_init_data){ 837 .name = "gsbi3_qup_src", 838 .parent_names = gcc_pxo_pll8, 839 .num_parents = 2, 840 .ops = &clk_rcg_ops, 841 .flags = CLK_SET_PARENT_GATE, 842 }, 843 }, 844 }; 845 846 static struct clk_branch gsbi3_qup_clk = { 847 .halt_reg = 0x2fcc, 848 .halt_bit = 0, 849 .clkr = { 850 .enable_reg = 0x2a0c, 851 .enable_mask = BIT(9), 852 .hw.init = &(struct clk_init_data){ 853 .name = "gsbi3_qup_clk", 854 .parent_names = (const char *[]){ "gsbi3_qup_src" }, 855 .num_parents = 1, 856 .ops = &clk_branch_ops, 857 .flags = CLK_SET_RATE_PARENT, 858 }, 859 }, 860 }; 861 862 static struct clk_rcg gsbi4_qup_src = { 863 .ns_reg = 0x2a2c, 864 .md_reg = 0x2a28, 865 .mn = { 866 .mnctr_en_bit = 8, 867 .mnctr_reset_bit = 7, 868 .mnctr_mode_shift = 5, 869 .n_val_shift = 16, 870 .m_val_shift = 16, 871 .width = 8, 872 }, 873 .p = { 874 .pre_div_shift = 3, 875 .pre_div_width = 2, 876 }, 877 .s = { 878 .src_sel_shift = 0, 879 .parent_map = gcc_pxo_pll8_map, 880 }, 881 .freq_tbl = clk_tbl_gsbi_qup, 882 .clkr = { 883 .enable_reg = 0x2a2c, 884 .enable_mask = BIT(11), 885 .hw.init = &(struct clk_init_data){ 886 .name = "gsbi4_qup_src", 887 .parent_names = gcc_pxo_pll8, 888 .num_parents = 2, 889 .ops = &clk_rcg_ops, 890 .flags = CLK_SET_PARENT_GATE, 891 }, 892 }, 893 }; 894 895 static struct clk_branch gsbi4_qup_clk = { 896 .halt_reg = 0x2fd0, 897 .halt_bit = 24, 898 .clkr = { 899 .enable_reg = 0x2a2c, 900 .enable_mask = BIT(9), 901 .hw.init = &(struct clk_init_data){ 902 .name = "gsbi4_qup_clk", 903 .parent_names = (const char *[]){ "gsbi4_qup_src" }, 904 .num_parents = 1, 905 .ops = &clk_branch_ops, 906 .flags = CLK_SET_RATE_PARENT, 907 }, 908 }, 909 }; 910 911 static struct clk_rcg gsbi5_qup_src = { 912 .ns_reg = 0x2a4c, 913 .md_reg = 0x2a48, 914 .mn = { 915 .mnctr_en_bit = 8, 916 .mnctr_reset_bit = 7, 917 .mnctr_mode_shift = 5, 918 .n_val_shift = 16, 919 .m_val_shift = 16, 920 .width = 8, 921 }, 922 .p = { 923 .pre_div_shift = 3, 924 .pre_div_width = 2, 925 }, 926 .s = { 927 .src_sel_shift = 0, 928 .parent_map = gcc_pxo_pll8_map, 929 }, 930 .freq_tbl = clk_tbl_gsbi_qup, 931 .clkr = { 932 .enable_reg = 0x2a4c, 933 .enable_mask = BIT(11), 934 .hw.init = &(struct clk_init_data){ 935 .name = "gsbi5_qup_src", 936 .parent_names = gcc_pxo_pll8, 937 .num_parents = 2, 938 .ops = &clk_rcg_ops, 939 .flags = CLK_SET_PARENT_GATE, 940 }, 941 }, 942 }; 943 944 static struct clk_branch gsbi5_qup_clk = { 945 .halt_reg = 0x2fd0, 946 .halt_bit = 20, 947 .clkr = { 948 .enable_reg = 0x2a4c, 949 .enable_mask = BIT(9), 950 .hw.init = &(struct clk_init_data){ 951 .name = "gsbi5_qup_clk", 952 .parent_names = (const char *[]){ "gsbi5_qup_src" }, 953 .num_parents = 1, 954 .ops = &clk_branch_ops, 955 .flags = CLK_SET_RATE_PARENT, 956 }, 957 }, 958 }; 959 960 static struct clk_rcg gsbi6_qup_src = { 961 .ns_reg = 0x2a6c, 962 .md_reg = 0x2a68, 963 .mn = { 964 .mnctr_en_bit = 8, 965 .mnctr_reset_bit = 7, 966 .mnctr_mode_shift = 5, 967 .n_val_shift = 16, 968 .m_val_shift = 16, 969 .width = 8, 970 }, 971 .p = { 972 .pre_div_shift = 3, 973 .pre_div_width = 2, 974 }, 975 .s = { 976 .src_sel_shift = 0, 977 .parent_map = gcc_pxo_pll8_map, 978 }, 979 .freq_tbl = clk_tbl_gsbi_qup, 980 .clkr = { 981 .enable_reg = 0x2a6c, 982 .enable_mask = BIT(11), 983 .hw.init = &(struct clk_init_data){ 984 .name = "gsbi6_qup_src", 985 .parent_names = gcc_pxo_pll8, 986 .num_parents = 2, 987 .ops = &clk_rcg_ops, 988 .flags = CLK_SET_PARENT_GATE, 989 }, 990 }, 991 }; 992 993 static struct clk_branch gsbi6_qup_clk = { 994 .halt_reg = 0x2fd0, 995 .halt_bit = 16, 996 .clkr = { 997 .enable_reg = 0x2a6c, 998 .enable_mask = BIT(9), 999 .hw.init = &(struct clk_init_data){ 1000 .name = "gsbi6_qup_clk", 1001 .parent_names = (const char *[]){ "gsbi6_qup_src" }, 1002 .num_parents = 1, 1003 .ops = &clk_branch_ops, 1004 .flags = CLK_SET_RATE_PARENT, 1005 }, 1006 }, 1007 }; 1008 1009 static struct clk_rcg gsbi7_qup_src = { 1010 .ns_reg = 0x2a8c, 1011 .md_reg = 0x2a88, 1012 .mn = { 1013 .mnctr_en_bit = 8, 1014 .mnctr_reset_bit = 7, 1015 .mnctr_mode_shift = 5, 1016 .n_val_shift = 16, 1017 .m_val_shift = 16, 1018 .width = 8, 1019 }, 1020 .p = { 1021 .pre_div_shift = 3, 1022 .pre_div_width = 2, 1023 }, 1024 .s = { 1025 .src_sel_shift = 0, 1026 .parent_map = gcc_pxo_pll8_map, 1027 }, 1028 .freq_tbl = clk_tbl_gsbi_qup, 1029 .clkr = { 1030 .enable_reg = 0x2a8c, 1031 .enable_mask = BIT(11), 1032 .hw.init = &(struct clk_init_data){ 1033 .name = "gsbi7_qup_src", 1034 .parent_names = gcc_pxo_pll8, 1035 .num_parents = 2, 1036 .ops = &clk_rcg_ops, 1037 .flags = CLK_SET_PARENT_GATE, 1038 }, 1039 }, 1040 }; 1041 1042 static struct clk_branch gsbi7_qup_clk = { 1043 .halt_reg = 0x2fd0, 1044 .halt_bit = 12, 1045 .clkr = { 1046 .enable_reg = 0x2a8c, 1047 .enable_mask = BIT(9), 1048 .hw.init = &(struct clk_init_data){ 1049 .name = "gsbi7_qup_clk", 1050 .parent_names = (const char *[]){ "gsbi7_qup_src" }, 1051 .num_parents = 1, 1052 .ops = &clk_branch_ops, 1053 .flags = CLK_SET_RATE_PARENT, 1054 }, 1055 }, 1056 }; 1057 1058 static struct clk_rcg gsbi8_qup_src = { 1059 .ns_reg = 0x2aac, 1060 .md_reg = 0x2aa8, 1061 .mn = { 1062 .mnctr_en_bit = 8, 1063 .mnctr_reset_bit = 7, 1064 .mnctr_mode_shift = 5, 1065 .n_val_shift = 16, 1066 .m_val_shift = 16, 1067 .width = 8, 1068 }, 1069 .p = { 1070 .pre_div_shift = 3, 1071 .pre_div_width = 2, 1072 }, 1073 .s = { 1074 .src_sel_shift = 0, 1075 .parent_map = gcc_pxo_pll8_map, 1076 }, 1077 .freq_tbl = clk_tbl_gsbi_qup, 1078 .clkr = { 1079 .enable_reg = 0x2aac, 1080 .enable_mask = BIT(11), 1081 .hw.init = &(struct clk_init_data){ 1082 .name = "gsbi8_qup_src", 1083 .parent_names = gcc_pxo_pll8, 1084 .num_parents = 2, 1085 .ops = &clk_rcg_ops, 1086 .flags = CLK_SET_PARENT_GATE, 1087 }, 1088 }, 1089 }; 1090 1091 static struct clk_branch gsbi8_qup_clk = { 1092 .halt_reg = 0x2fd0, 1093 .halt_bit = 8, 1094 .clkr = { 1095 .enable_reg = 0x2aac, 1096 .enable_mask = BIT(9), 1097 .hw.init = &(struct clk_init_data){ 1098 .name = "gsbi8_qup_clk", 1099 .parent_names = (const char *[]){ "gsbi8_qup_src" }, 1100 .num_parents = 1, 1101 .ops = &clk_branch_ops, 1102 .flags = CLK_SET_RATE_PARENT, 1103 }, 1104 }, 1105 }; 1106 1107 static struct clk_rcg gsbi9_qup_src = { 1108 .ns_reg = 0x2acc, 1109 .md_reg = 0x2ac8, 1110 .mn = { 1111 .mnctr_en_bit = 8, 1112 .mnctr_reset_bit = 7, 1113 .mnctr_mode_shift = 5, 1114 .n_val_shift = 16, 1115 .m_val_shift = 16, 1116 .width = 8, 1117 }, 1118 .p = { 1119 .pre_div_shift = 3, 1120 .pre_div_width = 2, 1121 }, 1122 .s = { 1123 .src_sel_shift = 0, 1124 .parent_map = gcc_pxo_pll8_map, 1125 }, 1126 .freq_tbl = clk_tbl_gsbi_qup, 1127 .clkr = { 1128 .enable_reg = 0x2acc, 1129 .enable_mask = BIT(11), 1130 .hw.init = &(struct clk_init_data){ 1131 .name = "gsbi9_qup_src", 1132 .parent_names = gcc_pxo_pll8, 1133 .num_parents = 2, 1134 .ops = &clk_rcg_ops, 1135 .flags = CLK_SET_PARENT_GATE, 1136 }, 1137 }, 1138 }; 1139 1140 static struct clk_branch gsbi9_qup_clk = { 1141 .halt_reg = 0x2fd0, 1142 .halt_bit = 4, 1143 .clkr = { 1144 .enable_reg = 0x2acc, 1145 .enable_mask = BIT(9), 1146 .hw.init = &(struct clk_init_data){ 1147 .name = "gsbi9_qup_clk", 1148 .parent_names = (const char *[]){ "gsbi9_qup_src" }, 1149 .num_parents = 1, 1150 .ops = &clk_branch_ops, 1151 .flags = CLK_SET_RATE_PARENT, 1152 }, 1153 }, 1154 }; 1155 1156 static struct clk_rcg gsbi10_qup_src = { 1157 .ns_reg = 0x2aec, 1158 .md_reg = 0x2ae8, 1159 .mn = { 1160 .mnctr_en_bit = 8, 1161 .mnctr_reset_bit = 7, 1162 .mnctr_mode_shift = 5, 1163 .n_val_shift = 16, 1164 .m_val_shift = 16, 1165 .width = 8, 1166 }, 1167 .p = { 1168 .pre_div_shift = 3, 1169 .pre_div_width = 2, 1170 }, 1171 .s = { 1172 .src_sel_shift = 0, 1173 .parent_map = gcc_pxo_pll8_map, 1174 }, 1175 .freq_tbl = clk_tbl_gsbi_qup, 1176 .clkr = { 1177 .enable_reg = 0x2aec, 1178 .enable_mask = BIT(11), 1179 .hw.init = &(struct clk_init_data){ 1180 .name = "gsbi10_qup_src", 1181 .parent_names = gcc_pxo_pll8, 1182 .num_parents = 2, 1183 .ops = &clk_rcg_ops, 1184 .flags = CLK_SET_PARENT_GATE, 1185 }, 1186 }, 1187 }; 1188 1189 static struct clk_branch gsbi10_qup_clk = { 1190 .halt_reg = 0x2fd0, 1191 .halt_bit = 0, 1192 .clkr = { 1193 .enable_reg = 0x2aec, 1194 .enable_mask = BIT(9), 1195 .hw.init = &(struct clk_init_data){ 1196 .name = "gsbi10_qup_clk", 1197 .parent_names = (const char *[]){ "gsbi10_qup_src" }, 1198 .num_parents = 1, 1199 .ops = &clk_branch_ops, 1200 .flags = CLK_SET_RATE_PARENT, 1201 }, 1202 }, 1203 }; 1204 1205 static struct clk_rcg gsbi11_qup_src = { 1206 .ns_reg = 0x2b0c, 1207 .md_reg = 0x2b08, 1208 .mn = { 1209 .mnctr_en_bit = 8, 1210 .mnctr_reset_bit = 7, 1211 .mnctr_mode_shift = 5, 1212 .n_val_shift = 16, 1213 .m_val_shift = 16, 1214 .width = 8, 1215 }, 1216 .p = { 1217 .pre_div_shift = 3, 1218 .pre_div_width = 2, 1219 }, 1220 .s = { 1221 .src_sel_shift = 0, 1222 .parent_map = gcc_pxo_pll8_map, 1223 }, 1224 .freq_tbl = clk_tbl_gsbi_qup, 1225 .clkr = { 1226 .enable_reg = 0x2b0c, 1227 .enable_mask = BIT(11), 1228 .hw.init = &(struct clk_init_data){ 1229 .name = "gsbi11_qup_src", 1230 .parent_names = gcc_pxo_pll8, 1231 .num_parents = 2, 1232 .ops = &clk_rcg_ops, 1233 .flags = CLK_SET_PARENT_GATE, 1234 }, 1235 }, 1236 }; 1237 1238 static struct clk_branch gsbi11_qup_clk = { 1239 .halt_reg = 0x2fd4, 1240 .halt_bit = 15, 1241 .clkr = { 1242 .enable_reg = 0x2b0c, 1243 .enable_mask = BIT(9), 1244 .hw.init = &(struct clk_init_data){ 1245 .name = "gsbi11_qup_clk", 1246 .parent_names = (const char *[]){ "gsbi11_qup_src" }, 1247 .num_parents = 1, 1248 .ops = &clk_branch_ops, 1249 .flags = CLK_SET_RATE_PARENT, 1250 }, 1251 }, 1252 }; 1253 1254 static struct clk_rcg gsbi12_qup_src = { 1255 .ns_reg = 0x2b2c, 1256 .md_reg = 0x2b28, 1257 .mn = { 1258 .mnctr_en_bit = 8, 1259 .mnctr_reset_bit = 7, 1260 .mnctr_mode_shift = 5, 1261 .n_val_shift = 16, 1262 .m_val_shift = 16, 1263 .width = 8, 1264 }, 1265 .p = { 1266 .pre_div_shift = 3, 1267 .pre_div_width = 2, 1268 }, 1269 .s = { 1270 .src_sel_shift = 0, 1271 .parent_map = gcc_pxo_pll8_map, 1272 }, 1273 .freq_tbl = clk_tbl_gsbi_qup, 1274 .clkr = { 1275 .enable_reg = 0x2b2c, 1276 .enable_mask = BIT(11), 1277 .hw.init = &(struct clk_init_data){ 1278 .name = "gsbi12_qup_src", 1279 .parent_names = gcc_pxo_pll8, 1280 .num_parents = 2, 1281 .ops = &clk_rcg_ops, 1282 .flags = CLK_SET_PARENT_GATE, 1283 }, 1284 }, 1285 }; 1286 1287 static struct clk_branch gsbi12_qup_clk = { 1288 .halt_reg = 0x2fd4, 1289 .halt_bit = 11, 1290 .clkr = { 1291 .enable_reg = 0x2b2c, 1292 .enable_mask = BIT(9), 1293 .hw.init = &(struct clk_init_data){ 1294 .name = "gsbi12_qup_clk", 1295 .parent_names = (const char *[]){ "gsbi12_qup_src" }, 1296 .num_parents = 1, 1297 .ops = &clk_branch_ops, 1298 .flags = CLK_SET_RATE_PARENT, 1299 }, 1300 }, 1301 }; 1302 1303 static const struct freq_tbl clk_tbl_gp[] = { 1304 { 9600000, P_CXO, 2, 0, 0 }, 1305 { 13500000, P_PXO, 2, 0, 0 }, 1306 { 19200000, P_CXO, 1, 0, 0 }, 1307 { 27000000, P_PXO, 1, 0, 0 }, 1308 { 64000000, P_PLL8, 2, 1, 3 }, 1309 { 76800000, P_PLL8, 1, 1, 5 }, 1310 { 96000000, P_PLL8, 4, 0, 0 }, 1311 { 128000000, P_PLL8, 3, 0, 0 }, 1312 { 192000000, P_PLL8, 2, 0, 0 }, 1313 { } 1314 }; 1315 1316 static struct clk_rcg gp0_src = { 1317 .ns_reg = 0x2d24, 1318 .md_reg = 0x2d00, 1319 .mn = { 1320 .mnctr_en_bit = 8, 1321 .mnctr_reset_bit = 7, 1322 .mnctr_mode_shift = 5, 1323 .n_val_shift = 16, 1324 .m_val_shift = 16, 1325 .width = 8, 1326 }, 1327 .p = { 1328 .pre_div_shift = 3, 1329 .pre_div_width = 2, 1330 }, 1331 .s = { 1332 .src_sel_shift = 0, 1333 .parent_map = gcc_pxo_pll8_cxo_map, 1334 }, 1335 .freq_tbl = clk_tbl_gp, 1336 .clkr = { 1337 .enable_reg = 0x2d24, 1338 .enable_mask = BIT(11), 1339 .hw.init = &(struct clk_init_data){ 1340 .name = "gp0_src", 1341 .parent_names = gcc_pxo_pll8_cxo, 1342 .num_parents = 3, 1343 .ops = &clk_rcg_ops, 1344 .flags = CLK_SET_PARENT_GATE, 1345 }, 1346 } 1347 }; 1348 1349 static struct clk_branch gp0_clk = { 1350 .halt_reg = 0x2fd8, 1351 .halt_bit = 7, 1352 .clkr = { 1353 .enable_reg = 0x2d24, 1354 .enable_mask = BIT(9), 1355 .hw.init = &(struct clk_init_data){ 1356 .name = "gp0_clk", 1357 .parent_names = (const char *[]){ "gp0_src" }, 1358 .num_parents = 1, 1359 .ops = &clk_branch_ops, 1360 .flags = CLK_SET_RATE_PARENT, 1361 }, 1362 }, 1363 }; 1364 1365 static struct clk_rcg gp1_src = { 1366 .ns_reg = 0x2d44, 1367 .md_reg = 0x2d40, 1368 .mn = { 1369 .mnctr_en_bit = 8, 1370 .mnctr_reset_bit = 7, 1371 .mnctr_mode_shift = 5, 1372 .n_val_shift = 16, 1373 .m_val_shift = 16, 1374 .width = 8, 1375 }, 1376 .p = { 1377 .pre_div_shift = 3, 1378 .pre_div_width = 2, 1379 }, 1380 .s = { 1381 .src_sel_shift = 0, 1382 .parent_map = gcc_pxo_pll8_cxo_map, 1383 }, 1384 .freq_tbl = clk_tbl_gp, 1385 .clkr = { 1386 .enable_reg = 0x2d44, 1387 .enable_mask = BIT(11), 1388 .hw.init = &(struct clk_init_data){ 1389 .name = "gp1_src", 1390 .parent_names = gcc_pxo_pll8_cxo, 1391 .num_parents = 3, 1392 .ops = &clk_rcg_ops, 1393 .flags = CLK_SET_RATE_GATE, 1394 }, 1395 } 1396 }; 1397 1398 static struct clk_branch gp1_clk = { 1399 .halt_reg = 0x2fd8, 1400 .halt_bit = 6, 1401 .clkr = { 1402 .enable_reg = 0x2d44, 1403 .enable_mask = BIT(9), 1404 .hw.init = &(struct clk_init_data){ 1405 .name = "gp1_clk", 1406 .parent_names = (const char *[]){ "gp1_src" }, 1407 .num_parents = 1, 1408 .ops = &clk_branch_ops, 1409 .flags = CLK_SET_RATE_PARENT, 1410 }, 1411 }, 1412 }; 1413 1414 static struct clk_rcg gp2_src = { 1415 .ns_reg = 0x2d64, 1416 .md_reg = 0x2d60, 1417 .mn = { 1418 .mnctr_en_bit = 8, 1419 .mnctr_reset_bit = 7, 1420 .mnctr_mode_shift = 5, 1421 .n_val_shift = 16, 1422 .m_val_shift = 16, 1423 .width = 8, 1424 }, 1425 .p = { 1426 .pre_div_shift = 3, 1427 .pre_div_width = 2, 1428 }, 1429 .s = { 1430 .src_sel_shift = 0, 1431 .parent_map = gcc_pxo_pll8_cxo_map, 1432 }, 1433 .freq_tbl = clk_tbl_gp, 1434 .clkr = { 1435 .enable_reg = 0x2d64, 1436 .enable_mask = BIT(11), 1437 .hw.init = &(struct clk_init_data){ 1438 .name = "gp2_src", 1439 .parent_names = gcc_pxo_pll8_cxo, 1440 .num_parents = 3, 1441 .ops = &clk_rcg_ops, 1442 .flags = CLK_SET_RATE_GATE, 1443 }, 1444 } 1445 }; 1446 1447 static struct clk_branch gp2_clk = { 1448 .halt_reg = 0x2fd8, 1449 .halt_bit = 5, 1450 .clkr = { 1451 .enable_reg = 0x2d64, 1452 .enable_mask = BIT(9), 1453 .hw.init = &(struct clk_init_data){ 1454 .name = "gp2_clk", 1455 .parent_names = (const char *[]){ "gp2_src" }, 1456 .num_parents = 1, 1457 .ops = &clk_branch_ops, 1458 .flags = CLK_SET_RATE_PARENT, 1459 }, 1460 }, 1461 }; 1462 1463 static struct clk_branch pmem_clk = { 1464 .hwcg_reg = 0x25a0, 1465 .hwcg_bit = 6, 1466 .halt_reg = 0x2fc8, 1467 .halt_bit = 20, 1468 .clkr = { 1469 .enable_reg = 0x25a0, 1470 .enable_mask = BIT(4), 1471 .hw.init = &(struct clk_init_data){ 1472 .name = "pmem_clk", 1473 .ops = &clk_branch_ops, 1474 }, 1475 }, 1476 }; 1477 1478 static struct clk_rcg prng_src = { 1479 .ns_reg = 0x2e80, 1480 .p = { 1481 .pre_div_shift = 3, 1482 .pre_div_width = 4, 1483 }, 1484 .s = { 1485 .src_sel_shift = 0, 1486 .parent_map = gcc_pxo_pll8_map, 1487 }, 1488 .clkr.hw = { 1489 .init = &(struct clk_init_data){ 1490 .name = "prng_src", 1491 .parent_names = gcc_pxo_pll8, 1492 .num_parents = 2, 1493 .ops = &clk_rcg_ops, 1494 }, 1495 }, 1496 }; 1497 1498 static struct clk_branch prng_clk = { 1499 .halt_reg = 0x2fd8, 1500 .halt_check = BRANCH_HALT_VOTED, 1501 .halt_bit = 10, 1502 .clkr = { 1503 .enable_reg = 0x3080, 1504 .enable_mask = BIT(10), 1505 .hw.init = &(struct clk_init_data){ 1506 .name = "prng_clk", 1507 .parent_names = (const char *[]){ "prng_src" }, 1508 .num_parents = 1, 1509 .ops = &clk_branch_ops, 1510 }, 1511 }, 1512 }; 1513 1514 static const struct freq_tbl clk_tbl_sdc[] = { 1515 { 144000, P_PXO, 3, 2, 125 }, 1516 { 400000, P_PLL8, 4, 1, 240 }, 1517 { 16000000, P_PLL8, 4, 1, 6 }, 1518 { 17070000, P_PLL8, 1, 2, 45 }, 1519 { 20210000, P_PLL8, 1, 1, 19 }, 1520 { 24000000, P_PLL8, 4, 1, 4 }, 1521 { 48000000, P_PLL8, 4, 1, 2 }, 1522 { } 1523 }; 1524 1525 static struct clk_rcg sdc1_src = { 1526 .ns_reg = 0x282c, 1527 .md_reg = 0x2828, 1528 .mn = { 1529 .mnctr_en_bit = 8, 1530 .mnctr_reset_bit = 7, 1531 .mnctr_mode_shift = 5, 1532 .n_val_shift = 16, 1533 .m_val_shift = 16, 1534 .width = 8, 1535 }, 1536 .p = { 1537 .pre_div_shift = 3, 1538 .pre_div_width = 2, 1539 }, 1540 .s = { 1541 .src_sel_shift = 0, 1542 .parent_map = gcc_pxo_pll8_map, 1543 }, 1544 .freq_tbl = clk_tbl_sdc, 1545 .clkr = { 1546 .enable_reg = 0x282c, 1547 .enable_mask = BIT(11), 1548 .hw.init = &(struct clk_init_data){ 1549 .name = "sdc1_src", 1550 .parent_names = gcc_pxo_pll8, 1551 .num_parents = 2, 1552 .ops = &clk_rcg_ops, 1553 }, 1554 } 1555 }; 1556 1557 static struct clk_branch sdc1_clk = { 1558 .halt_reg = 0x2fc8, 1559 .halt_bit = 6, 1560 .clkr = { 1561 .enable_reg = 0x282c, 1562 .enable_mask = BIT(9), 1563 .hw.init = &(struct clk_init_data){ 1564 .name = "sdc1_clk", 1565 .parent_names = (const char *[]){ "sdc1_src" }, 1566 .num_parents = 1, 1567 .ops = &clk_branch_ops, 1568 .flags = CLK_SET_RATE_PARENT, 1569 }, 1570 }, 1571 }; 1572 1573 static struct clk_rcg sdc2_src = { 1574 .ns_reg = 0x284c, 1575 .md_reg = 0x2848, 1576 .mn = { 1577 .mnctr_en_bit = 8, 1578 .mnctr_reset_bit = 7, 1579 .mnctr_mode_shift = 5, 1580 .n_val_shift = 16, 1581 .m_val_shift = 16, 1582 .width = 8, 1583 }, 1584 .p = { 1585 .pre_div_shift = 3, 1586 .pre_div_width = 2, 1587 }, 1588 .s = { 1589 .src_sel_shift = 0, 1590 .parent_map = gcc_pxo_pll8_map, 1591 }, 1592 .freq_tbl = clk_tbl_sdc, 1593 .clkr = { 1594 .enable_reg = 0x284c, 1595 .enable_mask = BIT(11), 1596 .hw.init = &(struct clk_init_data){ 1597 .name = "sdc2_src", 1598 .parent_names = gcc_pxo_pll8, 1599 .num_parents = 2, 1600 .ops = &clk_rcg_ops, 1601 }, 1602 } 1603 }; 1604 1605 static struct clk_branch sdc2_clk = { 1606 .halt_reg = 0x2fc8, 1607 .halt_bit = 5, 1608 .clkr = { 1609 .enable_reg = 0x284c, 1610 .enable_mask = BIT(9), 1611 .hw.init = &(struct clk_init_data){ 1612 .name = "sdc2_clk", 1613 .parent_names = (const char *[]){ "sdc2_src" }, 1614 .num_parents = 1, 1615 .ops = &clk_branch_ops, 1616 .flags = CLK_SET_RATE_PARENT, 1617 }, 1618 }, 1619 }; 1620 1621 static struct clk_rcg sdc3_src = { 1622 .ns_reg = 0x286c, 1623 .md_reg = 0x2868, 1624 .mn = { 1625 .mnctr_en_bit = 8, 1626 .mnctr_reset_bit = 7, 1627 .mnctr_mode_shift = 5, 1628 .n_val_shift = 16, 1629 .m_val_shift = 16, 1630 .width = 8, 1631 }, 1632 .p = { 1633 .pre_div_shift = 3, 1634 .pre_div_width = 2, 1635 }, 1636 .s = { 1637 .src_sel_shift = 0, 1638 .parent_map = gcc_pxo_pll8_map, 1639 }, 1640 .freq_tbl = clk_tbl_sdc, 1641 .clkr = { 1642 .enable_reg = 0x286c, 1643 .enable_mask = BIT(11), 1644 .hw.init = &(struct clk_init_data){ 1645 .name = "sdc3_src", 1646 .parent_names = gcc_pxo_pll8, 1647 .num_parents = 2, 1648 .ops = &clk_rcg_ops, 1649 }, 1650 } 1651 }; 1652 1653 static struct clk_branch sdc3_clk = { 1654 .halt_reg = 0x2fc8, 1655 .halt_bit = 4, 1656 .clkr = { 1657 .enable_reg = 0x286c, 1658 .enable_mask = BIT(9), 1659 .hw.init = &(struct clk_init_data){ 1660 .name = "sdc3_clk", 1661 .parent_names = (const char *[]){ "sdc3_src" }, 1662 .num_parents = 1, 1663 .ops = &clk_branch_ops, 1664 .flags = CLK_SET_RATE_PARENT, 1665 }, 1666 }, 1667 }; 1668 1669 static struct clk_rcg sdc4_src = { 1670 .ns_reg = 0x288c, 1671 .md_reg = 0x2888, 1672 .mn = { 1673 .mnctr_en_bit = 8, 1674 .mnctr_reset_bit = 7, 1675 .mnctr_mode_shift = 5, 1676 .n_val_shift = 16, 1677 .m_val_shift = 16, 1678 .width = 8, 1679 }, 1680 .p = { 1681 .pre_div_shift = 3, 1682 .pre_div_width = 2, 1683 }, 1684 .s = { 1685 .src_sel_shift = 0, 1686 .parent_map = gcc_pxo_pll8_map, 1687 }, 1688 .freq_tbl = clk_tbl_sdc, 1689 .clkr = { 1690 .enable_reg = 0x288c, 1691 .enable_mask = BIT(11), 1692 .hw.init = &(struct clk_init_data){ 1693 .name = "sdc4_src", 1694 .parent_names = gcc_pxo_pll8, 1695 .num_parents = 2, 1696 .ops = &clk_rcg_ops, 1697 }, 1698 } 1699 }; 1700 1701 static struct clk_branch sdc4_clk = { 1702 .halt_reg = 0x2fc8, 1703 .halt_bit = 3, 1704 .clkr = { 1705 .enable_reg = 0x288c, 1706 .enable_mask = BIT(9), 1707 .hw.init = &(struct clk_init_data){ 1708 .name = "sdc4_clk", 1709 .parent_names = (const char *[]){ "sdc4_src" }, 1710 .num_parents = 1, 1711 .ops = &clk_branch_ops, 1712 .flags = CLK_SET_RATE_PARENT, 1713 }, 1714 }, 1715 }; 1716 1717 static struct clk_rcg sdc5_src = { 1718 .ns_reg = 0x28ac, 1719 .md_reg = 0x28a8, 1720 .mn = { 1721 .mnctr_en_bit = 8, 1722 .mnctr_reset_bit = 7, 1723 .mnctr_mode_shift = 5, 1724 .n_val_shift = 16, 1725 .m_val_shift = 16, 1726 .width = 8, 1727 }, 1728 .p = { 1729 .pre_div_shift = 3, 1730 .pre_div_width = 2, 1731 }, 1732 .s = { 1733 .src_sel_shift = 0, 1734 .parent_map = gcc_pxo_pll8_map, 1735 }, 1736 .freq_tbl = clk_tbl_sdc, 1737 .clkr = { 1738 .enable_reg = 0x28ac, 1739 .enable_mask = BIT(11), 1740 .hw.init = &(struct clk_init_data){ 1741 .name = "sdc5_src", 1742 .parent_names = gcc_pxo_pll8, 1743 .num_parents = 2, 1744 .ops = &clk_rcg_ops, 1745 }, 1746 } 1747 }; 1748 1749 static struct clk_branch sdc5_clk = { 1750 .halt_reg = 0x2fc8, 1751 .halt_bit = 2, 1752 .clkr = { 1753 .enable_reg = 0x28ac, 1754 .enable_mask = BIT(9), 1755 .hw.init = &(struct clk_init_data){ 1756 .name = "sdc5_clk", 1757 .parent_names = (const char *[]){ "sdc5_src" }, 1758 .num_parents = 1, 1759 .ops = &clk_branch_ops, 1760 .flags = CLK_SET_RATE_PARENT, 1761 }, 1762 }, 1763 }; 1764 1765 static const struct freq_tbl clk_tbl_tsif_ref[] = { 1766 { 105000, P_PXO, 1, 1, 256 }, 1767 { } 1768 }; 1769 1770 static struct clk_rcg tsif_ref_src = { 1771 .ns_reg = 0x2710, 1772 .md_reg = 0x270c, 1773 .mn = { 1774 .mnctr_en_bit = 8, 1775 .mnctr_reset_bit = 7, 1776 .mnctr_mode_shift = 5, 1777 .n_val_shift = 16, 1778 .m_val_shift = 16, 1779 .width = 16, 1780 }, 1781 .p = { 1782 .pre_div_shift = 3, 1783 .pre_div_width = 2, 1784 }, 1785 .s = { 1786 .src_sel_shift = 0, 1787 .parent_map = gcc_pxo_pll8_map, 1788 }, 1789 .freq_tbl = clk_tbl_tsif_ref, 1790 .clkr = { 1791 .enable_reg = 0x2710, 1792 .enable_mask = BIT(11), 1793 .hw.init = &(struct clk_init_data){ 1794 .name = "tsif_ref_src", 1795 .parent_names = gcc_pxo_pll8, 1796 .num_parents = 2, 1797 .ops = &clk_rcg_ops, 1798 .flags = CLK_SET_RATE_GATE, 1799 }, 1800 } 1801 }; 1802 1803 static struct clk_branch tsif_ref_clk = { 1804 .halt_reg = 0x2fd4, 1805 .halt_bit = 5, 1806 .clkr = { 1807 .enable_reg = 0x2710, 1808 .enable_mask = BIT(9), 1809 .hw.init = &(struct clk_init_data){ 1810 .name = "tsif_ref_clk", 1811 .parent_names = (const char *[]){ "tsif_ref_src" }, 1812 .num_parents = 1, 1813 .ops = &clk_branch_ops, 1814 .flags = CLK_SET_RATE_PARENT, 1815 }, 1816 }, 1817 }; 1818 1819 static const struct freq_tbl clk_tbl_usb[] = { 1820 { 60000000, P_PLL8, 1, 5, 32 }, 1821 { } 1822 }; 1823 1824 static struct clk_rcg usb_hs1_xcvr_src = { 1825 .ns_reg = 0x290c, 1826 .md_reg = 0x2908, 1827 .mn = { 1828 .mnctr_en_bit = 8, 1829 .mnctr_reset_bit = 7, 1830 .mnctr_mode_shift = 5, 1831 .n_val_shift = 16, 1832 .m_val_shift = 16, 1833 .width = 8, 1834 }, 1835 .p = { 1836 .pre_div_shift = 3, 1837 .pre_div_width = 2, 1838 }, 1839 .s = { 1840 .src_sel_shift = 0, 1841 .parent_map = gcc_pxo_pll8_map, 1842 }, 1843 .freq_tbl = clk_tbl_usb, 1844 .clkr = { 1845 .enable_reg = 0x290c, 1846 .enable_mask = BIT(11), 1847 .hw.init = &(struct clk_init_data){ 1848 .name = "usb_hs1_xcvr_src", 1849 .parent_names = gcc_pxo_pll8, 1850 .num_parents = 2, 1851 .ops = &clk_rcg_ops, 1852 .flags = CLK_SET_RATE_GATE, 1853 }, 1854 } 1855 }; 1856 1857 static struct clk_branch usb_hs1_xcvr_clk = { 1858 .halt_reg = 0x2fc8, 1859 .halt_bit = 0, 1860 .clkr = { 1861 .enable_reg = 0x290c, 1862 .enable_mask = BIT(9), 1863 .hw.init = &(struct clk_init_data){ 1864 .name = "usb_hs1_xcvr_clk", 1865 .parent_names = (const char *[]){ "usb_hs1_xcvr_src" }, 1866 .num_parents = 1, 1867 .ops = &clk_branch_ops, 1868 .flags = CLK_SET_RATE_PARENT, 1869 }, 1870 }, 1871 }; 1872 1873 static struct clk_rcg usb_fs1_xcvr_fs_src = { 1874 .ns_reg = 0x2968, 1875 .md_reg = 0x2964, 1876 .mn = { 1877 .mnctr_en_bit = 8, 1878 .mnctr_reset_bit = 7, 1879 .mnctr_mode_shift = 5, 1880 .n_val_shift = 16, 1881 .m_val_shift = 16, 1882 .width = 8, 1883 }, 1884 .p = { 1885 .pre_div_shift = 3, 1886 .pre_div_width = 2, 1887 }, 1888 .s = { 1889 .src_sel_shift = 0, 1890 .parent_map = gcc_pxo_pll8_map, 1891 }, 1892 .freq_tbl = clk_tbl_usb, 1893 .clkr = { 1894 .enable_reg = 0x2968, 1895 .enable_mask = BIT(11), 1896 .hw.init = &(struct clk_init_data){ 1897 .name = "usb_fs1_xcvr_fs_src", 1898 .parent_names = gcc_pxo_pll8, 1899 .num_parents = 2, 1900 .ops = &clk_rcg_ops, 1901 .flags = CLK_SET_RATE_GATE, 1902 }, 1903 } 1904 }; 1905 1906 static const char * const usb_fs1_xcvr_fs_src_p[] = { "usb_fs1_xcvr_fs_src" }; 1907 1908 static struct clk_branch usb_fs1_xcvr_fs_clk = { 1909 .halt_reg = 0x2fcc, 1910 .halt_bit = 15, 1911 .clkr = { 1912 .enable_reg = 0x2968, 1913 .enable_mask = BIT(9), 1914 .hw.init = &(struct clk_init_data){ 1915 .name = "usb_fs1_xcvr_fs_clk", 1916 .parent_names = usb_fs1_xcvr_fs_src_p, 1917 .num_parents = 1, 1918 .ops = &clk_branch_ops, 1919 .flags = CLK_SET_RATE_PARENT, 1920 }, 1921 }, 1922 }; 1923 1924 static struct clk_branch usb_fs1_system_clk = { 1925 .halt_reg = 0x2fcc, 1926 .halt_bit = 16, 1927 .clkr = { 1928 .enable_reg = 0x296c, 1929 .enable_mask = BIT(4), 1930 .hw.init = &(struct clk_init_data){ 1931 .parent_names = usb_fs1_xcvr_fs_src_p, 1932 .num_parents = 1, 1933 .name = "usb_fs1_system_clk", 1934 .ops = &clk_branch_ops, 1935 .flags = CLK_SET_RATE_PARENT, 1936 }, 1937 }, 1938 }; 1939 1940 static struct clk_rcg usb_fs2_xcvr_fs_src = { 1941 .ns_reg = 0x2988, 1942 .md_reg = 0x2984, 1943 .mn = { 1944 .mnctr_en_bit = 8, 1945 .mnctr_reset_bit = 7, 1946 .mnctr_mode_shift = 5, 1947 .n_val_shift = 16, 1948 .m_val_shift = 16, 1949 .width = 8, 1950 }, 1951 .p = { 1952 .pre_div_shift = 3, 1953 .pre_div_width = 2, 1954 }, 1955 .s = { 1956 .src_sel_shift = 0, 1957 .parent_map = gcc_pxo_pll8_map, 1958 }, 1959 .freq_tbl = clk_tbl_usb, 1960 .clkr = { 1961 .enable_reg = 0x2988, 1962 .enable_mask = BIT(11), 1963 .hw.init = &(struct clk_init_data){ 1964 .name = "usb_fs2_xcvr_fs_src", 1965 .parent_names = gcc_pxo_pll8, 1966 .num_parents = 2, 1967 .ops = &clk_rcg_ops, 1968 .flags = CLK_SET_RATE_GATE, 1969 }, 1970 } 1971 }; 1972 1973 static const char * const usb_fs2_xcvr_fs_src_p[] = { "usb_fs2_xcvr_fs_src" }; 1974 1975 static struct clk_branch usb_fs2_xcvr_fs_clk = { 1976 .halt_reg = 0x2fcc, 1977 .halt_bit = 12, 1978 .clkr = { 1979 .enable_reg = 0x2988, 1980 .enable_mask = BIT(9), 1981 .hw.init = &(struct clk_init_data){ 1982 .name = "usb_fs2_xcvr_fs_clk", 1983 .parent_names = usb_fs2_xcvr_fs_src_p, 1984 .num_parents = 1, 1985 .ops = &clk_branch_ops, 1986 .flags = CLK_SET_RATE_PARENT, 1987 }, 1988 }, 1989 }; 1990 1991 static struct clk_branch usb_fs2_system_clk = { 1992 .halt_reg = 0x2fcc, 1993 .halt_bit = 13, 1994 .clkr = { 1995 .enable_reg = 0x298c, 1996 .enable_mask = BIT(4), 1997 .hw.init = &(struct clk_init_data){ 1998 .name = "usb_fs2_system_clk", 1999 .parent_names = usb_fs2_xcvr_fs_src_p, 2000 .num_parents = 1, 2001 .ops = &clk_branch_ops, 2002 .flags = CLK_SET_RATE_PARENT, 2003 }, 2004 }, 2005 }; 2006 2007 static struct clk_branch gsbi1_h_clk = { 2008 .halt_reg = 0x2fcc, 2009 .halt_bit = 11, 2010 .clkr = { 2011 .enable_reg = 0x29c0, 2012 .enable_mask = BIT(4), 2013 .hw.init = &(struct clk_init_data){ 2014 .name = "gsbi1_h_clk", 2015 .ops = &clk_branch_ops, 2016 }, 2017 }, 2018 }; 2019 2020 static struct clk_branch gsbi2_h_clk = { 2021 .halt_reg = 0x2fcc, 2022 .halt_bit = 7, 2023 .clkr = { 2024 .enable_reg = 0x29e0, 2025 .enable_mask = BIT(4), 2026 .hw.init = &(struct clk_init_data){ 2027 .name = "gsbi2_h_clk", 2028 .ops = &clk_branch_ops, 2029 }, 2030 }, 2031 }; 2032 2033 static struct clk_branch gsbi3_h_clk = { 2034 .halt_reg = 0x2fcc, 2035 .halt_bit = 3, 2036 .clkr = { 2037 .enable_reg = 0x2a00, 2038 .enable_mask = BIT(4), 2039 .hw.init = &(struct clk_init_data){ 2040 .name = "gsbi3_h_clk", 2041 .ops = &clk_branch_ops, 2042 }, 2043 }, 2044 }; 2045 2046 static struct clk_branch gsbi4_h_clk = { 2047 .halt_reg = 0x2fd0, 2048 .halt_bit = 27, 2049 .clkr = { 2050 .enable_reg = 0x2a20, 2051 .enable_mask = BIT(4), 2052 .hw.init = &(struct clk_init_data){ 2053 .name = "gsbi4_h_clk", 2054 .ops = &clk_branch_ops, 2055 }, 2056 }, 2057 }; 2058 2059 static struct clk_branch gsbi5_h_clk = { 2060 .halt_reg = 0x2fd0, 2061 .halt_bit = 23, 2062 .clkr = { 2063 .enable_reg = 0x2a40, 2064 .enable_mask = BIT(4), 2065 .hw.init = &(struct clk_init_data){ 2066 .name = "gsbi5_h_clk", 2067 .ops = &clk_branch_ops, 2068 }, 2069 }, 2070 }; 2071 2072 static struct clk_branch gsbi6_h_clk = { 2073 .halt_reg = 0x2fd0, 2074 .halt_bit = 19, 2075 .clkr = { 2076 .enable_reg = 0x2a60, 2077 .enable_mask = BIT(4), 2078 .hw.init = &(struct clk_init_data){ 2079 .name = "gsbi6_h_clk", 2080 .ops = &clk_branch_ops, 2081 }, 2082 }, 2083 }; 2084 2085 static struct clk_branch gsbi7_h_clk = { 2086 .halt_reg = 0x2fd0, 2087 .halt_bit = 15, 2088 .clkr = { 2089 .enable_reg = 0x2a80, 2090 .enable_mask = BIT(4), 2091 .hw.init = &(struct clk_init_data){ 2092 .name = "gsbi7_h_clk", 2093 .ops = &clk_branch_ops, 2094 }, 2095 }, 2096 }; 2097 2098 static struct clk_branch gsbi8_h_clk = { 2099 .halt_reg = 0x2fd0, 2100 .halt_bit = 11, 2101 .clkr = { 2102 .enable_reg = 0x2aa0, 2103 .enable_mask = BIT(4), 2104 .hw.init = &(struct clk_init_data){ 2105 .name = "gsbi8_h_clk", 2106 .ops = &clk_branch_ops, 2107 }, 2108 }, 2109 }; 2110 2111 static struct clk_branch gsbi9_h_clk = { 2112 .halt_reg = 0x2fd0, 2113 .halt_bit = 7, 2114 .clkr = { 2115 .enable_reg = 0x2ac0, 2116 .enable_mask = BIT(4), 2117 .hw.init = &(struct clk_init_data){ 2118 .name = "gsbi9_h_clk", 2119 .ops = &clk_branch_ops, 2120 }, 2121 }, 2122 }; 2123 2124 static struct clk_branch gsbi10_h_clk = { 2125 .halt_reg = 0x2fd0, 2126 .halt_bit = 3, 2127 .clkr = { 2128 .enable_reg = 0x2ae0, 2129 .enable_mask = BIT(4), 2130 .hw.init = &(struct clk_init_data){ 2131 .name = "gsbi10_h_clk", 2132 .ops = &clk_branch_ops, 2133 }, 2134 }, 2135 }; 2136 2137 static struct clk_branch gsbi11_h_clk = { 2138 .halt_reg = 0x2fd4, 2139 .halt_bit = 18, 2140 .clkr = { 2141 .enable_reg = 0x2b00, 2142 .enable_mask = BIT(4), 2143 .hw.init = &(struct clk_init_data){ 2144 .name = "gsbi11_h_clk", 2145 .ops = &clk_branch_ops, 2146 }, 2147 }, 2148 }; 2149 2150 static struct clk_branch gsbi12_h_clk = { 2151 .halt_reg = 0x2fd4, 2152 .halt_bit = 14, 2153 .clkr = { 2154 .enable_reg = 0x2b20, 2155 .enable_mask = BIT(4), 2156 .hw.init = &(struct clk_init_data){ 2157 .name = "gsbi12_h_clk", 2158 .ops = &clk_branch_ops, 2159 }, 2160 }, 2161 }; 2162 2163 static struct clk_branch tsif_h_clk = { 2164 .halt_reg = 0x2fd4, 2165 .halt_bit = 7, 2166 .clkr = { 2167 .enable_reg = 0x2700, 2168 .enable_mask = BIT(4), 2169 .hw.init = &(struct clk_init_data){ 2170 .name = "tsif_h_clk", 2171 .ops = &clk_branch_ops, 2172 }, 2173 }, 2174 }; 2175 2176 static struct clk_branch usb_fs1_h_clk = { 2177 .halt_reg = 0x2fcc, 2178 .halt_bit = 17, 2179 .clkr = { 2180 .enable_reg = 0x2960, 2181 .enable_mask = BIT(4), 2182 .hw.init = &(struct clk_init_data){ 2183 .name = "usb_fs1_h_clk", 2184 .ops = &clk_branch_ops, 2185 }, 2186 }, 2187 }; 2188 2189 static struct clk_branch usb_fs2_h_clk = { 2190 .halt_reg = 0x2fcc, 2191 .halt_bit = 14, 2192 .clkr = { 2193 .enable_reg = 0x2980, 2194 .enable_mask = BIT(4), 2195 .hw.init = &(struct clk_init_data){ 2196 .name = "usb_fs2_h_clk", 2197 .ops = &clk_branch_ops, 2198 }, 2199 }, 2200 }; 2201 2202 static struct clk_branch usb_hs1_h_clk = { 2203 .halt_reg = 0x2fc8, 2204 .halt_bit = 1, 2205 .clkr = { 2206 .enable_reg = 0x2900, 2207 .enable_mask = BIT(4), 2208 .hw.init = &(struct clk_init_data){ 2209 .name = "usb_hs1_h_clk", 2210 .ops = &clk_branch_ops, 2211 }, 2212 }, 2213 }; 2214 2215 static struct clk_branch sdc1_h_clk = { 2216 .halt_reg = 0x2fc8, 2217 .halt_bit = 11, 2218 .clkr = { 2219 .enable_reg = 0x2820, 2220 .enable_mask = BIT(4), 2221 .hw.init = &(struct clk_init_data){ 2222 .name = "sdc1_h_clk", 2223 .ops = &clk_branch_ops, 2224 }, 2225 }, 2226 }; 2227 2228 static struct clk_branch sdc2_h_clk = { 2229 .halt_reg = 0x2fc8, 2230 .halt_bit = 10, 2231 .clkr = { 2232 .enable_reg = 0x2840, 2233 .enable_mask = BIT(4), 2234 .hw.init = &(struct clk_init_data){ 2235 .name = "sdc2_h_clk", 2236 .ops = &clk_branch_ops, 2237 }, 2238 }, 2239 }; 2240 2241 static struct clk_branch sdc3_h_clk = { 2242 .halt_reg = 0x2fc8, 2243 .halt_bit = 9, 2244 .clkr = { 2245 .enable_reg = 0x2860, 2246 .enable_mask = BIT(4), 2247 .hw.init = &(struct clk_init_data){ 2248 .name = "sdc3_h_clk", 2249 .ops = &clk_branch_ops, 2250 }, 2251 }, 2252 }; 2253 2254 static struct clk_branch sdc4_h_clk = { 2255 .halt_reg = 0x2fc8, 2256 .halt_bit = 8, 2257 .clkr = { 2258 .enable_reg = 0x2880, 2259 .enable_mask = BIT(4), 2260 .hw.init = &(struct clk_init_data){ 2261 .name = "sdc4_h_clk", 2262 .ops = &clk_branch_ops, 2263 }, 2264 }, 2265 }; 2266 2267 static struct clk_branch sdc5_h_clk = { 2268 .halt_reg = 0x2fc8, 2269 .halt_bit = 7, 2270 .clkr = { 2271 .enable_reg = 0x28a0, 2272 .enable_mask = BIT(4), 2273 .hw.init = &(struct clk_init_data){ 2274 .name = "sdc5_h_clk", 2275 .ops = &clk_branch_ops, 2276 }, 2277 }, 2278 }; 2279 2280 static struct clk_branch ebi2_2x_clk = { 2281 .halt_reg = 0x2fcc, 2282 .halt_bit = 18, 2283 .clkr = { 2284 .enable_reg = 0x2660, 2285 .enable_mask = BIT(4), 2286 .hw.init = &(struct clk_init_data){ 2287 .name = "ebi2_2x_clk", 2288 .ops = &clk_branch_ops, 2289 }, 2290 }, 2291 }; 2292 2293 static struct clk_branch ebi2_clk = { 2294 .halt_reg = 0x2fcc, 2295 .halt_bit = 19, 2296 .clkr = { 2297 .enable_reg = 0x2664, 2298 .enable_mask = BIT(4), 2299 .hw.init = &(struct clk_init_data){ 2300 .name = "ebi2_clk", 2301 .ops = &clk_branch_ops, 2302 }, 2303 }, 2304 }; 2305 2306 static struct clk_branch adm0_clk = { 2307 .halt_reg = 0x2fdc, 2308 .halt_check = BRANCH_HALT_VOTED, 2309 .halt_bit = 14, 2310 .clkr = { 2311 .enable_reg = 0x3080, 2312 .enable_mask = BIT(2), 2313 .hw.init = &(struct clk_init_data){ 2314 .name = "adm0_clk", 2315 .ops = &clk_branch_ops, 2316 }, 2317 }, 2318 }; 2319 2320 static struct clk_branch adm0_pbus_clk = { 2321 .halt_reg = 0x2fdc, 2322 .halt_check = BRANCH_HALT_VOTED, 2323 .halt_bit = 13, 2324 .clkr = { 2325 .enable_reg = 0x3080, 2326 .enable_mask = BIT(3), 2327 .hw.init = &(struct clk_init_data){ 2328 .name = "adm0_pbus_clk", 2329 .ops = &clk_branch_ops, 2330 }, 2331 }, 2332 }; 2333 2334 static struct clk_branch adm1_clk = { 2335 .halt_reg = 0x2fdc, 2336 .halt_bit = 12, 2337 .halt_check = BRANCH_HALT_VOTED, 2338 .clkr = { 2339 .enable_reg = 0x3080, 2340 .enable_mask = BIT(4), 2341 .hw.init = &(struct clk_init_data){ 2342 .name = "adm1_clk", 2343 .ops = &clk_branch_ops, 2344 }, 2345 }, 2346 }; 2347 2348 static struct clk_branch adm1_pbus_clk = { 2349 .halt_reg = 0x2fdc, 2350 .halt_bit = 11, 2351 .halt_check = BRANCH_HALT_VOTED, 2352 .clkr = { 2353 .enable_reg = 0x3080, 2354 .enable_mask = BIT(5), 2355 .hw.init = &(struct clk_init_data){ 2356 .name = "adm1_pbus_clk", 2357 .ops = &clk_branch_ops, 2358 }, 2359 }, 2360 }; 2361 2362 static struct clk_branch modem_ahb1_h_clk = { 2363 .halt_reg = 0x2fdc, 2364 .halt_bit = 8, 2365 .halt_check = BRANCH_HALT_VOTED, 2366 .clkr = { 2367 .enable_reg = 0x3080, 2368 .enable_mask = BIT(0), 2369 .hw.init = &(struct clk_init_data){ 2370 .name = "modem_ahb1_h_clk", 2371 .ops = &clk_branch_ops, 2372 }, 2373 }, 2374 }; 2375 2376 static struct clk_branch modem_ahb2_h_clk = { 2377 .halt_reg = 0x2fdc, 2378 .halt_bit = 7, 2379 .halt_check = BRANCH_HALT_VOTED, 2380 .clkr = { 2381 .enable_reg = 0x3080, 2382 .enable_mask = BIT(1), 2383 .hw.init = &(struct clk_init_data){ 2384 .name = "modem_ahb2_h_clk", 2385 .ops = &clk_branch_ops, 2386 }, 2387 }, 2388 }; 2389 2390 static struct clk_branch pmic_arb0_h_clk = { 2391 .halt_reg = 0x2fd8, 2392 .halt_check = BRANCH_HALT_VOTED, 2393 .halt_bit = 22, 2394 .clkr = { 2395 .enable_reg = 0x3080, 2396 .enable_mask = BIT(8), 2397 .hw.init = &(struct clk_init_data){ 2398 .name = "pmic_arb0_h_clk", 2399 .ops = &clk_branch_ops, 2400 }, 2401 }, 2402 }; 2403 2404 static struct clk_branch pmic_arb1_h_clk = { 2405 .halt_reg = 0x2fd8, 2406 .halt_check = BRANCH_HALT_VOTED, 2407 .halt_bit = 21, 2408 .clkr = { 2409 .enable_reg = 0x3080, 2410 .enable_mask = BIT(9), 2411 .hw.init = &(struct clk_init_data){ 2412 .name = "pmic_arb1_h_clk", 2413 .ops = &clk_branch_ops, 2414 }, 2415 }, 2416 }; 2417 2418 static struct clk_branch pmic_ssbi2_clk = { 2419 .halt_reg = 0x2fd8, 2420 .halt_check = BRANCH_HALT_VOTED, 2421 .halt_bit = 23, 2422 .clkr = { 2423 .enable_reg = 0x3080, 2424 .enable_mask = BIT(7), 2425 .hw.init = &(struct clk_init_data){ 2426 .name = "pmic_ssbi2_clk", 2427 .ops = &clk_branch_ops, 2428 }, 2429 }, 2430 }; 2431 2432 static struct clk_branch rpm_msg_ram_h_clk = { 2433 .hwcg_reg = 0x27e0, 2434 .hwcg_bit = 6, 2435 .halt_reg = 0x2fd8, 2436 .halt_check = BRANCH_HALT_VOTED, 2437 .halt_bit = 12, 2438 .clkr = { 2439 .enable_reg = 0x3080, 2440 .enable_mask = BIT(6), 2441 .hw.init = &(struct clk_init_data){ 2442 .name = "rpm_msg_ram_h_clk", 2443 .ops = &clk_branch_ops, 2444 }, 2445 }, 2446 }; 2447 2448 static struct clk_regmap *gcc_msm8660_clks[] = { 2449 [PLL8] = &pll8.clkr, 2450 [PLL8_VOTE] = &pll8_vote, 2451 [GSBI1_UART_SRC] = &gsbi1_uart_src.clkr, 2452 [GSBI1_UART_CLK] = &gsbi1_uart_clk.clkr, 2453 [GSBI2_UART_SRC] = &gsbi2_uart_src.clkr, 2454 [GSBI2_UART_CLK] = &gsbi2_uart_clk.clkr, 2455 [GSBI3_UART_SRC] = &gsbi3_uart_src.clkr, 2456 [GSBI3_UART_CLK] = &gsbi3_uart_clk.clkr, 2457 [GSBI4_UART_SRC] = &gsbi4_uart_src.clkr, 2458 [GSBI4_UART_CLK] = &gsbi4_uart_clk.clkr, 2459 [GSBI5_UART_SRC] = &gsbi5_uart_src.clkr, 2460 [GSBI5_UART_CLK] = &gsbi5_uart_clk.clkr, 2461 [GSBI6_UART_SRC] = &gsbi6_uart_src.clkr, 2462 [GSBI6_UART_CLK] = &gsbi6_uart_clk.clkr, 2463 [GSBI7_UART_SRC] = &gsbi7_uart_src.clkr, 2464 [GSBI7_UART_CLK] = &gsbi7_uart_clk.clkr, 2465 [GSBI8_UART_SRC] = &gsbi8_uart_src.clkr, 2466 [GSBI8_UART_CLK] = &gsbi8_uart_clk.clkr, 2467 [GSBI9_UART_SRC] = &gsbi9_uart_src.clkr, 2468 [GSBI9_UART_CLK] = &gsbi9_uart_clk.clkr, 2469 [GSBI10_UART_SRC] = &gsbi10_uart_src.clkr, 2470 [GSBI10_UART_CLK] = &gsbi10_uart_clk.clkr, 2471 [GSBI11_UART_SRC] = &gsbi11_uart_src.clkr, 2472 [GSBI11_UART_CLK] = &gsbi11_uart_clk.clkr, 2473 [GSBI12_UART_SRC] = &gsbi12_uart_src.clkr, 2474 [GSBI12_UART_CLK] = &gsbi12_uart_clk.clkr, 2475 [GSBI1_QUP_SRC] = &gsbi1_qup_src.clkr, 2476 [GSBI1_QUP_CLK] = &gsbi1_qup_clk.clkr, 2477 [GSBI2_QUP_SRC] = &gsbi2_qup_src.clkr, 2478 [GSBI2_QUP_CLK] = &gsbi2_qup_clk.clkr, 2479 [GSBI3_QUP_SRC] = &gsbi3_qup_src.clkr, 2480 [GSBI3_QUP_CLK] = &gsbi3_qup_clk.clkr, 2481 [GSBI4_QUP_SRC] = &gsbi4_qup_src.clkr, 2482 [GSBI4_QUP_CLK] = &gsbi4_qup_clk.clkr, 2483 [GSBI5_QUP_SRC] = &gsbi5_qup_src.clkr, 2484 [GSBI5_QUP_CLK] = &gsbi5_qup_clk.clkr, 2485 [GSBI6_QUP_SRC] = &gsbi6_qup_src.clkr, 2486 [GSBI6_QUP_CLK] = &gsbi6_qup_clk.clkr, 2487 [GSBI7_QUP_SRC] = &gsbi7_qup_src.clkr, 2488 [GSBI7_QUP_CLK] = &gsbi7_qup_clk.clkr, 2489 [GSBI8_QUP_SRC] = &gsbi8_qup_src.clkr, 2490 [GSBI8_QUP_CLK] = &gsbi8_qup_clk.clkr, 2491 [GSBI9_QUP_SRC] = &gsbi9_qup_src.clkr, 2492 [GSBI9_QUP_CLK] = &gsbi9_qup_clk.clkr, 2493 [GSBI10_QUP_SRC] = &gsbi10_qup_src.clkr, 2494 [GSBI10_QUP_CLK] = &gsbi10_qup_clk.clkr, 2495 [GSBI11_QUP_SRC] = &gsbi11_qup_src.clkr, 2496 [GSBI11_QUP_CLK] = &gsbi11_qup_clk.clkr, 2497 [GSBI12_QUP_SRC] = &gsbi12_qup_src.clkr, 2498 [GSBI12_QUP_CLK] = &gsbi12_qup_clk.clkr, 2499 [GP0_SRC] = &gp0_src.clkr, 2500 [GP0_CLK] = &gp0_clk.clkr, 2501 [GP1_SRC] = &gp1_src.clkr, 2502 [GP1_CLK] = &gp1_clk.clkr, 2503 [GP2_SRC] = &gp2_src.clkr, 2504 [GP2_CLK] = &gp2_clk.clkr, 2505 [PMEM_CLK] = &pmem_clk.clkr, 2506 [PRNG_SRC] = &prng_src.clkr, 2507 [PRNG_CLK] = &prng_clk.clkr, 2508 [SDC1_SRC] = &sdc1_src.clkr, 2509 [SDC1_CLK] = &sdc1_clk.clkr, 2510 [SDC2_SRC] = &sdc2_src.clkr, 2511 [SDC2_CLK] = &sdc2_clk.clkr, 2512 [SDC3_SRC] = &sdc3_src.clkr, 2513 [SDC3_CLK] = &sdc3_clk.clkr, 2514 [SDC4_SRC] = &sdc4_src.clkr, 2515 [SDC4_CLK] = &sdc4_clk.clkr, 2516 [SDC5_SRC] = &sdc5_src.clkr, 2517 [SDC5_CLK] = &sdc5_clk.clkr, 2518 [TSIF_REF_SRC] = &tsif_ref_src.clkr, 2519 [TSIF_REF_CLK] = &tsif_ref_clk.clkr, 2520 [USB_HS1_XCVR_SRC] = &usb_hs1_xcvr_src.clkr, 2521 [USB_HS1_XCVR_CLK] = &usb_hs1_xcvr_clk.clkr, 2522 [USB_FS1_XCVR_FS_SRC] = &usb_fs1_xcvr_fs_src.clkr, 2523 [USB_FS1_XCVR_FS_CLK] = &usb_fs1_xcvr_fs_clk.clkr, 2524 [USB_FS1_SYSTEM_CLK] = &usb_fs1_system_clk.clkr, 2525 [USB_FS2_XCVR_FS_SRC] = &usb_fs2_xcvr_fs_src.clkr, 2526 [USB_FS2_XCVR_FS_CLK] = &usb_fs2_xcvr_fs_clk.clkr, 2527 [USB_FS2_SYSTEM_CLK] = &usb_fs2_system_clk.clkr, 2528 [GSBI1_H_CLK] = &gsbi1_h_clk.clkr, 2529 [GSBI2_H_CLK] = &gsbi2_h_clk.clkr, 2530 [GSBI3_H_CLK] = &gsbi3_h_clk.clkr, 2531 [GSBI4_H_CLK] = &gsbi4_h_clk.clkr, 2532 [GSBI5_H_CLK] = &gsbi5_h_clk.clkr, 2533 [GSBI6_H_CLK] = &gsbi6_h_clk.clkr, 2534 [GSBI7_H_CLK] = &gsbi7_h_clk.clkr, 2535 [GSBI8_H_CLK] = &gsbi8_h_clk.clkr, 2536 [GSBI9_H_CLK] = &gsbi9_h_clk.clkr, 2537 [GSBI10_H_CLK] = &gsbi10_h_clk.clkr, 2538 [GSBI11_H_CLK] = &gsbi11_h_clk.clkr, 2539 [GSBI12_H_CLK] = &gsbi12_h_clk.clkr, 2540 [TSIF_H_CLK] = &tsif_h_clk.clkr, 2541 [USB_FS1_H_CLK] = &usb_fs1_h_clk.clkr, 2542 [USB_FS2_H_CLK] = &usb_fs2_h_clk.clkr, 2543 [USB_HS1_H_CLK] = &usb_hs1_h_clk.clkr, 2544 [SDC1_H_CLK] = &sdc1_h_clk.clkr, 2545 [SDC2_H_CLK] = &sdc2_h_clk.clkr, 2546 [SDC3_H_CLK] = &sdc3_h_clk.clkr, 2547 [SDC4_H_CLK] = &sdc4_h_clk.clkr, 2548 [SDC5_H_CLK] = &sdc5_h_clk.clkr, 2549 [EBI2_2X_CLK] = &ebi2_2x_clk.clkr, 2550 [EBI2_CLK] = &ebi2_clk.clkr, 2551 [ADM0_CLK] = &adm0_clk.clkr, 2552 [ADM0_PBUS_CLK] = &adm0_pbus_clk.clkr, 2553 [ADM1_CLK] = &adm1_clk.clkr, 2554 [ADM1_PBUS_CLK] = &adm1_pbus_clk.clkr, 2555 [MODEM_AHB1_H_CLK] = &modem_ahb1_h_clk.clkr, 2556 [MODEM_AHB2_H_CLK] = &modem_ahb2_h_clk.clkr, 2557 [PMIC_ARB0_H_CLK] = &pmic_arb0_h_clk.clkr, 2558 [PMIC_ARB1_H_CLK] = &pmic_arb1_h_clk.clkr, 2559 [PMIC_SSBI2_CLK] = &pmic_ssbi2_clk.clkr, 2560 [RPM_MSG_RAM_H_CLK] = &rpm_msg_ram_h_clk.clkr, 2561 }; 2562 2563 static const struct qcom_reset_map gcc_msm8660_resets[] = { 2564 [AFAB_CORE_RESET] = { 0x2080, 7 }, 2565 [SCSS_SYS_RESET] = { 0x20b4, 1 }, 2566 [SCSS_SYS_POR_RESET] = { 0x20b4 }, 2567 [AFAB_SMPSS_S_RESET] = { 0x20b8, 2 }, 2568 [AFAB_SMPSS_M1_RESET] = { 0x20b8, 1 }, 2569 [AFAB_SMPSS_M0_RESET] = { 0x20b8 }, 2570 [AFAB_EBI1_S_RESET] = { 0x20c0, 7 }, 2571 [SFAB_CORE_RESET] = { 0x2120, 7 }, 2572 [SFAB_ADM0_M0_RESET] = { 0x21e0, 7 }, 2573 [SFAB_ADM0_M1_RESET] = { 0x21e4, 7 }, 2574 [SFAB_ADM0_M2_RESET] = { 0x21e4, 7 }, 2575 [ADM0_C2_RESET] = { 0x220c, 4 }, 2576 [ADM0_C1_RESET] = { 0x220c, 3 }, 2577 [ADM0_C0_RESET] = { 0x220c, 2 }, 2578 [ADM0_PBUS_RESET] = { 0x220c, 1 }, 2579 [ADM0_RESET] = { 0x220c }, 2580 [SFAB_ADM1_M0_RESET] = { 0x2220, 7 }, 2581 [SFAB_ADM1_M1_RESET] = { 0x2224, 7 }, 2582 [SFAB_ADM1_M2_RESET] = { 0x2228, 7 }, 2583 [MMFAB_ADM1_M3_RESET] = { 0x2240, 7 }, 2584 [ADM1_C3_RESET] = { 0x226c, 5 }, 2585 [ADM1_C2_RESET] = { 0x226c, 4 }, 2586 [ADM1_C1_RESET] = { 0x226c, 3 }, 2587 [ADM1_C0_RESET] = { 0x226c, 2 }, 2588 [ADM1_PBUS_RESET] = { 0x226c, 1 }, 2589 [ADM1_RESET] = { 0x226c }, 2590 [IMEM0_RESET] = { 0x2280, 7 }, 2591 [SFAB_LPASS_Q6_RESET] = { 0x23a0, 7 }, 2592 [SFAB_AFAB_M_RESET] = { 0x23e0, 7 }, 2593 [AFAB_SFAB_M0_RESET] = { 0x2420, 7 }, 2594 [AFAB_SFAB_M1_RESET] = { 0x2424, 7 }, 2595 [DFAB_CORE_RESET] = { 0x24ac, 7 }, 2596 [SFAB_DFAB_M_RESET] = { 0x2500, 7 }, 2597 [DFAB_SFAB_M_RESET] = { 0x2520, 7 }, 2598 [DFAB_SWAY0_RESET] = { 0x2540, 7 }, 2599 [DFAB_SWAY1_RESET] = { 0x2544, 7 }, 2600 [DFAB_ARB0_RESET] = { 0x2560, 7 }, 2601 [DFAB_ARB1_RESET] = { 0x2564, 7 }, 2602 [PPSS_PROC_RESET] = { 0x2594, 1 }, 2603 [PPSS_RESET] = { 0x2594 }, 2604 [PMEM_RESET] = { 0x25a0, 7 }, 2605 [DMA_BAM_RESET] = { 0x25c0, 7 }, 2606 [SIC_RESET] = { 0x25e0, 7 }, 2607 [SPS_TIC_RESET] = { 0x2600, 7 }, 2608 [CFBP0_RESET] = { 0x2650, 7 }, 2609 [CFBP1_RESET] = { 0x2654, 7 }, 2610 [CFBP2_RESET] = { 0x2658, 7 }, 2611 [EBI2_RESET] = { 0x2664, 7 }, 2612 [SFAB_CFPB_M_RESET] = { 0x2680, 7 }, 2613 [CFPB_MASTER_RESET] = { 0x26a0, 7 }, 2614 [SFAB_CFPB_S_RESET] = { 0x26c0, 7 }, 2615 [CFPB_SPLITTER_RESET] = { 0x26e0, 7 }, 2616 [TSIF_RESET] = { 0x2700, 7 }, 2617 [CE1_RESET] = { 0x2720, 7 }, 2618 [CE2_RESET] = { 0x2740, 7 }, 2619 [SFAB_SFPB_M_RESET] = { 0x2780, 7 }, 2620 [SFAB_SFPB_S_RESET] = { 0x27a0, 7 }, 2621 [RPM_PROC_RESET] = { 0x27c0, 7 }, 2622 [RPM_BUS_RESET] = { 0x27c4, 7 }, 2623 [RPM_MSG_RAM_RESET] = { 0x27e0, 7 }, 2624 [PMIC_ARB0_RESET] = { 0x2800, 7 }, 2625 [PMIC_ARB1_RESET] = { 0x2804, 7 }, 2626 [PMIC_SSBI2_RESET] = { 0x280c, 12 }, 2627 [SDC1_RESET] = { 0x2830 }, 2628 [SDC2_RESET] = { 0x2850 }, 2629 [SDC3_RESET] = { 0x2870 }, 2630 [SDC4_RESET] = { 0x2890 }, 2631 [SDC5_RESET] = { 0x28b0 }, 2632 [USB_HS1_RESET] = { 0x2910 }, 2633 [USB_HS2_XCVR_RESET] = { 0x2934, 1 }, 2634 [USB_HS2_RESET] = { 0x2934 }, 2635 [USB_FS1_XCVR_RESET] = { 0x2974, 1 }, 2636 [USB_FS1_RESET] = { 0x2974 }, 2637 [USB_FS2_XCVR_RESET] = { 0x2994, 1 }, 2638 [USB_FS2_RESET] = { 0x2994 }, 2639 [GSBI1_RESET] = { 0x29dc }, 2640 [GSBI2_RESET] = { 0x29fc }, 2641 [GSBI3_RESET] = { 0x2a1c }, 2642 [GSBI4_RESET] = { 0x2a3c }, 2643 [GSBI5_RESET] = { 0x2a5c }, 2644 [GSBI6_RESET] = { 0x2a7c }, 2645 [GSBI7_RESET] = { 0x2a9c }, 2646 [GSBI8_RESET] = { 0x2abc }, 2647 [GSBI9_RESET] = { 0x2adc }, 2648 [GSBI10_RESET] = { 0x2afc }, 2649 [GSBI11_RESET] = { 0x2b1c }, 2650 [GSBI12_RESET] = { 0x2b3c }, 2651 [SPDM_RESET] = { 0x2b6c }, 2652 [SEC_CTRL_RESET] = { 0x2b80, 7 }, 2653 [TLMM_H_RESET] = { 0x2ba0, 7 }, 2654 [TLMM_RESET] = { 0x2ba4, 7 }, 2655 [MARRM_PWRON_RESET] = { 0x2bd4, 1 }, 2656 [MARM_RESET] = { 0x2bd4 }, 2657 [MAHB1_RESET] = { 0x2be4, 7 }, 2658 [SFAB_MSS_S_RESET] = { 0x2c00, 7 }, 2659 [MAHB2_RESET] = { 0x2c20, 7 }, 2660 [MODEM_SW_AHB_RESET] = { 0x2c48, 1 }, 2661 [MODEM_RESET] = { 0x2c48 }, 2662 [SFAB_MSS_MDM1_RESET] = { 0x2c4c, 1 }, 2663 [SFAB_MSS_MDM0_RESET] = { 0x2c4c }, 2664 [MSS_SLP_RESET] = { 0x2c60, 7 }, 2665 [MSS_MARM_SAW_RESET] = { 0x2c68, 1 }, 2666 [MSS_WDOG_RESET] = { 0x2c68 }, 2667 [TSSC_RESET] = { 0x2ca0, 7 }, 2668 [PDM_RESET] = { 0x2cc0, 12 }, 2669 [SCSS_CORE0_RESET] = { 0x2d60, 1 }, 2670 [SCSS_CORE0_POR_RESET] = { 0x2d60 }, 2671 [SCSS_CORE1_RESET] = { 0x2d80, 1 }, 2672 [SCSS_CORE1_POR_RESET] = { 0x2d80 }, 2673 [MPM_RESET] = { 0x2da4, 1 }, 2674 [EBI1_1X_DIV_RESET] = { 0x2dec, 9 }, 2675 [EBI1_RESET] = { 0x2dec, 7 }, 2676 [SFAB_SMPSS_S_RESET] = { 0x2e00, 7 }, 2677 [USB_PHY0_RESET] = { 0x2e20 }, 2678 [USB_PHY1_RESET] = { 0x2e40 }, 2679 [PRNG_RESET] = { 0x2e80, 12 }, 2680 }; 2681 2682 static const struct regmap_config gcc_msm8660_regmap_config = { 2683 .reg_bits = 32, 2684 .reg_stride = 4, 2685 .val_bits = 32, 2686 .max_register = 0x363c, 2687 .fast_io = true, 2688 }; 2689 2690 static const struct qcom_cc_desc gcc_msm8660_desc = { 2691 .config = &gcc_msm8660_regmap_config, 2692 .clks = gcc_msm8660_clks, 2693 .num_clks = ARRAY_SIZE(gcc_msm8660_clks), 2694 .resets = gcc_msm8660_resets, 2695 .num_resets = ARRAY_SIZE(gcc_msm8660_resets), 2696 }; 2697 2698 static const struct of_device_id gcc_msm8660_match_table[] = { 2699 { .compatible = "qcom,gcc-msm8660" }, 2700 { } 2701 }; 2702 MODULE_DEVICE_TABLE(of, gcc_msm8660_match_table); 2703 2704 static int gcc_msm8660_probe(struct platform_device *pdev) 2705 { 2706 int ret; 2707 struct device *dev = &pdev->dev; 2708 2709 ret = qcom_cc_register_board_clk(dev, "cxo_board", "cxo", 19200000); 2710 if (ret) 2711 return ret; 2712 2713 ret = qcom_cc_register_board_clk(dev, "pxo_board", "pxo", 27000000); 2714 if (ret) 2715 return ret; 2716 2717 return qcom_cc_probe(pdev, &gcc_msm8660_desc); 2718 } 2719 2720 static struct platform_driver gcc_msm8660_driver = { 2721 .probe = gcc_msm8660_probe, 2722 .driver = { 2723 .name = "gcc-msm8660", 2724 .of_match_table = gcc_msm8660_match_table, 2725 }, 2726 }; 2727 2728 static int __init gcc_msm8660_init(void) 2729 { 2730 return platform_driver_register(&gcc_msm8660_driver); 2731 } 2732 core_initcall(gcc_msm8660_init); 2733 2734 static void __exit gcc_msm8660_exit(void) 2735 { 2736 platform_driver_unregister(&gcc_msm8660_driver); 2737 } 2738 module_exit(gcc_msm8660_exit); 2739 2740 MODULE_DESCRIPTION("GCC MSM 8660 Driver"); 2741 MODULE_LICENSE("GPL v2"); 2742 MODULE_ALIAS("platform:gcc-msm8660"); 2743