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

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'clk-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux

Pull clk fixes from Stephen Boyd:
"A pile of Qualcomm clk driver fixes with two main themes: the alpha
PLL driver and shared RCGs, and one fix for the Starfive JH7110 SoC.

- The Alpha PLL clk_ops had multiple problems around setting rates.

There are a handful of patches here that fix masks and skip
enabling the clk from set_rate() when the PLL is disabled. The PLLs
are crucial to operation of the system as almost all frequencies in
the system are derived from them.

- Parking shared RCGs at a slow always on clk at registration time
breaks stuff.

USB host mode can't handle such a slow frequency and the serial
console gets all garbled when the UART clk is handed over to the
kernel. There's a few patches that don't use the shared clk_ops for
the UART clks and another one to skip parking the USB clk at
registration time.

- The Starfive PLL driver used for the CPU was busted causing cpufreq
to fail because the clk didn't change to a safe parent during
set_rate().

The fix is to register a notifier and switch to a safe parent so
the PLL can change rate in a glitch free manner"

* tag 'clk-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/clk/linux:
clk: qcom: gcc-sc8280xp: don't use parking clk_ops for QUPs
clk: starfive: jh7110-sys: Add notifier for PLL0 clock
clk: qcom: gcc-sm8650: Don't use shared clk_ops for QUPs
clk: qcom: gcc-sm8550: Don't park the USB RCG at registration time
clk: qcom: gcc-sm8550: Don't use parking clk_ops for QUPs
clk: qcom: gcc-x1e80100: Don't use parking clk_ops for QUPs
clk: qcom: ipq9574: Update the alpha PLL type for GPLLs
clk: qcom: gcc-x1e80100: Fix USB 0 and 1 PHY GDSC pwrsts flags
clk: qcom: clk-alpha-pll: Update set_rate for Zonda PLL
clk: qcom: clk-alpha-pll: Fix zonda set_rate failure when PLL is disabled
clk: qcom: clk-alpha-pll: Fix the trion pll postdiv set rate API
clk: qcom: clk-alpha-pll: Fix the pll post div mask

