1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_RESET_H_
3 #define _LINUX_RESET_H_
5 #include <linux/device.h>
9 #ifdef CONFIG_RESET_CONTROLLER
11 int reset_control_reset(struct reset_control *rstc);
12 int reset_control_assert(struct reset_control *rstc);
13 int reset_control_deassert(struct reset_control *rstc);
14 int reset_control_status(struct reset_control *rstc);
16 struct reset_control *__of_reset_control_get(struct device_node *node,
17 const char *id, int index, bool shared,
19 struct reset_control *__reset_control_get(struct device *dev, const char *id,
20 int index, bool shared,
22 void reset_control_put(struct reset_control *rstc);
23 struct reset_control *__devm_reset_control_get(struct device *dev,
24 const char *id, int index, bool shared,
27 int __must_check device_reset(struct device *dev);
29 struct reset_control *devm_reset_control_array_get(struct device *dev,
30 bool shared, bool optional);
31 struct reset_control *of_reset_control_array_get(struct device_node *np,
32 bool shared, bool optional);
34 static inline int device_reset_optional(struct device *dev)
36 return device_reset(dev);
41 static inline int reset_control_reset(struct reset_control *rstc)
46 static inline int reset_control_assert(struct reset_control *rstc)
51 static inline int reset_control_deassert(struct reset_control *rstc)
56 static inline int reset_control_status(struct reset_control *rstc)
61 static inline void reset_control_put(struct reset_control *rstc)
65 static inline int __must_check device_reset(struct device *dev)
71 static inline int device_reset_optional(struct device *dev)
76 static inline struct reset_control *__of_reset_control_get(
77 struct device_node *node,
78 const char *id, int index, bool shared,
81 return optional ? NULL : ERR_PTR(-ENOTSUPP);
84 static inline struct reset_control *__reset_control_get(
85 struct device *dev, const char *id,
86 int index, bool shared, bool optional)
88 return optional ? NULL : ERR_PTR(-ENOTSUPP);
91 static inline struct reset_control *__devm_reset_control_get(
92 struct device *dev, const char *id,
93 int index, bool shared, bool optional)
95 return optional ? NULL : ERR_PTR(-ENOTSUPP);
98 static inline struct reset_control *
99 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
101 return optional ? NULL : ERR_PTR(-ENOTSUPP);
104 static inline struct reset_control *
105 of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
107 return optional ? NULL : ERR_PTR(-ENOTSUPP);
110 #endif /* CONFIG_RESET_CONTROLLER */
113 * reset_control_get_exclusive - Lookup and obtain an exclusive reference
114 * to a reset controller.
115 * @dev: device to be reset by the controller
116 * @id: reset line name
118 * Returns a struct reset_control or IS_ERR() condition containing errno.
119 * If this function is called more then once for the same reset_control it will
122 * See reset_control_get_shared for details on shared references to
125 * Use of id names is optional.
127 static inline struct reset_control *
128 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
130 #ifndef CONFIG_RESET_CONTROLLER
133 return __reset_control_get(dev, id, 0, false, false);
137 * reset_control_get_shared - Lookup and obtain a shared reference to a
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 * This function is intended for use with reset-controls which are shared
144 * between hardware-blocks.
146 * When a reset-control is shared, the behavior of reset_control_assert /
147 * deassert is changed, the reset-core will keep track of a deassert_count
148 * and only (re-)assert the reset after reset_control_assert has been called
149 * as many times as reset_control_deassert was called. Also see the remark
150 * about shared reset-controls in the reset_control_assert docs.
152 * Calling reset_control_assert without first calling reset_control_deassert
153 * is not allowed on a shared reset control. Calling reset_control_reset is
154 * also not allowed on a shared reset control.
156 * Use of id names is optional.
158 static inline struct reset_control *reset_control_get_shared(
159 struct device *dev, const char *id)
161 return __reset_control_get(dev, id, 0, true, false);
164 static inline struct reset_control *reset_control_get_optional_exclusive(
165 struct device *dev, const char *id)
167 return __reset_control_get(dev, id, 0, false, true);
170 static inline struct reset_control *reset_control_get_optional_shared(
171 struct device *dev, const char *id)
173 return __reset_control_get(dev, id, 0, true, true);
177 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
178 * to a reset controller.
179 * @node: device to be reset by the controller
180 * @id: reset line name
182 * Returns a struct reset_control or IS_ERR() condition containing errno.
184 * Use of id names is optional.
186 static inline struct reset_control *of_reset_control_get_exclusive(
187 struct device_node *node, const char *id)
189 return __of_reset_control_get(node, id, 0, false, false);
193 * of_reset_control_get_shared - Lookup and obtain an shared reference
194 * to a reset controller.
195 * @node: device to be reset by the controller
196 * @id: reset line name
198 * When a reset-control is shared, the behavior of reset_control_assert /
199 * deassert is changed, the reset-core will keep track of a deassert_count
200 * and only (re-)assert the reset after reset_control_assert has been called
201 * as many times as reset_control_deassert was called. Also see the remark
202 * about shared reset-controls in the reset_control_assert docs.
204 * Calling reset_control_assert without first calling reset_control_deassert
205 * is not allowed on a shared reset control. Calling reset_control_reset is
206 * also not allowed on a shared reset control.
207 * Returns a struct reset_control or IS_ERR() condition containing errno.
209 * Use of id names is optional.
211 static inline struct reset_control *of_reset_control_get_shared(
212 struct device_node *node, const char *id)
214 return __of_reset_control_get(node, id, 0, true, false);
218 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
219 * reference to a reset controller
221 * @node: device to be reset by the controller
222 * @index: index of the reset controller
224 * This is to be used to perform a list of resets for a device or power domain
225 * in whatever order. Returns a struct reset_control or IS_ERR() condition
228 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
229 struct device_node *node, int index)
231 return __of_reset_control_get(node, NULL, index, false, false);
235 * of_reset_control_get_shared_by_index - Lookup and obtain an shared
236 * reference to a reset controller
238 * @node: device to be reset by the controller
239 * @index: index of the reset controller
241 * When a reset-control is shared, the behavior of reset_control_assert /
242 * deassert is changed, the reset-core will keep track of a deassert_count
243 * and only (re-)assert the reset after reset_control_assert has been called
244 * as many times as reset_control_deassert was called. Also see the remark
245 * about shared reset-controls in the reset_control_assert docs.
247 * Calling reset_control_assert without first calling reset_control_deassert
248 * is not allowed on a shared reset control. Calling reset_control_reset is
249 * also not allowed on a shared reset control.
250 * Returns a struct reset_control or IS_ERR() condition containing errno.
252 * This is to be used to perform a list of resets for a device or power domain
253 * in whatever order. Returns a struct reset_control or IS_ERR() condition
256 static inline struct reset_control *of_reset_control_get_shared_by_index(
257 struct device_node *node, int index)
259 return __of_reset_control_get(node, NULL, index, true, false);
263 * devm_reset_control_get_exclusive - resource managed
264 * reset_control_get_exclusive()
265 * @dev: device to be reset by the controller
266 * @id: reset line name
268 * Managed reset_control_get_exclusive(). For reset controllers returned
269 * from this function, reset_control_put() is called automatically on driver
272 * See reset_control_get_exclusive() for more information.
274 static inline struct reset_control *
275 __must_check devm_reset_control_get_exclusive(struct device *dev,
278 #ifndef CONFIG_RESET_CONTROLLER
281 return __devm_reset_control_get(dev, id, 0, false, false);
285 * devm_reset_control_get_shared - resource managed reset_control_get_shared()
286 * @dev: device to be reset by the controller
287 * @id: reset line name
289 * Managed reset_control_get_shared(). For reset controllers returned from
290 * this function, reset_control_put() is called automatically on driver detach.
291 * See reset_control_get_shared() for more information.
293 static inline struct reset_control *devm_reset_control_get_shared(
294 struct device *dev, const char *id)
296 return __devm_reset_control_get(dev, id, 0, true, false);
299 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
300 struct device *dev, const char *id)
302 return __devm_reset_control_get(dev, id, 0, false, true);
305 static inline struct reset_control *devm_reset_control_get_optional_shared(
306 struct device *dev, const char *id)
308 return __devm_reset_control_get(dev, id, 0, true, true);
312 * devm_reset_control_get_exclusive_by_index - resource managed
313 * reset_control_get_exclusive()
314 * @dev: device to be reset by the controller
315 * @index: index of the reset controller
317 * Managed reset_control_get_exclusive(). For reset controllers returned from
318 * this function, reset_control_put() is called automatically on driver
321 * See reset_control_get_exclusive() for more information.
323 static inline struct reset_control *
324 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
326 return __devm_reset_control_get(dev, NULL, index, false, false);
330 * devm_reset_control_get_shared_by_index - resource managed
331 * reset_control_get_shared
332 * @dev: device to be reset by the controller
333 * @index: index of the reset controller
335 * Managed reset_control_get_shared(). For reset controllers returned from
336 * this function, reset_control_put() is called automatically on driver detach.
337 * See reset_control_get_shared() for more information.
339 static inline struct reset_control *
340 devm_reset_control_get_shared_by_index(struct device *dev, int index)
342 return __devm_reset_control_get(dev, NULL, index, true, false);
346 * TEMPORARY calls to use during transition:
348 * of_reset_control_get() => of_reset_control_get_exclusive()
350 * These inline function calls will be removed once all consumers
351 * have been moved over to the new explicit API.
353 static inline struct reset_control *reset_control_get(
354 struct device *dev, const char *id)
356 return reset_control_get_exclusive(dev, id);
359 static inline struct reset_control *reset_control_get_optional(
360 struct device *dev, const char *id)
362 return reset_control_get_optional_exclusive(dev, id);
365 static inline struct reset_control *of_reset_control_get(
366 struct device_node *node, const char *id)
368 return of_reset_control_get_exclusive(node, id);
371 static inline struct reset_control *of_reset_control_get_by_index(
372 struct device_node *node, int index)
374 return of_reset_control_get_exclusive_by_index(node, index);
377 static inline struct reset_control *devm_reset_control_get(
378 struct device *dev, const char *id)
380 return devm_reset_control_get_exclusive(dev, id);
383 static inline struct reset_control *devm_reset_control_get_optional(
384 struct device *dev, const char *id)
386 return devm_reset_control_get_optional_exclusive(dev, id);
390 static inline struct reset_control *devm_reset_control_get_by_index(
391 struct device *dev, int index)
393 return devm_reset_control_get_exclusive_by_index(dev, index);
397 * APIs to manage a list of reset controllers
399 static inline struct reset_control *
400 devm_reset_control_array_get_exclusive(struct device *dev)
402 return devm_reset_control_array_get(dev, false, false);
405 static inline struct reset_control *
406 devm_reset_control_array_get_shared(struct device *dev)
408 return devm_reset_control_array_get(dev, true, false);
411 static inline struct reset_control *
412 devm_reset_control_array_get_optional_exclusive(struct device *dev)
414 return devm_reset_control_array_get(dev, false, true);
417 static inline struct reset_control *
418 devm_reset_control_array_get_optional_shared(struct device *dev)
420 return devm_reset_control_array_get(dev, true, true);
423 static inline struct reset_control *
424 of_reset_control_array_get_exclusive(struct device_node *node)
426 return of_reset_control_array_get(node, false, false);
429 static inline struct reset_control *
430 of_reset_control_array_get_shared(struct device_node *node)
432 return of_reset_control_array_get(node, true, false);
435 static inline struct reset_control *
436 of_reset_control_array_get_optional_exclusive(struct device_node *node)
438 return of_reset_control_array_get(node, false, true);
441 static inline struct reset_control *
442 of_reset_control_array_get_optional_shared(struct device_node *node)
444 return of_reset_control_array_get(node, true, true);