Loading...
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
7static void devm_clk_release(struct device *dev, void *res)
8{
9 clk_put(*(struct clk **)res);
10}
11
12struct 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}
30EXPORT_SYMBOL(devm_clk_get);
31
32struct 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}
41EXPORT_SYMBOL(devm_clk_get_optional);
42
43struct clk_bulk_devres {
44 struct clk_bulk_data *clks;
45 int num_clks;
46};
47
48static 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
55static 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
81int __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}
86EXPORT_SYMBOL_GPL(devm_clk_bulk_get);
87
88int __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}
93EXPORT_SYMBOL_GPL(devm_clk_bulk_get_optional);
94
95int __must_check devm_clk_bulk_get_all(struct device *dev,
96 struct clk_bulk_data **clks)
97{
98 struct clk_bulk_devres *devres;
99 int ret;
100
101 devres = devres_alloc(devm_clk_bulk_release,
102 sizeof(*devres), GFP_KERNEL);
103 if (!devres)
104 return -ENOMEM;
105
106 ret = clk_bulk_get_all(dev, &devres->clks);
107 if (ret > 0) {
108 *clks = devres->clks;
109 devres->num_clks = ret;
110 devres_add(dev, devres);
111 } else {
112 devres_free(devres);
113 }
114
115 return ret;
116}
117EXPORT_SYMBOL_GPL(devm_clk_bulk_get_all);
118
119static int devm_clk_match(struct device *dev, void *res, void *data)
120{
121 struct clk **c = res;
122 if (!c || !*c) {
123 WARN_ON(!c || !*c);
124 return 0;
125 }
126 return *c == data;
127}
128
129void devm_clk_put(struct device *dev, struct clk *clk)
130{
131 int ret;
132
133 ret = devres_release(dev, devm_clk_release, devm_clk_match, clk);
134
135 WARN_ON(ret);
136}
137EXPORT_SYMBOL(devm_clk_put);
138
139struct clk *devm_get_clk_from_child(struct device *dev,
140 struct device_node *np, const char *con_id)
141{
142 struct clk **ptr, *clk;
143
144 ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
145 if (!ptr)
146 return ERR_PTR(-ENOMEM);
147
148 clk = of_clk_get_by_name(np, con_id);
149 if (!IS_ERR(clk)) {
150 *ptr = clk;
151 devres_add(dev, ptr);
152 } else {
153 devres_free(ptr);
154 }
155
156 return clk;
157}
158EXPORT_SYMBOL(devm_get_clk_from_child);
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License version 2 as
4 * published by the Free Software Foundation.
5 */
6
7#include <linux/clk.h>
8#include <linux/device.h>
9#include <linux/export.h>
10#include <linux/gfp.h>
11
12static void devm_clk_release(struct device *dev, void *res)
13{
14 clk_put(*(struct clk **)res);
15}
16
17struct clk *devm_clk_get(struct device *dev, const char *id)
18{
19 struct clk **ptr, *clk;
20
21 ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
22 if (!ptr)
23 return ERR_PTR(-ENOMEM);
24
25 clk = clk_get(dev, id);
26 if (!IS_ERR(clk)) {
27 *ptr = clk;
28 devres_add(dev, ptr);
29 } else {
30 devres_free(ptr);
31 }
32
33 return clk;
34}
35EXPORT_SYMBOL(devm_clk_get);
36
37struct clk_bulk_devres {
38 struct clk_bulk_data *clks;
39 int num_clks;
40};
41
42static void devm_clk_bulk_release(struct device *dev, void *res)
43{
44 struct clk_bulk_devres *devres = res;
45
46 clk_bulk_put(devres->num_clks, devres->clks);
47}
48
49int __must_check devm_clk_bulk_get(struct device *dev, int num_clks,
50 struct clk_bulk_data *clks)
51{
52 struct clk_bulk_devres *devres;
53 int ret;
54
55 devres = devres_alloc(devm_clk_bulk_release,
56 sizeof(*devres), GFP_KERNEL);
57 if (!devres)
58 return -ENOMEM;
59
60 ret = clk_bulk_get(dev, num_clks, clks);
61 if (!ret) {
62 devres->clks = clks;
63 devres->num_clks = num_clks;
64 devres_add(dev, devres);
65 } else {
66 devres_free(devres);
67 }
68
69 return ret;
70}
71EXPORT_SYMBOL_GPL(devm_clk_bulk_get);
72
73static int devm_clk_match(struct device *dev, void *res, void *data)
74{
75 struct clk **c = res;
76 if (!c || !*c) {
77 WARN_ON(!c || !*c);
78 return 0;
79 }
80 return *c == data;
81}
82
83void devm_clk_put(struct device *dev, struct clk *clk)
84{
85 int ret;
86
87 ret = devres_release(dev, devm_clk_release, devm_clk_match, clk);
88
89 WARN_ON(ret);
90}
91EXPORT_SYMBOL(devm_clk_put);
92
93struct clk *devm_get_clk_from_child(struct device *dev,
94 struct device_node *np, const char *con_id)
95{
96 struct clk **ptr, *clk;
97
98 ptr = devres_alloc(devm_clk_release, sizeof(*ptr), GFP_KERNEL);
99 if (!ptr)
100 return ERR_PTR(-ENOMEM);
101
102 clk = of_clk_get_by_name(np, con_id);
103 if (!IS_ERR(clk)) {
104 *ptr = clk;
105 devres_add(dev, ptr);
106 } else {
107 devres_free(ptr);
108 }
109
110 return clk;
111}
112EXPORT_SYMBOL(devm_get_clk_from_child);