devres.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015 Masahiro Yamada <yamada.masahiro@socionext.com>
  4. *
  5. * Based on the original work in Linux by
  6. * Copyright (c) 2006 SUSE Linux Products GmbH
  7. * Copyright (c) 2006 Tejun Heo <teheo@suse.de>
  8. */
  9. #define LOG_CATEGORY LOGC_DEVRES
  10. #include <common.h>
  11. #include <log.h>
  12. #include <malloc.h>
  13. #include <linux/compat.h>
  14. #include <linux/kernel.h>
  15. #include <linux/list.h>
  16. #include <dm/device.h>
  17. #include <dm/devres.h>
  18. #include <dm/root.h>
  19. #include <dm/util.h>
  20. /** enum devres_phase - Shows where resource was allocated
  21. *
  22. * DEVRES_PHASE_BIND: In the bind() method
  23. * DEVRES_PHASE_OFDATA: In the of_to_plat() method
  24. * DEVRES_PHASE_PROBE: In the probe() method
  25. */
  26. enum devres_phase {
  27. DEVRES_PHASE_BIND,
  28. DEVRES_PHASE_OFDATA,
  29. DEVRES_PHASE_PROBE,
  30. };
  31. /**
  32. * struct devres - Bookkeeping info for managed device resource
  33. * @entry: List to associate this structure with a device
  34. * @release: Callback invoked when this resource is released
  35. * @probe: Show where this resource was allocated
  36. * @name: Name of release function
  37. * @size: Size of resource data
  38. * @data: Resource data
  39. */
  40. struct devres {
  41. struct list_head entry;
  42. dr_release_t release;
  43. enum devres_phase phase;
  44. #ifdef CONFIG_DEBUG_DEVRES
  45. const char *name;
  46. size_t size;
  47. #endif
  48. unsigned long long data[];
  49. };
  50. #ifdef CONFIG_DEBUG_DEVRES
  51. static void set_node_dbginfo(struct devres *dr, const char *name, size_t size)
  52. {
  53. dr->name = name;
  54. dr->size = size;
  55. }
  56. static void devres_log(struct udevice *dev, struct devres *dr,
  57. const char *op)
  58. {
  59. log_debug("%s: DEVRES %3s %p %s (%lu bytes)\n", dev->name, op, dr,
  60. dr->name, (unsigned long)dr->size);
  61. }
  62. #else /* CONFIG_DEBUG_DEVRES */
  63. #define set_node_dbginfo(dr, n, s) do {} while (0)
  64. #define devres_log(dev, dr, op) do {} while (0)
  65. #endif
  66. #if CONFIG_DEBUG_DEVRES
  67. void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
  68. const char *name)
  69. #else
  70. void *_devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
  71. #endif
  72. {
  73. size_t tot_size = sizeof(struct devres) + size;
  74. struct devres *dr;
  75. dr = kmalloc(tot_size, gfp);
  76. if (unlikely(!dr))
  77. return NULL;
  78. INIT_LIST_HEAD(&dr->entry);
  79. dr->release = release;
  80. set_node_dbginfo(dr, name, size);
  81. return dr->data;
  82. }
  83. void devres_free(void *res)
  84. {
  85. if (res) {
  86. struct devres *dr = container_of(res, struct devres, data);
  87. assert_noisy(list_empty(&dr->entry));
  88. kfree(dr);
  89. }
  90. }
  91. void devres_add(struct udevice *dev, void *res)
  92. {
  93. struct devres *dr = container_of(res, struct devres, data);
  94. devres_log(dev, dr, "ADD");
  95. assert_noisy(list_empty(&dr->entry));
  96. if (dev->flags & DM_FLAG_PLATDATA_VALID)
  97. dr->phase = DEVRES_PHASE_PROBE;
  98. else if (dev->flags & DM_FLAG_BOUND)
  99. dr->phase = DEVRES_PHASE_OFDATA;
  100. else
  101. dr->phase = DEVRES_PHASE_BIND;
  102. list_add_tail(&dr->entry, &dev->devres_head);
  103. }
  104. void *devres_find(struct udevice *dev, dr_release_t release,
  105. dr_match_t match, void *match_data)
  106. {
  107. struct devres *dr;
  108. list_for_each_entry_reverse(dr, &dev->devres_head, entry) {
  109. if (dr->release != release)
  110. continue;
  111. if (match && !match(dev, dr->data, match_data))
  112. continue;
  113. return dr->data;
  114. }
  115. return NULL;
  116. }
  117. void *devres_get(struct udevice *dev, void *new_res,
  118. dr_match_t match, void *match_data)
  119. {
  120. struct devres *new_dr = container_of(new_res, struct devres, data);
  121. void *res;
  122. res = devres_find(dev, new_dr->release, match, match_data);
  123. if (!res) {
  124. devres_add(dev, new_res);
  125. res = new_res;
  126. new_res = NULL;
  127. }
  128. devres_free(new_res);
  129. return res;
  130. }
  131. void *devres_remove(struct udevice *dev, dr_release_t release,
  132. dr_match_t match, void *match_data)
  133. {
  134. void *res;
  135. res = devres_find(dev, release, match, match_data);
  136. if (res) {
  137. struct devres *dr = container_of(res, struct devres, data);
  138. list_del_init(&dr->entry);
  139. devres_log(dev, dr, "REM");
  140. }
  141. return res;
  142. }
  143. int devres_destroy(struct udevice *dev, dr_release_t release,
  144. dr_match_t match, void *match_data)
  145. {
  146. void *res;
  147. res = devres_remove(dev, release, match, match_data);
  148. if (unlikely(!res))
  149. return -ENOENT;
  150. devres_free(res);
  151. return 0;
  152. }
  153. int devres_release(struct udevice *dev, dr_release_t release,
  154. dr_match_t match, void *match_data)
  155. {
  156. void *res;
  157. res = devres_remove(dev, release, match, match_data);
  158. if (unlikely(!res))
  159. return -ENOENT;
  160. (*release)(dev, res);
  161. devres_free(res);
  162. return 0;
  163. }
  164. static void release_nodes(struct udevice *dev, struct list_head *head,
  165. bool probe_and_ofdata_only)
  166. {
  167. struct devres *dr, *tmp;
  168. list_for_each_entry_safe_reverse(dr, tmp, head, entry) {
  169. if (probe_and_ofdata_only && dr->phase == DEVRES_PHASE_BIND)
  170. break;
  171. devres_log(dev, dr, "REL");
  172. dr->release(dev, dr->data);
  173. list_del(&dr->entry);
  174. kfree(dr);
  175. }
  176. }
  177. void devres_release_probe(struct udevice *dev)
  178. {
  179. release_nodes(dev, &dev->devres_head, true);
  180. }
  181. void devres_release_all(struct udevice *dev)
  182. {
  183. release_nodes(dev, &dev->devres_head, false);
  184. }
  185. #ifdef CONFIG_DEBUG_DEVRES
  186. static char *const devres_phase_name[] = {"BIND", "OFDATA", "PROBE"};
  187. static void dump_resources(struct udevice *dev, int depth)
  188. {
  189. struct devres *dr;
  190. struct udevice *child;
  191. printf("- %s\n", dev->name);
  192. list_for_each_entry(dr, &dev->devres_head, entry)
  193. printf(" %p (%lu byte) %s %s\n", dr,
  194. (unsigned long)dr->size, dr->name,
  195. devres_phase_name[dr->phase]);
  196. list_for_each_entry(child, &dev->child_head, sibling_node)
  197. dump_resources(child, depth + 1);
  198. }
  199. void dm_dump_devres(void)
  200. {
  201. struct udevice *root;
  202. root = dm_root();
  203. if (root)
  204. dump_resources(root, 0);
  205. }
  206. void devres_get_stats(const struct udevice *dev, struct devres_stats *stats)
  207. {
  208. struct devres *dr;
  209. stats->allocs = 0;
  210. stats->total_size = 0;
  211. list_for_each_entry(dr, &dev->devres_head, entry) {
  212. stats->allocs++;
  213. stats->total_size += dr->size;
  214. }
  215. }
  216. #endif
  217. /*
  218. * Managed kmalloc/kfree
  219. */
  220. static void devm_kmalloc_release(struct udevice *dev, void *res)
  221. {
  222. /* noop */
  223. }
  224. static int devm_kmalloc_match(struct udevice *dev, void *res, void *data)
  225. {
  226. return res == data;
  227. }
  228. void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp)
  229. {
  230. void *data;
  231. data = _devres_alloc(devm_kmalloc_release, size, gfp);
  232. if (unlikely(!data))
  233. return NULL;
  234. devres_add(dev, data);
  235. return data;
  236. }
  237. void devm_kfree(struct udevice *dev, void *p)
  238. {
  239. int rc;
  240. rc = devres_destroy(dev, devm_kmalloc_release, devm_kmalloc_match, p);
  241. assert_noisy(!rc);
  242. }