]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - include/linux/reset.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_RESET_H_
3 #define _LINUX_RESET_H_
6 #include <linux/errno.h>
7 #include <linux/types.h>
14 * struct reset_control_bulk_data - Data used for bulk reset control operations.
16 * @id: reset control consumer ID
17 * @rstc: struct reset_control * to store the associated reset control
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.
23 struct reset_control_bulk_data
{
25 struct reset_control
*rstc
;
28 #ifdef CONFIG_RESET_CONTROLLER
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
);
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
);
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
);
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
);
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
,
70 int reset_control_get_count(struct device
*dev
);
74 static inline int reset_control_reset(struct reset_control
*rstc
)
79 static inline int reset_control_rearm(struct reset_control
*rstc
)
84 static inline int reset_control_assert(struct reset_control
*rstc
)
89 static inline int reset_control_deassert(struct reset_control
*rstc
)
94 static inline int reset_control_status(struct reset_control
*rstc
)
99 static inline int reset_control_acquire(struct reset_control
*rstc
)
104 static inline void reset_control_release(struct reset_control
*rstc
)
108 static inline void reset_control_put(struct reset_control
*rstc
)
112 static inline int __device_reset(struct device
*dev
, bool optional
)
114 return optional
? 0 : -ENOTSUPP
;
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
)
122 return optional
? NULL
: ERR_PTR(-ENOTSUPP
);
125 static inline struct reset_control
*__reset_control_get(
126 struct device
*dev
, const char *id
,
127 int index
, bool shared
, bool optional
,
130 return optional
? NULL
: ERR_PTR(-ENOTSUPP
);
134 reset_control_bulk_reset(int num_rstcs
, struct reset_control_bulk_data
*rstcs
)
140 reset_control_bulk_assert(int num_rstcs
, struct reset_control_bulk_data
*rstcs
)
146 reset_control_bulk_deassert(int num_rstcs
, struct reset_control_bulk_data
*rstcs
)
152 reset_control_bulk_acquire(int num_rstcs
, struct reset_control_bulk_data
*rstcs
)
158 reset_control_bulk_release(int num_rstcs
, struct reset_control_bulk_data
*rstcs
)
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
)
167 return optional
? 0 : -EOPNOTSUPP
;
171 reset_control_bulk_put(int num_rstcs
, struct reset_control_bulk_data
*rstcs
)
175 static inline struct reset_control
*__devm_reset_control_get(
176 struct device
*dev
, const char *id
,
177 int index
, bool shared
, bool optional
,
180 return optional
? NULL
: ERR_PTR(-ENOTSUPP
);
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
)
188 return optional
? 0 : -EOPNOTSUPP
;
191 static inline struct reset_control
*
192 devm_reset_control_array_get(struct device
*dev
, bool shared
, bool optional
)
194 return optional
? NULL
: ERR_PTR(-ENOTSUPP
);
197 static inline struct reset_control
*
198 of_reset_control_array_get(struct device_node
*np
, bool shared
, bool optional
,
201 return optional
? NULL
: ERR_PTR(-ENOTSUPP
);
204 static inline int reset_control_get_count(struct device
*dev
)
209 #endif /* CONFIG_RESET_CONTROLLER */
211 static inline int __must_check
device_reset(struct device
*dev
)
213 return __device_reset(dev
, false);
216 static inline int device_reset_optional(struct device
*dev
)
218 return __device_reset(dev
, true);
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
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
231 * See reset_control_get_shared() for details on shared references to
234 * Use of id names is optional.
236 static inline struct reset_control
*
237 __must_check
reset_control_get_exclusive(struct device
*dev
, const char *id
)
239 return __reset_control_get(dev
, id
, 0, false, false, true);
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
249 * Fills the rstcs array with pointers to exclusive reset controls and
250 * returns 0, or an IS_ERR() condition containing errno.
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
)
256 return __reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, false, true);
260 * reset_control_get_exclusive_released - Lookup and obtain a temoprarily
261 * exclusive reference to a reset
263 * @dev: device to be reset by the controller
264 * @id: reset line name
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.
271 * Use of id names is optional.
273 static inline struct reset_control
*
274 __must_check
reset_control_get_exclusive_released(struct device
*dev
,
277 return __reset_control_get(dev
, id
, 0, false, false, false);
281 * reset_control_bulk_get_exclusive_released - Lookup and obtain temporarily
282 * exclusive references to multiple reset
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
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.
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
)
298 return __reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, false, false);
302 * reset_control_bulk_get_optional_exclusive_released - Lookup and obtain optional
303 * temporarily exclusive references to multiple
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
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.
313 * See reset_control_bulk_get_exclusive_released() for more information.
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
)
319 return __reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, true, false);
323 * reset_control_get_shared - Lookup and obtain a shared reference to a
325 * @dev: device to be reset by the controller
326 * @id: reset line name
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.
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.
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.
342 * Use of id names is optional.
344 static inline struct reset_control
*reset_control_get_shared(
345 struct device
*dev
, const char *id
)
347 return __reset_control_get(dev
, id
, 0, true, false, false);
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
357 * Fills the rstcs array with pointers to shared reset controls and
358 * returns 0, or an IS_ERR() condition containing errno.
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
)
364 return __reset_control_bulk_get(dev
, num_rstcs
, rstcs
, true, false, false);
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
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
376 * See reset_control_get_exclusive() for more information.
378 static inline struct reset_control
*reset_control_get_optional_exclusive(
379 struct device
*dev
, const char *id
)
381 return __reset_control_get(dev
, id
, 0, false, true, true);
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
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.
395 * See reset_control_bulk_get_exclusive() for more information.
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
)
401 return __reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, true, true);
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
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
413 * See reset_control_get_shared() for more information.
415 static inline struct reset_control
*reset_control_get_optional_shared(
416 struct device
*dev
, const char *id
)
418 return __reset_control_get(dev
, id
, 0, true, true, false);
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
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.
432 * See reset_control_bulk_get_shared() for more information.
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
)
438 return __reset_control_bulk_get(dev
, num_rstcs
, rstcs
, true, true, false);
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
447 * Returns a struct reset_control or IS_ERR() condition containing errno.
449 * Use of id names is optional.
451 static inline struct reset_control
*of_reset_control_get_exclusive(
452 struct device_node
*node
, const char *id
)
454 return __of_reset_control_get(node
, id
, 0, false, false, true);
458 * of_reset_control_get_shared - Lookup and obtain a shared reference
459 * to a reset controller.
460 * @node: device to be reset by the controller
461 * @id: reset line name
463 * When a reset-control is shared, the behavior of reset_control_assert /
464 * deassert is changed, the reset-core will keep track of a deassert_count
465 * and only (re-)assert the reset after reset_control_assert has been called
466 * as many times as reset_control_deassert was called. Also see the remark
467 * about shared reset-controls in the reset_control_assert docs.
469 * Calling reset_control_assert without first calling reset_control_deassert
470 * is not allowed on a shared reset control. Calling reset_control_reset is
471 * also not allowed on a shared reset control.
472 * Returns a struct reset_control or IS_ERR() condition containing errno.
474 * Use of id names is optional.
476 static inline struct reset_control
*of_reset_control_get_shared(
477 struct device_node
*node
, const char *id
)
479 return __of_reset_control_get(node
, id
, 0, true, false, false);
483 * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
484 * reference to a reset controller
486 * @node: device to be reset by the controller
487 * @index: index of the reset controller
489 * This is to be used to perform a list of resets for a device or power domain
490 * in whatever order. Returns a struct reset_control or IS_ERR() condition
493 static inline struct reset_control
*of_reset_control_get_exclusive_by_index(
494 struct device_node
*node
, int index
)
496 return __of_reset_control_get(node
, NULL
, index
, false, false, true);
500 * of_reset_control_get_shared_by_index - Lookup and obtain a shared
501 * reference to a reset controller
503 * @node: device to be reset by the controller
504 * @index: index of the reset controller
506 * When a reset-control is shared, the behavior of reset_control_assert /
507 * deassert is changed, the reset-core will keep track of a deassert_count
508 * and only (re-)assert the reset after reset_control_assert has been called
509 * as many times as reset_control_deassert was called. Also see the remark
510 * about shared reset-controls in the reset_control_assert docs.
512 * Calling reset_control_assert without first calling reset_control_deassert
513 * is not allowed on a shared reset control. Calling reset_control_reset is
514 * also not allowed on a shared reset control.
515 * Returns a struct reset_control or IS_ERR() condition containing errno.
517 * This is to be used to perform a list of resets for a device or power domain
518 * in whatever order. Returns a struct reset_control or IS_ERR() condition
521 static inline struct reset_control
*of_reset_control_get_shared_by_index(
522 struct device_node
*node
, int index
)
524 return __of_reset_control_get(node
, NULL
, index
, true, false, false);
528 * devm_reset_control_get_exclusive - resource managed
529 * reset_control_get_exclusive()
530 * @dev: device to be reset by the controller
531 * @id: reset line name
533 * Managed reset_control_get_exclusive(). For reset controllers returned
534 * from this function, reset_control_put() is called automatically on driver
537 * See reset_control_get_exclusive() for more information.
539 static inline struct reset_control
*
540 __must_check
devm_reset_control_get_exclusive(struct device
*dev
,
543 return __devm_reset_control_get(dev
, id
, 0, false, false, true);
547 * devm_reset_control_bulk_get_exclusive - resource managed
548 * reset_control_bulk_get_exclusive()
549 * @dev: device to be reset by the controller
550 * @num_rstcs: number of entries in rstcs array
551 * @rstcs: array of struct reset_control_bulk_data with reset line names set
553 * Managed reset_control_bulk_get_exclusive(). For reset controllers returned
554 * from this function, reset_control_put() is called automatically on driver
557 * See reset_control_bulk_get_exclusive() for more information.
559 static inline int __must_check
560 devm_reset_control_bulk_get_exclusive(struct device
*dev
, int num_rstcs
,
561 struct reset_control_bulk_data
*rstcs
)
563 return __devm_reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, false, true);
567 * devm_reset_control_get_exclusive_released - resource managed
568 * reset_control_get_exclusive_released()
569 * @dev: device to be reset by the controller
570 * @id: reset line name
572 * Managed reset_control_get_exclusive_released(). For reset controllers
573 * returned from this function, reset_control_put() is called automatically on
576 * See reset_control_get_exclusive_released() for more information.
578 static inline struct reset_control
*
579 __must_check
devm_reset_control_get_exclusive_released(struct device
*dev
,
582 return __devm_reset_control_get(dev
, id
, 0, false, false, false);
586 * devm_reset_control_bulk_get_exclusive_released - resource managed
587 * reset_control_bulk_get_exclusive_released()
588 * @dev: device to be reset by the controller
589 * @num_rstcs: number of entries in rstcs array
590 * @rstcs: array of struct reset_control_bulk_data with reset line names set
592 * Managed reset_control_bulk_get_exclusive_released(). For reset controllers
593 * returned from this function, reset_control_put() is called automatically on
596 * See reset_control_bulk_get_exclusive_released() for more information.
598 static inline int __must_check
599 devm_reset_control_bulk_get_exclusive_released(struct device
*dev
, int num_rstcs
,
600 struct reset_control_bulk_data
*rstcs
)
602 return __devm_reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, false, false);
606 * devm_reset_control_get_optional_exclusive_released - resource managed
607 * reset_control_get_optional_exclusive_released()
608 * @dev: device to be reset by the controller
609 * @id: reset line name
611 * Managed-and-optional variant of reset_control_get_exclusive_released(). For
612 * reset controllers returned from this function, reset_control_put() is called
613 * automatically on driver detach.
615 * See reset_control_get_exclusive_released() for more information.
617 static inline struct reset_control
*
618 __must_check
devm_reset_control_get_optional_exclusive_released(struct device
*dev
,
621 return __devm_reset_control_get(dev
, id
, 0, false, true, false);
625 * devm_reset_control_bulk_get_optional_exclusive_released - resource managed
626 * reset_control_bulk_optional_get_exclusive_released()
627 * @dev: device to be reset by the controller
628 * @num_rstcs: number of entries in rstcs array
629 * @rstcs: array of struct reset_control_bulk_data with reset line names set
631 * Managed reset_control_bulk_optional_get_exclusive_released(). For reset
632 * controllers returned from this function, reset_control_put() is called
633 * automatically on driver detach.
635 * See reset_control_bulk_optional_get_exclusive_released() for more information.
637 static inline int __must_check
638 devm_reset_control_bulk_get_optional_exclusive_released(struct device
*dev
, int num_rstcs
,
639 struct reset_control_bulk_data
*rstcs
)
641 return __devm_reset_control_bulk_get(dev
, num_rstcs
, rstcs
, false, true, false);
645 * devm_reset_control_get_shared - resource managed reset_control_get_shared()
646 * @dev: device to be reset by the controller
647 * @id: reset line name
649 * Managed reset_control_get_shared(). For reset controllers returned from
650 * this function, reset_control_put() is called automatically on driver detach.
651 * See reset_control_get_shared() for more information.
653 static inline struct reset_control
*devm_reset_control_get_shared(
654 struct device
*dev
, const char *id
)
656 return __devm_reset_control_get(dev
, id
, 0, true, false, false);
660 * devm_reset_control_bulk_get_shared - resource managed
661 * reset_control_bulk_get_shared()
662 * @dev: device to be reset by the controller
663 * @num_rstcs: number of entries in rstcs array
664 * @rstcs: array of struct reset_control_bulk_data with reset line names set
666 * Managed reset_control_bulk_get_shared(). For reset controllers returned
667 * from this function, reset_control_put() is called automatically on driver
670 * See reset_control_bulk_get_shared() for more information.
672 static inline int __must_check
673 devm_reset_control_bulk_get_shared(struct device
*dev
, int num_rstcs
,
674 struct reset_control_bulk_data
*rstcs
)
676 return __devm_reset_control_bulk_get(dev
, num_rstcs
, rstcs
, true, false, false);
680 * devm_reset_control_get_optional_exclusive - resource managed
681 * reset_control_get_optional_exclusive()
682 * @dev: device to be reset by the controller
683 * @id: reset line name
685 * Managed reset_control_get_optional_exclusive(). For reset controllers
686 * returned from this function, reset_control_put() is called automatically on
689 * See reset_control_get_optional_exclusive() for more information.
691 static inline struct reset_control
*devm_reset_control_get_optional_exclusive(
692 struct device
*dev
, const char *id
)
694 return __devm_reset_control_get(dev
, id
, 0, false, true, true);
698 * devm_reset_control_bulk_get_optional_exclusive - resource managed
699 * reset_control_bulk_get_optional_exclusive()
700 * @dev: device to be reset by the controller
701 * @num_rstcs: number of entries in rstcs array
702 * @rstcs: array of struct reset_control_bulk_data with reset line names set
704 * Managed reset_control_bulk_get_optional_exclusive(). For reset controllers
705 * returned from this function, reset_control_put() is called automatically on
708 * See reset_control_bulk_get_optional_exclusive() for more information.
710 static inline int __must_check
711 devm_reset_control_bulk_get_optional_exclusive(struct device
*dev
, int num_rstcs
,
712 struct reset_control_bulk_data
*rstcs
)
714 return __devm_reset_control_bulk_get(dev
, num_rstcs
, rstcs
, true, false, true);
718 * devm_reset_control_get_optional_shared - resource managed
719 * reset_control_get_optional_shared()
720 * @dev: device to be reset by the controller
721 * @id: reset line name
723 * Managed reset_control_get_optional_shared(). For reset controllers returned
724 * from this function, reset_control_put() is called automatically on driver
727 * See reset_control_get_optional_shared() for more information.
729 static inline struct reset_control
*devm_reset_control_get_optional_shared(
730 struct device
*dev
, const char *id
)
732 return __devm_reset_control_get(dev
, id
, 0, true, true, false);
736 * devm_reset_control_bulk_get_optional_shared - resource managed
737 * reset_control_bulk_get_optional_shared()
738 * @dev: device to be reset by the controller
739 * @num_rstcs: number of entries in rstcs array
740 * @rstcs: array of struct reset_control_bulk_data with reset line names set
742 * Managed reset_control_bulk_get_optional_shared(). For reset controllers
743 * returned from this function, reset_control_put() is called automatically on
746 * See reset_control_bulk_get_optional_shared() for more information.
748 static inline int __must_check
749 devm_reset_control_bulk_get_optional_shared(struct device
*dev
, int num_rstcs
,
750 struct reset_control_bulk_data
*rstcs
)
752 return __devm_reset_control_bulk_get(dev
, num_rstcs
, rstcs
, true, true, false);
756 * devm_reset_control_get_exclusive_by_index - resource managed
757 * reset_control_get_exclusive()
758 * @dev: device to be reset by the controller
759 * @index: index of the reset controller
761 * Managed reset_control_get_exclusive(). For reset controllers returned from
762 * this function, reset_control_put() is called automatically on driver
765 * See reset_control_get_exclusive() for more information.
767 static inline struct reset_control
*
768 devm_reset_control_get_exclusive_by_index(struct device
*dev
, int index
)
770 return __devm_reset_control_get(dev
, NULL
, index
, false, false, true);
774 * devm_reset_control_get_shared_by_index - resource managed
775 * reset_control_get_shared
776 * @dev: device to be reset by the controller
777 * @index: index of the reset controller
779 * Managed reset_control_get_shared(). For reset controllers returned from
780 * this function, reset_control_put() is called automatically on driver detach.
781 * See reset_control_get_shared() for more information.
783 static inline struct reset_control
*
784 devm_reset_control_get_shared_by_index(struct device
*dev
, int index
)
786 return __devm_reset_control_get(dev
, NULL
, index
, true, false, false);
790 * TEMPORARY calls to use during transition:
792 * of_reset_control_get() => of_reset_control_get_exclusive()
794 * These inline function calls will be removed once all consumers
795 * have been moved over to the new explicit API.
797 static inline struct reset_control
*of_reset_control_get(
798 struct device_node
*node
, const char *id
)
800 return of_reset_control_get_exclusive(node
, id
);
803 static inline struct reset_control
*of_reset_control_get_by_index(
804 struct device_node
*node
, int index
)
806 return of_reset_control_get_exclusive_by_index(node
, index
);
809 static inline struct reset_control
*devm_reset_control_get(
810 struct device
*dev
, const char *id
)
812 return devm_reset_control_get_exclusive(dev
, id
);
815 static inline struct reset_control
*devm_reset_control_get_optional(
816 struct device
*dev
, const char *id
)
818 return devm_reset_control_get_optional_exclusive(dev
, id
);
822 static inline struct reset_control
*devm_reset_control_get_by_index(
823 struct device
*dev
, int index
)
825 return devm_reset_control_get_exclusive_by_index(dev
, index
);
829 * APIs to manage a list of reset controllers
831 static inline struct reset_control
*
832 devm_reset_control_array_get_exclusive(struct device
*dev
)
834 return devm_reset_control_array_get(dev
, false, false);
837 static inline struct reset_control
*
838 devm_reset_control_array_get_shared(struct device
*dev
)
840 return devm_reset_control_array_get(dev
, true, false);
843 static inline struct reset_control
*
844 devm_reset_control_array_get_optional_exclusive(struct device
*dev
)
846 return devm_reset_control_array_get(dev
, false, true);
849 static inline struct reset_control
*
850 devm_reset_control_array_get_optional_shared(struct device
*dev
)
852 return devm_reset_control_array_get(dev
, true, true);
855 static inline struct reset_control
*
856 of_reset_control_array_get_exclusive(struct device_node
*node
)
858 return of_reset_control_array_get(node
, false, false, true);
861 static inline struct reset_control
*
862 of_reset_control_array_get_exclusive_released(struct device_node
*node
)
864 return of_reset_control_array_get(node
, false, false, false);
867 static inline struct reset_control
*
868 of_reset_control_array_get_shared(struct device_node
*node
)
870 return of_reset_control_array_get(node
, true, false, true);
873 static inline struct reset_control
*
874 of_reset_control_array_get_optional_exclusive(struct device_node
*node
)
876 return of_reset_control_array_get(node
, false, true, true);
879 static inline struct reset_control
*
880 of_reset_control_array_get_optional_shared(struct device_node
*node
)
882 return of_reset_control_array_get(node
, true, true, true);