+196 -115
+22 -3
drivers/clk/qcom/clk-alpha-pll.c
··· 40 40 41 41 #define PLL_USER_CTL(p) ((p)->offset + (p)->regs[PLL_OFF_USER_CTL]) 42 42 # define PLL_POST_DIV_SHIFT 8 43 - # define PLL_POST_DIV_MASK(p) GENMASK((p)->width, 0) 43 + # define PLL_POST_DIV_MASK(p) GENMASK((p)->width - 1, 0) 44 + # define PLL_ALPHA_MSB BIT(15) 44 45 # define PLL_ALPHA_EN BIT(24) 45 46 # define PLL_ALPHA_MODE BIT(25) 46 47 # define PLL_VCO_SHIFT 20 ··· 1553 1552 } 1554 1553 1555 1554 return regmap_update_bits(regmap, PLL_USER_CTL(pll), 1556 - PLL_POST_DIV_MASK(pll) << PLL_POST_DIV_SHIFT, 1557 - val << PLL_POST_DIV_SHIFT); 1555 + PLL_POST_DIV_MASK(pll) << pll->post_div_shift, 1556 + val << pll->post_div_shift); 1558 1557 } 1559 1558 1560 1559 const struct clk_ops clk_alpha_pll_postdiv_trion_ops = { ··· 2118 2117 regmap_write(regmap, PLL_OPMODE(pll), 0x0); 2119 2118 } 2120 2119 2120 + static void zonda_pll_adjust_l_val(unsigned long rate, unsigned long prate, u32 *l) 2121 + { 2122 + u64 remainder, quotient; 2123 + 2124 + quotient = rate; 2125 + remainder = do_div(quotient, prate); 2126 + *l = quotient; 2127 + 2128 + if ((remainder * 2) / prate) 2129 + *l = *l + 1; 2130 + } 2131 + 2121 2132 static int clk_zonda_pll_set_rate(struct clk_hw *hw, unsigned long rate, 2122 2133 unsigned long prate) 2123 2134 { ··· 2146 2133 if (ret < 0) 2147 2134 return ret; 2148 2135 2136 + if (a & PLL_ALPHA_MSB) 2137 + zonda_pll_adjust_l_val(rate, prate, &l); 2138 + 2149 2139 regmap_write(pll->clkr.regmap, PLL_ALPHA_VAL(pll), a); 2150 2140 regmap_write(pll->clkr.regmap, PLL_L_VAL(pll), l); 2141 + 2142 + if (!clk_hw_is_enabled(hw)) 2143 + return 0; 2151 2144 2152 2145 /* Wait before polling for the frequency latch */ 2153 2146 udelay(5);
+1
drivers/clk/qcom/clk-rcg.h
··· 198 198 extern const struct clk_ops clk_pixel_ops; 199 199 extern const struct clk_ops clk_gfx3d_ops; 200 200 extern const struct clk_ops clk_rcg2_shared_ops; 201 + extern const struct clk_ops clk_rcg2_shared_no_init_park_ops; 201 202 extern const struct clk_ops clk_dp_ops; 202 203 203 204 struct clk_rcg_dfs_data {
+30
drivers/clk/qcom/clk-rcg2.c
··· 1348 1348 }; 1349 1349 EXPORT_SYMBOL_GPL(clk_rcg2_shared_ops); 1350 1350 1351 + static int clk_rcg2_shared_no_init_park(struct clk_hw *hw) 1352 + { 1353 + struct clk_rcg2 *rcg = to_clk_rcg2(hw); 1354 + 1355 + /* 1356 + * Read the config register so that the parent is properly mapped at 1357 + * registration time. 1358 + */ 1359 + regmap_read(rcg->clkr.regmap, rcg->cmd_rcgr + CFG_REG, &rcg->parked_cfg); 1360 + 1361 + return 0; 1362 + } 1363 + 1364 + /* 1365 + * Like clk_rcg2_shared_ops but skip the init so that the clk frequency is left 1366 + * unchanged at registration time. 1367 + */ 1368 + const struct clk_ops clk_rcg2_shared_no_init_park_ops = { 1369 + .init = clk_rcg2_shared_no_init_park, 1370 + .enable = clk_rcg2_shared_enable, 1371 + .disable = clk_rcg2_shared_disable, 1372 + .get_parent = clk_rcg2_shared_get_parent, 1373 + .set_parent = clk_rcg2_shared_set_parent, 1374 + .recalc_rate = clk_rcg2_shared_recalc_rate, 1375 + .determine_rate = clk_rcg2_determine_rate, 1376 + .set_rate = clk_rcg2_shared_set_rate, 1377 + .set_rate_and_parent = clk_rcg2_shared_set_rate_and_parent, 1378 + }; 1379 + EXPORT_SYMBOL_GPL(clk_rcg2_shared_no_init_park_ops); 1380 + 1351 1381 /* Common APIs to be used for DFS based RCGR */ 1352 1382 static void clk_rcg2_dfs_populate_freq(struct clk_hw *hw, unsigned int l, 1353 1383 struct freq_tbl *f)
+6 -6
drivers/clk/qcom/gcc-ipq9574.c
··· 68 68 69 69 static struct clk_alpha_pll gpll0_main = { 70 70 .offset = 0x20000, 71 - .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT], 71 + .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT_EVO], 72 72 .clkr = { 73 73 .enable_reg = 0x0b000, 74 74 .enable_mask = BIT(0), ··· 96 96 97 97 static struct clk_alpha_pll_postdiv gpll0 = { 98 98 .offset = 0x20000, 99 - .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT], 99 + .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT_EVO], 100 100 .width = 4, 101 101 .clkr.hw.init = &(const struct clk_init_data) { 102 102 .name = "gpll0", ··· 110 110 111 111 static struct clk_alpha_pll gpll4_main = { 112 112 .offset = 0x22000, 113 - .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT], 113 + .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT_EVO], 114 114 .clkr = { 115 115 .enable_reg = 0x0b000, 116 116 .enable_mask = BIT(2), ··· 125 125 126 126 static struct clk_alpha_pll_postdiv gpll4 = { 127 127 .offset = 0x22000, 128 - .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT], 128 + .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT_EVO], 129 129 .width = 4, 130 130 .clkr.hw.init = &(const struct clk_init_data) { 131 131 .name = "gpll4", ··· 139 139 140 140 static struct clk_alpha_pll gpll2_main = { 141 141 .offset = 0x21000, 142 - .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT], 142 + .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT_EVO], 143 143 .clkr = { 144 144 .enable_reg = 0x0b000, 145 145 .enable_mask = BIT(1), ··· 154 154 155 155 static struct clk_alpha_pll_postdiv gpll2 = { 156 156 .offset = 0x21000, 157 - .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT], 157 + .regs = clk_alpha_pll_regs[CLK_ALPHA_PLL_TYPE_DEFAULT_EVO], 158 158 .width = 4, 159 159 .clkr.hw.init = &(const struct clk_init_data) { 160 160 .name = "gpll2",
+24 -24
drivers/clk/qcom/gcc-sc8280xp.c
··· 1500 1500 .parent_data = gcc_parent_data_0, 1501 1501 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1502 1502 .flags = CLK_SET_RATE_PARENT, 1503 - .ops = &clk_rcg2_shared_ops, 1503 + .ops = &clk_rcg2_ops, 1504 1504 }; 1505 1505 1506 1506 static struct clk_rcg2 gcc_qupv3_wrap0_s0_clk_src = { ··· 1517 1517 .parent_data = gcc_parent_data_0, 1518 1518 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1519 1519 .flags = CLK_SET_RATE_PARENT, 1520 - .ops = &clk_rcg2_shared_ops, 1520 + .ops = &clk_rcg2_ops, 1521 1521 }; 1522 1522 1523 1523 static struct clk_rcg2 gcc_qupv3_wrap0_s1_clk_src = { ··· 1534 1534 .parent_data = gcc_parent_data_0, 1535 1535 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1536 1536 .flags = CLK_SET_RATE_PARENT, 1537 - .ops = &clk_rcg2_shared_ops, 1537 + .ops = &clk_rcg2_ops, 1538 1538 }; 1539 1539 1540 1540 static struct clk_rcg2 gcc_qupv3_wrap0_s2_clk_src = { ··· 1551 1551 .parent_data = gcc_parent_data_0, 1552 1552 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1553 1553 .flags = CLK_SET_RATE_PARENT, 1554 - .ops = &clk_rcg2_shared_ops, 1554 + .ops = &clk_rcg2_ops, 1555 1555 }; 1556 1556 1557 1557 static struct clk_rcg2 gcc_qupv3_wrap0_s3_clk_src = { ··· 1568 1568 .parent_data = gcc_parent_data_0, 1569 1569 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1570 1570 .flags = CLK_SET_RATE_PARENT, 1571 - .ops = &clk_rcg2_shared_ops, 1571 + .ops = &clk_rcg2_ops, 1572 1572 }; 1573 1573 1574 1574 static struct clk_rcg2 gcc_qupv3_wrap0_s4_clk_src = { ··· 1585 1585 .parent_data = gcc_parent_data_0, 1586 1586 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1587 1587 .flags = CLK_SET_RATE_PARENT, 1588 - .ops = &clk_rcg2_shared_ops, 1588 + .ops = &clk_rcg2_ops, 1589 1589 }; 1590 1590 1591 1591 static struct clk_rcg2 gcc_qupv3_wrap0_s5_clk_src = { ··· 1617 1617 .parent_data = gcc_parent_data_0, 1618 1618 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1619 1619 .flags = CLK_SET_RATE_PARENT, 1620 - .ops = &clk_rcg2_shared_ops, 1620 + .ops = &clk_rcg2_ops, 1621 1621 }; 1622 1622 1623 1623 static struct clk_rcg2 gcc_qupv3_wrap0_s6_clk_src = { ··· 1634 1634 .parent_data = gcc_parent_data_0, 1635 1635 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1636 1636 .flags = CLK_SET_RATE_PARENT, 1637 - .ops = &clk_rcg2_shared_ops, 1637 + .ops = &clk_rcg2_ops, 1638 1638 }; 1639 1639 1640 1640 static struct clk_rcg2 gcc_qupv3_wrap0_s7_clk_src = { ··· 1651 1651 .parent_data = gcc_parent_data_0, 1652 1652 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1653 1653 .flags = CLK_SET_RATE_PARENT, 1654 - .ops = &clk_rcg2_shared_ops, 1654 + .ops = &clk_rcg2_ops, 1655 1655 }; 1656 1656 1657 1657 static struct clk_rcg2 gcc_qupv3_wrap1_s0_clk_src = { ··· 1668 1668 .parent_data = gcc_parent_data_0, 1669 1669 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1670 1670 .flags = CLK_SET_RATE_PARENT, 1671 - .ops = &clk_rcg2_shared_ops, 1671 + .ops = &clk_rcg2_ops, 1672 1672 }; 1673 1673 1674 1674 static struct clk_rcg2 gcc_qupv3_wrap1_s1_clk_src = { ··· 1685 1685 .parent_data = gcc_parent_data_0, 1686 1686 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1687 1687 .flags = CLK_SET_RATE_PARENT, 1688 - .ops = &clk_rcg2_shared_ops, 1688 + .ops = &clk_rcg2_ops, 1689 1689 }; 1690 1690 1691 1691 static struct clk_rcg2 gcc_qupv3_wrap1_s2_clk_src = { ··· 1702 1702 .parent_data = gcc_parent_data_0, 1703 1703 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1704 1704 .flags = CLK_SET_RATE_PARENT, 1705 - .ops = &clk_rcg2_shared_ops, 1705 + .ops = &clk_rcg2_ops, 1706 1706 }; 1707 1707 1708 1708 static struct clk_rcg2 gcc_qupv3_wrap1_s3_clk_src = { ··· 1719 1719 .parent_data = gcc_parent_data_0, 1720 1720 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1721 1721 .flags = CLK_SET_RATE_PARENT, 1722 - .ops = &clk_rcg2_shared_ops, 1722 + .ops = &clk_rcg2_ops, 1723 1723 }; 1724 1724 1725 1725 static struct clk_rcg2 gcc_qupv3_wrap1_s4_clk_src = { ··· 1736 1736 .parent_data = gcc_parent_data_0, 1737 1737 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1738 1738 .flags = CLK_SET_RATE_PARENT, 1739 - .ops = &clk_rcg2_shared_ops, 1739 + .ops = &clk_rcg2_ops, 1740 1740 }; 1741 1741 1742 1742 static struct clk_rcg2 gcc_qupv3_wrap1_s5_clk_src = { ··· 1753 1753 .parent_data = gcc_parent_data_0, 1754 1754 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1755 1755 .flags = CLK_SET_RATE_PARENT, 1756 - .ops = &clk_rcg2_shared_ops, 1756 + .ops = &clk_rcg2_ops, 1757 1757 }; 1758 1758 1759 1759 static struct clk_rcg2 gcc_qupv3_wrap1_s6_clk_src = { ··· 1770 1770 .parent_data = gcc_parent_data_0, 1771 1771 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1772 1772 .flags = CLK_SET_RATE_PARENT, 1773 - .ops = &clk_rcg2_shared_ops, 1773 + .ops = &clk_rcg2_ops, 1774 1774 }; 1775 1775 1776 1776 static struct clk_rcg2 gcc_qupv3_wrap1_s7_clk_src = { ··· 1787 1787 .parent_data = gcc_parent_data_0, 1788 1788 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1789 1789 .flags = CLK_SET_RATE_PARENT, 1790 - .ops = &clk_rcg2_shared_ops, 1790 + .ops = &clk_rcg2_ops, 1791 1791 }; 1792 1792 1793 1793 static struct clk_rcg2 gcc_qupv3_wrap2_s0_clk_src = { ··· 1804 1804 .parent_data = gcc_parent_data_0, 1805 1805 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1806 1806 .flags = CLK_SET_RATE_PARENT, 1807 - .ops = &clk_rcg2_shared_ops, 1807 + .ops = &clk_rcg2_ops, 1808 1808 }; 1809 1809 1810 1810 static struct clk_rcg2 gcc_qupv3_wrap2_s1_clk_src = { ··· 1821 1821 .parent_data = gcc_parent_data_0, 1822 1822 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1823 1823 .flags = CLK_SET_RATE_PARENT, 1824 - .ops = &clk_rcg2_shared_ops, 1824 + .ops = &clk_rcg2_ops, 1825 1825 }; 1826 1826 1827 1827 static struct clk_rcg2 gcc_qupv3_wrap2_s2_clk_src = { ··· 1838 1838 .parent_data = gcc_parent_data_0, 1839 1839 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1840 1840 .flags = CLK_SET_RATE_PARENT, 1841 - .ops = &clk_rcg2_shared_ops, 1841 + .ops = &clk_rcg2_ops, 1842 1842 }; 1843 1843 1844 1844 static struct clk_rcg2 gcc_qupv3_wrap2_s3_clk_src = { ··· 1855 1855 .parent_data = gcc_parent_data_0, 1856 1856 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1857 1857 .flags = CLK_SET_RATE_PARENT, 1858 - .ops = &clk_rcg2_shared_ops, 1858 + .ops = &clk_rcg2_ops, 1859 1859 }; 1860 1860 1861 1861 static struct clk_rcg2 gcc_qupv3_wrap2_s4_clk_src = { ··· 1872 1872 .parent_data = gcc_parent_data_0, 1873 1873 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1874 1874 .flags = CLK_SET_RATE_PARENT, 1875 - .ops = &clk_rcg2_shared_ops, 1875 + .ops = &clk_rcg2_ops, 1876 1876 }; 1877 1877 1878 1878 static struct clk_rcg2 gcc_qupv3_wrap2_s5_clk_src = { ··· 1889 1889 .parent_data = gcc_parent_data_0, 1890 1890 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1891 1891 .flags = CLK_SET_RATE_PARENT, 1892 - .ops = &clk_rcg2_shared_ops, 1892 + .ops = &clk_rcg2_ops, 1893 1893 }; 1894 1894 1895 1895 static struct clk_rcg2 gcc_qupv3_wrap2_s6_clk_src = { ··· 1906 1906 .parent_data = gcc_parent_data_0, 1907 1907 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1908 1908 .flags = CLK_SET_RATE_PARENT, 1909 - .ops = &clk_rcg2_shared_ops, 1909 + .ops = &clk_rcg2_ops, 1910 1910 }; 1911 1911 1912 1912 static struct clk_rcg2 gcc_qupv3_wrap2_s7_clk_src = {
+27 -27
drivers/clk/qcom/gcc-sm8550.c
··· 536 536 .parent_data = gcc_parent_data_0, 537 537 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 538 538 .flags = CLK_SET_RATE_PARENT, 539 - .ops = &clk_rcg2_shared_ops, 539 + .ops = &clk_rcg2_ops, 540 540 }, 541 541 }; 542 542 ··· 551 551 .parent_data = gcc_parent_data_0, 552 552 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 553 553 .flags = CLK_SET_RATE_PARENT, 554 - .ops = &clk_rcg2_shared_ops, 554 + .ops = &clk_rcg2_ops, 555 555 }, 556 556 }; 557 557 ··· 566 566 .parent_data = gcc_parent_data_0, 567 567 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 568 568 .flags = CLK_SET_RATE_PARENT, 569 - .ops = &clk_rcg2_shared_ops, 569 + .ops = &clk_rcg2_ops, 570 570 }, 571 571 }; 572 572 ··· 581 581 .parent_data = gcc_parent_data_0, 582 582 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 583 583 .flags = CLK_SET_RATE_PARENT, 584 - .ops = &clk_rcg2_shared_ops, 584 + .ops = &clk_rcg2_ops, 585 585 }, 586 586 }; 587 587 ··· 596 596 .parent_data = gcc_parent_data_0, 597 597 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 598 598 .flags = CLK_SET_RATE_PARENT, 599 - .ops = &clk_rcg2_shared_ops, 599 + .ops = &clk_rcg2_ops, 600 600 }, 601 601 }; 602 602 ··· 611 611 .parent_data = gcc_parent_data_0, 612 612 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 613 613 .flags = CLK_SET_RATE_PARENT, 614 - .ops = &clk_rcg2_shared_ops, 614 + .ops = &clk_rcg2_ops, 615 615 }, 616 616 }; 617 617 ··· 626 626 .parent_data = gcc_parent_data_0, 627 627 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 628 628 .flags = CLK_SET_RATE_PARENT, 629 - .ops = &clk_rcg2_shared_ops, 629 + .ops = &clk_rcg2_ops, 630 630 }, 631 631 }; 632 632 ··· 641 641 .parent_data = gcc_parent_data_0, 642 642 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 643 643 .flags = CLK_SET_RATE_PARENT, 644 - .ops = &clk_rcg2_shared_ops, 644 + .ops = &clk_rcg2_ops, 645 645 }, 646 646 }; 647 647 ··· 656 656 .parent_data = gcc_parent_data_0, 657 657 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 658 658 .flags = CLK_SET_RATE_PARENT, 659 - .ops = &clk_rcg2_shared_ops, 659 + .ops = &clk_rcg2_ops, 660 660 }, 661 661 }; 662 662 ··· 671 671 .parent_data = gcc_parent_data_0, 672 672 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 673 673 .flags = CLK_SET_RATE_PARENT, 674 - .ops = &clk_rcg2_shared_ops, 674 + .ops = &clk_rcg2_ops, 675 675 }, 676 676 }; 677 677 ··· 700 700 .parent_data = gcc_parent_data_0, 701 701 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 702 702 .flags = CLK_SET_RATE_PARENT, 703 - .ops = &clk_rcg2_shared_ops, 703 + .ops = &clk_rcg2_ops, 704 704 }; 705 705 706 706 static struct clk_rcg2 gcc_qupv3_wrap1_s0_clk_src = { ··· 717 717 .parent_data = gcc_parent_data_0, 718 718 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 719 719 .flags = CLK_SET_RATE_PARENT, 720 - .ops = &clk_rcg2_shared_ops, 720 + .ops = &clk_rcg2_ops, 721 721 }; 722 722 723 723 static struct clk_rcg2 gcc_qupv3_wrap1_s1_clk_src = { ··· 750 750 .parent_data = gcc_parent_data_0, 751 751 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 752 752 .flags = CLK_SET_RATE_PARENT, 753 - .ops = &clk_rcg2_shared_ops, 753 + .ops = &clk_rcg2_ops, 754 754 }; 755 755 756 756 static struct clk_rcg2 gcc_qupv3_wrap1_s2_clk_src = { ··· 767 767 .parent_data = gcc_parent_data_0, 768 768 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 769 769 .flags = CLK_SET_RATE_PARENT, 770 - .ops = &clk_rcg2_shared_ops, 770 + .ops = &clk_rcg2_ops, 771 771 }; 772 772 773 773 static struct clk_rcg2 gcc_qupv3_wrap1_s3_clk_src = { ··· 784 784 .parent_data = gcc_parent_data_0, 785 785 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 786 786 .flags = CLK_SET_RATE_PARENT, 787 - .ops = &clk_rcg2_shared_ops, 787 + .ops = &clk_rcg2_ops, 788 788 }; 789 789 790 790 static struct clk_rcg2 gcc_qupv3_wrap1_s4_clk_src = { ··· 801 801 .parent_data = gcc_parent_data_0, 802 802 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 803 803 .flags = CLK_SET_RATE_PARENT, 804 - .ops = &clk_rcg2_shared_ops, 804 + .ops = &clk_rcg2_ops, 805 805 }; 806 806 807 807 static struct clk_rcg2 gcc_qupv3_wrap1_s5_clk_src = { ··· 818 818 .parent_data = gcc_parent_data_0, 819 819 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 820 820 .flags = CLK_SET_RATE_PARENT, 821 - .ops = &clk_rcg2_shared_ops, 821 + .ops = &clk_rcg2_ops, 822 822 }; 823 823 824 824 static struct clk_rcg2 gcc_qupv3_wrap1_s6_clk_src = { ··· 835 835 .parent_data = gcc_parent_data_0, 836 836 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 837 837 .flags = CLK_SET_RATE_PARENT, 838 - .ops = &clk_rcg2_shared_ops, 838 + .ops = &clk_rcg2_ops, 839 839 }; 840 840 841 841 static struct clk_rcg2 gcc_qupv3_wrap1_s7_clk_src = { ··· 852 852 .parent_data = gcc_parent_data_0, 853 853 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 854 854 .flags = CLK_SET_RATE_PARENT, 855 - .ops = &clk_rcg2_shared_ops, 855 + .ops = &clk_rcg2_ops, 856 856 }; 857 857 858 858 static struct clk_rcg2 gcc_qupv3_wrap2_s0_clk_src = { ··· 869 869 .parent_data = gcc_parent_data_0, 870 870 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 871 871 .flags = CLK_SET_RATE_PARENT, 872 - .ops = &clk_rcg2_shared_ops, 872 + .ops = &clk_rcg2_ops, 873 873 }; 874 874 875 875 static struct clk_rcg2 gcc_qupv3_wrap2_s1_clk_src = { ··· 886 886 .parent_data = gcc_parent_data_0, 887 887 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 888 888 .flags = CLK_SET_RATE_PARENT, 889 - .ops = &clk_rcg2_shared_ops, 889 + .ops = &clk_rcg2_ops, 890 890 }; 891 891 892 892 static struct clk_rcg2 gcc_qupv3_wrap2_s2_clk_src = { ··· 903 903 .parent_data = gcc_parent_data_0, 904 904 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 905 905 .flags = CLK_SET_RATE_PARENT, 906 - .ops = &clk_rcg2_shared_ops, 906 + .ops = &clk_rcg2_ops, 907 907 }; 908 908 909 909 static struct clk_rcg2 gcc_qupv3_wrap2_s3_clk_src = { ··· 920 920 .parent_data = gcc_parent_data_0, 921 921 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 922 922 .flags = CLK_SET_RATE_PARENT, 923 - .ops = &clk_rcg2_shared_ops, 923 + .ops = &clk_rcg2_ops, 924 924 }; 925 925 926 926 static struct clk_rcg2 gcc_qupv3_wrap2_s4_clk_src = { ··· 937 937 .parent_data = gcc_parent_data_0, 938 938 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 939 939 .flags = CLK_SET_RATE_PARENT, 940 - .ops = &clk_rcg2_shared_ops, 940 + .ops = &clk_rcg2_ops, 941 941 }; 942 942 943 943 static struct clk_rcg2 gcc_qupv3_wrap2_s5_clk_src = { ··· 975 975 .parent_data = gcc_parent_data_8, 976 976 .num_parents = ARRAY_SIZE(gcc_parent_data_8), 977 977 .flags = CLK_SET_RATE_PARENT, 978 - .ops = &clk_rcg2_shared_ops, 978 + .ops = &clk_rcg2_ops, 979 979 }; 980 980 981 981 static struct clk_rcg2 gcc_qupv3_wrap2_s6_clk_src = { ··· 992 992 .parent_data = gcc_parent_data_0, 993 993 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 994 994 .flags = CLK_SET_RATE_PARENT, 995 - .ops = &clk_rcg2_shared_ops, 995 + .ops = &clk_rcg2_ops, 996 996 }; 997 997 998 998 static struct clk_rcg2 gcc_qupv3_wrap2_s7_clk_src = { ··· 1159 1159 .parent_data = gcc_parent_data_0, 1160 1160 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1161 1161 .flags = CLK_SET_RATE_PARENT, 1162 - .ops = &clk_rcg2_shared_ops, 1162 + .ops = &clk_rcg2_shared_no_init_park_ops, 1163 1163 }, 1164 1164 }; 1165 1165
+28 -28
drivers/clk/qcom/gcc-sm8650.c
··· 713 713 .parent_data = gcc_parent_data_0, 714 714 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 715 715 .flags = CLK_SET_RATE_PARENT, 716 - .ops = &clk_rcg2_shared_ops, 716 + .ops = &clk_rcg2_ops, 717 717 }, 718 718 }; 719 719 ··· 728 728 .parent_data = gcc_parent_data_0, 729 729 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 730 730 .flags = CLK_SET_RATE_PARENT, 731 - .ops = &clk_rcg2_shared_ops, 731 + .ops = &clk_rcg2_ops, 732 732 }, 733 733 }; 734 734 ··· 743 743 .parent_data = gcc_parent_data_0, 744 744 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 745 745 .flags = CLK_SET_RATE_PARENT, 746 - .ops = &clk_rcg2_shared_ops, 746 + .ops = &clk_rcg2_ops, 747 747 }, 748 748 }; 749 749 ··· 758 758 .parent_data = gcc_parent_data_0, 759 759 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 760 760 .flags = CLK_SET_RATE_PARENT, 761 - .ops = &clk_rcg2_shared_ops, 761 + .ops = &clk_rcg2_ops, 762 762 }, 763 763 }; 764 764 ··· 773 773 .parent_data = gcc_parent_data_0, 774 774 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 775 775 .flags = CLK_SET_RATE_PARENT, 776 - .ops = &clk_rcg2_shared_ops, 776 + .ops = &clk_rcg2_ops, 777 777 }, 778 778 }; 779 779 ··· 788 788 .parent_data = gcc_parent_data_0, 789 789 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 790 790 .flags = CLK_SET_RATE_PARENT, 791 - .ops = &clk_rcg2_shared_ops, 791 + .ops = &clk_rcg2_ops, 792 792 }, 793 793 }; 794 794 ··· 803 803 .parent_data = gcc_parent_data_0, 804 804 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 805 805 .flags = CLK_SET_RATE_PARENT, 806 - .ops = &clk_rcg2_shared_ops, 806 + .ops = &clk_rcg2_ops, 807 807 }, 808 808 }; 809 809 ··· 818 818 .parent_data = gcc_parent_data_0, 819 819 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 820 820 .flags = CLK_SET_RATE_PARENT, 821 - .ops = &clk_rcg2_shared_ops, 821 + .ops = &clk_rcg2_ops, 822 822 }, 823 823 }; 824 824 ··· 833 833 .parent_data = gcc_parent_data_0, 834 834 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 835 835 .flags = CLK_SET_RATE_PARENT, 836 - .ops = &clk_rcg2_shared_ops, 836 + .ops = &clk_rcg2_ops, 837 837 }, 838 838 }; 839 839 ··· 848 848 .parent_data = gcc_parent_data_0, 849 849 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 850 850 .flags = CLK_SET_RATE_PARENT, 851 - .ops = &clk_rcg2_shared_ops, 851 + .ops = &clk_rcg2_ops, 852 852 }, 853 853 }; 854 854 ··· 863 863 .parent_data = gcc_parent_data_0, 864 864 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 865 865 .flags = CLK_SET_RATE_PARENT, 866 - .ops = &clk_rcg2_shared_ops, 866 + .ops = &clk_rcg2_ops, 867 867 }; 868 868 869 869 static struct clk_rcg2 gcc_qupv3_wrap1_qspi_ref_clk_src = { ··· 899 899 .parent_data = gcc_parent_data_0, 900 900 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 901 901 .flags = CLK_SET_RATE_PARENT, 902 - .ops = &clk_rcg2_shared_ops, 902 + .ops = &clk_rcg2_ops, 903 903 }; 904 904 905 905 static struct clk_rcg2 gcc_qupv3_wrap1_s0_clk_src = { ··· 916 916 .parent_data = gcc_parent_data_0, 917 917 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 918 918 .flags = CLK_SET_RATE_PARENT, 919 - .ops = &clk_rcg2_shared_ops, 919 + .ops = &clk_rcg2_ops, 920 920 }; 921 921 922 922 static struct clk_rcg2 gcc_qupv3_wrap1_s1_clk_src = { ··· 948 948 .parent_data = gcc_parent_data_0, 949 949 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 950 950 .flags = CLK_SET_RATE_PARENT, 951 - .ops = &clk_rcg2_shared_ops, 951 + .ops = &clk_rcg2_ops, 952 952 }; 953 953 954 954 static struct clk_rcg2 gcc_qupv3_wrap1_s3_clk_src = { ··· 980 980 .parent_data = gcc_parent_data_0, 981 981 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 982 982 .flags = CLK_SET_RATE_PARENT, 983 - .ops = &clk_rcg2_shared_ops, 983 + .ops = &clk_rcg2_ops, 984 984 }; 985 985 986 986 static struct clk_rcg2 gcc_qupv3_wrap1_s4_clk_src = { ··· 997 997 .parent_data = gcc_parent_data_0, 998 998 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 999 999 .flags = CLK_SET_RATE_PARENT, 1000 - .ops = &clk_rcg2_shared_ops, 1000 + .ops = &clk_rcg2_ops, 1001 1001 }; 1002 1002 1003 1003 static struct clk_rcg2 gcc_qupv3_wrap1_s5_clk_src = { ··· 1014 1014 .parent_data = gcc_parent_data_0, 1015 1015 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1016 1016 .flags = CLK_SET_RATE_PARENT, 1017 - .ops = &clk_rcg2_shared_ops, 1017 + .ops = &clk_rcg2_ops, 1018 1018 }; 1019 1019 1020 1020 static struct clk_rcg2 gcc_qupv3_wrap1_s6_clk_src = { ··· 1031 1031 .parent_data = gcc_parent_data_0, 1032 1032 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1033 1033 .flags = CLK_SET_RATE_PARENT, 1034 - .ops = &clk_rcg2_shared_ops, 1034 + .ops = &clk_rcg2_ops, 1035 1035 }; 1036 1036 1037 1037 static struct clk_rcg2 gcc_qupv3_wrap1_s7_clk_src = { ··· 1059 1059 .parent_data = gcc_parent_data_2, 1060 1060 .num_parents = ARRAY_SIZE(gcc_parent_data_2), 1061 1061 .flags = CLK_SET_RATE_PARENT, 1062 - .ops = &clk_rcg2_shared_ops, 1062 + .ops = &clk_rcg2_ops, 1063 1063 }, 1064 1064 }; 1065 1065 ··· 1068 1068 .parent_data = gcc_parent_data_0, 1069 1069 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1070 1070 .flags = CLK_SET_RATE_PARENT, 1071 - .ops = &clk_rcg2_shared_ops, 1071 + .ops = &clk_rcg2_ops, 1072 1072 }; 1073 1073 1074 1074 static struct clk_rcg2 gcc_qupv3_wrap2_s0_clk_src = { ··· 1085 1085 .parent_data = gcc_parent_data_0, 1086 1086 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1087 1087 .flags = CLK_SET_RATE_PARENT, 1088 - .ops = &clk_rcg2_shared_ops, 1088 + .ops = &clk_rcg2_ops, 1089 1089 }; 1090 1090 1091 1091 static struct clk_rcg2 gcc_qupv3_wrap2_s1_clk_src = { ··· 1102 1102 .parent_data = gcc_parent_data_0, 1103 1103 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1104 1104 .flags = CLK_SET_RATE_PARENT, 1105 - .ops = &clk_rcg2_shared_ops, 1105 + .ops = &clk_rcg2_ops, 1106 1106 }; 1107 1107 1108 1108 static struct clk_rcg2 gcc_qupv3_wrap2_s2_clk_src = { ··· 1119 1119 .parent_data = gcc_parent_data_0, 1120 1120 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1121 1121 .flags = CLK_SET_RATE_PARENT, 1122 - .ops = &clk_rcg2_shared_ops, 1122 + .ops = &clk_rcg2_ops, 1123 1123 }; 1124 1124 1125 1125 static struct clk_rcg2 gcc_qupv3_wrap2_s3_clk_src = { ··· 1136 1136 .parent_data = gcc_parent_data_0, 1137 1137 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1138 1138 .flags = CLK_SET_RATE_PARENT, 1139 - .ops = &clk_rcg2_shared_ops, 1139 + .ops = &clk_rcg2_ops, 1140 1140 }; 1141 1141 1142 1142 static struct clk_rcg2 gcc_qupv3_wrap2_s4_clk_src = { ··· 1153 1153 .parent_data = gcc_parent_data_0, 1154 1154 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1155 1155 .flags = CLK_SET_RATE_PARENT, 1156 - .ops = &clk_rcg2_shared_ops, 1156 + .ops = &clk_rcg2_ops, 1157 1157 }; 1158 1158 1159 1159 static struct clk_rcg2 gcc_qupv3_wrap2_s5_clk_src = { ··· 1186 1186 .parent_data = gcc_parent_data_10, 1187 1187 .num_parents = ARRAY_SIZE(gcc_parent_data_10), 1188 1188 .flags = CLK_SET_RATE_PARENT, 1189 - .ops = &clk_rcg2_shared_ops, 1189 + .ops = &clk_rcg2_ops, 1190 1190 }; 1191 1191 1192 1192 static struct clk_rcg2 gcc_qupv3_wrap2_s6_clk_src = { ··· 1203 1203 .parent_data = gcc_parent_data_0, 1204 1204 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1205 1205 .flags = CLK_SET_RATE_PARENT, 1206 - .ops = &clk_rcg2_shared_ops, 1206 + .ops = &clk_rcg2_ops, 1207 1207 }; 1208 1208 1209 1209 static struct clk_rcg2 gcc_qupv3_wrap2_s7_clk_src = { ··· 1226 1226 .parent_data = gcc_parent_data_0, 1227 1227 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1228 1228 .flags = CLK_SET_RATE_PARENT, 1229 - .ops = &clk_rcg2_shared_ops, 1229 + .ops = &clk_rcg2_ops, 1230 1230 }; 1231 1231 1232 1232 static struct clk_rcg2 gcc_qupv3_wrap3_qspi_ref_clk_src = {
+26 -26
drivers/clk/qcom/gcc-x1e80100.c
··· 670 670 .parent_data = gcc_parent_data_0, 671 671 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 672 672 .flags = CLK_SET_RATE_PARENT, 673 - .ops = &clk_rcg2_shared_ops, 673 + .ops = &clk_rcg2_ops, 674 674 }; 675 675 676 676 static struct clk_rcg2 gcc_qupv3_wrap0_s0_clk_src = { ··· 687 687 .parent_data = gcc_parent_data_0, 688 688 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 689 689 .flags = CLK_SET_RATE_PARENT, 690 - .ops = &clk_rcg2_shared_ops, 690 + .ops = &clk_rcg2_ops, 691 691 }; 692 692 693 693 static struct clk_rcg2 gcc_qupv3_wrap0_s1_clk_src = { ··· 719 719 .parent_data = gcc_parent_data_0, 720 720 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 721 721 .flags = CLK_SET_RATE_PARENT, 722 - .ops = &clk_rcg2_shared_ops, 722 + .ops = &clk_rcg2_ops, 723 723 }; 724 724 725 725 static struct clk_rcg2 gcc_qupv3_wrap0_s2_clk_src = { ··· 736 736 .parent_data = gcc_parent_data_0, 737 737 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 738 738 .flags = CLK_SET_RATE_PARENT, 739 - .ops = &clk_rcg2_shared_ops, 739 + .ops = &clk_rcg2_ops, 740 740 }; 741 741 742 742 static struct clk_rcg2 gcc_qupv3_wrap0_s3_clk_src = { ··· 768 768 .parent_data = gcc_parent_data_0, 769 769 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 770 770 .flags = CLK_SET_RATE_PARENT, 771 - .ops = &clk_rcg2_shared_ops, 771 + .ops = &clk_rcg2_ops, 772 772 }; 773 773 774 774 static struct clk_rcg2 gcc_qupv3_wrap0_s4_clk_src = { ··· 785 785 .parent_data = gcc_parent_data_0, 786 786 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 787 787 .flags = CLK_SET_RATE_PARENT, 788 - .ops = &clk_rcg2_shared_ops, 788 + .ops = &clk_rcg2_ops, 789 789 }; 790 790 791 791 static struct clk_rcg2 gcc_qupv3_wrap0_s5_clk_src = { ··· 802 802 .parent_data = gcc_parent_data_0, 803 803 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 804 804 .flags = CLK_SET_RATE_PARENT, 805 - .ops = &clk_rcg2_shared_ops, 805 + .ops = &clk_rcg2_ops, 806 806 }; 807 807 808 808 static struct clk_rcg2 gcc_qupv3_wrap0_s6_clk_src = { ··· 819 819 .parent_data = gcc_parent_data_0, 820 820 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 821 821 .flags = CLK_SET_RATE_PARENT, 822 - .ops = &clk_rcg2_shared_ops, 822 + .ops = &clk_rcg2_ops, 823 823 }; 824 824 825 825 static struct clk_rcg2 gcc_qupv3_wrap0_s7_clk_src = { ··· 836 836 .parent_data = gcc_parent_data_0, 837 837 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 838 838 .flags = CLK_SET_RATE_PARENT, 839 - .ops = &clk_rcg2_shared_ops, 839 + .ops = &clk_rcg2_ops, 840 840 }; 841 841 842 842 static struct clk_rcg2 gcc_qupv3_wrap1_s0_clk_src = { ··· 853 853 .parent_data = gcc_parent_data_0, 854 854 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 855 855 .flags = CLK_SET_RATE_PARENT, 856 - .ops = &clk_rcg2_shared_ops, 856 + .ops = &clk_rcg2_ops, 857 857 }; 858 858 859 859 static struct clk_rcg2 gcc_qupv3_wrap1_s1_clk_src = { ··· 870 870 .parent_data = gcc_parent_data_0, 871 871 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 872 872 .flags = CLK_SET_RATE_PARENT, 873 - .ops = &clk_rcg2_shared_ops, 873 + .ops = &clk_rcg2_ops, 874 874 }; 875 875 876 876 static struct clk_rcg2 gcc_qupv3_wrap1_s2_clk_src = { ··· 887 887 .parent_data = gcc_parent_data_0, 888 888 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 889 889 .flags = CLK_SET_RATE_PARENT, 890 - .ops = &clk_rcg2_shared_ops, 890 + .ops = &clk_rcg2_ops, 891 891 }; 892 892 893 893 static struct clk_rcg2 gcc_qupv3_wrap1_s3_clk_src = { ··· 904 904 .parent_data = gcc_parent_data_0, 905 905 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 906 906 .flags = CLK_SET_RATE_PARENT, 907 - .ops = &clk_rcg2_shared_ops, 907 + .ops = &clk_rcg2_ops, 908 908 }; 909 909 910 910 static struct clk_rcg2 gcc_qupv3_wrap1_s4_clk_src = { ··· 921 921 .parent_data = gcc_parent_data_0, 922 922 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 923 923 .flags = CLK_SET_RATE_PARENT, 924 - .ops = &clk_rcg2_shared_ops, 924 + .ops = &clk_rcg2_ops, 925 925 }; 926 926 927 927 static struct clk_rcg2 gcc_qupv3_wrap1_s5_clk_src = { ··· 938 938 .parent_data = gcc_parent_data_0, 939 939 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 940 940 .flags = CLK_SET_RATE_PARENT, 941 - .ops = &clk_rcg2_shared_ops, 941 + .ops = &clk_rcg2_ops, 942 942 }; 943 943 944 944 static struct clk_rcg2 gcc_qupv3_wrap1_s6_clk_src = { ··· 955 955 .parent_data = gcc_parent_data_0, 956 956 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 957 957 .flags = CLK_SET_RATE_PARENT, 958 - .ops = &clk_rcg2_shared_ops, 958 + .ops = &clk_rcg2_ops, 959 959 }; 960 960 961 961 static struct clk_rcg2 gcc_qupv3_wrap1_s7_clk_src = { ··· 972 972 .parent_data = gcc_parent_data_0, 973 973 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 974 974 .flags = CLK_SET_RATE_PARENT, 975 - .ops = &clk_rcg2_shared_ops, 975 + .ops = &clk_rcg2_ops, 976 976 }; 977 977 978 978 static struct clk_rcg2 gcc_qupv3_wrap2_s0_clk_src = { ··· 989 989 .parent_data = gcc_parent_data_0, 990 990 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 991 991 .flags = CLK_SET_RATE_PARENT, 992 - .ops = &clk_rcg2_shared_ops, 992 + .ops = &clk_rcg2_ops, 993 993 }; 994 994 995 995 static struct clk_rcg2 gcc_qupv3_wrap2_s1_clk_src = { ··· 1006 1006 .parent_data = gcc_parent_data_0, 1007 1007 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1008 1008 .flags = CLK_SET_RATE_PARENT, 1009 - .ops = &clk_rcg2_shared_ops, 1009 + .ops = &clk_rcg2_ops, 1010 1010 }; 1011 1011 1012 1012 static struct clk_rcg2 gcc_qupv3_wrap2_s2_clk_src = { ··· 1023 1023 .parent_data = gcc_parent_data_0, 1024 1024 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1025 1025 .flags = CLK_SET_RATE_PARENT, 1026 - .ops = &clk_rcg2_shared_ops, 1026 + .ops = &clk_rcg2_ops, 1027 1027 }; 1028 1028 1029 1029 static struct clk_rcg2 gcc_qupv3_wrap2_s3_clk_src = { ··· 1040 1040 .parent_data = gcc_parent_data_0, 1041 1041 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1042 1042 .flags = CLK_SET_RATE_PARENT, 1043 - .ops = &clk_rcg2_shared_ops, 1043 + .ops = &clk_rcg2_ops, 1044 1044 }; 1045 1045 1046 1046 static struct clk_rcg2 gcc_qupv3_wrap2_s4_clk_src = { ··· 1057 1057 .parent_data = gcc_parent_data_0, 1058 1058 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1059 1059 .flags = CLK_SET_RATE_PARENT, 1060 - .ops = &clk_rcg2_shared_ops, 1060 + .ops = &clk_rcg2_ops, 1061 1061 }; 1062 1062 1063 1063 static struct clk_rcg2 gcc_qupv3_wrap2_s5_clk_src = { ··· 1074 1074 .parent_data = gcc_parent_data_8, 1075 1075 .num_parents = ARRAY_SIZE(gcc_parent_data_8), 1076 1076 .flags = CLK_SET_RATE_PARENT, 1077 - .ops = &clk_rcg2_shared_ops, 1077 + .ops = &clk_rcg2_ops, 1078 1078 }; 1079 1079 1080 1080 static struct clk_rcg2 gcc_qupv3_wrap2_s6_clk_src = { ··· 1091 1091 .parent_data = gcc_parent_data_0, 1092 1092 .num_parents = ARRAY_SIZE(gcc_parent_data_0), 1093 1093 .flags = CLK_SET_RATE_PARENT, 1094 - .ops = &clk_rcg2_shared_ops, 1094 + .ops = &clk_rcg2_ops, 1095 1095 }; 1096 1096 1097 1097 static struct clk_rcg2 gcc_qupv3_wrap2_s7_clk_src = { ··· 6203 6203 .pd = { 6204 6204 .name = "gcc_usb_0_phy_gdsc", 6205 6205 }, 6206 - .pwrsts = PWRSTS_OFF_ON, 6206 + .pwrsts = PWRSTS_RET_ON, 6207 6207 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE, 6208 6208 }; 6209 6209 ··· 6215 6215 .pd = { 6216 6216 .name = "gcc_usb_1_phy_gdsc", 6217 6217 }, 6218 - .pwrsts = PWRSTS_OFF_ON, 6218 + .pwrsts = PWRSTS_RET_ON, 6219 6219 .flags = POLL_CFG_GDSCR | RETAIN_FF_ENABLE, 6220 6220 }; 6221 6221
+30 -1
drivers/clk/starfive/clk-starfive-jh7110-sys.c
··· 385 385 } 386 386 EXPORT_SYMBOL_GPL(jh7110_reset_controller_register); 387 387 388 + /* 389 + * This clock notifier is called when the rate of PLL0 clock is to be changed. 390 + * The cpu_root clock should save the curent parent clock and switch its parent 391 + * clock to osc before PLL0 rate will be changed. Then switch its parent clock 392 + * back after the PLL0 rate is completed. 393 + */ 394 + static int jh7110_pll0_clk_notifier_cb(struct notifier_block *nb, 395 + unsigned long action, void *data) 396 + { 397 + struct jh71x0_clk_priv *priv = container_of(nb, struct jh71x0_clk_priv, pll_clk_nb); 398 + struct clk *cpu_root = priv->reg[JH7110_SYSCLK_CPU_ROOT].hw.clk; 399 + int ret = 0; 400 + 401 + if (action == PRE_RATE_CHANGE) { 402 + struct clk *osc = clk_get(priv->dev, "osc"); 403 + 404 + priv->original_clk = clk_get_parent(cpu_root); 405 + ret = clk_set_parent(cpu_root, osc); 406 + clk_put(osc); 407 + } else if (action == POST_RATE_CHANGE) { 408 + ret = clk_set_parent(cpu_root, priv->original_clk); 409 + } 410 + 411 + return notifier_from_errno(ret); 412 + } 413 + 388 414 static int __init jh7110_syscrg_probe(struct platform_device *pdev) 389 415 { 390 416 struct jh71x0_clk_priv *priv; ··· 439 413 if (IS_ERR(priv->pll[0])) 440 414 return PTR_ERR(priv->pll[0]); 441 415 } else { 442 - clk_put(pllclk); 416 + priv->pll_clk_nb.notifier_call = jh7110_pll0_clk_notifier_cb; 417 + ret = clk_notifier_register(pllclk, &priv->pll_clk_nb); 418 + if (ret) 419 + return ret; 443 420 priv->pll[0] = NULL; 444 421 } 445 422
+2
drivers/clk/starfive/clk-starfive-jh71x0.h
··· 114 114 spinlock_t rmw_lock; 115 115 struct device *dev; 116 116 void __iomem *base; 117 + struct clk *original_clk; 118 + struct notifier_block pll_clk_nb; 117 119 struct clk_hw *pll[3]; 118 120 struct jh71x0_clk reg[]; 119 121 };