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