reset-uclass.c 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2016, NVIDIA CORPORATION.
  4. */
  5. #include <common.h>
  6. #include <dm.h>
  7. #include <fdtdec.h>
  8. #include <log.h>
  9. #include <malloc.h>
  10. #include <reset.h>
  11. #include <reset-uclass.h>
  12. #include <dm/devres.h>
  13. static inline struct reset_ops *reset_dev_ops(struct udevice *dev)
  14. {
  15. return (struct reset_ops *)dev->driver->ops;
  16. }
  17. static int reset_of_xlate_default(struct reset_ctl *reset_ctl,
  18. struct ofnode_phandle_args *args)
  19. {
  20. debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  21. if (args->args_count != 1) {
  22. debug("Invaild args_count: %d\n", args->args_count);
  23. return -EINVAL;
  24. }
  25. reset_ctl->id = args->args[0];
  26. return 0;
  27. }
  28. static int reset_get_by_index_tail(int ret, ofnode node,
  29. struct ofnode_phandle_args *args,
  30. const char *list_name, int index,
  31. struct reset_ctl *reset_ctl)
  32. {
  33. struct udevice *dev_reset;
  34. struct reset_ops *ops;
  35. assert(reset_ctl);
  36. reset_ctl->dev = NULL;
  37. if (ret)
  38. return ret;
  39. ret = uclass_get_device_by_ofnode(UCLASS_RESET, args->node,
  40. &dev_reset);
  41. if (ret) {
  42. debug("%s: uclass_get_device_by_ofnode() failed: %d\n",
  43. __func__, ret);
  44. debug("%s %d\n", ofnode_get_name(args->node), args->args[0]);
  45. return ret;
  46. }
  47. ops = reset_dev_ops(dev_reset);
  48. reset_ctl->dev = dev_reset;
  49. if (ops->of_xlate)
  50. ret = ops->of_xlate(reset_ctl, args);
  51. else
  52. ret = reset_of_xlate_default(reset_ctl, args);
  53. if (ret) {
  54. debug("of_xlate() failed: %d\n", ret);
  55. return ret;
  56. }
  57. ret = ops->request(reset_ctl);
  58. if (ret) {
  59. debug("ops->request() failed: %d\n", ret);
  60. return ret;
  61. }
  62. return 0;
  63. }
  64. int reset_get_by_index(struct udevice *dev, int index,
  65. struct reset_ctl *reset_ctl)
  66. {
  67. struct ofnode_phandle_args args;
  68. int ret;
  69. ret = dev_read_phandle_with_args(dev, "resets", "#reset-cells", 0,
  70. index, &args);
  71. return reset_get_by_index_tail(ret, dev_ofnode(dev), &args, "resets",
  72. index > 0, reset_ctl);
  73. }
  74. int reset_get_by_index_nodev(ofnode node, int index,
  75. struct reset_ctl *reset_ctl)
  76. {
  77. struct ofnode_phandle_args args;
  78. int ret;
  79. ret = ofnode_parse_phandle_with_args(node, "resets", "#reset-cells", 0,
  80. index > 0, &args);
  81. return reset_get_by_index_tail(ret, node, &args, "resets",
  82. index > 0, reset_ctl);
  83. }
  84. int reset_get_bulk(struct udevice *dev, struct reset_ctl_bulk *bulk)
  85. {
  86. int i, ret, err, count;
  87. bulk->count = 0;
  88. count = dev_count_phandle_with_args(dev, "resets", "#reset-cells");
  89. if (count < 1)
  90. return count;
  91. bulk->resets = devm_kcalloc(dev, count, sizeof(struct reset_ctl),
  92. GFP_KERNEL);
  93. if (!bulk->resets)
  94. return -ENOMEM;
  95. for (i = 0; i < count; i++) {
  96. ret = reset_get_by_index(dev, i, &bulk->resets[i]);
  97. if (ret < 0)
  98. goto bulk_get_err;
  99. ++bulk->count;
  100. }
  101. return 0;
  102. bulk_get_err:
  103. err = reset_release_all(bulk->resets, bulk->count);
  104. if (err)
  105. debug("%s: could release all resets for %p\n",
  106. __func__, dev);
  107. return ret;
  108. }
  109. int reset_get_by_name(struct udevice *dev, const char *name,
  110. struct reset_ctl *reset_ctl)
  111. {
  112. int index;
  113. debug("%s(dev=%p, name=%s, reset_ctl=%p)\n", __func__, dev, name,
  114. reset_ctl);
  115. reset_ctl->dev = NULL;
  116. index = dev_read_stringlist_search(dev, "reset-names", name);
  117. if (index < 0) {
  118. debug("fdt_stringlist_search() failed: %d\n", index);
  119. return index;
  120. }
  121. return reset_get_by_index(dev, index, reset_ctl);
  122. }
  123. int reset_request(struct reset_ctl *reset_ctl)
  124. {
  125. struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
  126. debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  127. return ops->request(reset_ctl);
  128. }
  129. int reset_free(struct reset_ctl *reset_ctl)
  130. {
  131. struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
  132. debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  133. return ops->rfree(reset_ctl);
  134. }
  135. int reset_assert(struct reset_ctl *reset_ctl)
  136. {
  137. struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
  138. debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  139. return ops->rst_assert(reset_ctl);
  140. }
  141. int reset_assert_bulk(struct reset_ctl_bulk *bulk)
  142. {
  143. int i, ret;
  144. for (i = 0; i < bulk->count; i++) {
  145. ret = reset_assert(&bulk->resets[i]);
  146. if (ret < 0)
  147. return ret;
  148. }
  149. return 0;
  150. }
  151. int reset_deassert(struct reset_ctl *reset_ctl)
  152. {
  153. struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
  154. debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  155. return ops->rst_deassert(reset_ctl);
  156. }
  157. int reset_deassert_bulk(struct reset_ctl_bulk *bulk)
  158. {
  159. int i, ret;
  160. for (i = 0; i < bulk->count; i++) {
  161. ret = reset_deassert(&bulk->resets[i]);
  162. if (ret < 0)
  163. return ret;
  164. }
  165. return 0;
  166. }
  167. int reset_status(struct reset_ctl *reset_ctl)
  168. {
  169. struct reset_ops *ops = reset_dev_ops(reset_ctl->dev);
  170. debug("%s(reset_ctl=%p)\n", __func__, reset_ctl);
  171. return ops->rst_status(reset_ctl);
  172. }
  173. int reset_release_all(struct reset_ctl *reset_ctl, int count)
  174. {
  175. int i, ret;
  176. for (i = 0; i < count; i++) {
  177. debug("%s(reset_ctl[%d]=%p)\n", __func__, i, &reset_ctl[i]);
  178. /* check if reset has been previously requested */
  179. if (!reset_ctl[i].dev)
  180. continue;
  181. ret = reset_assert(&reset_ctl[i]);
  182. if (ret)
  183. return ret;
  184. ret = reset_free(&reset_ctl[i]);
  185. if (ret)
  186. return ret;
  187. }
  188. return 0;
  189. }
  190. UCLASS_DRIVER(reset) = {
  191. .id = UCLASS_RESET,
  192. .name = "reset",
  193. };