1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_RESET_H_
3#define _LINUX_RESET_H_
4
5#include <linux/types.h>
6
7struct device;
8struct device_node;
9struct reset_control;
10
11#ifdef CONFIG_RESET_CONTROLLER
12
13int reset_control_reset(struct reset_control *rstc);
14int reset_control_assert(struct reset_control *rstc);
15int reset_control_deassert(struct reset_control *rstc);
16int reset_control_status(struct reset_control *rstc);
17
18struct reset_control *__of_reset_control_get(struct device_node *node,
19 const char *id, int index, bool shared,
20 bool optional);
21struct reset_control *__reset_control_get(struct device *dev, const char *id,
22 int index, bool shared,
23 bool optional);
24void reset_control_put(struct reset_control *rstc);
25int __device_reset(struct device *dev, bool optional);
26struct reset_control *__devm_reset_control_get(struct device *dev,
27 const char *id, int index, bool shared,
28 bool optional);
29
30struct reset_control *devm_reset_control_array_get(struct device *dev,
31 bool shared, bool optional);
32struct reset_control *of_reset_control_array_get(struct device_node *np,
33 bool shared, bool optional);
34
35int reset_control_get_count(struct device *dev);
36
37#else
38
39static inline int reset_control_reset(struct reset_control *rstc)
40{
41 return 0;
42}
43
44static inline int reset_control_assert(struct reset_control *rstc)
45{
46 return 0;
47}
48
49static inline int reset_control_deassert(struct reset_control *rstc)
50{
51 return 0;
52}
53
54static inline int reset_control_status(struct reset_control *rstc)
55{
56 return 0;
57}
58
59static inline void reset_control_put(struct reset_control *rstc)
60{
61}
62
63static inline int __device_reset(struct device *dev, bool optional)
64{
65 return optional ? 0 : -ENOTSUPP;
66}
67
68static inline struct reset_control *__of_reset_control_get(
69 struct device_node *node,
70 const char *id, int index, bool shared,
71 bool optional)
72{
73 return optional ? NULL : ERR_PTR(-ENOTSUPP);
74}
75
76static 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
83static inline struct reset_control *__devm_reset_control_get(
84 struct device *dev, const char *id,
85 int index, bool shared, bool optional)
86{
87 return optional ? NULL : ERR_PTR(-ENOTSUPP);
88}
89
90static inline struct reset_control *
91devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
92{
93 return optional ? NULL : ERR_PTR(-ENOTSUPP);
94}
95
96static inline struct reset_control *
97of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
98{
99 return optional ? NULL : ERR_PTR(-ENOTSUPP);
100}
101
102static inline int reset_control_get_count(struct device *dev)
103{
104 return -ENOENT;
105}
106
107#endif /* CONFIG_RESET_CONTROLLER */
108
109static inline int __must_check device_reset(struct device *dev)
110{
111 return __device_reset(dev, false);
112}
113
114static inline int device_reset_optional(struct device *dev)
115{
116 return __device_reset(dev, true);
117}
118
119/**
120 * reset_control_get_exclusive - Lookup and obtain an exclusive reference
121 * to a reset controller.
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.
126 * If this function is called more than once for the same reset_control it will
127 * return -EBUSY.
128 *
129 * See reset_control_get_shared for details on shared references to
130 * reset-controls.
131 *
132 * Use of id names is optional.
133 */
134static inline struct reset_control *
135__must_check reset_control_get_exclusive(struct device *dev, const char *id)
136{
137 return __reset_control_get(dev, id, 0, false, false);
138}
139
140/**
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
148 * between hardware blocks.
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 */
162static inline struct reset_control *reset_control_get_shared(
163 struct device *dev, const char *id)
164{
165 return __reset_control_get(dev, id, 0, true, false);
166}
167
168static inline struct reset_control *reset_control_get_optional_exclusive(
169 struct device *dev, const char *id)
170{
171 return __reset_control_get(dev, id, 0, false, true);
172}
173
174static inline struct reset_control *reset_control_get_optional_shared(
175 struct device *dev, const char *id)
176{
177 return __reset_control_get(dev, id, 0, true, true);
178}
179
180/**
181 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
182 * to a reset controller.
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 */
190static inline struct reset_control *of_reset_control_get_exclusive(
191 struct device_node *node, const char *id)
192{
193 return __of_reset_control_get(node, id, 0, false, false);
194}
195
196/**
197 * of_reset_control_get_shared - Lookup and obtain a shared reference
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 */
215static inline struct reset_control *of_reset_control_get_shared(
216 struct device_node *node, const char *id)
217{
218 return __of_reset_control_get(node, id, 0, true, false);
219}
220
221/**
222 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
223 * reference to a reset controller
224 * by index.
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 */
232static inline struct reset_control *of_reset_control_get_exclusive_by_index(
233 struct device_node *node, int index)
234{
235 return __of_reset_control_get(node, NULL, index, false, false);
236}
237
238/**
239 * of_reset_control_get_shared_by_index - Lookup and obtain a shared
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.
255 *
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.
259 */
260static inline struct reset_control *of_reset_control_get_shared_by_index(
261 struct device_node *node, int index)
262{
263 return __of_reset_control_get(node, NULL, index, true, false);
264}
265
266/**
267 * devm_reset_control_get_exclusive - resource managed
268 * reset_control_get_exclusive()
269 * @dev: device to be reset by the controller
270 * @id: reset line name
271 *
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.
277 */
278static inline struct reset_control *
279__must_check devm_reset_control_get_exclusive(struct device *dev,
280 const char *id)
281{
282 return __devm_reset_control_get(dev, id, 0, false, false);
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 */
294static inline struct reset_control *devm_reset_control_get_shared(
295 struct device *dev, const char *id)
296{
297 return __devm_reset_control_get(dev, id, 0, true, false);
298}
299
300static inline struct reset_control *devm_reset_control_get_optional_exclusive(
301 struct device *dev, const char *id)
302{
303 return __devm_reset_control_get(dev, id, 0, false, true);
304}
305
306static inline struct reset_control *devm_reset_control_get_optional_shared(
307 struct device *dev, const char *id)
308{
309 return __devm_reset_control_get(dev, id, 0, true, true);
310}
311
312/**
313 * devm_reset_control_get_exclusive_by_index - resource managed
314 * reset_control_get_exclusive()
315 * @dev: device to be reset by the controller
316 * @index: index of the reset controller
317 *
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.
323 */
324static inline struct reset_control *
325devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
326{
327 return __devm_reset_control_get(dev, NULL, index, false, false);
328}
329
330/**
331 * devm_reset_control_get_shared_by_index - resource managed
332 * reset_control_get_shared
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 */
340static inline struct reset_control *
341devm_reset_control_get_shared_by_index(struct device *dev, int index)
342{
343 return __devm_reset_control_get(dev, NULL, index, true, false);
344}
345
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 */
354static 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
360static 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
366static 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
372static 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
379static 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}
384
385/*
386 * APIs to manage a list of reset controllers
387 */
388static inline struct reset_control *
389devm_reset_control_array_get_exclusive(struct device *dev)
390{
391 return devm_reset_control_array_get(dev, false, false);
392}
393
394static inline struct reset_control *
395devm_reset_control_array_get_shared(struct device *dev)
396{
397 return devm_reset_control_array_get(dev, true, false);
398}
399
400static inline struct reset_control *
401devm_reset_control_array_get_optional_exclusive(struct device *dev)
402{
403 return devm_reset_control_array_get(dev, false, true);
404}
405
406static inline struct reset_control *
407devm_reset_control_array_get_optional_shared(struct device *dev)
408{
409 return devm_reset_control_array_get(dev, true, true);
410}
411
412static inline struct reset_control *
413of_reset_control_array_get_exclusive(struct device_node *node)
414{
415 return of_reset_control_array_get(node, false, false);
416}
417
418static inline struct reset_control *
419of_reset_control_array_get_shared(struct device_node *node)
420{
421 return of_reset_control_array_get(node, true, false);
422}
423
424static inline struct reset_control *
425of_reset_control_array_get_optional_exclusive(struct device_node *node)
426{
427 return of_reset_control_array_get(node, false, true);
428}
429
430static inline struct reset_control *
431of_reset_control_array_get_optional_shared(struct device_node *node)
432{
433 return of_reset_control_array_get(node, true, true);
434}
435#endif
436