1
2
3
4
5
6
7
8
9
10#include <linux/device.h>
11#include <linux/module.h>
12
13#include "base.h"
14
15struct devres_node {
16 struct list_head entry;
17 dr_release_t release;
18#ifdef CONFIG_DEBUG_DEVRES
19 const char *name;
20 size_t size;
21#endif
22};
23
24struct devres {
25 struct devres_node node;
26
27 unsigned long long data[];
28};
29
30struct devres_group {
31 struct devres_node node[2];
32 void *id;
33 int color;
34
35};
36
37#ifdef CONFIG_DEBUG_DEVRES
38static int log_devres = 0;
39module_param_named(log, log_devres, int, S_IRUGO | S_IWUSR);
40
41static void set_node_dbginfo(struct devres_node *node, const char *name,
42 size_t size)
43{
44 node->name = name;
45 node->size = size;
46}
47
48static void devres_log(struct device *dev, struct devres_node *node,
49 const char *op)
50{
51 if (unlikely(log_devres))
52 dev_printk(KERN_ERR, dev, "DEVRES %3s %p %s (%lu bytes)\n",
53 op, node, node->name, (unsigned long)node->size);
54}
55#else
56#define set_node_dbginfo(node, n, s) do {} while (0)
57#define devres_log(dev, node, op) do {} while (0)
58#endif
59
60
61
62
63
64static void group_open_release(struct device *dev, void *res)
65{
66
67}
68
69static void group_close_release(struct device *dev, void *res)
70{
71
72}
73
74static struct devres_group * node_to_group(struct devres_node *node)
75{
76 if (node->release == &group_open_release)
77 return container_of(node, struct devres_group, node[0]);
78 if (node->release == &group_close_release)
79 return container_of(node, struct devres_group, node[1]);
80 return NULL;
81}
82
83static __always_inline struct devres * alloc_dr(dr_release_t release,
84 size_t size, gfp_t gfp)
85{
86 size_t tot_size = sizeof(struct devres) + size;
87 struct devres *dr;
88
89 dr = kmalloc_track_caller(tot_size, gfp);
90 if (unlikely(!dr))
91 return NULL;
92
93 memset(dr, 0, tot_size);
94 INIT_LIST_HEAD(&dr->node.entry);
95 dr->node.release = release;
96 return dr;
97}
98
99static void add_dr(struct device *dev, struct devres_node *node)
100{
101 devres_log(dev, node, "ADD");
102 BUG_ON(!list_empty(&node->entry));
103 list_add_tail(&node->entry, &dev->devres_head);
104}
105
106#ifdef CONFIG_DEBUG_DEVRES
107void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
108 const char *name)
109{
110 struct devres *dr;
111
112 dr = alloc_dr(release, size, gfp);
113 if (unlikely(!dr))
114 return NULL;
115 set_node_dbginfo(&dr->node, name, size);
116 return dr->data;
117}
118EXPORT_SYMBOL_GPL(__devres_alloc);
119#else
120
121
122
123
124
125
126
127
128
129
130
131
132
133void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
134{
135 struct devres *dr;
136
137 dr = alloc_dr(release, size, gfp);
138 if (unlikely(!dr))
139 return NULL;
140 return dr->data;
141}
142EXPORT_SYMBOL_GPL(devres_alloc);
143#endif
144
145
146
147
148
149
150
151void devres_free(void *res)
152{
153 if (res) {
154 struct devres *dr = container_of(res, struct devres, data);
155
156 BUG_ON(!list_empty(&dr->node.entry));
157 kfree(dr);
158 }
159}
160EXPORT_SYMBOL_GPL(devres_free);
161
162
163
164
165
166
167
168
169
170
171void devres_add(struct device *dev, void *res)
172{
173 struct devres *dr = container_of(res, struct devres, data);
174 unsigned long flags;
175
176 spin_lock_irqsave(&dev->devres_lock, flags);
177 add_dr(dev, &dr->node);
178 spin_unlock_irqrestore(&dev->devres_lock, flags);
179}
180EXPORT_SYMBOL_GPL(devres_add);
181
182static struct devres *find_dr(struct device *dev, dr_release_t release,
183 dr_match_t match, void *match_data)
184{
185 struct devres_node *node;
186
187 list_for_each_entry_reverse(node, &dev->devres_head, entry) {
188 struct devres *dr = container_of(node, struct devres, node);
189
190 if (node->release != release)
191 continue;
192 if (match && !match(dev, dr->data, match_data))
193 continue;
194 return dr;
195 }
196
197 return NULL;
198}
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214void * devres_find(struct device *dev, dr_release_t release,
215 dr_match_t match, void *match_data)
216{
217 struct devres *dr;
218 unsigned long flags;
219
220 spin_lock_irqsave(&dev->devres_lock, flags);
221 dr = find_dr(dev, release, match, match_data);
222 spin_unlock_irqrestore(&dev->devres_lock, flags);
223
224 if (dr)
225 return dr->data;
226 return NULL;
227}
228EXPORT_SYMBOL_GPL(devres_find);
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244void * devres_get(struct device *dev, void *new_res,
245 dr_match_t match, void *match_data)
246{
247 struct devres *new_dr = container_of(new_res, struct devres, data);
248 struct devres *dr;
249 unsigned long flags;
250
251 spin_lock_irqsave(&dev->devres_lock, flags);
252 dr = find_dr(dev, new_dr->node.release, match, match_data);
253 if (!dr) {
254 add_dr(dev, &new_dr->node);
255 dr = new_dr;
256 new_dr = NULL;
257 }
258 spin_unlock_irqrestore(&dev->devres_lock, flags);
259 devres_free(new_dr);
260
261 return dr->data;
262}
263EXPORT_SYMBOL_GPL(devres_get);
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280void * devres_remove(struct device *dev, dr_release_t release,
281 dr_match_t match, void *match_data)
282{
283 struct devres *dr;
284 unsigned long flags;
285
286 spin_lock_irqsave(&dev->devres_lock, flags);
287 dr = find_dr(dev, release, match, match_data);
288 if (dr) {
289 list_del_init(&dr->node.entry);
290 devres_log(dev, &dr->node, "REM");
291 }
292 spin_unlock_irqrestore(&dev->devres_lock, flags);
293
294 if (dr)
295 return dr->data;
296 return NULL;
297}
298EXPORT_SYMBOL_GPL(devres_remove);
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314int devres_destroy(struct device *dev, dr_release_t release,
315 dr_match_t match, void *match_data)
316{
317 void *res;
318
319 res = devres_remove(dev, release, match, match_data);
320 if (unlikely(!res))
321 return -ENOENT;
322
323 devres_free(res);
324 return 0;
325}
326EXPORT_SYMBOL_GPL(devres_destroy);
327
328static int remove_nodes(struct device *dev,
329 struct list_head *first, struct list_head *end,
330 struct list_head *todo)
331{
332 int cnt = 0, nr_groups = 0;
333 struct list_head *cur;
334
335
336
337
338 cur = first;
339 while (cur != end) {
340 struct devres_node *node;
341 struct devres_group *grp;
342
343 node = list_entry(cur, struct devres_node, entry);
344 cur = cur->next;
345
346 grp = node_to_group(node);
347 if (grp) {
348
349 grp->color = 0;
350 nr_groups++;
351 } else {
352
353 if (&node->entry == first)
354 first = first->next;
355 list_move_tail(&node->entry, todo);
356 cnt++;
357 }
358 }
359
360 if (!nr_groups)
361 return cnt;
362
363
364
365
366
367
368
369 cur = first;
370 while (cur != end) {
371 struct devres_node *node;
372 struct devres_group *grp;
373
374 node = list_entry(cur, struct devres_node, entry);
375 cur = cur->next;
376
377 grp = node_to_group(node);
378 BUG_ON(!grp || list_empty(&grp->node[0].entry));
379
380 grp->color++;
381 if (list_empty(&grp->node[1].entry))
382 grp->color++;
383
384 BUG_ON(grp->color <= 0 || grp->color > 2);
385 if (grp->color == 2) {
386
387
388
389 list_move_tail(&grp->node[0].entry, todo);
390 list_del_init(&grp->node[1].entry);
391 }
392 }
393
394 return cnt;
395}
396
397static int release_nodes(struct device *dev, struct list_head *first,
398 struct list_head *end, unsigned long flags)
399{
400 LIST_HEAD(todo);
401 int cnt;
402 struct devres *dr, *tmp;
403
404 cnt = remove_nodes(dev, first, end, &todo);
405
406 spin_unlock_irqrestore(&dev->devres_lock, flags);
407
408
409
410
411 list_for_each_entry_safe_reverse(dr, tmp, &todo, node.entry) {
412 devres_log(dev, &dr->node, "REL");
413 dr->node.release(dev, dr->data);
414 kfree(dr);
415 }
416
417 return cnt;
418}
419
420
421
422
423
424
425
426
427int devres_release_all(struct device *dev)
428{
429 unsigned long flags;
430
431
432 if (WARN_ON(dev->devres_head.next == NULL))
433 return -ENODEV;
434 spin_lock_irqsave(&dev->devres_lock, flags);
435 return release_nodes(dev, dev->devres_head.next, &dev->devres_head,
436 flags);
437}
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452void * devres_open_group(struct device *dev, void *id, gfp_t gfp)
453{
454 struct devres_group *grp;
455 unsigned long flags;
456
457 grp = kmalloc(sizeof(*grp), gfp);
458 if (unlikely(!grp))
459 return NULL;
460
461 grp->node[0].release = &group_open_release;
462 grp->node[1].release = &group_close_release;
463 INIT_LIST_HEAD(&grp->node[0].entry);
464 INIT_LIST_HEAD(&grp->node[1].entry);
465 set_node_dbginfo(&grp->node[0], "grp<", 0);
466 set_node_dbginfo(&grp->node[1], "grp>", 0);
467 grp->id = grp;
468 if (id)
469 grp->id = id;
470
471 spin_lock_irqsave(&dev->devres_lock, flags);
472 add_dr(dev, &grp->node[0]);
473 spin_unlock_irqrestore(&dev->devres_lock, flags);
474 return grp->id;
475}
476EXPORT_SYMBOL_GPL(devres_open_group);
477
478
479static struct devres_group * find_group(struct device *dev, void *id)
480{
481 struct devres_node *node;
482
483 list_for_each_entry_reverse(node, &dev->devres_head, entry) {
484 struct devres_group *grp;
485
486 if (node->release != &group_open_release)
487 continue;
488
489 grp = container_of(node, struct devres_group, node[0]);
490
491 if (id) {
492 if (grp->id == id)
493 return grp;
494 } else if (list_empty(&grp->node[1].entry))
495 return grp;
496 }
497
498 return NULL;
499}
500
501
502
503
504
505
506
507
508
509void devres_close_group(struct device *dev, void *id)
510{
511 struct devres_group *grp;
512 unsigned long flags;
513
514 spin_lock_irqsave(&dev->devres_lock, flags);
515
516 grp = find_group(dev, id);
517 if (grp)
518 add_dr(dev, &grp->node[1]);
519 else
520 WARN_ON(1);
521
522 spin_unlock_irqrestore(&dev->devres_lock, flags);
523}
524EXPORT_SYMBOL_GPL(devres_close_group);
525
526
527
528
529
530
531
532
533
534
535void devres_remove_group(struct device *dev, void *id)
536{
537 struct devres_group *grp;
538 unsigned long flags;
539
540 spin_lock_irqsave(&dev->devres_lock, flags);
541
542 grp = find_group(dev, id);
543 if (grp) {
544 list_del_init(&grp->node[0].entry);
545 list_del_init(&grp->node[1].entry);
546 devres_log(dev, &grp->node[0], "REM");
547 } else
548 WARN_ON(1);
549
550 spin_unlock_irqrestore(&dev->devres_lock, flags);
551
552 kfree(grp);
553}
554EXPORT_SYMBOL_GPL(devres_remove_group);
555
556
557
558
559
560
561
562
563
564
565
566
567
568int devres_release_group(struct device *dev, void *id)
569{
570 struct devres_group *grp;
571 unsigned long flags;
572 int cnt = 0;
573
574 spin_lock_irqsave(&dev->devres_lock, flags);
575
576 grp = find_group(dev, id);
577 if (grp) {
578 struct list_head *first = &grp->node[0].entry;
579 struct list_head *end = &dev->devres_head;
580
581 if (!list_empty(&grp->node[1].entry))
582 end = grp->node[1].entry.next;
583
584 cnt = release_nodes(dev, first, end, flags);
585 } else {
586 WARN_ON(1);
587 spin_unlock_irqrestore(&dev->devres_lock, flags);
588 }
589
590 return cnt;
591}
592EXPORT_SYMBOL_GPL(devres_release_group);
593
594
595
596
597static void devm_kzalloc_release(struct device *dev, void *res)
598{
599
600}
601
602static int devm_kzalloc_match(struct device *dev, void *res, void *data)
603{
604 return res == data;
605}
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620void * devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
621{
622 struct devres *dr;
623
624
625 dr = alloc_dr(devm_kzalloc_release, size, gfp);
626 if (unlikely(!dr))
627 return NULL;
628
629 set_node_dbginfo(&dr->node, "devm_kzalloc_release", size);
630 devres_add(dev, dr->data);
631 return dr->data;
632}
633EXPORT_SYMBOL_GPL(devm_kzalloc);
634
635
636
637
638
639
640
641
642void devm_kfree(struct device *dev, void *p)
643{
644 int rc;
645
646 rc = devres_destroy(dev, devm_kzalloc_release, devm_kzalloc_match, p);
647 WARN_ON(rc);
648}
649EXPORT_SYMBOL_GPL(devm_kfree);
650