clk-devres.c 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <linux/clk.h>
  3. #include <linux/device.h>
  4. #include <linux/export.h>
  5. #include <linux/gfp.h>
  6. struct devm_clk_state {
  7. struct clk *clk;
  8. void (*exit)(struct clk *clk);
  9. };
  10. static void devm_clk_release(struct device *dev, void *res)
  11. {
  12. struct devm_clk_state *state = res;
  13. if (state->exit)
  14. state->exit(state->clk);
  15. clk_put(state->clk);
  16. }
  17. static struct clk *__devm_clk_get(struct device *dev, const char *id,
  18. struct clk *(*get)(struct device *dev, const char *id),
  19. int (*init)(struct clk *clk),
  20. void (*exit)(struct clk *clk))
  21. {
  22. struct devm_clk_state *state;
  23. struct clk *clk;
  24. int ret;
  25. state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
  26. if (!state)
  27. return ERR_PTR(-ENOMEM);
  28. clk = get(dev, id);
  29. if (IS_ERR(clk)) {
  30. ret = PTR_ERR(clk);
  31. goto err_clk_get;
  32. }
  33. if (init) {
  34. ret = init(clk);
  35. if (ret)
  36. goto err_clk_init;
  37. }
  38. state->clk = clk;
  39. state->exit = exit;
  40. devres_add(dev, state);
  41. return clk;
  42. err_clk_init:
  43. clk_put(clk);
  44. err_clk_get:
  45. devres_free(state);
  46. return ERR_PTR(ret);
  47. }
  48. struct clk *devm_clk_get(struct device *dev, const char *id)
  49. {
  50. return __devm_clk_get(dev, id, clk_get, NULL, NULL);
  51. }
  52. EXPORT_SYMBOL(devm_clk_get);
  53. struct clk *devm_clk_get_prepared(struct device *dev, const char *id)
  54. {
  55. return __devm_clk_get(dev, id, clk_get, clk_prepare, clk_unprepare);
  56. }
  57. EXPORT_SYMBOL_GPL(devm_clk_get_prepared);
  58. struct clk *devm_clk_get_enabled(struct device *dev, const char *id)
  59. {
  60. return __devm_clk_get(dev, id, clk_get,
  61. clk_prepare_enable, clk_disable_unprepare);
  62. }
  63. EXPORT_SYMBOL_GPL(devm_clk_get_enabled);
  64. struct clk *devm_clk_get_optional(struct device *dev, const char *id)
  65. {
  66. return __devm_clk_get(dev, id, clk_get_optional, NULL, NULL);
  67. }
  68. EXPORT_SYMBOL(devm_clk_get_optional);
  69. struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id)
  70. {
  71. return __devm_clk_get(dev, id, clk_get_optional,
  72. clk_prepare, clk_unprepare);
  73. }
  74. EXPORT_SYMBOL_GPL(devm_clk_get_optional_prepared);
  75. struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id)
  76. {
  77. return __devm_clk_get(dev, id, clk_get_optional,
  78. clk_prepare_enable, clk_disable_unprepare);
  79. }
  80. EXPORT_SYMBOL_GPL(devm_clk_get_optional_enabled);
  81. struct clk_bulk_devres {
  82. struct clk_bulk_data *clks;
  83. int num_clks;
  84. };
  85. static void devm_clk_bulk_release(struct device *dev, void *res)
  86. {
  87. struct clk_bulk_devres *devres = res;
  88. clk_bulk_put(devres->num_clks, devres->clks);
  89. }
  90. static int __devm_clk_bulk_get(struct device *dev, int num_clks,
  91. struct clk_bulk_data *clks, bool optional)
  92. {
  93. struct clk_bulk_devres *devres;
  94. int ret;
  95. devres = devres_alloc(devm_clk_bulk_release,
  96. sizeof(*devres), GFP_KERNEL);
  97. if (!devres)
  98. return -ENOMEM;
  99. if (optional)
  100. ret = clk_bulk_get_optional(dev, num_clks, clks);
  101. else
  102. ret = clk_bulk_get(dev, num_clks, clks);
  103. if (!ret) {
  104. devres->clks = clks;
  105. devres->num_clks = num_clks;
  106. devres_add(dev, devres);
  107. } else {
  108. devres_free(devres);
  109. }
  110. return ret;
  111. }
  112. int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
  113. struct clk_bulk_data *clks)
  114. {
  115. return __devm_clk_bulk_get(dev, num_clks, clks, false);
  116. }
  117. EXPORT_SYMBOL_GPL(devm_clk_bulk_get);
  118. int __must_check devm_clk_bulk_get_optional(struct device *dev, int num_clks,
  119. struct clk_bulk_data *clks)
  120. {
  121. return __devm_clk_bulk_get(dev, num_clks, clks, true);
  122. }
  123. EXPORT_SYMBOL_GPL(devm_clk_bulk_get_optional);
  124. static void devm_clk_bulk_release_all(struct device *dev, void *res)
  125. {
  126. struct clk_bulk_devres *devres = res;
  127. clk_bulk_put_all(devres->num_clks, devres->clks);
  128. }
  129. int __must_check devm_clk_bulk_get_all(struct device *dev,
  130. struct clk_bulk_data **clks)
  131. {
  132. struct clk_bulk_devres *devres;
  133. int ret;
  134. devres = devres_alloc(devm_clk_bulk_release_all,
  135. sizeof(*devres), GFP_KERNEL);
  136. if (!devres)
  137. return -ENOMEM;
  138. ret = clk_bulk_get_all(dev, &devres->clks);
  139. if (ret > 0) {
  140. *clks = devres->clks;
  141. devres->num_clks = ret;
  142. devres_add(dev, devres);
  143. } else {
  144. devres_free(devres);
  145. }
  146. return ret;
  147. }
  148. EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all);
  149. static int devm_clk_match(struct device *dev, void *res, void *data)
  150. {
  151. struct clk **c = res;
  152. if (!c || !*c) {
  153. WARN_ON(!c || !*c);
  154. return 0;
  155. }
  156. return *c == data;
  157. }
  158. void devm_clk_put(struct device *dev, struct clk *clk)
  159. {
  160. int ret;
  161. ret = devres_release(dev, devm_clk_release, devm_clk_match, clk);
  162. WARN_ON(ret);
  163. }
  164. EXPORT_SYMBOL(devm_clk_put);
  165. struct clk *devm_get_clk_from_child(struct device *dev,
  166. struct device_node *np, const char *con_id)
  167. {
  168. struct devm_clk_state *state;
  169. struct clk *clk;
  170. state = devres_alloc(devm_clk_release, sizeof(*state), GFP_KERNEL);
  171. if (!state)
  172. return ERR_PTR(-ENOMEM);
  173. clk = of_clk_get_by_name(np, con_id);
  174. if (!IS_ERR(clk)) {
  175. state->clk = clk;
  176. devres_add(dev, state);
  177. } else {
  178. devres_free(state);
  179. }
  180. return clk;
  181. }
  182. EXPORT_SYMBOL(devm_get_clk_from_child);