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 int __device_reset(struct device *dev, bool optional);
24 struct reset_control *__devm_reset_control_get(struct device *dev,
25 const char *id, int index, bool shared,
28 struct reset_control *devm_reset_control_array_get(struct device *dev,
29 bool shared, bool optional);
30 struct reset_control *of_reset_control_array_get(struct device_node *np,
31 bool shared, bool optional);
35 static inline int reset_control_reset(struct reset_control *rstc)
40 static inline int reset_control_assert(struct reset_control *rstc)
45 static inline int reset_control_deassert(struct reset_control *rstc)
50 static inline int reset_control_status(struct reset_control *rstc)
55 static inline void reset_control_put(struct reset_control *rstc)
59 static inline int __device_reset(struct device *dev, bool optional)
61 return optional ? 0 : -ENOTSUPP;
64 static inline struct reset_control *__of_reset_control_get(
65 struct device_node *node,
66 const char *id, int index, bool shared,
69 return optional ? NULL : ERR_PTR(-ENOTSUPP);
72 static inline struct reset_control *__reset_control_get(
73 struct device *dev, const char *id,
74 int index, bool shared, bool optional)
76 return optional ? NULL : ERR_PTR(-ENOTSUPP);
79 static inline struct reset_control *__devm_reset_control_get(
80 struct device *dev, const char *id,
81 int index, bool shared, bool optional)
83 return optional ? NULL : ERR_PTR(-ENOTSUPP);
86 static inline struct reset_control *
87 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
89 return optional ? NULL : ERR_PTR(-ENOTSUPP);
92 static inline struct reset_control *
93 of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
95 return optional ? NULL : ERR_PTR(-ENOTSUPP);
98 #endif /* CONFIG_RESET_CONTROLLER */
100 static inline int __must_check device_reset(struct device *dev)
102 return __device_reset(dev, false);
105 static inline int device_reset_optional(struct device *dev)
107 return __device_reset(dev, true);
111 * reset_control_get_exclusive - Lookup and obtain an exclusive reference
112 * to a reset controller.
113 * @dev: device to be reset by the controller
114 * @id: reset line name
116 * Returns a struct reset_control or IS_ERR() condition containing errno.
117 * If this function is called more then once for the same reset_control it will
120 * See reset_control_get_shared for details on shared references to
123 * Use of id names is optional.
125 static inline struct reset_control *
126 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
128 return __reset_control_get(dev, id, 0, false, false);
132 * reset_control_get_shared - Lookup and obtain a shared reference to a
134 * @dev: device to be reset by the controller
135 * @id: reset line name
137 * Returns a struct reset_control or IS_ERR() condition containing errno.
138 * This function is intended for use with reset-controls which are shared
139 * between hardware-blocks.
141 * When a reset-control is shared, the behavior of reset_control_assert /
142 * deassert is changed, the reset-core will keep track of a deassert_count
143 * and only (re-)assert the reset after reset_control_assert has been called
144 * as many times as reset_control_deassert was called. Also see the remark
145 * about shared reset-controls in the reset_control_assert docs.
147 * Calling reset_control_assert without first calling reset_control_deassert
148 * is not allowed on a shared reset control. Calling reset_control_reset is
149 * also not allowed on a shared reset control.
151 * Use of id names is optional.
153 static inline struct reset_control *reset_control_get_shared(
154 struct device *dev, const char *id)
156 return __reset_control_get(dev, id, 0, true, false);
159 static inline struct reset_control *reset_control_get_optional_exclusive(
160 struct device *dev, const char *id)
162 return __reset_control_get(dev, id, 0, false, true);
165 static inline struct reset_control *reset_control_get_optional_shared(
166 struct device *dev, const char *id)
168 return __reset_control_get(dev, id, 0, true, true);
172 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
173 * to a reset controller.
174 * @node: device to be reset by the controller
175 * @id: reset line name
177 * Returns a struct reset_control or IS_ERR() condition containing errno.
179 * Use of id names is optional.
181 static inline struct reset_control *of_reset_control_get_exclusive(
182 struct device_node *node, const char *id)
184 return __of_reset_control_get(node, id, 0, false, false);
188 * of_reset_control_get_shared - Lookup and obtain an shared reference
189 * to a reset controller.
190 * @node: device to be reset by the controller
191 * @id: reset line name
193 * When a reset-control is shared, the behavior of reset_control_assert /
194 * deassert is changed, the reset-core will keep track of a deassert_count
195 * and only (re-)assert the reset after reset_control_assert has been called
196 * as many times as reset_control_deassert was called. Also see the remark
197 * about shared reset-controls in the reset_control_assert docs.
199 * Calling reset_control_assert without first calling reset_control_deassert
200 * is not allowed on a shared reset control. Calling reset_control_reset is
201 * also not allowed on a shared reset control.
202 * Returns a struct reset_control or IS_ERR() condition containing errno.
204 * Use of id names is optional.
206 static inline struct reset_control *of_reset_control_get_shared(
207 struct device_node *node, const char *id)
209 return __of_reset_control_get(node, id, 0, true, false);
213 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
214 * reference to a reset controller
216 * @node: device to be reset by the controller
217 * @index: index of the reset controller
219 * This is to be used to perform a list of resets for a device or power domain
220 * in whatever order. Returns a struct reset_control or IS_ERR() condition
223 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
224 struct device_node *node, int index)
226 return __of_reset_control_get(node, NULL, index, false, false);
230 * of_reset_control_get_shared_by_index - Lookup and obtain an shared
231 * reference to a reset controller
233 * @node: device to be reset by the controller
234 * @index: index of the reset controller
236 * When a reset-control is shared, the behavior of reset_control_assert /
237 * deassert is changed, the reset-core will keep track of a deassert_count
238 * and only (re-)assert the reset after reset_control_assert has been called
239 * as many times as reset_control_deassert was called. Also see the remark
240 * about shared reset-controls in the reset_control_assert docs.
242 * Calling reset_control_assert without first calling reset_control_deassert
243 * is not allowed on a shared reset control. Calling reset_control_reset is
244 * also not allowed on a shared reset control.
245 * Returns a struct reset_control or IS_ERR() condition containing errno.
247 * This is to be used to perform a list of resets for a device or power domain
248 * in whatever order. Returns a struct reset_control or IS_ERR() condition
251 static inline struct reset_control *of_reset_control_get_shared_by_index(
252 struct device_node *node, int index)
254 return __of_reset_control_get(node, NULL, index, true, false);
258 * devm_reset_control_get_exclusive - resource managed
259 * reset_control_get_exclusive()
260 * @dev: device to be reset by the controller
261 * @id: reset line name
263 * Managed reset_control_get_exclusive(). For reset controllers returned
264 * from this function, reset_control_put() is called automatically on driver
267 * See reset_control_get_exclusive() for more information.
269 static inline struct reset_control *
270 __must_check devm_reset_control_get_exclusive(struct device *dev,
273 return __devm_reset_control_get(dev, id, 0, false, false);
277 * devm_reset_control_get_shared - resource managed reset_control_get_shared()
278 * @dev: device to be reset by the controller
279 * @id: reset line name
281 * Managed reset_control_get_shared(). For reset controllers returned from
282 * this function, reset_control_put() is called automatically on driver detach.
283 * See reset_control_get_shared() for more information.
285 static inline struct reset_control *devm_reset_control_get_shared(
286 struct device *dev, const char *id)
288 return __devm_reset_control_get(dev, id, 0, true, false);
291 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
292 struct device *dev, const char *id)
294 return __devm_reset_control_get(dev, id, 0, false, true);
297 static inline struct reset_control *devm_reset_control_get_optional_shared(
298 struct device *dev, const char *id)
300 return __devm_reset_control_get(dev, id, 0, true, true);
304 * devm_reset_control_get_exclusive_by_index - resource managed
305 * reset_control_get_exclusive()
306 * @dev: device to be reset by the controller
307 * @index: index of the reset controller
309 * Managed reset_control_get_exclusive(). For reset controllers returned from
310 * this function, reset_control_put() is called automatically on driver
313 * See reset_control_get_exclusive() for more information.
315 static inline struct reset_control *
316 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
318 return __devm_reset_control_get(dev, NULL, index, false, false);
322 * devm_reset_control_get_shared_by_index - resource managed
323 * reset_control_get_shared
324 * @dev: device to be reset by the controller
325 * @index: index of the reset controller
327 * Managed reset_control_get_shared(). For reset controllers returned from
328 * this function, reset_control_put() is called automatically on driver detach.
329 * See reset_control_get_shared() for more information.
331 static inline struct reset_control *
332 devm_reset_control_get_shared_by_index(struct device *dev, int index)
334 return __devm_reset_control_get(dev, NULL, index, true, false);
338 * TEMPORARY calls to use during transition:
340 * of_reset_control_get() => of_reset_control_get_exclusive()
342 * These inline function calls will be removed once all consumers
343 * have been moved over to the new explicit API.
345 static inline struct reset_control *reset_control_get(
346 struct device *dev, const char *id)
348 return reset_control_get_exclusive(dev, id);
351 static inline struct reset_control *reset_control_get_optional(
352 struct device *dev, const char *id)
354 return reset_control_get_optional_exclusive(dev, id);
357 static inline struct reset_control *of_reset_control_get(
358 struct device_node *node, const char *id)
360 return of_reset_control_get_exclusive(node, id);
363 static inline struct reset_control *of_reset_control_get_by_index(
364 struct device_node *node, int index)
366 return of_reset_control_get_exclusive_by_index(node, index);
369 static inline struct reset_control *devm_reset_control_get(
370 struct device *dev, const char *id)
372 return devm_reset_control_get_exclusive(dev, id);
375 static inline struct reset_control *devm_reset_control_get_optional(
376 struct device *dev, const char *id)
378 return devm_reset_control_get_optional_exclusive(dev, id);
382 static inline struct reset_control *devm_reset_control_get_by_index(
383 struct device *dev, int index)
385 return devm_reset_control_get_exclusive_by_index(dev, index);
389 * APIs to manage a list of reset controllers
391 static inline struct reset_control *
392 devm_reset_control_array_get_exclusive(struct device *dev)
394 return devm_reset_control_array_get(dev, false, false);
397 static inline struct reset_control *
398 devm_reset_control_array_get_shared(struct device *dev)
400 return devm_reset_control_array_get(dev, true, false);
403 static inline struct reset_control *
404 devm_reset_control_array_get_optional_exclusive(struct device *dev)
406 return devm_reset_control_array_get(dev, false, true);
409 static inline struct reset_control *
410 devm_reset_control_array_get_optional_shared(struct device *dev)
412 return devm_reset_control_array_get(dev, true, true);
415 static inline struct reset_control *
416 of_reset_control_array_get_exclusive(struct device_node *node)
418 return of_reset_control_array_get(node, false, false);
421 static inline struct reset_control *
422 of_reset_control_array_get_shared(struct device_node *node)
424 return of_reset_control_array_get(node, true, false);
427 static inline struct reset_control *
428 of_reset_control_array_get_optional_exclusive(struct device_node *node)
430 return of_reset_control_array_get(node, false, true);
433 static inline struct reset_control *
434 of_reset_control_array_get_optional_shared(struct device_node *node)
436 return of_reset_control_array_get(node, true, true);