]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | /* SPDX-License-Identifier: GPL-2.0 */ |
61fc4131 PZ |
2 | #ifndef _LINUX_RESET_H_ |
3 | #define _LINUX_RESET_H_ | |
4 | ||
dfc1d9b2 | 5 | #include <linux/types.h> |
6c96f05c | 6 | |
dfc1d9b2 MY |
7 | struct device; |
8 | struct device_node; | |
61fc4131 PZ |
9 | struct reset_control; |
10 | ||
b424080a PZ |
11 | #ifdef CONFIG_RESET_CONTROLLER |
12 | ||
61fc4131 PZ |
13 | int reset_control_reset(struct reset_control *rstc); |
14 | int reset_control_assert(struct reset_control *rstc); | |
15 | int reset_control_deassert(struct reset_control *rstc); | |
729de41b | 16 | int reset_control_status(struct reset_control *rstc); |
61fc4131 | 17 | |
6c96f05c | 18 | struct reset_control *__of_reset_control_get(struct device_node *node, |
bb475230 RO |
19 | const char *id, int index, bool shared, |
20 | bool optional); | |
62e24c57 PZ |
21 | struct reset_control *__reset_control_get(struct device *dev, const char *id, |
22 | int index, bool shared, | |
23 | bool optional); | |
61fc4131 | 24 | void reset_control_put(struct reset_control *rstc); |
1554bbd4 | 25 | int __device_reset(struct device *dev, bool optional); |
6c96f05c | 26 | struct reset_control *__devm_reset_control_get(struct device *dev, |
bb475230 RO |
27 | const char *id, int index, bool shared, |
28 | bool optional); | |
61fc4131 | 29 | |
17c82e20 VG |
30 | struct reset_control *devm_reset_control_array_get(struct device *dev, |
31 | bool shared, bool optional); | |
32 | struct reset_control *of_reset_control_array_get(struct device_node *np, | |
33 | bool shared, bool optional); | |
34 | ||
eaf91db0 GU |
35 | int reset_control_get_count(struct device *dev); |
36 | ||
b424080a PZ |
37 | #else |
38 | ||
39 | static inline int reset_control_reset(struct reset_control *rstc) | |
40 | { | |
b424080a PZ |
41 | return 0; |
42 | } | |
43 | ||
44 | static inline int reset_control_assert(struct reset_control *rstc) | |
45 | { | |
b424080a PZ |
46 | return 0; |
47 | } | |
48 | ||
49 | static inline int reset_control_deassert(struct reset_control *rstc) | |
50 | { | |
b424080a PZ |
51 | return 0; |
52 | } | |
53 | ||
729de41b DN |
54 | static inline int reset_control_status(struct reset_control *rstc) |
55 | { | |
729de41b DN |
56 | return 0; |
57 | } | |
58 | ||
b424080a PZ |
59 | static inline void reset_control_put(struct reset_control *rstc) |
60 | { | |
b424080a PZ |
61 | } |
62 | ||
1554bbd4 | 63 | static inline int __device_reset(struct device *dev, bool optional) |
b424080a | 64 | { |
1554bbd4 | 65 | return optional ? 0 : -ENOTSUPP; |
b424080a PZ |
66 | } |
67 | ||
6c96f05c HG |
68 | static inline struct reset_control *__of_reset_control_get( |
69 | struct device_node *node, | |
bb475230 RO |
70 | const char *id, int index, bool shared, |
71 | bool optional) | |
5bcd0b7f | 72 | { |
0ca10b60 | 73 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
5bcd0b7f AL |
74 | } |
75 | ||
62e24c57 PZ |
76 | static inline struct reset_control *__reset_control_get( |
77 | struct device *dev, const char *id, | |
78 | int index, bool shared, bool optional) | |
79 | { | |
80 | return optional ? NULL : ERR_PTR(-ENOTSUPP); | |
81 | } | |
82 | ||
6c96f05c | 83 | static inline struct reset_control *__devm_reset_control_get( |
bb475230 RO |
84 | struct device *dev, const char *id, |
85 | int index, bool shared, bool optional) | |
5bcd0b7f | 86 | { |
0ca10b60 | 87 | return optional ? NULL : ERR_PTR(-ENOTSUPP); |
5bcd0b7f AL |
88 | } |
89 | ||
17c82e20 VG |
90 | static inline struct reset_control * |
91 | devm_reset_control_array_get(struct device *dev, bool shared, bool optional) | |
92 | { | |
93 | return optional ? NULL : ERR_PTR(-ENOTSUPP); | |
94 | } | |
95 | ||
96 | static inline struct reset_control * | |
97 | of_reset_control_array_get(struct device_node *np, bool shared, bool optional) | |
98 | { | |
99 | return optional ? NULL : ERR_PTR(-ENOTSUPP); | |
100 | } | |
101 | ||
eaf91db0 GU |
102 | static inline int reset_control_get_count(struct device *dev) |
103 | { | |
104 | return -ENOENT; | |
105 | } | |
106 | ||
6c96f05c HG |
107 | #endif /* CONFIG_RESET_CONTROLLER */ |
108 | ||
1554bbd4 MY |
109 | static inline int __must_check device_reset(struct device *dev) |
110 | { | |
111 | return __device_reset(dev, false); | |
112 | } | |
113 | ||
114 | static inline int device_reset_optional(struct device *dev) | |
115 | { | |
116 | return __device_reset(dev, true); | |
117 | } | |
118 | ||
6c96f05c | 119 | /** |
a53e35db LJ |
120 | * reset_control_get_exclusive - Lookup and obtain an exclusive reference |
121 | * to a reset controller. | |
6c96f05c HG |
122 | * @dev: device to be reset by the controller |
123 | * @id: reset line name | |
124 | * | |
125 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
34845c93 | 126 | * If this function is called more than once for the same reset_control it will |
0b52297f HG |
127 | * return -EBUSY. |
128 | * | |
129 | * See reset_control_get_shared for details on shared references to | |
130 | * reset-controls. | |
6c96f05c HG |
131 | * |
132 | * Use of id names is optional. | |
133 | */ | |
a53e35db LJ |
134 | static inline struct reset_control * |
135 | __must_check reset_control_get_exclusive(struct device *dev, const char *id) | |
b424080a | 136 | { |
62e24c57 | 137 | return __reset_control_get(dev, id, 0, false, false); |
b424080a PZ |
138 | } |
139 | ||
6c96f05c | 140 | /** |
0b52297f HG |
141 | * reset_control_get_shared - Lookup and obtain a shared reference to a |
142 | * reset controller. | |
143 | * @dev: device to be reset by the controller | |
144 | * @id: reset line name | |
145 | * | |
146 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
147 | * This function is intended for use with reset-controls which are shared | |
12c62b9d | 148 | * between hardware blocks. |
0b52297f HG |
149 | * |
150 | * When a reset-control is shared, the behavior of reset_control_assert / | |
151 | * deassert is changed, the reset-core will keep track of a deassert_count | |
152 | * and only (re-)assert the reset after reset_control_assert has been called | |
153 | * as many times as reset_control_deassert was called. Also see the remark | |
154 | * about shared reset-controls in the reset_control_assert docs. | |
155 | * | |
156 | * Calling reset_control_assert without first calling reset_control_deassert | |
157 | * is not allowed on a shared reset control. Calling reset_control_reset is | |
158 | * also not allowed on a shared reset control. | |
159 | * | |
160 | * Use of id names is optional. | |
161 | */ | |
162 | static inline struct reset_control *reset_control_get_shared( | |
163 | struct device *dev, const char *id) | |
164 | { | |
62e24c57 | 165 | return __reset_control_get(dev, id, 0, true, false); |
0b52297f HG |
166 | } |
167 | ||
a53e35db | 168 | static inline struct reset_control *reset_control_get_optional_exclusive( |
3c35f6ed LJ |
169 | struct device *dev, const char *id) |
170 | { | |
62e24c57 | 171 | return __reset_control_get(dev, id, 0, false, true); |
3c35f6ed LJ |
172 | } |
173 | ||
c33d61a0 LJ |
174 | static inline struct reset_control *reset_control_get_optional_shared( |
175 | struct device *dev, const char *id) | |
176 | { | |
62e24c57 | 177 | return __reset_control_get(dev, id, 0, true, true); |
c33d61a0 LJ |
178 | } |
179 | ||
0b52297f | 180 | /** |
a53e35db LJ |
181 | * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference |
182 | * to a reset controller. | |
6c96f05c HG |
183 | * @node: device to be reset by the controller |
184 | * @id: reset line name | |
185 | * | |
186 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
187 | * | |
188 | * Use of id names is optional. | |
189 | */ | |
a53e35db | 190 | static inline struct reset_control *of_reset_control_get_exclusive( |
e3ec0a8c HG |
191 | struct device_node *node, const char *id) |
192 | { | |
bb475230 | 193 | return __of_reset_control_get(node, id, 0, false, false); |
e3ec0a8c HG |
194 | } |
195 | ||
6c96f05c | 196 | /** |
12c62b9d | 197 | * of_reset_control_get_shared - Lookup and obtain a shared reference |
40faee8e LJ |
198 | * to a reset controller. |
199 | * @node: device to be reset by the controller | |
200 | * @id: reset line name | |
201 | * | |
202 | * When a reset-control is shared, the behavior of reset_control_assert / | |
203 | * deassert is changed, the reset-core will keep track of a deassert_count | |
204 | * and only (re-)assert the reset after reset_control_assert has been called | |
205 | * as many times as reset_control_deassert was called. Also see the remark | |
206 | * about shared reset-controls in the reset_control_assert docs. | |
207 | * | |
208 | * Calling reset_control_assert without first calling reset_control_deassert | |
209 | * is not allowed on a shared reset control. Calling reset_control_reset is | |
210 | * also not allowed on a shared reset control. | |
211 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
212 | * | |
213 | * Use of id names is optional. | |
214 | */ | |
215 | static inline struct reset_control *of_reset_control_get_shared( | |
216 | struct device_node *node, const char *id) | |
217 | { | |
bb475230 | 218 | return __of_reset_control_get(node, id, 0, true, false); |
40faee8e LJ |
219 | } |
220 | ||
6c96f05c | 221 | /** |
a53e35db LJ |
222 | * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive |
223 | * reference to a reset controller | |
224 | * by index. | |
6c96f05c HG |
225 | * @node: device to be reset by the controller |
226 | * @index: index of the reset controller | |
227 | * | |
228 | * This is to be used to perform a list of resets for a device or power domain | |
229 | * in whatever order. Returns a struct reset_control or IS_ERR() condition | |
230 | * containing errno. | |
231 | */ | |
a53e35db | 232 | static inline struct reset_control *of_reset_control_get_exclusive_by_index( |
6c96f05c | 233 | struct device_node *node, int index) |
c0a13aa6 | 234 | { |
bb475230 | 235 | return __of_reset_control_get(node, NULL, index, false, false); |
c0a13aa6 VH |
236 | } |
237 | ||
6c96f05c | 238 | /** |
12c62b9d | 239 | * of_reset_control_get_shared_by_index - Lookup and obtain a shared |
40faee8e LJ |
240 | * reference to a reset controller |
241 | * by index. | |
242 | * @node: device to be reset by the controller | |
243 | * @index: index of the reset controller | |
244 | * | |
245 | * When a reset-control is shared, the behavior of reset_control_assert / | |
246 | * deassert is changed, the reset-core will keep track of a deassert_count | |
247 | * and only (re-)assert the reset after reset_control_assert has been called | |
248 | * as many times as reset_control_deassert was called. Also see the remark | |
249 | * about shared reset-controls in the reset_control_assert docs. | |
250 | * | |
251 | * Calling reset_control_assert without first calling reset_control_deassert | |
252 | * is not allowed on a shared reset control. Calling reset_control_reset is | |
253 | * also not allowed on a shared reset control. | |
254 | * Returns a struct reset_control or IS_ERR() condition containing errno. | |
6c96f05c | 255 | * |
40faee8e LJ |
256 | * This is to be used to perform a list of resets for a device or power domain |
257 | * in whatever order. Returns a struct reset_control or IS_ERR() condition | |
258 | * containing errno. | |
6c96f05c | 259 | */ |
40faee8e LJ |
260 | static inline struct reset_control *of_reset_control_get_shared_by_index( |
261 | struct device_node *node, int index) | |
6c96f05c | 262 | { |
bb475230 | 263 | return __of_reset_control_get(node, NULL, index, true, false); |
6c96f05c HG |
264 | } |
265 | ||
266 | /** | |
a53e35db LJ |
267 | * devm_reset_control_get_exclusive - resource managed |
268 | * reset_control_get_exclusive() | |
6c96f05c | 269 | * @dev: device to be reset by the controller |
6c96f05c | 270 | * @id: reset line name |
6c96f05c | 271 | * |
a53e35db LJ |
272 | * Managed reset_control_get_exclusive(). For reset controllers returned |
273 | * from this function, reset_control_put() is called automatically on driver | |
274 | * detach. | |
275 | * | |
276 | * See reset_control_get_exclusive() for more information. | |
6c96f05c | 277 | */ |
a53e35db LJ |
278 | static inline struct reset_control * |
279 | __must_check devm_reset_control_get_exclusive(struct device *dev, | |
280 | const char *id) | |
6c96f05c | 281 | { |
bb475230 | 282 | return __devm_reset_control_get(dev, id, 0, false, false); |
0b52297f HG |
283 | } |
284 | ||
285 | /** | |
286 | * devm_reset_control_get_shared - resource managed reset_control_get_shared() | |
287 | * @dev: device to be reset by the controller | |
288 | * @id: reset line name | |
289 | * | |
290 | * Managed reset_control_get_shared(). For reset controllers returned from | |
291 | * this function, reset_control_put() is called automatically on driver detach. | |
292 | * See reset_control_get_shared() for more information. | |
293 | */ | |
294 | static inline struct reset_control *devm_reset_control_get_shared( | |
295 | struct device *dev, const char *id) | |
296 | { | |
bb475230 | 297 | return __devm_reset_control_get(dev, id, 0, true, false); |
0b52297f HG |
298 | } |
299 | ||
a53e35db | 300 | static inline struct reset_control *devm_reset_control_get_optional_exclusive( |
6c96f05c HG |
301 | struct device *dev, const char *id) |
302 | { | |
bb475230 | 303 | return __devm_reset_control_get(dev, id, 0, false, true); |
6c96f05c HG |
304 | } |
305 | ||
c33d61a0 LJ |
306 | static inline struct reset_control *devm_reset_control_get_optional_shared( |
307 | struct device *dev, const char *id) | |
308 | { | |
bb475230 | 309 | return __devm_reset_control_get(dev, id, 0, true, true); |
c33d61a0 LJ |
310 | } |
311 | ||
6c96f05c | 312 | /** |
a53e35db LJ |
313 | * devm_reset_control_get_exclusive_by_index - resource managed |
314 | * reset_control_get_exclusive() | |
6c96f05c HG |
315 | * @dev: device to be reset by the controller |
316 | * @index: index of the reset controller | |
317 | * | |
a53e35db LJ |
318 | * Managed reset_control_get_exclusive(). For reset controllers returned from |
319 | * this function, reset_control_put() is called automatically on driver | |
320 | * detach. | |
321 | * | |
322 | * See reset_control_get_exclusive() for more information. | |
6c96f05c | 323 | */ |
a53e35db LJ |
324 | static inline struct reset_control * |
325 | devm_reset_control_get_exclusive_by_index(struct device *dev, int index) | |
6c96f05c | 326 | { |
bb475230 | 327 | return __devm_reset_control_get(dev, NULL, index, false, false); |
0b52297f HG |
328 | } |
329 | ||
0b52297f HG |
330 | /** |
331 | * devm_reset_control_get_shared_by_index - resource managed | |
12c62b9d | 332 | * reset_control_get_shared |
0b52297f HG |
333 | * @dev: device to be reset by the controller |
334 | * @index: index of the reset controller | |
335 | * | |
336 | * Managed reset_control_get_shared(). For reset controllers returned from | |
337 | * this function, reset_control_put() is called automatically on driver detach. | |
338 | * See reset_control_get_shared() for more information. | |
339 | */ | |
0bcc0eab LJ |
340 | static inline struct reset_control * |
341 | devm_reset_control_get_shared_by_index(struct device *dev, int index) | |
0b52297f | 342 | { |
bb475230 | 343 | return __devm_reset_control_get(dev, NULL, index, true, false); |
6c96f05c | 344 | } |
61fc4131 | 345 | |
a53e35db LJ |
346 | /* |
347 | * TEMPORARY calls to use during transition: | |
348 | * | |
349 | * of_reset_control_get() => of_reset_control_get_exclusive() | |
350 | * | |
351 | * These inline function calls will be removed once all consumers | |
352 | * have been moved over to the new explicit API. | |
353 | */ | |
a53e35db LJ |
354 | static inline struct reset_control *of_reset_control_get( |
355 | struct device_node *node, const char *id) | |
356 | { | |
357 | return of_reset_control_get_exclusive(node, id); | |
358 | } | |
359 | ||
360 | static inline struct reset_control *of_reset_control_get_by_index( | |
361 | struct device_node *node, int index) | |
362 | { | |
363 | return of_reset_control_get_exclusive_by_index(node, index); | |
364 | } | |
365 | ||
366 | static inline struct reset_control *devm_reset_control_get( | |
367 | struct device *dev, const char *id) | |
368 | { | |
369 | return devm_reset_control_get_exclusive(dev, id); | |
370 | } | |
371 | ||
372 | static inline struct reset_control *devm_reset_control_get_optional( | |
373 | struct device *dev, const char *id) | |
374 | { | |
375 | return devm_reset_control_get_optional_exclusive(dev, id); | |
376 | ||
377 | } | |
378 | ||
379 | static inline struct reset_control *devm_reset_control_get_by_index( | |
380 | struct device *dev, int index) | |
381 | { | |
382 | return devm_reset_control_get_exclusive_by_index(dev, index); | |
383 | } | |
17c82e20 VG |
384 | |
385 | /* | |
386 | * APIs to manage a list of reset controllers | |
387 | */ | |
388 | static inline struct reset_control * | |
389 | devm_reset_control_array_get_exclusive(struct device *dev) | |
390 | { | |
391 | return devm_reset_control_array_get(dev, false, false); | |
392 | } | |
393 | ||
394 | static inline struct reset_control * | |
395 | devm_reset_control_array_get_shared(struct device *dev) | |
396 | { | |
397 | return devm_reset_control_array_get(dev, true, false); | |
398 | } | |
399 | ||
400 | static inline struct reset_control * | |
401 | devm_reset_control_array_get_optional_exclusive(struct device *dev) | |
402 | { | |
403 | return devm_reset_control_array_get(dev, false, true); | |
404 | } | |
405 | ||
406 | static inline struct reset_control * | |
407 | devm_reset_control_array_get_optional_shared(struct device *dev) | |
408 | { | |
409 | return devm_reset_control_array_get(dev, true, true); | |
410 | } | |
411 | ||
412 | static inline struct reset_control * | |
413 | of_reset_control_array_get_exclusive(struct device_node *node) | |
414 | { | |
415 | return of_reset_control_array_get(node, false, false); | |
416 | } | |
417 | ||
418 | static inline struct reset_control * | |
419 | of_reset_control_array_get_shared(struct device_node *node) | |
420 | { | |
421 | return of_reset_control_array_get(node, true, false); | |
422 | } | |
423 | ||
424 | static inline struct reset_control * | |
425 | of_reset_control_array_get_optional_exclusive(struct device_node *node) | |
426 | { | |
427 | return of_reset_control_array_get(node, false, true); | |
428 | } | |
429 | ||
430 | static inline struct reset_control * | |
431 | of_reset_control_array_get_optional_shared(struct device_node *node) | |
432 | { | |
433 | return of_reset_control_array_get(node, true, true); | |
434 | } | |
61fc4131 | 435 | #endif |