Merge tag 'dma-mapping-5.18-1' of git://git.infradead.org/users/hch/dma-mapping
[linux-block.git] / drivers / clk / clk-devres.c
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
7 static void devm_clk_release(struct device *dev, void *res)
8 {
9         clk_put(*(struct clk **)res);
10 }
11
12 struct clk *devm_clk_get(struct device *dev, const char *id)
13 {
14         struct clk **ptr, *clk;
15
16         ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
17         if (!ptr)
18                 return ERR_PTR(-ENOMEM);
19
20         clk = clk_get(dev, id);
21         if (!IS_ERR(clk)) {
22                 *ptr = clk;
23                 devres_add(dev, ptr);
24         } else {
25                 devres_free(ptr);
26         }
27
28         return clk;
29 }
30 EXPORT_SYMBOL(devm_clk_get);
31
32 struct clk *devm_clk_get_optional(struct device *dev, const char *id)
33 {
34         struct clk *clk = devm_clk_get(dev, id);
35
36         if (clk == ERR_PTR(-ENOENT))
37                 return NULL;
38
39         return clk;
40 }
41 EXPORT_SYMBOL(devm_clk_get_optional);
42
43 struct clk_bulk_devres {
44         struct clk_bulk_data *clks;
45         int num_clks;
46 };
47
48 static void devm_clk_bulk_release(struct device *dev, void *res)
49 {
50         struct clk_bulk_devres *devres = res;
51
52         clk_bulk_put(devres->num_clks, devres->clks);
53 }
54
55 static int __devm_clk_bulk_get(struct device *dev, int num_clks,
56                                struct clk_bulk_data *clks, bool optional)
57 {
58         struct clk_bulk_devres *devres;
59         int ret;
60
61         devres = devres_alloc(devm_clk_bulk_release,
62                               sizeof(*devres), GFP_KERNEL);
63         if (!devres)
64                 return -ENOMEM;
65
66         if (optional)
67                 ret = clk_bulk_get_optional(dev, num_clks, clks);
68         else
69                 ret = clk_bulk_get(dev, num_clks, clks);
70         if (!ret) {
71                 devres->clks = clks;
72                 devres->num_clks = num_clks;
73                 devres_add(dev, devres);
74         } else {
75                 devres_free(devres);
76         }
77
78         return ret;
79 }
80
81 int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
82                       struct clk_bulk_data *clks)
83 {
84         return __devm_clk_bulk_get(dev, num_clks, clks, false);
85 }
86 EXPORT_SYMBOL_GPL(devm_clk_bulk_get);
87
88 int __must_check devm_clk_bulk_get_optional(struct device *dev, int num_clks,
89                       struct clk_bulk_data *clks)
90 {
91         return __devm_clk_bulk_get(dev, num_clks, clks, true);
92 }
93 EXPORT_SYMBOL_GPL(devm_clk_bulk_get_optional);
94
95 static void devm_clk_bulk_release_all(struct device *dev, void *res)
96 {
97         struct clk_bulk_devres *devres = res;
98
99         clk_bulk_put_all(devres->num_clks, devres->clks);
100 }
101
102 int __must_check devm_clk_bulk_get_all(struct device *dev,
103                                        struct clk_bulk_data **clks)
104 {
105         struct clk_bulk_devres *devres;
106         int ret;
107
108         devres = devres_alloc(devm_clk_bulk_release_all,
109                               sizeof(*devres), GFP_KERNEL);
110         if (!devres)
111                 return -ENOMEM;
112
113         ret = clk_bulk_get_all(dev, &devres->clks);
114         if (ret > 0) {
115                 *clks = devres->clks;
116                 devres->num_clks = ret;
117                 devres_add(dev, devres);
118         } else {
119                 devres_free(devres);
120         }
121
122         return ret;
123 }
124 EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all);
125
126 static int devm_clk_match(struct device *dev, void *res, void *data)
127 {
128         struct clk **c = res;
129         if (!c || !*c) {
130                 WARN_ON(!c || !*c);
131                 return 0;
132         }
133         return *c == data;
134 }
135
136 void devm_clk_put(struct device *dev, struct clk *clk)
137 {
138         int ret;
139
140         ret = devres_release(dev, devm_clk_release, devm_clk_match, clk);
141
142         WARN_ON(ret);
143 }
144 EXPORT_SYMBOL(devm_clk_put);
145
146 struct clk *devm_get_clk_from_child(struct device *dev,
147                                     struct device_node *np, const char *con_id)
148 {
149         struct clk **ptr, *clk;
150
151         ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
152         if (!ptr)
153                 return ERR_PTR(-ENOMEM);
154
155         clk = of_clk_get_by_name(np, con_id);
156         if (!IS_ERR(clk)) {
157                 *ptr = clk;
158                 devres_add(dev, ptr);
159         } else {
160                 devres_free(ptr);
161         }
162
163         return clk;
164 }
165 EXPORT_SYMBOL(devm_get_clk_from_child);