ehci-generic.c 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015 Alexey Brodkin <abrodkin@synopsys.com>
  4. */
  5. #include <common.h>
  6. #include <clk.h>
  7. #include <dm/device_compat.h>
  8. #include <dm/devres.h>
  9. #include <dm/ofnode.h>
  10. #include <generic-phy.h>
  11. #include <reset.h>
  12. #include <asm/io.h>
  13. #include <dm.h>
  14. #include "ehci.h"
  15. #include <power/regulator.h>
  16. /*
  17. * Even though here we don't explicitly use "struct ehci_ctrl"
  18. * ehci_register() expects it to be the first thing that resides in
  19. * device's private data.
  20. */
  21. struct generic_ehci {
  22. struct ehci_ctrl ctrl;
  23. struct clk *clocks;
  24. struct reset_ctl *resets;
  25. struct phy phy;
  26. #ifdef CONFIG_DM_REGULATOR
  27. struct udevice *vbus_supply;
  28. #endif
  29. int clock_count;
  30. int reset_count;
  31. };
  32. #ifdef CONFIG_DM_REGULATOR
  33. static int ehci_enable_vbus_supply(struct udevice *dev)
  34. {
  35. struct generic_ehci *priv = dev_get_priv(dev);
  36. int ret;
  37. ret = device_get_supply_regulator(dev, "vbus-supply",
  38. &priv->vbus_supply);
  39. if (ret && ret != -ENOENT)
  40. return ret;
  41. if (priv->vbus_supply) {
  42. ret = regulator_set_enable(priv->vbus_supply, true);
  43. if (ret) {
  44. dev_err(dev, "Error enabling VBUS supply\n");
  45. return ret;
  46. }
  47. } else {
  48. dev_dbg(dev, "No vbus supply\n");
  49. }
  50. return 0;
  51. }
  52. static int ehci_disable_vbus_supply(struct generic_ehci *priv)
  53. {
  54. if (priv->vbus_supply)
  55. return regulator_set_enable(priv->vbus_supply, false);
  56. else
  57. return 0;
  58. }
  59. #else
  60. static int ehci_enable_vbus_supply(struct udevice *dev)
  61. {
  62. return 0;
  63. }
  64. static int ehci_disable_vbus_supply(struct generic_ehci *priv)
  65. {
  66. return 0;
  67. }
  68. #endif
  69. static int ehci_usb_probe(struct udevice *dev)
  70. {
  71. struct generic_ehci *priv = dev_get_priv(dev);
  72. struct ehci_hccr *hccr;
  73. struct ehci_hcor *hcor;
  74. int i, err, ret, clock_nb, reset_nb;
  75. err = 0;
  76. priv->clock_count = 0;
  77. clock_nb = ofnode_count_phandle_with_args(dev_ofnode(dev), "clocks",
  78. "#clock-cells");
  79. if (clock_nb > 0) {
  80. priv->clocks = devm_kcalloc(dev, clock_nb, sizeof(struct clk),
  81. GFP_KERNEL);
  82. if (!priv->clocks)
  83. return -ENOMEM;
  84. for (i = 0; i < clock_nb; i++) {
  85. err = clk_get_by_index(dev, i, &priv->clocks[i]);
  86. if (err < 0)
  87. break;
  88. err = clk_enable(&priv->clocks[i]);
  89. if (err && err != -ENOSYS) {
  90. dev_err(dev, "failed to enable clock %d\n", i);
  91. clk_free(&priv->clocks[i]);
  92. goto clk_err;
  93. }
  94. priv->clock_count++;
  95. }
  96. } else {
  97. if (clock_nb != -ENOENT) {
  98. dev_err(dev, "failed to get clock phandle(%d)\n",
  99. clock_nb);
  100. return clock_nb;
  101. }
  102. }
  103. priv->reset_count = 0;
  104. reset_nb = ofnode_count_phandle_with_args(dev_ofnode(dev), "resets",
  105. "#reset-cells");
  106. if (reset_nb > 0) {
  107. priv->resets = devm_kcalloc(dev, reset_nb,
  108. sizeof(struct reset_ctl),
  109. GFP_KERNEL);
  110. if (!priv->resets)
  111. return -ENOMEM;
  112. for (i = 0; i < reset_nb; i++) {
  113. err = reset_get_by_index(dev, i, &priv->resets[i]);
  114. if (err < 0)
  115. break;
  116. if (reset_deassert(&priv->resets[i])) {
  117. dev_err(dev, "failed to deassert reset %d\n",
  118. i);
  119. reset_free(&priv->resets[i]);
  120. goto reset_err;
  121. }
  122. priv->reset_count++;
  123. }
  124. } else {
  125. if (reset_nb != -ENOENT) {
  126. dev_err(dev, "failed to get reset phandle(%d)\n",
  127. reset_nb);
  128. goto clk_err;
  129. }
  130. }
  131. err = ehci_enable_vbus_supply(dev);
  132. if (err)
  133. goto reset_err;
  134. err = ehci_setup_phy(dev, &priv->phy, 0);
  135. if (err)
  136. goto regulator_err;
  137. hccr = map_physmem(dev_read_addr(dev), 0x100, MAP_NOCACHE);
  138. hcor = (struct ehci_hcor *)((uintptr_t)hccr +
  139. HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
  140. err = ehci_register(dev, hccr, hcor, NULL, 0, USB_INIT_HOST);
  141. if (err)
  142. goto phy_err;
  143. return 0;
  144. phy_err:
  145. ret = ehci_shutdown_phy(dev, &priv->phy);
  146. if (ret)
  147. dev_err(dev, "failed to shutdown usb phy\n");
  148. regulator_err:
  149. ret = ehci_disable_vbus_supply(priv);
  150. if (ret)
  151. dev_err(dev, "failed to disable VBUS supply\n");
  152. reset_err:
  153. ret = reset_release_all(priv->resets, priv->reset_count);
  154. if (ret)
  155. dev_err(dev, "failed to assert all resets\n");
  156. clk_err:
  157. ret = clk_release_all(priv->clocks, priv->clock_count);
  158. if (ret)
  159. dev_err(dev, "failed to disable all clocks\n");
  160. return err;
  161. }
  162. static int ehci_usb_remove(struct udevice *dev)
  163. {
  164. struct generic_ehci *priv = dev_get_priv(dev);
  165. int ret;
  166. ret = ehci_deregister(dev);
  167. if (ret)
  168. return ret;
  169. ret = ehci_shutdown_phy(dev, &priv->phy);
  170. if (ret)
  171. return ret;
  172. ret = ehci_disable_vbus_supply(priv);
  173. if (ret)
  174. return ret;
  175. ret = reset_release_all(priv->resets, priv->reset_count);
  176. if (ret)
  177. return ret;
  178. return clk_release_all(priv->clocks, priv->clock_count);
  179. }
  180. static const struct udevice_id ehci_usb_ids[] = {
  181. { .compatible = "generic-ehci" },
  182. { }
  183. };
  184. U_BOOT_DRIVER(ehci_generic) = {
  185. .name = "ehci_generic",
  186. .id = UCLASS_USB,
  187. .of_match = ehci_usb_ids,
  188. .probe = ehci_usb_probe,
  189. .remove = ehci_usb_remove,
  190. .ops = &ehci_usb_ops,
  191. .priv_auto_alloc_size = sizeof(struct generic_ehci),
  192. .flags = DM_FLAG_ALLOC_PRIV_DMA,
  193. };