cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

reset.h (31684B)


      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/**
     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 */
     23struct reset_control_bulk_data {
     24	const char			*id;
     25	struct reset_control		*rstc;
     26};
     27
     28#ifdef CONFIG_RESET_CONTROLLER
     29
     30int reset_control_reset(struct reset_control *rstc);
     31int reset_control_rearm(struct reset_control *rstc);
     32int reset_control_assert(struct reset_control *rstc);
     33int reset_control_deassert(struct reset_control *rstc);
     34int reset_control_status(struct reset_control *rstc);
     35int reset_control_acquire(struct reset_control *rstc);
     36void reset_control_release(struct reset_control *rstc);
     37
     38int reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs);
     39int reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs);
     40int reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs);
     41int reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs);
     42void reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs);
     43
     44struct reset_control *__of_reset_control_get(struct device_node *node,
     45				     const char *id, int index, bool shared,
     46				     bool optional, bool acquired);
     47struct reset_control *__reset_control_get(struct device *dev, const char *id,
     48					  int index, bool shared,
     49					  bool optional, bool acquired);
     50void reset_control_put(struct reset_control *rstc);
     51int __reset_control_bulk_get(struct device *dev, int num_rstcs,
     52			     struct reset_control_bulk_data *rstcs,
     53			     bool shared, bool optional, bool acquired);
     54void reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs);
     55
     56int __device_reset(struct device *dev, bool optional);
     57struct reset_control *__devm_reset_control_get(struct device *dev,
     58				     const char *id, int index, bool shared,
     59				     bool optional, bool acquired);
     60int __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
     64struct reset_control *devm_reset_control_array_get(struct device *dev,
     65						   bool shared, bool optional);
     66struct reset_control *of_reset_control_array_get(struct device_node *np,
     67						 bool shared, bool optional,
     68						 bool acquired);
     69
     70int reset_control_get_count(struct device *dev);
     71
     72#else
     73
     74static inline int reset_control_reset(struct reset_control *rstc)
     75{
     76	return 0;
     77}
     78
     79static inline int reset_control_rearm(struct reset_control *rstc)
     80{
     81	return 0;
     82}
     83
     84static inline int reset_control_assert(struct reset_control *rstc)
     85{
     86	return 0;
     87}
     88
     89static inline int reset_control_deassert(struct reset_control *rstc)
     90{
     91	return 0;
     92}
     93
     94static inline int reset_control_status(struct reset_control *rstc)
     95{
     96	return 0;
     97}
     98
     99static inline int reset_control_acquire(struct reset_control *rstc)
    100{
    101	return 0;
    102}
    103
    104static inline void reset_control_release(struct reset_control *rstc)
    105{
    106}
    107
    108static inline void reset_control_put(struct reset_control *rstc)
    109{
    110}
    111
    112static inline int __device_reset(struct device *dev, bool optional)
    113{
    114	return optional ? 0 : -ENOTSUPP;
    115}
    116
    117static 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
    125static 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
    133static inline int
    134reset_control_bulk_reset(int num_rstcs, struct reset_control_bulk_data *rstcs)
    135{
    136	return 0;
    137}
    138
    139static inline int
    140reset_control_bulk_assert(int num_rstcs, struct reset_control_bulk_data *rstcs)
    141{
    142	return 0;
    143}
    144
    145static inline int
    146reset_control_bulk_deassert(int num_rstcs, struct reset_control_bulk_data *rstcs)
    147{
    148	return 0;
    149}
    150
    151static inline int
    152reset_control_bulk_acquire(int num_rstcs, struct reset_control_bulk_data *rstcs)
    153{
    154	return 0;
    155}
    156
    157static inline void
    158reset_control_bulk_release(int num_rstcs, struct reset_control_bulk_data *rstcs)
    159{
    160}
    161
    162static 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
    170static inline void
    171reset_control_bulk_put(int num_rstcs, struct reset_control_bulk_data *rstcs)
    172{
    173}
    174
    175static 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
    183static 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
    191static inline struct reset_control *
    192devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
    193{
    194	return optional ? NULL : ERR_PTR(-ENOTSUPP);
    195}
    196
    197static inline struct reset_control *
    198of_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
    204static inline int reset_control_get_count(struct device *dev)
    205{
    206	return -ENOENT;
    207}
    208
    209#endif /* CONFIG_RESET_CONTROLLER */
    210
    211static inline int __must_check device_reset(struct device *dev)
    212{
    213	return __device_reset(dev, false);
    214}
    215
    216static 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 */
    236static 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 */
    252static inline int __must_check
    253reset_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 */
    273static 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 */
    294static inline int __must_check
    295reset_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 */
    315static inline int __must_check
    316reset_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 */
    344static 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 */
    360static inline int __must_check
    361reset_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 */
    378static 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 */
    397static inline int __must_check
    398reset_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 */
    415static 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 */
    434static inline int __must_check
    435reset_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 */
    451static 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 */
    471static 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 */
    496static 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 */
    513static 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 */
    541static 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 */
    559static 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 */
    579static inline int __must_check
    580devm_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 */
    598static 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 */
    618static inline int __must_check
    619devm_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 */
    637static 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 */
    657static inline int __must_check
    658devm_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 */
    673static 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 */
    692static inline int __must_check
    693devm_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 */
    711static 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 */
    730static inline int __must_check
    731devm_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, true, false, 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 */
    749static 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 */
    768static inline int __must_check
    769devm_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 */
    787static inline struct reset_control *
    788devm_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 */
    803static inline struct reset_control *
    804devm_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 */
    817static 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
    823static 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
    829static 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
    835static 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
    842static 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 */
    851static inline struct reset_control *
    852devm_reset_control_array_get_exclusive(struct device *dev)
    853{
    854	return devm_reset_control_array_get(dev, false, false);
    855}
    856
    857static inline struct reset_control *
    858devm_reset_control_array_get_shared(struct device *dev)
    859{
    860	return devm_reset_control_array_get(dev, true, false);
    861}
    862
    863static inline struct reset_control *
    864devm_reset_control_array_get_optional_exclusive(struct device *dev)
    865{
    866	return devm_reset_control_array_get(dev, false, true);
    867}
    868
    869static inline struct reset_control *
    870devm_reset_control_array_get_optional_shared(struct device *dev)
    871{
    872	return devm_reset_control_array_get(dev, true, true);
    873}
    874
    875static inline struct reset_control *
    876of_reset_control_array_get_exclusive(struct device_node *node)
    877{
    878	return of_reset_control_array_get(node, false, false, true);
    879}
    880
    881static inline struct reset_control *
    882of_reset_control_array_get_exclusive_released(struct device_node *node)
    883{
    884	return of_reset_control_array_get(node, false, false, false);
    885}
    886
    887static inline struct reset_control *
    888of_reset_control_array_get_shared(struct device_node *node)
    889{
    890	return of_reset_control_array_get(node, true, false, true);
    891}
    892
    893static inline struct reset_control *
    894of_reset_control_array_get_optional_exclusive(struct device_node *node)
    895{
    896	return of_reset_control_array_get(node, false, true, true);
    897}
    898
    899static inline struct reset_control *
    900of_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