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