1// SPDX-License-Identifier: GPL-2.0
2/*
3 * KUnit helpers for clk providers and consumers
4 */
5#include <linux/clk.h>
6#include <linux/clk-provider.h>
7#include <linux/err.h>
8#include <linux/kernel.h>
9#include <linux/slab.h>
10
11#include <kunit/clk.h>
12#include <kunit/resource.h>
13
14KUNIT_DEFINE_ACTION_WRAPPER(clk_disable_unprepare_wrapper,
15 clk_disable_unprepare, struct clk *);
16/**
17 * clk_prepare_enable_kunit() - Test managed clk_prepare_enable()
18 * @test: The test context
19 * @clk: clk to prepare and enable
20 *
21 * Return: 0 on success, or negative errno on failure.
22 */
23int clk_prepare_enable_kunit(struct kunit *test, struct clk *clk)
24{
25 int ret;
26
27 ret = clk_prepare_enable(clk);
28 if (ret)
29 return ret;
30
31 return kunit_add_action_or_reset(test, action: clk_disable_unprepare_wrapper,
32 ctx: clk);
33}
34EXPORT_SYMBOL_GPL(clk_prepare_enable_kunit);
35
36KUNIT_DEFINE_ACTION_WRAPPER(clk_put_wrapper, clk_put, struct clk *);
37
38static struct clk *__clk_get_kunit(struct kunit *test, struct clk *clk)
39{
40 int ret;
41
42 if (IS_ERR(ptr: clk))
43 return clk;
44
45 ret = kunit_add_action_or_reset(test, action: clk_put_wrapper, ctx: clk);
46 if (ret)
47 return ERR_PTR(error: ret);
48
49 return clk;
50}
51
52/**
53 * clk_get_kunit() - Test managed clk_get()
54 * @test: The test context
55 * @dev: device for clock "consumer"
56 * @con_id: clock consumer ID
57 *
58 * Just like clk_get(), except the clk is managed by the test case and is
59 * automatically put with clk_put() after the test case concludes.
60 *
61 * Return: new clk consumer or ERR_PTR on failure.
62 */
63struct clk *
64clk_get_kunit(struct kunit *test, struct device *dev, const char *con_id)
65{
66 struct clk *clk;
67
68 clk = clk_get(dev, id: con_id);
69
70 return __clk_get_kunit(test, clk);
71}
72EXPORT_SYMBOL_GPL(clk_get_kunit);
73
74/**
75 * of_clk_get_kunit() - Test managed of_clk_get()
76 * @test: The test context
77 * @np: device_node for clock "consumer"
78 * @index: index in 'clocks' property of @np
79 *
80 * Just like of_clk_get(), except the clk is managed by the test case and is
81 * automatically put with clk_put() after the test case concludes.
82 *
83 * Return: new clk consumer or ERR_PTR on failure.
84 */
85struct clk *
86of_clk_get_kunit(struct kunit *test, struct device_node *np, int index)
87{
88 struct clk *clk;
89
90 clk = of_clk_get(np, index);
91
92 return __clk_get_kunit(test, clk);
93}
94EXPORT_SYMBOL_GPL(of_clk_get_kunit);
95
96/**
97 * clk_hw_get_clk_kunit() - Test managed clk_hw_get_clk()
98 * @test: The test context
99 * @hw: clk_hw associated with the clk being consumed
100 * @con_id: connection ID string on device
101 *
102 * Just like clk_hw_get_clk(), except the clk is managed by the test case and
103 * is automatically put with clk_put() after the test case concludes.
104 *
105 * Return: new clk consumer or ERR_PTR on failure.
106 */
107struct clk *
108clk_hw_get_clk_kunit(struct kunit *test, struct clk_hw *hw, const char *con_id)
109{
110 struct clk *clk;
111
112 clk = clk_hw_get_clk(hw, con_id);
113
114 return __clk_get_kunit(test, clk);
115}
116EXPORT_SYMBOL_GPL(clk_hw_get_clk_kunit);
117
118/**
119 * clk_hw_get_clk_prepared_enabled_kunit() - Test managed clk_hw_get_clk() + clk_prepare_enable()
120 * @test: The test context
121 * @hw: clk_hw associated with the clk being consumed
122 * @con_id: connection ID string on device
123 *
124 * Just like
125 *
126 * .. code-block:: c
127 *
128 * struct clk *clk = clk_hw_get_clk(...);
129 * clk_prepare_enable(clk);
130 *
131 * except the clk is managed by the test case and is automatically disabled and
132 * unprepared with clk_disable_unprepare() and put with clk_put() after the
133 * test case concludes.
134 *
135 * Return: new clk consumer that is prepared and enabled or ERR_PTR on failure.
136 */
137struct clk *
138clk_hw_get_clk_prepared_enabled_kunit(struct kunit *test, struct clk_hw *hw,
139 const char *con_id)
140{
141 int ret;
142 struct clk *clk;
143
144 clk = clk_hw_get_clk_kunit(test, hw, con_id);
145 if (IS_ERR(ptr: clk))
146 return clk;
147
148 ret = clk_prepare_enable_kunit(test, clk);
149 if (ret)
150 return ERR_PTR(error: ret);
151
152 return clk;
153}
154EXPORT_SYMBOL_GPL(clk_hw_get_clk_prepared_enabled_kunit);
155
156KUNIT_DEFINE_ACTION_WRAPPER(clk_hw_unregister_wrapper,
157 clk_hw_unregister, struct clk_hw *);
158
159/**
160 * clk_hw_register_kunit() - Test managed clk_hw_register()
161 * @test: The test context
162 * @dev: device that is registering this clock
163 * @hw: link to hardware-specific clock data
164 *
165 * Just like clk_hw_register(), except the clk registration is managed by the
166 * test case and is automatically unregistered after the test case concludes.
167 *
168 * Return: 0 on success or a negative errno value on failure.
169 */
170int clk_hw_register_kunit(struct kunit *test, struct device *dev, struct clk_hw *hw)
171{
172 int ret;
173
174 ret = clk_hw_register(dev, hw);
175 if (ret)
176 return ret;
177
178 return kunit_add_action_or_reset(test, action: clk_hw_unregister_wrapper, ctx: hw);
179}
180EXPORT_SYMBOL_GPL(clk_hw_register_kunit);
181
182/**
183 * of_clk_hw_register_kunit() - Test managed of_clk_hw_register()
184 * @test: The test context
185 * @node: device_node of device that is registering this clock
186 * @hw: link to hardware-specific clock data
187 *
188 * Just like of_clk_hw_register(), except the clk registration is managed by
189 * the test case and is automatically unregistered after the test case
190 * concludes.
191 *
192 * Return: 0 on success or a negative errno value on failure.
193 */
194int of_clk_hw_register_kunit(struct kunit *test, struct device_node *node, struct clk_hw *hw)
195{
196 int ret;
197
198 ret = of_clk_hw_register(node, hw);
199 if (ret)
200 return ret;
201
202 return kunit_add_action_or_reset(test, action: clk_hw_unregister_wrapper, ctx: hw);
203}
204EXPORT_SYMBOL_GPL(of_clk_hw_register_kunit);
205
206KUNIT_DEFINE_ACTION_WRAPPER(of_clk_del_provider_wrapper,
207 of_clk_del_provider, struct device_node *);
208
209/**
210 * of_clk_add_hw_provider_kunit() - Test managed of_clk_add_hw_provider()
211 * @test: The test context
212 * @np: Device node pointer associated with clock provider
213 * @get: Callback for decoding clk_hw
214 * @data: Context pointer for @get callback.
215 *
216 * Just like of_clk_add_hw_provider(), except the clk_hw provider is managed by
217 * the test case and is automatically unregistered after the test case
218 * concludes.
219 *
220 * Return: 0 on success or a negative errno value on failure.
221 */
222int of_clk_add_hw_provider_kunit(struct kunit *test, struct device_node *np,
223 struct clk_hw *(*get)(struct of_phandle_args *clkspec, void *data),
224 void *data)
225{
226 int ret;
227
228 ret = of_clk_add_hw_provider(np, get, data);
229 if (ret)
230 return ret;
231
232 return kunit_add_action_or_reset(test, action: of_clk_del_provider_wrapper, ctx: np);
233}
234EXPORT_SYMBOL_GPL(of_clk_add_hw_provider_kunit);
235
236MODULE_LICENSE("GPL");
237MODULE_DESCRIPTION("KUnit helpers for clk providers and consumers");
238

source code of linux/drivers/clk/clk_kunit_helpers.c