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 /**
14 * struct reset_control_bulk_data - Data used for bulk reset control operations.
15 *
16 * @id: reset control consumer ID
17 * @rstc: struct reset_control * to store the associated reset control
18 *
19 * The reset APIs provide a series of reset_control_bulk_*() API calls as
20 * a convenience to consumers which require multiple reset controls.
21 * This structure is used to manage data for these calls.
22 */
23 struct reset_control_bulk_data {
24 const char *id;
25 struct reset_control *rstc;
26 };
27
28 #ifdef CONFIG_RESET_CONTROLLER
29
30 int reset_control_reset(struct reset_control *rstc);
31 int reset_control_rearm(struct reset_control *rstc);
32 int reset_control_assert(struct reset_control *rstc);
33 int reset_control_deassert(struct reset_control *rstc);
34 int reset_control_status(struct reset_control *rstc);
35 int reset_control_acquire(struct reset_control *rstc);
36 void reset_control_release(struct reset_control *rstc);
37
38 int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs);
39 int reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs);
40 int reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs);
41 int reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs);
42 void reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs);
43
44 struct reset_control *__of_reset_control_get(struct device_node *node,
45 const char *id, int index, bool shared,
46 bool optional, bool acquired);
47 struct reset_control *__reset_control_get(struct device *dev, const char *id,
48 int index, bool shared,
49 bool optional, bool acquired);
50 void reset_control_put(struct reset_control *rstc);
51 int __reset_control_bulk_get(struct device *dev, int num_rstcs,
52 struct reset_control_bulk_data *rstcs,
53 bool shared, bool optional, bool acquired);
54 void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs);
55
56 int __device_reset(struct device *dev, bool optional);
57 struct reset_control *__devm_reset_control_get(struct device *dev,
58 const char *id, int index, bool shared,
59 bool optional, bool acquired);
60 int __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,
61 struct reset_control_bulk_data *rstcs,
62 bool shared, bool optional, bool acquired);
63
64 struct reset_control *devm_reset_control_array_get(struct device *dev,
65 bool shared, bool optional);
66 struct reset_control *of_reset_control_array_get(struct device_node *np,
67 bool shared, bool optional,
68 bool acquired);
69
70 int reset_control_get_count(struct device *dev);
71
72 #else
73
74 static inline int reset_control_reset(struct reset_control *rstc)
75 {
76 return 0;
77 }
78
79 static inline int reset_control_rearm(struct reset_control *rstc)
80 {
81 return 0;
82 }
83
84 static inline int reset_control_assert(struct reset_control *rstc)
85 {
86 return 0;
87 }
88
89 static inline int reset_control_deassert(struct reset_control *rstc)
90 {
91 return 0;
92 }
93
94 static inline int reset_control_status(struct reset_control *rstc)
95 {
96 return 0;
97 }
98
99 static inline int reset_control_acquire(struct reset_control *rstc)
100 {
101 return 0;
102 }
103
104 static inline void reset_control_release(struct reset_control *rstc)
105 {
106 }
107
108 static inline void reset_control_put(struct reset_control *rstc)
109 {
110 }
111
112 static inline int __device_reset(struct device *dev, bool optional)
113 {
114 return optional ? 0 : -ENOTSUPP;
115 }
116
117 static inline struct reset_control *__of_reset_control_get(
118 struct device_node *node,
119 const char *id, int index, bool shared,
120 bool optional, bool acquired)
121 {
122 return optional ? NULL : ERR_PTR(-ENOTSUPP);
123 }
124
125 static inline struct reset_control *__reset_control_get(
126 struct device *dev, const char *id,
127 int index, bool shared, bool optional,
128 bool acquired)
129 {
130 return optional ? NULL : ERR_PTR(-ENOTSUPP);
131 }
132
133 static inline int
134 reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs)
135 {
136 return 0;
137 }
138
139 static inline int
140 reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs)
141 {
142 return 0;
143 }
144
145 static inline int
146 reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs)
147 {
148 return 0;
149 }
150
151 static inline int
152 reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs)
153 {
154 return 0;
155 }
156
157 static inline void
158 reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs)
159 {
160 }
161
162 static inline int
163 __reset_control_bulk_get(struct device *dev, int num_rstcs,
164 struct reset_control_bulk_data *rstcs,
165 bool shared, bool optional, bool acquired)
166 {
167 return optional ? 0 : -EOPNOTSUPP;
168 }
169
170 static inline void
171 reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)
172 {
173 }
174
175 static inline struct reset_control *__devm_reset_control_get(
176 struct device *dev, const char *id,
177 int index, bool shared, bool optional,
178 bool acquired)
179 {
180 return optional ? NULL : ERR_PTR(-ENOTSUPP);
181 }
182
183 static inline int
184 __devm_reset_control_bulk_get(struct device *dev, int num_rstcs,
185 struct reset_control_bulk_data *rstcs,
186 bool shared, bool optional, bool acquired)
187 {
188 return optional ? 0 : -EOPNOTSUPP;
189 }
190
191 static inline struct reset_control *
192 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
193 {
194 return optional ? NULL : ERR_PTR(-ENOTSUPP);
195 }
196
197 static inline struct reset_control *
198 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
199 bool acquired)
200 {
201 return optional ? NULL : ERR_PTR(-ENOTSUPP);
202 }
203
204 static inline int reset_control_get_count(struct device *dev)
205 {
206 return -ENOENT;
207 }
208
209 #endif /* CONFIG_RESET_CONTROLLER */
210
211 static inline int __must_check device_reset(struct device *dev)
212 {
213 return __device_reset(dev, false);
214 }
215
216 static inline int device_reset_optional(struct device *dev)
217 {
218 return __device_reset(dev, true);
219 }
220
221 /**
222 * reset_control_get_exclusive - Lookup and obtain an exclusive reference
223 * to a reset controller.
224 * @dev: device to be reset by the controller
225 * @id: reset line name
226 *
227 * Returns a struct reset_control or IS_ERR() condition containing errno.
228 * If this function is called more than once for the same reset_control it will
229 * return -EBUSY.
230 *
231 * See reset_control_get_shared() for details on shared references to
232 * reset-controls.
233 *
234 * Use of id names is optional.
235 */
236 static inline struct reset_control *
237 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
238 {
239 return __reset_control_get(dev, id, 0, false, false, true);
240 }
241
242 /**
243 * reset_control_bulk_get_exclusive - Lookup and obtain exclusive references to
244 * multiple reset controllers.
245 * @dev: device to be reset by the controller
246 * @num_rstcs: number of entries in rstcs array
247 * @rstcs: array of struct reset_control_bulk_data with reset line names set
248 *
249 * Fills the rstcs array with pointers to exclusive reset controls and
250 * returns 0, or an IS_ERR() condition containing errno.
251 */
252 static inline int __must_check
253 reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs,
254 struct reset_control_bulk_data *rstcs)
255 {
256 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, true);
257 }
258
259 /**
260 * reset_control_get_exclusive_released - Lookup and obtain a temoprarily
261 * exclusive reference to a reset
262 * controller.
263 * @dev: device to be reset by the controller
264 * @id: reset line name
265 *
266 * Returns a struct reset_control or IS_ERR() condition containing errno.
267 * reset-controls returned by this function must be acquired via
268 * reset_control_acquire() before they can be used and should be released
269 * via reset_control_release() afterwards.
270 *
271 * Use of id names is optional.
272 */
273 static inline struct reset_control *
274 __must_check reset_control_get_exclusive_released(struct device *dev,
275 const char *id)
276 {
277 return __reset_control_get(dev, id, 0, false, false, false);
278 }
279
280 /**
281 * reset_control_bulk_get_exclusive_released - Lookup and obtain temporarily
282 * exclusive references to multiple reset
283 * controllers.
284 * @dev: device to be reset by the controller
285 * @num_rstcs: number of entries in rstcs array
286 * @rstcs: array of struct reset_control_bulk_data with reset line names set
287 *
288 * Fills the rstcs array with pointers to exclusive reset controls and
289 * returns 0, or an IS_ERR() condition containing errno.
290 * reset-controls returned by this function must be acquired via
291 * reset_control_bulk_acquire() before they can be used and should be released
292 * via reset_control_bulk_release() afterwards.
293 */
294 static inline int __must_check
295 reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs,
296 struct reset_control_bulk_data *rstcs)
297 {
298 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, false);
299 }
300
301 /**
302 * reset_control_bulk_get_optional_exclusive_released - Lookup and obtain optional
303 * temporarily exclusive references to multiple
304 * reset controllers.
305 * @dev: device to be reset by the controller
306 * @num_rstcs: number of entries in rstcs array
307 * @rstcs: array of struct reset_control_bulk_data with reset line names set
308 *
309 * Optional variant of reset_control_bulk_get_exclusive_released(). If the
310 * requested reset is not specified in the device tree, this function returns 0
311 * instead of an error and missing rtsc is set to NULL.
312 *
313 * See reset_control_bulk_get_exclusive_released() for more information.
314 */
315 static inline int __must_check
316 reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs,
317 struct reset_control_bulk_data *rstcs)
318 {
319 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, false);
320 }
321
322 /**
323 * reset_control_get_shared - Lookup and obtain a shared reference to a
324 * reset controller.
325 * @dev: device to be reset by the controller
326 * @id: reset line name
327 *
328 * Returns a struct reset_control or IS_ERR() condition containing errno.
329 * This function is intended for use with reset-controls which are shared
330 * between hardware blocks.
331 *
332 * When a reset-control is shared, the behavior of reset_control_assert /
333 * deassert is changed, the reset-core will keep track of a deassert_count
334 * and only (re-)assert the reset after reset_control_assert has been called
335 * as many times as reset_control_deassert was called. Also see the remark
336 * about shared reset-controls in the reset_control_assert docs.
337 *
338 * Calling reset_control_assert without first calling reset_control_deassert
339 * is not allowed on a shared reset control. Calling reset_control_reset is
340 * also not allowed on a shared reset control.
341 *
342 * Use of id names is optional.
343 */
344 static inline struct reset_control *reset_control_get_shared(
345 struct device *dev, const char *id)
346 {
347 return __reset_control_get(dev, id, 0, true, false, false);
348 }
349
350 /**
351 * reset_control_bulk_get_shared - Lookup and obtain shared references to
352 * multiple reset controllers.
353 * @dev: device to be reset by the controller
354 * @num_rstcs: number of entries in rstcs array
355 * @rstcs: array of struct reset_control_bulk_data with reset line names set
356 *
357 * Fills the rstcs array with pointers to shared reset controls and
358 * returns 0, or an IS_ERR() condition containing errno.
359 */
360 static inline int __must_check
361 reset_control_bulk_get_shared(struct device *dev, int num_rstcs,
362 struct reset_control_bulk_data *rstcs)
363 {
364 return __reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, false);
365 }
366
367 /**
368 * reset_control_get_optional_exclusive - optional reset_control_get_exclusive()
369 * @dev: device to be reset by the controller
370 * @id: reset line name
371 *
372 * Optional variant of reset_control_get_exclusive(). If the requested reset
373 * is not specified in the device tree, this function returns NULL instead of
374 * an error.
375 *
376 * See reset_control_get_exclusive() for more information.
377 */
378 static inline struct reset_control *reset_control_get_optional_exclusive(
379 struct device *dev, const char *id)
380 {
381 return __reset_control_get(dev, id, 0, false, true, true);
382 }
383
384 /**
385 * reset_control_bulk_get_optional_exclusive - optional
386 * reset_control_bulk_get_exclusive()
387 * @dev: device to be reset by the controller
388 * @num_rstcs: number of entries in rstcs array
389 * @rstcs: array of struct reset_control_bulk_data with reset line names set
390 *
391 * Optional variant of reset_control_bulk_get_exclusive(). If any of the
392 * requested resets are not specified in the device tree, this function sets
393 * them to NULL instead of returning an error.
394 *
395 * See reset_control_bulk_get_exclusive() for more information.
396 */
397 static inline int __must_check
398 reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs,
399 struct reset_control_bulk_data *rstcs)
400 {
401 return __reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, true);
402 }
403
404 /**
405 * reset_control_get_optional_shared - optional reset_control_get_shared()
406 * @dev: device to be reset by the controller
407 * @id: reset line name
408 *
409 * Optional variant of reset_control_get_shared(). If the requested reset
410 * is not specified in the device tree, this function returns NULL instead of
411 * an error.
412 *
413 * See reset_control_get_shared() for more information.
414 */
415 static inline struct reset_control *reset_control_get_optional_shared(
416 struct device *dev, const char *id)
417 {
418 return __reset_control_get(dev, id, 0, true, true, false);
419 }
420
421 /**
422 * reset_control_bulk_get_optional_shared - optional
423 * reset_control_bulk_get_shared()
424 * @dev: device to be reset by the controller
425 * @num_rstcs: number of entries in rstcs array
426 * @rstcs: array of struct reset_control_bulk_data with reset line names set
427 *
428 * Optional variant of reset_control_bulk_get_shared(). If the requested resets
429 * are not specified in the device tree, this function sets them to NULL
430 * instead of returning an error.
431 *
432 * See reset_control_bulk_get_shared() for more information.
433 */
434 static inline int __must_check
435 reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs,
436 struct reset_control_bulk_data *rstcs)
437 {
438 return __reset_control_bulk_get(dev, num_rstcs, rstcs, true, true, false);
439 }
440
441 /**
442 * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
443 * to a reset controller.
444 * @node: device to be reset by the controller
445 * @id: reset line name
446 *
447 * Returns a struct reset_control or IS_ERR() condition containing errno.
448 *
449 * Use of id names is optional.
450 */
451 static inline struct reset_control *of_reset_control_get_exclusive(
452 struct device_node *node, const char *id)
453 {
454 return __of_reset_control_get(node, id, 0, false, false, true);
455 }
456
457 /**
458 * of_reset_control_get_optional_exclusive - Lookup and obtain an optional exclusive
459 * reference to a reset controller.
460 * @node: device to be reset by the controller
461 * @id: reset line name
462 *
463 * Optional variant of of_reset_control_get_exclusive(). If the requested reset
464 * is not specified in the device tree, this function returns NULL instead of
465 * an error.
466 *
467 * Returns a struct reset_control or IS_ERR() condition containing errno.
468 *
469 * Use of id names is optional.
470 */
471 static inline struct reset_control *of_reset_control_get_optional_exclusive(
472 struct device_node *node, const char *id)
473 {
474 return __of_reset_control_get(node, id, 0, false, true, true);
475 }
476
477 /**
478 * of_reset_control_get_shared - Lookup and obtain a shared reference
479 * to a reset controller.
480 * @node: device to be reset by the controller
481 * @id: reset line name
482 *
483 * When a reset-control is shared, the behavior of reset_control_assert /
484 * deassert is changed, the reset-core will keep track of a deassert_count
485 * and only (re-)assert the reset after reset_control_assert has been called
486 * as many times as reset_control_deassert was called. Also see the remark
487 * about shared reset-controls in the reset_control_assert docs.
488 *
489 * Calling reset_control_assert without first calling reset_control_deassert
490 * is not allowed on a shared reset control. Calling reset_control_reset is
491 * also not allowed on a shared reset control.
492 * Returns a struct reset_control or IS_ERR() condition containing errno.
493 *
494 * Use of id names is optional.
495 */
496 static inline struct reset_control *of_reset_control_get_shared(
497 struct device_node *node, const char *id)
498 {
499 return __of_reset_control_get(node, id, 0, true, false, false);
500 }
501
502 /**
503 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
504 * reference to a reset controller
505 * by index.
506 * @node: device to be reset by the controller
507 * @index: index of the reset controller
508 *
509 * This is to be used to perform a list of resets for a device or power domain
510 * in whatever order. Returns a struct reset_control or IS_ERR() condition
511 * containing errno.
512 */
513 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
514 struct device_node *node, int index)
515 {
516 return __of_reset_control_get(node, NULL, index, false, false, true);
517 }
518
519 /**
520 * of_reset_control_get_shared_by_index - Lookup and obtain a shared
521 * reference to a reset controller
522 * by index.
523 * @node: device to be reset by the controller
524 * @index: index of the reset controller
525 *
526 * When a reset-control is shared, the behavior of reset_control_assert /
527 * deassert is changed, the reset-core will keep track of a deassert_count
528 * and only (re-)assert the reset after reset_control_assert has been called
529 * as many times as reset_control_deassert was called. Also see the remark
530 * about shared reset-controls in the reset_control_assert docs.
531 *
532 * Calling reset_control_assert without first calling reset_control_deassert
533 * is not allowed on a shared reset control. Calling reset_control_reset is
534 * also not allowed on a shared reset control.
535 * Returns a struct reset_control or IS_ERR() condition containing errno.
536 *
537 * This is to be used to perform a list of resets for a device or power domain
538 * in whatever order. Returns a struct reset_control or IS_ERR() condition
539 * containing errno.
540 */
541 static inline struct reset_control *of_reset_control_get_shared_by_index(
542 struct device_node *node, int index)
543 {
544 return __of_reset_control_get(node, NULL, index, true, false, false);
545 }
546
547 /**
548 * devm_reset_control_get_exclusive - resource managed
549 * reset_control_get_exclusive()
550 * @dev: device to be reset by the controller
551 * @id: reset line name
552 *
553 * Managed reset_control_get_exclusive(). For reset controllers returned
554 * from this function, reset_control_put() is called automatically on driver
555 * detach.
556 *
557 * See reset_control_get_exclusive() for more information.
558 */
559 static inline struct reset_control *
560 __must_check devm_reset_control_get_exclusive(struct device *dev,
561 const char *id)
562 {
563 return __devm_reset_control_get(dev, id, 0, false, false, true);
564 }
565
566 /**
567 * devm_reset_control_bulk_get_exclusive - resource managed
568 * reset_control_bulk_get_exclusive()
569 * @dev: device to be reset by the controller
570 * @num_rstcs: number of entries in rstcs array
571 * @rstcs: array of struct reset_control_bulk_data with reset line names set
572 *
573 * Managed reset_control_bulk_get_exclusive(). For reset controllers returned
574 * from this function, reset_control_put() is called automatically on driver
575 * detach.
576 *
577 * See reset_control_bulk_get_exclusive() for more information.
578 */
579 static inline int __must_check
580 devm_reset_control_bulk_get_exclusive(struct device *dev, int num_rstcs,
581 struct reset_control_bulk_data *rstcs)
582 {
583 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, true);
584 }
585
586 /**
587 * devm_reset_control_get_exclusive_released - resource managed
588 * reset_control_get_exclusive_released()
589 * @dev: device to be reset by the controller
590 * @id: reset line name
591 *
592 * Managed reset_control_get_exclusive_released(). For reset controllers
593 * returned from this function, reset_control_put() is called automatically on
594 * driver detach.
595 *
596 * See reset_control_get_exclusive_released() for more information.
597 */
598 static inline struct reset_control *
599 __must_check devm_reset_control_get_exclusive_released(struct device *dev,
600 const char *id)
601 {
602 return __devm_reset_control_get(dev, id, 0, false, false, false);
603 }
604
605 /**
606 * devm_reset_control_bulk_get_exclusive_released - resource managed
607 * reset_control_bulk_get_exclusive_released()
608 * @dev: device to be reset by the controller
609 * @num_rstcs: number of entries in rstcs array
610 * @rstcs: array of struct reset_control_bulk_data with reset line names set
611 *
612 * Managed reset_control_bulk_get_exclusive_released(). For reset controllers
613 * returned from this function, reset_control_put() is called automatically on
614 * driver detach.
615 *
616 * See reset_control_bulk_get_exclusive_released() for more information.
617 */
618 static inline int __must_check
619 devm_reset_control_bulk_get_exclusive_released(struct device *dev, int num_rstcs,
620 struct reset_control_bulk_data *rstcs)
621 {
622 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, false, false);
623 }
624
625 /**
626 * devm_reset_control_get_optional_exclusive_released - resource managed
627 * reset_control_get_optional_exclusive_released()
628 * @dev: device to be reset by the controller
629 * @id: reset line name
630 *
631 * Managed-and-optional variant of reset_control_get_exclusive_released(). For
632 * reset controllers returned from this function, reset_control_put() is called
633 * automatically on driver detach.
634 *
635 * See reset_control_get_exclusive_released() for more information.
636 */
637 static inline struct reset_control *
638 __must_check devm_reset_control_get_optional_exclusive_released(struct device *dev,
639 const char *id)
640 {
641 return __devm_reset_control_get(dev, id, 0, false, true, false);
642 }
643
644 /**
645 * devm_reset_control_bulk_get_optional_exclusive_released - resource managed
646 * reset_control_bulk_optional_get_exclusive_released()
647 * @dev: device to be reset by the controller
648 * @num_rstcs: number of entries in rstcs array
649 * @rstcs: array of struct reset_control_bulk_data with reset line names set
650 *
651 * Managed reset_control_bulk_optional_get_exclusive_released(). For reset
652 * controllers returned from this function, reset_control_put() is called
653 * automatically on driver detach.
654 *
655 * See reset_control_bulk_optional_get_exclusive_released() for more information.
656 */
657 static inline int __must_check
658 devm_reset_control_bulk_get_optional_exclusive_released(struct device *dev, int num_rstcs,
659 struct reset_control_bulk_data *rstcs)
660 {
661 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, false);
662 }
663
664 /**
665 * devm_reset_control_get_shared - resource managed reset_control_get_shared()
666 * @dev: device to be reset by the controller
667 * @id: reset line name
668 *
669 * Managed reset_control_get_shared(). For reset controllers returned from
670 * this function, reset_control_put() is called automatically on driver detach.
671 * See reset_control_get_shared() for more information.
672 */
673 static inline struct reset_control *devm_reset_control_get_shared(
674 struct device *dev, const char *id)
675 {
676 return __devm_reset_control_get(dev, id, 0, true, false, false);
677 }
678
679 /**
680 * devm_reset_control_bulk_get_shared - resource managed
681 * reset_control_bulk_get_shared()
682 * @dev: device to be reset by the controller
683 * @num_rstcs: number of entries in rstcs array
684 * @rstcs: array of struct reset_control_bulk_data with reset line names set
685 *
686 * Managed reset_control_bulk_get_shared(). For reset controllers returned
687 * from this function, reset_control_put() is called automatically on driver
688 * detach.
689 *
690 * See reset_control_bulk_get_shared() for more information.
691 */
692 static inline int __must_check
693 devm_reset_control_bulk_get_shared(struct device *dev, int num_rstcs,
694 struct reset_control_bulk_data *rstcs)
695 {
696 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, false, false);
697 }
698
699 /**
700 * devm_reset_control_get_optional_exclusive - resource managed
701 * reset_control_get_optional_exclusive()
702 * @dev: device to be reset by the controller
703 * @id: reset line name
704 *
705 * Managed reset_control_get_optional_exclusive(). For reset controllers
706 * returned from this function, reset_control_put() is called automatically on
707 * driver detach.
708 *
709 * See reset_control_get_optional_exclusive() for more information.
710 */
711 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
712 struct device *dev, const char *id)
713 {
714 return __devm_reset_control_get(dev, id, 0, false, true, true);
715 }
716
717 /**
718 * devm_reset_control_bulk_get_optional_exclusive - resource managed
719 * reset_control_bulk_get_optional_exclusive()
720 * @dev: device to be reset by the controller
721 * @num_rstcs: number of entries in rstcs array
722 * @rstcs: array of struct reset_control_bulk_data with reset line names set
723 *
724 * Managed reset_control_bulk_get_optional_exclusive(). For reset controllers
725 * returned from this function, reset_control_put() is called automatically on
726 * driver detach.
727 *
728 * See reset_control_bulk_get_optional_exclusive() for more information.
729 */
730 static inline int __must_check
731 devm_reset_control_bulk_get_optional_exclusive(struct device *dev, int num_rstcs,
732 struct reset_control_bulk_data *rstcs)
733 {
734 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, false, true, true);
735 }
736
737 /**
738 * devm_reset_control_get_optional_shared - resource managed
739 * reset_control_get_optional_shared()
740 * @dev: device to be reset by the controller
741 * @id: reset line name
742 *
743 * Managed reset_control_get_optional_shared(). For reset controllers returned
744 * from this function, reset_control_put() is called automatically on driver
745 * detach.
746 *
747 * See reset_control_get_optional_shared() for more information.
748 */
749 static inline struct reset_control *devm_reset_control_get_optional_shared(
750 struct device *dev, const char *id)
751 {
752 return __devm_reset_control_get(dev, id, 0, true, true, false);
753 }
754
755 /**
756 * devm_reset_control_bulk_get_optional_shared - resource managed
757 * reset_control_bulk_get_optional_shared()
758 * @dev: device to be reset by the controller
759 * @num_rstcs: number of entries in rstcs array
760 * @rstcs: array of struct reset_control_bulk_data with reset line names set
761 *
762 * Managed reset_control_bulk_get_optional_shared(). For reset controllers
763 * returned from this function, reset_control_put() is called automatically on
764 * driver detach.
765 *
766 * See reset_control_bulk_get_optional_shared() for more information.
767 */
768 static inline int __must_check
769 devm_reset_control_bulk_get_optional_shared(struct device *dev, int num_rstcs,
770 struct reset_control_bulk_data *rstcs)
771 {
772 return __devm_reset_control_bulk_get(dev, num_rstcs, rstcs, true, true, false);
773 }
774
775 /**
776 * devm_reset_control_get_exclusive_by_index - resource managed
777 * reset_control_get_exclusive()
778 * @dev: device to be reset by the controller
779 * @index: index of the reset controller
780 *
781 * Managed reset_control_get_exclusive(). For reset controllers returned from
782 * this function, reset_control_put() is called automatically on driver
783 * detach.
784 *
785 * See reset_control_get_exclusive() for more information.
786 */
787 static inline struct reset_control *
788 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
789 {
790 return __devm_reset_control_get(dev, NULL, index, false, false, true);
791 }
792
793 /**
794 * devm_reset_control_get_shared_by_index - resource managed
795 * reset_control_get_shared
796 * @dev: device to be reset by the controller
797 * @index: index of the reset controller
798 *
799 * Managed reset_control_get_shared(). For reset controllers returned from
800 * this function, reset_control_put() is called automatically on driver detach.
801 * See reset_control_get_shared() for more information.
802 */
803 static inline struct reset_control *
804 devm_reset_control_get_shared_by_index(struct device *dev, int index)
805 {
806 return __devm_reset_control_get(dev, NULL, index, true, false, false);
807 }
808
809 /*
810 * TEMPORARY calls to use during transition:
811 *
812 * of_reset_control_get() => of_reset_control_get_exclusive()
813 *
814 * These inline function calls will be removed once all consumers
815 * have been moved over to the new explicit API.
816 */
817 static inline struct reset_control *of_reset_control_get(
818 struct device_node *node, const char *id)
819 {
820 return of_reset_control_get_exclusive(node, id);
821 }
822
823 static inline struct reset_control *of_reset_control_get_by_index(
824 struct device_node *node, int index)
825 {
826 return of_reset_control_get_exclusive_by_index(node, index);
827 }
828
829 static inline struct reset_control *devm_reset_control_get(
830 struct device *dev, const char *id)
831 {
832 return devm_reset_control_get_exclusive(dev, id);
833 }
834
835 static inline struct reset_control *devm_reset_control_get_optional(
836 struct device *dev, const char *id)
837 {
838 return devm_reset_control_get_optional_exclusive(dev, id);
839
840 }
841
842 static inline struct reset_control *devm_reset_control_get_by_index(
843 struct device *dev, int index)
844 {
845 return devm_reset_control_get_exclusive_by_index(dev, index);
846 }
847
848 /*
849 * APIs to manage a list of reset controllers
850 */
851 static inline struct reset_control *
852 devm_reset_control_array_get_exclusive(struct device *dev)
853 {
854 return devm_reset_control_array_get(dev, false, false);
855 }
856
857 static inline struct reset_control *
858 devm_reset_control_array_get_shared(struct device *dev)
859 {
860 return devm_reset_control_array_get(dev, true, false);
861 }
862
863 static inline struct reset_control *
864 devm_reset_control_array_get_optional_exclusive(struct device *dev)
865 {
866 return devm_reset_control_array_get(dev, false, true);
867 }
868
869 static inline struct reset_control *
870 devm_reset_control_array_get_optional_shared(struct device *dev)
871 {
872 return devm_reset_control_array_get(dev, true, true);
873 }
874
875 static inline struct reset_control *
876 of_reset_control_array_get_exclusive(struct device_node *node)
877 {
878 return of_reset_control_array_get(node, false, false, true);
879 }
880
881 static inline struct reset_control *
882 of_reset_control_array_get_exclusive_released(struct device_node *node)
883 {
884 return of_reset_control_array_get(node, false, false, false);
885 }
886
887 static inline struct reset_control *
888 of_reset_control_array_get_shared(struct device_node *node)
889 {
890 return of_reset_control_array_get(node, true, false, true);
891 }
892
893 static inline struct reset_control *
894 of_reset_control_array_get_optional_exclusive(struct device_node *node)
895 {
896 return of_reset_control_array_get(node, false, true, true);
897 }
898
899 static inline struct reset_control *
900 of_reset_control_array_get_optional_shared(struct device_node *node)
901 {
902 return of_reset_control_array_get(node, true, true, true);
903 }
904 #endif
905
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.