Loading...
Note: File does not exist in v3.5.6.
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_RESET_H_
3#define _LINUX_RESET_H_
4
5#include <linux/err.h>
6#include <linux/errno.h>
7#include <linux/types.h>
8
9struct device;
10struct device_node;
11struct reset_control;
12
13#ifdef CONFIG_RESET_CONTROLLER
14
15int reset_control_reset(struct reset_control *rstc);
16int reset_control_assert(struct reset_control *rstc);
17int reset_control_deassert(struct reset_control *rstc);
18int reset_control_status(struct reset_control *rstc);
19int reset_control_acquire(struct reset_control *rstc);
20void reset_control_release(struct reset_control *rstc);
21
22struct reset_control *__of_reset_control_get(struct device_node *node,
23 const char *id, int index, bool shared,
24 bool optional, bool acquired);
25struct reset_control *__reset_control_get(struct device *dev, const char *id,
26 int index, bool shared,
27 bool optional, bool acquired);
28void reset_control_put(struct reset_control *rstc);
29int __device_reset(struct device *dev, bool optional);
30struct reset_control *__devm_reset_control_get(struct device *dev,
31 const char *id, int index, bool shared,
32 bool optional, bool acquired);
33
34struct reset_control *devm_reset_control_array_get(struct device *dev,
35 bool shared, bool optional);
36struct reset_control *of_reset_control_array_get(struct device_node *np,
37 bool shared, bool optional,
38 bool acquired);
39
40int reset_control_get_count(struct device *dev);
41
42#else
43
44static inline int reset_control_reset(struct reset_control *rstc)
45{
46 return 0;
47}
48
49static inline int reset_control_assert(struct reset_control *rstc)
50{
51 return 0;
52}
53
54static inline int reset_control_deassert(struct reset_control *rstc)
55{
56 return 0;
57}
58
59static inline int reset_control_status(struct reset_control *rstc)
60{
61 return 0;
62}
63
64static inline int reset_control_acquire(struct reset_control *rstc)
65{
66 return 0;
67}
68
69static inline void reset_control_release(struct reset_control *rstc)
70{
71}
72
73static inline void reset_control_put(struct reset_control *rstc)
74{
75}
76
77static inline int __device_reset(struct device *dev, bool optional)
78{
79 return optional ? 0 : -ENOTSUPP;
80}
81
82static 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)
86{
87 return optional ? NULL : ERR_PTR(-ENOTSUPP);
88}
89
90static inline struct reset_control *__reset_control_get(
91 struct device *dev, const char *id,
92 int index, bool shared, bool optional,
93 bool acquired)
94{
95 return optional ? NULL : ERR_PTR(-ENOTSUPP);
96}
97
98static inline struct reset_control *__devm_reset_control_get(
99 struct device *dev, const char *id,
100 int index, bool shared, bool optional,
101 bool acquired)
102{
103 return optional ? NULL : ERR_PTR(-ENOTSUPP);
104}
105
106static inline struct reset_control *
107devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
108{
109 return optional ? NULL : ERR_PTR(-ENOTSUPP);
110}
111
112static inline struct reset_control *
113of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
114 bool acquired)
115{
116 return optional ? NULL : ERR_PTR(-ENOTSUPP);
117}
118
119static inline int reset_control_get_count(struct device *dev)
120{
121 return -ENOENT;
122}
123
124#endif /* CONFIG_RESET_CONTROLLER */
125
126static inline int __must_check device_reset(struct device *dev)
127{
128 return __device_reset(dev, false);
129}
130
131static inline int device_reset_optional(struct device *dev)
132{
133 return __device_reset(dev, true);
134}
135
136/**
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
141 *
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
144 * return -EBUSY.
145 *
146 * See reset_control_get_shared() for details on shared references to
147 * reset-controls.
148 *
149 * Use of id names is optional.
150 */
151static inline struct reset_control *
152__must_check reset_control_get_exclusive(struct device *dev, const char *id)
153{
154 return __reset_control_get(dev, id, 0, false, false, true);
155}
156
157/**
158 * reset_control_get_exclusive_released - Lookup and obtain a temoprarily
159 * exclusive reference to a reset
160 * controller.
161 * @dev: device to be reset by the controller
162 * @id: reset line name
163 *
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.
168 *
169 * Use of id names is optional.
170 */
171static inline struct reset_control *
172__must_check reset_control_get_exclusive_released(struct device *dev,
173 const char *id)
174{
175 return __reset_control_get(dev, id, 0, false, false, false);
176}
177
178/**
179 * reset_control_get_shared - Lookup and obtain a shared reference to a
180 * reset controller.
181 * @dev: device to be reset by the controller
182 * @id: reset line name
183 *
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.
187 *
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.
193 *
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.
197 *
198 * Use of id names is optional.
199 */
200static inline struct reset_control *reset_control_get_shared(
201 struct device *dev, const char *id)
202{
203 return __reset_control_get(dev, id, 0, true, false, false);
204}
205
206/**
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
210 *
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
213 * an error.
214 *
215 * See reset_control_get_exclusive() for more information.
216 */
217static inline struct reset_control *reset_control_get_optional_exclusive(
218 struct device *dev, const char *id)
219{
220 return __reset_control_get(dev, id, 0, false, true, true);
221}
222
223/**
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
227 *
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
230 * an error.
231 *
232 * See reset_control_get_shared() for more information.
233 */
234static inline struct reset_control *reset_control_get_optional_shared(
235 struct device *dev, const char *id)
236{
237 return __reset_control_get(dev, id, 0, true, true, false);
238}
239
240/**
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
245 *
246 * Returns a struct reset_control or IS_ERR() condition containing errno.
247 *
248 * Use of id names is optional.
249 */
250static inline struct reset_control *of_reset_control_get_exclusive(
251 struct device_node *node, const char *id)
252{
253 return __of_reset_control_get(node, id, 0, false, false, true);
254}
255
256/**
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
261 *
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.
267 *
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.
272 *
273 * Use of id names is optional.
274 */
275static inline struct reset_control *of_reset_control_get_shared(
276 struct device_node *node, const char *id)
277{
278 return __of_reset_control_get(node, id, 0, true, false, false);
279}
280
281/**
282 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
283 * reference to a reset controller
284 * by index.
285 * @node: device to be reset by the controller
286 * @index: index of the reset controller
287 *
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
290 * containing errno.
291 */
292static inline struct reset_control *of_reset_control_get_exclusive_by_index(
293 struct device_node *node, int index)
294{
295 return __of_reset_control_get(node, NULL, index, false, false, true);
296}
297
298/**
299 * of_reset_control_get_shared_by_index - Lookup and obtain a shared
300 * reference to a reset controller
301 * by index.
302 * @node: device to be reset by the controller
303 * @index: index of the reset controller
304 *
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.
310 *
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.
315 *
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
318 * containing errno.
319 */
320static inline struct reset_control *of_reset_control_get_shared_by_index(
321 struct device_node *node, int index)
322{
323 return __of_reset_control_get(node, NULL, index, true, false, false);
324}
325
326/**
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
331 *
332 * Managed reset_control_get_exclusive(). For reset controllers returned
333 * from this function, reset_control_put() is called automatically on driver
334 * detach.
335 *
336 * See reset_control_get_exclusive() for more information.
337 */
338static inline struct reset_control *
339__must_check devm_reset_control_get_exclusive(struct device *dev,
340 const char *id)
341{
342 return __devm_reset_control_get(dev, id, 0, false, false, true);
343}
344
345/**
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
350 *
351 * Managed reset_control_get_exclusive_released(). For reset controllers
352 * returned from this function, reset_control_put() is called automatically on
353 * driver detach.
354 *
355 * See reset_control_get_exclusive_released() for more information.
356 */
357static inline struct reset_control *
358__must_check devm_reset_control_get_exclusive_released(struct device *dev,
359 const char *id)
360{
361 return __devm_reset_control_get(dev, id, 0, false, false, false);
362}
363
364/**
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
368 *
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.
372 */
373static inline struct reset_control *devm_reset_control_get_shared(
374 struct device *dev, const char *id)
375{
376 return __devm_reset_control_get(dev, id, 0, true, false, false);
377}
378
379/**
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
384 *
385 * Managed reset_control_get_optional_exclusive(). For reset controllers
386 * returned from this function, reset_control_put() is called automatically on
387 * driver detach.
388 *
389 * See reset_control_get_optional_exclusive() for more information.
390 */
391static inline struct reset_control *devm_reset_control_get_optional_exclusive(
392 struct device *dev, const char *id)
393{
394 return __devm_reset_control_get(dev, id, 0, false, true, true);
395}
396
397/**
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
402 *
403 * Managed reset_control_get_optional_shared(). For reset controllers returned
404 * from this function, reset_control_put() is called automatically on driver
405 * detach.
406 *
407 * See reset_control_get_optional_shared() for more information.
408 */
409static inline struct reset_control *devm_reset_control_get_optional_shared(
410 struct device *dev, const char *id)
411{
412 return __devm_reset_control_get(dev, id, 0, true, true, false);
413}
414
415/**
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
420 *
421 * Managed reset_control_get_exclusive(). For reset controllers returned from
422 * this function, reset_control_put() is called automatically on driver
423 * detach.
424 *
425 * See reset_control_get_exclusive() for more information.
426 */
427static inline struct reset_control *
428devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
429{
430 return __devm_reset_control_get(dev, NULL, index, false, false, true);
431}
432
433/**
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
438 *
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.
442 */
443static inline struct reset_control *
444devm_reset_control_get_shared_by_index(struct device *dev, int index)
445{
446 return __devm_reset_control_get(dev, NULL, index, true, false, false);
447}
448
449/*
450 * TEMPORARY calls to use during transition:
451 *
452 * of_reset_control_get() => of_reset_control_get_exclusive()
453 *
454 * These inline function calls will be removed once all consumers
455 * have been moved over to the new explicit API.
456 */
457static inline struct reset_control *of_reset_control_get(
458 struct device_node *node, const char *id)
459{
460 return of_reset_control_get_exclusive(node, id);
461}
462
463static inline struct reset_control *of_reset_control_get_by_index(
464 struct device_node *node, int index)
465{
466 return of_reset_control_get_exclusive_by_index(node, index);
467}
468
469static inline struct reset_control *devm_reset_control_get(
470 struct device *dev, const char *id)
471{
472 return devm_reset_control_get_exclusive(dev, id);
473}
474
475static inline struct reset_control *devm_reset_control_get_optional(
476 struct device *dev, const char *id)
477{
478 return devm_reset_control_get_optional_exclusive(dev, id);
479
480}
481
482static inline struct reset_control *devm_reset_control_get_by_index(
483 struct device *dev, int index)
484{
485 return devm_reset_control_get_exclusive_by_index(dev, index);
486}
487
488/*
489 * APIs to manage a list of reset controllers
490 */
491static inline struct reset_control *
492devm_reset_control_array_get_exclusive(struct device *dev)
493{
494 return devm_reset_control_array_get(dev, false, false);
495}
496
497static inline struct reset_control *
498devm_reset_control_array_get_shared(struct device *dev)
499{
500 return devm_reset_control_array_get(dev, true, false);
501}
502
503static inline struct reset_control *
504devm_reset_control_array_get_optional_exclusive(struct device *dev)
505{
506 return devm_reset_control_array_get(dev, false, true);
507}
508
509static inline struct reset_control *
510devm_reset_control_array_get_optional_shared(struct device *dev)
511{
512 return devm_reset_control_array_get(dev, true, true);
513}
514
515static inline struct reset_control *
516of_reset_control_array_get_exclusive(struct device_node *node)
517{
518 return of_reset_control_array_get(node, false, false, true);
519}
520
521static inline struct reset_control *
522of_reset_control_array_get_exclusive_released(struct device_node *node)
523{
524 return of_reset_control_array_get(node, false, false, false);
525}
526
527static inline struct reset_control *
528of_reset_control_array_get_shared(struct device_node *node)
529{
530 return of_reset_control_array_get(node, true, false, true);
531}
532
533static inline struct reset_control *
534of_reset_control_array_get_optional_exclusive(struct device_node *node)
535{
536 return of_reset_control_array_get(node, false, true, true);
537}
538
539static inline struct reset_control *
540of_reset_control_array_get_optional_shared(struct device_node *node)
541{
542 return of_reset_control_array_get(node, true, true, true);
543}
544#endif