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, clk_disable_unprepare_wrapper,
 32					 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(clk))
 43		return clk;
 44
 45	ret = kunit_add_action_or_reset(test, clk_put_wrapper, clk);
 46	if (ret)
 47		return ERR_PTR(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, 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(clk))
146		return clk;
147
148	ret = clk_prepare_enable_kunit(test, clk);
149	if (ret)
150		return ERR_PTR(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, clk_hw_unregister_wrapper, 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, clk_hw_unregister_wrapper, 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, of_clk_del_provider_wrapper, np);
233}
234EXPORT_SYMBOL_GPL(of_clk_add_hw_provider_kunit);
235
236MODULE_LICENSE("GPL");
237MODULE_DESCRIPTION("KUnit helpers for clk providers and consumers");