1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_RESET_H_
3 #define _LINUX_RESET_H_
6 #include <linux/errno.h>
7 #include <linux/types.h>
13 #ifdef CONFIG_RESET_CONTROLLER
15 int reset_control_reset(struct reset_control *rstc);
16 int reset_control_assert(struct reset_control *rstc);
17 int reset_control_deassert(struct reset_control *rstc);
18 int reset_control_status(struct reset_control *rstc);
19 int reset_control_acquire(struct reset_control *rstc);
20 void reset_control_release(struct reset_control *rstc);
22 struct reset_control *__of_reset_control_get(struct device_node *node,
23 const char *id, int index, bool shared,
24 bool optional, bool acquired);
25 struct reset_control *__reset_control_get(struct device *dev, const char *id,
26 int index, bool shared,
27 bool optional, bool acquired);
28 void reset_control_put(struct reset_control *rstc);
29 int __device_reset(struct device *dev, bool optional);
30 struct reset_control *__devm_reset_control_get(struct device *dev,
31 const char *id, int index, bool shared,
32 bool optional, bool acquired);
34 struct reset_control *devm_reset_control_array_get(struct device *dev,
35 bool shared, bool optional);
36 struct reset_control *of_reset_control_array_get(struct device_node *np,
37 bool shared, bool optional,
40 int reset_control_get_count(struct device *dev);
44 static inline int reset_control_reset(struct reset_control *rstc)
49 static inline int reset_control_assert(struct reset_control *rstc)
54 static inline int reset_control_deassert(struct reset_control *rstc)
59 static inline int reset_control_status(struct reset_control *rstc)
64 static inline int reset_control_acquire(struct reset_control *rstc)
69 static inline void reset_control_release(struct reset_control *rstc)
73 static inline void reset_control_put(struct reset_control *rstc)
77 static inline int __device_reset(struct device *dev, bool optional)
79 return optional ? 0 : -ENOTSUPP;
82 static inline struct reset_control *__of_reset_control_get(
83 struct device_node *node,
84 const char *id, int index, bool shared,
85 bool optional, bool acquired)
87 return optional ? NULL : ERR_PTR(-ENOTSUPP);
90 static inline struct reset_control *__reset_control_get(
91 struct device *dev, const char *id,
92 int index, bool shared, bool optional,
95 return optional ? NULL : ERR_PTR(-ENOTSUPP);
98 static inline struct reset_control *__devm_reset_control_get(
99 struct device *dev, const char *id,
100 int index, bool shared, bool optional,
103 return optional ? NULL : ERR_PTR(-ENOTSUPP);
106 static inline struct reset_control *
107 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
109 return optional ? NULL : ERR_PTR(-ENOTSUPP);
112 static inline struct reset_control *
113 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
116 return optional ? NULL : ERR_PTR(-ENOTSUPP);
119 static inline int reset_control_get_count(struct device *dev)
124 #endif /* CONFIG_RESET_CONTROLLER */
126 static inline int __must_check device_reset(struct device *dev)
128 return __device_reset(dev, false);
131 static inline int device_reset_optional(struct device *dev)
133 return __device_reset(dev, true);
137 * reset_control_get_exclusive - Lookup and obtain an exclusive reference
138 * to a reset controller.
139 * @dev: device to be reset by the controller
140 * @id: reset line name
142 * Returns a struct reset_control or IS_ERR() condition containing errno.
143 * If this function is called more than once for the same reset_control it will
146 * See reset_control_get_shared() for details on shared references to
149 * Use of id names is optional.
151 static inline struct reset_control *
152 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
154 return __reset_control_get(dev, id, 0, false, false, true);
158 * reset_control_get_exclusive_released - Lookup and obtain a temoprarily
159 * exclusive reference to a reset
161 * @dev: device to be reset by the controller
162 * @id: reset line name
164 * Returns a struct reset_control or IS_ERR() condition containing errno.
165 * reset-controls returned by this function must be acquired via
166 * reset_control_acquire() before they can be used and should be released
167 * via reset_control_release() afterwards.
169 * Use of id names is optional.
171 static inline struct reset_control *
172 __must_check reset_control_get_exclusive_released(struct device *dev,
175 return __reset_control_get(dev, id, 0, false, false, false);
179 * reset_control_get_shared - Lookup and obtain a shared reference to a
181 * @dev: device to be reset by the controller
182 * @id: reset line name
184 * Returns a struct reset_control or IS_ERR() condition containing errno.
185 * This function is intended for use with reset-controls which are shared
186 * between hardware blocks.
188 * When a reset-control is shared, the behavior of reset_control_assert /
189 * deassert is changed, the reset-core will keep track of a deassert_count
190 * and only (re-)assert the reset after reset_control_assert has been called
191 * as many times as reset_control_deassert was called. Also see the remark
192 * about shared reset-controls in the reset_control_assert docs.
194 * Calling reset_control_assert without first calling reset_control_deassert
195 * is not allowed on a shared reset control. Calling reset_control_reset is
196 * also not allowed on a shared reset control.
198 * Use of id names is optional.
200 static inline struct reset_control *reset_control_get_shared(
201 struct device *dev, const char *id)
203 return __reset_control_get(dev, id, 0, true, false, false);
207 * reset_control_get_optional_exclusive - optional reset_control_get_exclusive()
208 * @dev: device to be reset by the controller
209 * @id: reset line name
211 * Optional variant of reset_control_get_exclusive(). If the requested reset
212 * is not specified in the device tree, this function returns NULL instead of
215 * See reset_control_get_exclusive() for more information.
217 static inline struct reset_control *reset_control_get_optional_exclusive(
218 struct device *dev, const char *id)
220 return __reset_control_get(dev, id, 0, false, true, true);
224 * reset_control_get_optional_shared - optional reset_control_get_shared()
225 * @dev: device to be reset by the controller
226 * @id: reset line name
228 * Optional variant of reset_control_get_shared(). If the requested reset
229 * is not specified in the device tree, this function returns NULL instead of
232 * See reset_control_get_shared() for more information.
234 static inline struct reset_control *reset_control_get_optional_shared(
235 struct device *dev, const char *id)
237 return __reset_control_get(dev, id, 0, true, true, false);
241 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
242 * to a reset controller.
243 * @node: device to be reset by the controller
244 * @id: reset line name
246 * Returns a struct reset_control or IS_ERR() condition containing errno.
248 * Use of id names is optional.
250 static inline struct reset_control *of_reset_control_get_exclusive(
251 struct device_node *node, const char *id)
253 return __of_reset_control_get(node, id, 0, false, false, true);
257 * of_reset_control_get_shared - Lookup and obtain a shared reference
258 * to a reset controller.
259 * @node: device to be reset by the controller
260 * @id: reset line name
262 * When a reset-control is shared, the behavior of reset_control_assert /
263 * deassert is changed, the reset-core will keep track of a deassert_count
264 * and only (re-)assert the reset after reset_control_assert has been called
265 * as many times as reset_control_deassert was called. Also see the remark
266 * about shared reset-controls in the reset_control_assert docs.
268 * Calling reset_control_assert without first calling reset_control_deassert
269 * is not allowed on a shared reset control. Calling reset_control_reset is
270 * also not allowed on a shared reset control.
271 * Returns a struct reset_control or IS_ERR() condition containing errno.
273 * Use of id names is optional.
275 static inline struct reset_control *of_reset_control_get_shared(
276 struct device_node *node, const char *id)
278 return __of_reset_control_get(node, id, 0, true, false, false);
282 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
283 * reference to a reset controller
285 * @node: device to be reset by the controller
286 * @index: index of the reset controller
288 * This is to be used to perform a list of resets for a device or power domain
289 * in whatever order. Returns a struct reset_control or IS_ERR() condition
292 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
293 struct device_node *node, int index)
295 return __of_reset_control_get(node, NULL, index, false, false, true);
299 * of_reset_control_get_shared_by_index - Lookup and obtain a shared
300 * reference to a reset controller
302 * @node: device to be reset by the controller
303 * @index: index of the reset controller
305 * When a reset-control is shared, the behavior of reset_control_assert /
306 * deassert is changed, the reset-core will keep track of a deassert_count
307 * and only (re-)assert the reset after reset_control_assert has been called
308 * as many times as reset_control_deassert was called. Also see the remark
309 * about shared reset-controls in the reset_control_assert docs.
311 * Calling reset_control_assert without first calling reset_control_deassert
312 * is not allowed on a shared reset control. Calling reset_control_reset is
313 * also not allowed on a shared reset control.
314 * Returns a struct reset_control or IS_ERR() condition containing errno.
316 * This is to be used to perform a list of resets for a device or power domain
317 * in whatever order. Returns a struct reset_control or IS_ERR() condition
320 static inline struct reset_control *of_reset_control_get_shared_by_index(
321 struct device_node *node, int index)
323 return __of_reset_control_get(node, NULL, index, true, false, false);
327 * devm_reset_control_get_exclusive - resource managed
328 * reset_control_get_exclusive()
329 * @dev: device to be reset by the controller
330 * @id: reset line name
332 * Managed reset_control_get_exclusive(). For reset controllers returned
333 * from this function, reset_control_put() is called automatically on driver
336 * See reset_control_get_exclusive() for more information.
338 static inline struct reset_control *
339 __must_check devm_reset_control_get_exclusive(struct device *dev,
342 return __devm_reset_control_get(dev, id, 0, false, false, true);
346 * devm_reset_control_get_exclusive_released - resource managed
347 * reset_control_get_exclusive_released()
348 * @dev: device to be reset by the controller
349 * @id: reset line name
351 * Managed reset_control_get_exclusive_released(). For reset controllers
352 * returned from this function, reset_control_put() is called automatically on
355 * See reset_control_get_exclusive_released() for more information.
357 static inline struct reset_control *
358 __must_check devm_reset_control_get_exclusive_released(struct device *dev,
361 return __devm_reset_control_get(dev, id, 0, false, false, false);
365 * devm_reset_control_get_shared - resource managed reset_control_get_shared()
366 * @dev: device to be reset by the controller
367 * @id: reset line name
369 * Managed reset_control_get_shared(). For reset controllers returned from
370 * this function, reset_control_put() is called automatically on driver detach.
371 * See reset_control_get_shared() for more information.
373 static inline struct reset_control *devm_reset_control_get_shared(
374 struct device *dev, const char *id)
376 return __devm_reset_control_get(dev, id, 0, true, false, false);
380 * devm_reset_control_get_optional_exclusive - resource managed
381 * reset_control_get_optional_exclusive()
382 * @dev: device to be reset by the controller
383 * @id: reset line name
385 * Managed reset_control_get_optional_exclusive(). For reset controllers
386 * returned from this function, reset_control_put() is called automatically on
389 * See reset_control_get_optional_exclusive() for more information.
391 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
392 struct device *dev, const char *id)
394 return __devm_reset_control_get(dev, id, 0, false, true, true);
398 * devm_reset_control_get_optional_shared - resource managed
399 * reset_control_get_optional_shared()
400 * @dev: device to be reset by the controller
401 * @id: reset line name
403 * Managed reset_control_get_optional_shared(). For reset controllers returned
404 * from this function, reset_control_put() is called automatically on driver
407 * See reset_control_get_optional_shared() for more information.
409 static inline struct reset_control *devm_reset_control_get_optional_shared(
410 struct device *dev, const char *id)
412 return __devm_reset_control_get(dev, id, 0, true, true, false);
416 * devm_reset_control_get_exclusive_by_index - resource managed
417 * reset_control_get_exclusive()
418 * @dev: device to be reset by the controller
419 * @index: index of the reset controller
421 * Managed reset_control_get_exclusive(). For reset controllers returned from
422 * this function, reset_control_put() is called automatically on driver
425 * See reset_control_get_exclusive() for more information.
427 static inline struct reset_control *
428 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
430 return __devm_reset_control_get(dev, NULL, index, false, false, true);
434 * devm_reset_control_get_shared_by_index - resource managed
435 * reset_control_get_shared
436 * @dev: device to be reset by the controller
437 * @index: index of the reset controller
439 * Managed reset_control_get_shared(). For reset controllers returned from
440 * this function, reset_control_put() is called automatically on driver detach.
441 * See reset_control_get_shared() for more information.
443 static inline struct reset_control *
444 devm_reset_control_get_shared_by_index(struct device *dev, int index)
446 return __devm_reset_control_get(dev, NULL, index, true, false, false);
450 * TEMPORARY calls to use during transition:
452 * of_reset_control_get() => of_reset_control_get_exclusive()
454 * These inline function calls will be removed once all consumers
455 * have been moved over to the new explicit API.
457 static inline struct reset_control *of_reset_control_get(
458 struct device_node *node, const char *id)
460 return of_reset_control_get_exclusive(node, id);
463 static inline struct reset_control *of_reset_control_get_by_index(
464 struct device_node *node, int index)
466 return of_reset_control_get_exclusive_by_index(node, index);
469 static inline struct reset_control *devm_reset_control_get(
470 struct device *dev, const char *id)
472 return devm_reset_control_get_exclusive(dev, id);
475 static inline struct reset_control *devm_reset_control_get_optional(
476 struct device *dev, const char *id)
478 return devm_reset_control_get_optional_exclusive(dev, id);
482 static inline struct reset_control *devm_reset_control_get_by_index(
483 struct device *dev, int index)
485 return devm_reset_control_get_exclusive_by_index(dev, index);
489 * APIs to manage a list of reset controllers
491 static inline struct reset_control *
492 devm_reset_control_array_get_exclusive(struct device *dev)
494 return devm_reset_control_array_get(dev, false, false);
497 static inline struct reset_control *
498 devm_reset_control_array_get_shared(struct device *dev)
500 return devm_reset_control_array_get(dev, true, false);
503 static inline struct reset_control *
504 devm_reset_control_array_get_optional_exclusive(struct device *dev)
506 return devm_reset_control_array_get(dev, false, true);
509 static inline struct reset_control *
510 devm_reset_control_array_get_optional_shared(struct device *dev)
512 return devm_reset_control_array_get(dev, true, true);
515 static inline struct reset_control *
516 of_reset_control_array_get_exclusive(struct device_node *node)
518 return of_reset_control_array_get(node, false, false, true);
521 static inline struct reset_control *
522 of_reset_control_array_get_exclusive_released(struct device_node *node)
524 return of_reset_control_array_get(node, false, false, false);
527 static inline struct reset_control *
528 of_reset_control_array_get_shared(struct device_node *node)
530 return of_reset_control_array_get(node, true, false, true);
533 static inline struct reset_control *
534 of_reset_control_array_get_optional_exclusive(struct device_node *node)
536 return of_reset_control_array_get(node, false, true, true);
539 static inline struct reset_control *
540 of_reset_control_array_get_optional_shared(struct device_node *node)
542 return of_reset_control_array_get(node, true, true, true);