ehci-generic.c 4.5 KB

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