rcar-usb2-clock-sel.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Renesas R-Car USB2.0 clock selector
  4. *
  5. * Copyright (C) 2017 Renesas Electronics Corp.
  6. *
  7. * Based on renesas-cpg-mssr.c
  8. *
  9. * Copyright (C) 2015 Glider bvba
  10. */
  11. #include <linux/clk.h>
  12. #include <linux/clk-provider.h>
  13. #include <linux/device.h>
  14. #include <linux/init.h>
  15. #include <linux/io.h>
  16. #include <linux/module.h>
  17. #include <linux/of_device.h>
  18. #include <linux/platform_device.h>
  19. #include <linux/pm.h>
  20. #include <linux/pm_runtime.h>
  21. #include <linux/reset.h>
  22. #include <linux/slab.h>
  23. #define USB20_CLKSET0 0x00
  24. #define CLKSET0_INTCLK_EN BIT(11)
  25. #define CLKSET0_PRIVATE BIT(0)
  26. #define CLKSET0_EXTAL_ONLY (CLKSET0_INTCLK_EN | CLKSET0_PRIVATE)
  27. static const struct clk_bulk_data rcar_usb2_clocks[] = {
  28. { .id = "ehci_ohci", },
  29. { .id = "hs-usb-if", },
  30. };
  31. struct usb2_clock_sel_priv {
  32. void __iomem *base;
  33. struct clk_hw hw;
  34. struct clk_bulk_data clks[ARRAY_SIZE(rcar_usb2_clocks)];
  35. struct reset_control *rsts;
  36. bool extal;
  37. bool xtal;
  38. };
  39. #define to_priv(_hw) container_of(_hw, struct usb2_clock_sel_priv, hw)
  40. static void usb2_clock_sel_enable_extal_only(struct usb2_clock_sel_priv *priv)
  41. {
  42. u16 val = readw(priv->base + USB20_CLKSET0);
  43. pr_debug("%s: enter %d %d %x\n", __func__,
  44. priv->extal, priv->xtal, val);
  45. if (priv->extal && !priv->xtal && val != CLKSET0_EXTAL_ONLY)
  46. writew(CLKSET0_EXTAL_ONLY, priv->base + USB20_CLKSET0);
  47. }
  48. static void usb2_clock_sel_disable_extal_only(struct usb2_clock_sel_priv *priv)
  49. {
  50. if (priv->extal && !priv->xtal)
  51. writew(CLKSET0_PRIVATE, priv->base + USB20_CLKSET0);
  52. }
  53. static int usb2_clock_sel_enable(struct clk_hw *hw)
  54. {
  55. struct usb2_clock_sel_priv *priv = to_priv(hw);
  56. int ret;
  57. ret = reset_control_deassert(priv->rsts);
  58. if (ret)
  59. return ret;
  60. ret = clk_bulk_prepare_enable(ARRAY_SIZE(priv->clks), priv->clks);
  61. if (ret) {
  62. reset_control_assert(priv->rsts);
  63. return ret;
  64. }
  65. usb2_clock_sel_enable_extal_only(priv);
  66. return 0;
  67. }
  68. static void usb2_clock_sel_disable(struct clk_hw *hw)
  69. {
  70. struct usb2_clock_sel_priv *priv = to_priv(hw);
  71. usb2_clock_sel_disable_extal_only(priv);
  72. clk_bulk_disable_unprepare(ARRAY_SIZE(priv->clks), priv->clks);
  73. reset_control_assert(priv->rsts);
  74. }
  75. /*
  76. * This module seems a mux, but this driver assumes a gate because
  77. * ehci/ohci platform drivers don't support clk_set_parent() for now.
  78. * If this driver acts as a gate, ehci/ohci-platform drivers don't need
  79. * any modification.
  80. */
  81. static const struct clk_ops usb2_clock_sel_clock_ops = {
  82. .enable = usb2_clock_sel_enable,
  83. .disable = usb2_clock_sel_disable,
  84. };
  85. static const struct of_device_id rcar_usb2_clock_sel_match[] = {
  86. { .compatible = "renesas,rcar-gen3-usb2-clock-sel" },
  87. { }
  88. };
  89. static int rcar_usb2_clock_sel_suspend(struct device *dev)
  90. {
  91. struct usb2_clock_sel_priv *priv = dev_get_drvdata(dev);
  92. usb2_clock_sel_disable_extal_only(priv);
  93. pm_runtime_put(dev);
  94. return 0;
  95. }
  96. static int rcar_usb2_clock_sel_resume(struct device *dev)
  97. {
  98. struct usb2_clock_sel_priv *priv = dev_get_drvdata(dev);
  99. pm_runtime_get_sync(dev);
  100. usb2_clock_sel_enable_extal_only(priv);
  101. return 0;
  102. }
  103. static int rcar_usb2_clock_sel_remove(struct platform_device *pdev)
  104. {
  105. struct device *dev = &pdev->dev;
  106. of_clk_del_provider(dev->of_node);
  107. pm_runtime_put(dev);
  108. pm_runtime_disable(dev);
  109. return 0;
  110. }
  111. static int rcar_usb2_clock_sel_probe(struct platform_device *pdev)
  112. {
  113. struct device *dev = &pdev->dev;
  114. struct device_node *np = dev->of_node;
  115. struct usb2_clock_sel_priv *priv;
  116. struct clk *clk;
  117. struct clk_init_data init;
  118. int ret;
  119. priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
  120. if (!priv)
  121. return -ENOMEM;
  122. priv->base = devm_platform_ioremap_resource(pdev, 0);
  123. if (IS_ERR(priv->base))
  124. return PTR_ERR(priv->base);
  125. memcpy(priv->clks, rcar_usb2_clocks, sizeof(priv->clks));
  126. ret = devm_clk_bulk_get(dev, ARRAY_SIZE(priv->clks), priv->clks);
  127. if (ret < 0)
  128. return ret;
  129. priv->rsts = devm_reset_control_array_get(dev, true, false);
  130. if (IS_ERR(priv->rsts))
  131. return PTR_ERR(priv->rsts);
  132. clk = devm_clk_get(dev, "usb_extal");
  133. if (!IS_ERR(clk) && !clk_prepare_enable(clk)) {
  134. priv->extal = !!clk_get_rate(clk);
  135. clk_disable_unprepare(clk);
  136. }
  137. clk = devm_clk_get(dev, "usb_xtal");
  138. if (!IS_ERR(clk) && !clk_prepare_enable(clk)) {
  139. priv->xtal = !!clk_get_rate(clk);
  140. clk_disable_unprepare(clk);
  141. }
  142. if (!priv->extal && !priv->xtal) {
  143. dev_err(dev, "This driver needs usb_extal or usb_xtal\n");
  144. return -ENOENT;
  145. }
  146. pm_runtime_enable(dev);
  147. pm_runtime_get_sync(dev);
  148. platform_set_drvdata(pdev, priv);
  149. dev_set_drvdata(dev, priv);
  150. init.name = "rcar_usb2_clock_sel";
  151. init.ops = &usb2_clock_sel_clock_ops;
  152. init.flags = 0;
  153. init.parent_names = NULL;
  154. init.num_parents = 0;
  155. priv->hw.init = &init;
  156. ret = devm_clk_hw_register(dev, &priv->hw);
  157. if (ret)
  158. goto pm_put;
  159. ret = of_clk_add_hw_provider(np, of_clk_hw_simple_get, &priv->hw);
  160. if (ret)
  161. goto pm_put;
  162. return 0;
  163. pm_put:
  164. pm_runtime_put(dev);
  165. pm_runtime_disable(dev);
  166. return ret;
  167. }
  168. static const struct dev_pm_ops rcar_usb2_clock_sel_pm_ops = {
  169. .suspend = rcar_usb2_clock_sel_suspend,
  170. .resume = rcar_usb2_clock_sel_resume,
  171. };
  172. static struct platform_driver rcar_usb2_clock_sel_driver = {
  173. .driver = {
  174. .name = "rcar-usb2-clock-sel",
  175. .of_match_table = rcar_usb2_clock_sel_match,
  176. .pm = &rcar_usb2_clock_sel_pm_ops,
  177. },
  178. .probe = rcar_usb2_clock_sel_probe,
  179. .remove = rcar_usb2_clock_sel_remove,
  180. };
  181. builtin_platform_driver(rcar_usb2_clock_sel_driver);
  182. MODULE_DESCRIPTION("Renesas R-Car USB2 clock selector Driver");
  183. MODULE_LICENSE("GPL v2");