Branch data Line data Source code
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 : :
9 : : struct device;
10 : : struct device_node;
11 : : struct reset_control;
12 : :
13 : : #ifdef CONFIG_RESET_CONTROLLER
14 : :
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);
21 : :
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);
33 : :
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,
38 : : bool acquired);
39 : :
40 : : int reset_control_get_count(struct device *dev);
41 : :
42 : : #else
43 : :
44 : : static inline int reset_control_reset(struct reset_control *rstc)
45 : : {
46 : : return 0;
47 : : }
48 : :
49 : : static inline int reset_control_assert(struct reset_control *rstc)
50 : : {
51 : : return 0;
52 : : }
53 : :
54 : : static inline int reset_control_deassert(struct reset_control *rstc)
55 : : {
56 : : return 0;
57 : : }
58 : :
59 : : static inline int reset_control_status(struct reset_control *rstc)
60 : : {
61 : : return 0;
62 : : }
63 : :
64 : : static inline int reset_control_acquire(struct reset_control *rstc)
65 : : {
66 : : return 0;
67 : : }
68 : :
69 : : static inline void reset_control_release(struct reset_control *rstc)
70 : : {
71 : : }
72 : :
73 : : static inline void reset_control_put(struct reset_control *rstc)
74 : : {
75 : : }
76 : :
77 : : static inline int __device_reset(struct device *dev, bool optional)
78 : : {
79 : : return optional ? 0 : -ENOTSUPP;
80 : : }
81 : :
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)
86 : : {
87 : : return optional ? NULL : ERR_PTR(-ENOTSUPP);
88 : : }
89 : :
90 : : static 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 : :
98 : : static 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 : :
106 : : static inline struct reset_control *
107 : : devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
108 : : {
109 : : return optional ? NULL : ERR_PTR(-ENOTSUPP);
110 : : }
111 : :
112 : : static inline struct reset_control *
113 : : of_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 : :
119 : : static inline int reset_control_get_count(struct device *dev)
120 : : {
121 : : return -ENOENT;
122 : : }
123 : :
124 : : #endif /* CONFIG_RESET_CONTROLLER */
125 : :
126 : : static inline int __must_check device_reset(struct device *dev)
127 : : {
128 : : return __device_reset(dev, false);
129 : : }
130 : :
131 : : static 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 : : */
151 : : static 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 : : */
171 : : static 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 : : */
200 : : static 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 : : */
217 : 672 : static inline struct reset_control *reset_control_get_optional_exclusive(
218 : : struct device *dev, const char *id)
219 : : {
220 : 672 : 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 : : */
234 : : static 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 : : */
250 : : static 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 : : */
275 : : static 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 : : */
292 : : static 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 : : */
320 : : static 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 : : */
338 : : static 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 : : */
357 : : static 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 : : */
373 : : static 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 : : */
391 : : static 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 : : */
409 : : static 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 : : */
427 : : static inline struct reset_control *
428 : : devm_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 : : */
443 : : static inline struct reset_control *
444 : : devm_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 : : */
457 : : static 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 : :
463 : : static 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 : :
469 : : static 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 : :
475 : : static 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 : :
482 : : static 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 : : */
491 : : static inline struct reset_control *
492 : : devm_reset_control_array_get_exclusive(struct device *dev)
493 : : {
494 : : return devm_reset_control_array_get(dev, false, false);
495 : : }
496 : :
497 : : static inline struct reset_control *
498 : : devm_reset_control_array_get_shared(struct device *dev)
499 : : {
500 : : return devm_reset_control_array_get(dev, true, false);
501 : : }
502 : :
503 : : static inline struct reset_control *
504 : : devm_reset_control_array_get_optional_exclusive(struct device *dev)
505 : : {
506 : : return devm_reset_control_array_get(dev, false, true);
507 : : }
508 : :
509 : : static inline struct reset_control *
510 : : devm_reset_control_array_get_optional_shared(struct device *dev)
511 : : {
512 : : return devm_reset_control_array_get(dev, true, true);
513 : : }
514 : :
515 : : static inline struct reset_control *
516 : : of_reset_control_array_get_exclusive(struct device_node *node)
517 : : {
518 : : return of_reset_control_array_get(node, false, false, true);
519 : : }
520 : :
521 : : static inline struct reset_control *
522 : : of_reset_control_array_get_exclusive_released(struct device_node *node)
523 : : {
524 : : return of_reset_control_array_get(node, false, false, false);
525 : : }
526 : :
527 : : static inline struct reset_control *
528 : : of_reset_control_array_get_shared(struct device_node *node)
529 : : {
530 : : return of_reset_control_array_get(node, true, false, true);
531 : : }
532 : :
533 : : static inline struct reset_control *
534 : : of_reset_control_array_get_optional_exclusive(struct device_node *node)
535 : : {
536 : : return of_reset_control_array_get(node, false, true, true);
537 : : }
538 : :
539 : : static inline struct reset_control *
540 : : of_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
|
