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