include/linux/reset.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _LINUX_RESET_H_
   3 #define _LINUX_RESET_H_
   4
   5 #include <linux/types.h>
   6
   7 struct device;
   8 struct device_node;
   9 struct reset_control;
  10
  11 #ifdef CONFIG_RESET_CONTROLLER
  12
  13 int reset_control_reset(struct reset_control *rstc);
  14 int reset_control_assert(struct reset_control *rstc);
  15 int reset_control_deassert(struct reset_control *rstc);
  16 int reset_control_status(struct reset_control *rstc);
  17
  18 struct reset_control *__of_reset_control_get(struct device_node *node,
  19                                      const char *id, int index, bool shared,
  20                                      bool optional);
  21 struct reset_control *__reset_control_get(struct device *dev, const char *id,
  22                                           int index, bool shared,
  23                                           bool optional);
  24 void reset_control_put(struct reset_control *rstc);
  25 int __device_reset(struct device *dev, bool optional);
  26 struct reset_control *__devm_reset_control_get(struct device *dev,
  27                                      const char *id, int index, bool shared,
  28                                      bool optional);
  29
  30 struct reset_control *devm_reset_control_array_get(struct device *dev,
  31                                                    bool shared, bool optional);
  32 struct reset_control *of_reset_control_array_get(struct device_node *np,
  33                                                  bool shared, bool optional);
  34
  35 #else
  36
  37 static inline int reset_control_reset(struct reset_control *rstc)
  38 {
  39         return 0;
  40 }
  41
  42 static inline int reset_control_assert(struct reset_control *rstc)
  43 {
  44         return 0;
  45 }
  46
  47 static inline int reset_control_deassert(struct reset_control *rstc)
  48 {
  49         return 0;
  50 }
  51
  52 static inline int reset_control_status(struct reset_control *rstc)
  53 {
  54         return 0;
  55 }
  56
  57 static inline void reset_control_put(struct reset_control *rstc)
  58 {
  59 }
  60
  61 static inline int __device_reset(struct device *dev, bool optional)
  62 {
  63         return optional ? 0 : -ENOTSUPP;
  64 }
  65
  66 static inline struct reset_control *__of_reset_control_get(
  67                                         struct device_node *node,
  68                                         const char *id, int index, bool shared,
  69                                         bool optional)
  70 {
  71         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  72 }
  73
  74 static inline struct reset_control *__reset_control_get(
  75                                         struct device *dev, const char *id,
  76                                         int index, bool shared, bool optional)
  77 {
  78         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  79 }
  80
  81 static inline struct reset_control *__devm_reset_control_get(
  82                                         struct device *dev, const char *id,
  83                                         int index, bool shared, bool optional)
  84 {
  85         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  86 }
  87
  88 static inline struct reset_control *
  89 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
  90 {
  91         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  92 }
  93
  94 static inline struct reset_control *
  95 of_reset_control_array_get(struct device_node *np, bool shared, bool optional)
  96 {
  97         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  98 }
  99
 100 #endif /* CONFIG_RESET_CONTROLLER */
 101
 102 static inline int __must_check device_reset(struct device *dev)
 103 {
 104         return __device_reset(dev, false);
 105 }
 106
 107 static inline int device_reset_optional(struct device *dev)
 108 {
 109         return __device_reset(dev, true);
 110 }
 111
 112 /**
 113  * reset_control_get_exclusive - Lookup and obtain an exclusive reference
 114  *                               to a reset controller.
 115  * @dev: device to be reset by the controller
 116  * @id: reset line name
 117  *
 118  * Returns a struct reset_control or IS_ERR() condition containing errno.
 119  * If this function is called more than once for the same reset_control it will
 120  * return -EBUSY.
 121  *
 122  * See reset_control_get_shared for details on shared references to
 123  * reset-controls.
 124  *
 125  * Use of id names is optional.
 126  */
 127 static inline struct reset_control *
 128 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
 129 {
 130         return __reset_control_get(dev, id, 0, false, false);
 131 }
 132
 133 /**
 134  * reset_control_get_shared - Lookup and obtain a shared reference to a
 135  *                            reset controller.
 136  * @dev: device to be reset by the controller
 137  * @id: reset line name
 138  *
 139  * Returns a struct reset_control or IS_ERR() condition containing errno.
 140  * This function is intended for use with reset-controls which are shared
 141  * between hardware-blocks.
 142  *
 143  * When a reset-control is shared, the behavior of reset_control_assert /
 144  * deassert is changed, the reset-core will keep track of a deassert_count
 145  * and only (re-)assert the reset after reset_control_assert has been called
 146  * as many times as reset_control_deassert was called. Also see the remark
 147  * about shared reset-controls in the reset_control_assert docs.
 148  *
 149  * Calling reset_control_assert without first calling reset_control_deassert
 150  * is not allowed on a shared reset control. Calling reset_control_reset is
 151  * also not allowed on a shared reset control.
 152  *
 153  * Use of id names is optional.
 154  */
 155 static inline struct reset_control *reset_control_get_shared(
 156                                         struct device *dev, const char *id)
 157 {
 158         return __reset_control_get(dev, id, 0, true, false);
 159 }
 160
 161 static inline struct reset_control *reset_control_get_optional_exclusive(
 162                                         struct device *dev, const char *id)
 163 {
 164         return __reset_control_get(dev, id, 0, false, true);
 165 }
 166
 167 static inline struct reset_control *reset_control_get_optional_shared(
 168                                         struct device *dev, const char *id)
 169 {
 170         return __reset_control_get(dev, id, 0, true, true);
 171 }
 172
 173 /**
 174  * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
 175  *                                  to a reset controller.
 176  * @node: device to be reset by the controller
 177  * @id: reset line name
 178  *
 179  * Returns a struct reset_control or IS_ERR() condition containing errno.
 180  *
 181  * Use of id names is optional.
 182  */
 183 static inline struct reset_control *of_reset_control_get_exclusive(
 184                                 struct device_node *node, const char *id)
 185 {
 186         return __of_reset_control_get(node, id, 0, false, false);
 187 }
 188
 189 /**
 190  * of_reset_control_get_shared - Lookup and obtain an shared reference
 191  *                               to a reset controller.
 192  * @node: device to be reset by the controller
 193  * @id: reset line name
 194  *
 195  * When a reset-control is shared, the behavior of reset_control_assert /
 196  * deassert is changed, the reset-core will keep track of a deassert_count
 197  * and only (re-)assert the reset after reset_control_assert has been called
 198  * as many times as reset_control_deassert was called. Also see the remark
 199  * about shared reset-controls in the reset_control_assert docs.
 200  *
 201  * Calling reset_control_assert without first calling reset_control_deassert
 202  * is not allowed on a shared reset control. Calling reset_control_reset is
 203  * also not allowed on a shared reset control.
 204  * Returns a struct reset_control or IS_ERR() condition containing errno.
 205  *
 206  * Use of id names is optional.
 207  */
 208 static inline struct reset_control *of_reset_control_get_shared(
 209                                 struct device_node *node, const char *id)
 210 {
 211         return __of_reset_control_get(node, id, 0, true, false);
 212 }
 213
 214 /**
 215  * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
 216  *                                           reference to a reset controller
 217  *                                           by index.
 218  * @node: device to be reset by the controller
 219  * @index: index of the reset controller
 220  *
 221  * This is to be used to perform a list of resets for a device or power domain
 222  * in whatever order. Returns a struct reset_control or IS_ERR() condition
 223  * containing errno.
 224  */
 225 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
 226                                         struct device_node *node, int index)
 227 {
 228         return __of_reset_control_get(node, NULL, index, false, false);
 229 }
 230
 231 /**
 232  * of_reset_control_get_shared_by_index - Lookup and obtain an shared
 233  *                                        reference to a reset controller
 234  *                                        by index.
 235  * @node: device to be reset by the controller
 236  * @index: index of the reset controller
 237  *
 238  * When a reset-control is shared, the behavior of reset_control_assert /
 239  * deassert is changed, the reset-core will keep track of a deassert_count
 240  * and only (re-)assert the reset after reset_control_assert has been called
 241  * as many times as reset_control_deassert was called. Also see the remark
 242  * about shared reset-controls in the reset_control_assert docs.
 243  *
 244  * Calling reset_control_assert without first calling reset_control_deassert
 245  * is not allowed on a shared reset control. Calling reset_control_reset is
 246  * also not allowed on a shared reset control.
 247  * Returns a struct reset_control or IS_ERR() condition containing errno.
 248  *
 249  * This is to be used to perform a list of resets for a device or power domain
 250  * in whatever order. Returns a struct reset_control or IS_ERR() condition
 251  * containing errno.
 252  */
 253 static inline struct reset_control *of_reset_control_get_shared_by_index(
 254                                         struct device_node *node, int index)
 255 {
 256         return __of_reset_control_get(node, NULL, index, true, false);
 257 }
 258
 259 /**
 260  * devm_reset_control_get_exclusive - resource managed
 261  *                                    reset_control_get_exclusive()
 262  * @dev: device to be reset by the controller
 263  * @id: reset line name
 264  *
 265  * Managed reset_control_get_exclusive(). For reset controllers returned
 266  * from this function, reset_control_put() is called automatically on driver
 267  * detach.
 268  *
 269  * See reset_control_get_exclusive() for more information.
 270  */
 271 static inline struct reset_control *
 272 __must_check devm_reset_control_get_exclusive(struct device *dev,
 273                                               const char *id)
 274 {
 275         return __devm_reset_control_get(dev, id, 0, false, false);
 276 }
 277
 278 /**
 279  * devm_reset_control_get_shared - resource managed reset_control_get_shared()
 280  * @dev: device to be reset by the controller
 281  * @id: reset line name
 282  *
 283  * Managed reset_control_get_shared(). For reset controllers returned from
 284  * this function, reset_control_put() is called automatically on driver detach.
 285  * See reset_control_get_shared() for more information.
 286  */
 287 static inline struct reset_control *devm_reset_control_get_shared(
 288                                         struct device *dev, const char *id)
 289 {
 290         return __devm_reset_control_get(dev, id, 0, true, false);
 291 }
 292
 293 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
 294                                         struct device *dev, const char *id)
 295 {
 296         return __devm_reset_control_get(dev, id, 0, false, true);
 297 }
 298
 299 static inline struct reset_control *devm_reset_control_get_optional_shared(
 300                                         struct device *dev, const char *id)
 301 {
 302         return __devm_reset_control_get(dev, id, 0, true, true);
 303 }
 304
 305 /**
 306  * devm_reset_control_get_exclusive_by_index - resource managed
 307  *                                             reset_control_get_exclusive()
 308  * @dev: device to be reset by the controller
 309  * @index: index of the reset controller
 310  *
 311  * Managed reset_control_get_exclusive(). For reset controllers returned from
 312  * this function, reset_control_put() is called automatically on driver
 313  * detach.
 314  *
 315  * See reset_control_get_exclusive() for more information.
 316  */
 317 static inline struct reset_control *
 318 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
 319 {
 320         return __devm_reset_control_get(dev, NULL, index, false, false);
 321 }
 322
 323 /**
 324  * devm_reset_control_get_shared_by_index - resource managed
 325  * reset_control_get_shared
 326  * @dev: device to be reset by the controller
 327  * @index: index of the reset controller
 328  *
 329  * Managed reset_control_get_shared(). For reset controllers returned from
 330  * this function, reset_control_put() is called automatically on driver detach.
 331  * See reset_control_get_shared() for more information.
 332  */
 333 static inline struct reset_control *
 334 devm_reset_control_get_shared_by_index(struct device *dev, int index)
 335 {
 336         return __devm_reset_control_get(dev, NULL, index, true, false);
 337 }
 338
 339 /*
 340  * TEMPORARY calls to use during transition:
 341  *
 342  *   of_reset_control_get() => of_reset_control_get_exclusive()
 343  *
 344  * These inline function calls will be removed once all consumers
 345  * have been moved over to the new explicit API.
 346  */
 347 static inline struct reset_control *of_reset_control_get(
 348                                 struct device_node *node, const char *id)
 349 {
 350         return of_reset_control_get_exclusive(node, id);
 351 }
 352
 353 static inline struct reset_control *of_reset_control_get_by_index(
 354                                 struct device_node *node, int index)
 355 {
 356         return of_reset_control_get_exclusive_by_index(node, index);
 357 }
 358
 359 static inline struct reset_control *devm_reset_control_get(
 360                                 struct device *dev, const char *id)
 361 {
 362         return devm_reset_control_get_exclusive(dev, id);
 363 }
 364
 365 static inline struct reset_control *devm_reset_control_get_optional(
 366                                 struct device *dev, const char *id)
 367 {
 368         return devm_reset_control_get_optional_exclusive(dev, id);
 369
 370 }
 371
 372 static inline struct reset_control *devm_reset_control_get_by_index(
 373                                 struct device *dev, int index)
 374 {
 375         return devm_reset_control_get_exclusive_by_index(dev, index);
 376 }
 377
 378 /*
 379  * APIs to manage a list of reset controllers
 380  */
 381 static inline struct reset_control *
 382 devm_reset_control_array_get_exclusive(struct device *dev)
 383 {
 384         return devm_reset_control_array_get(dev, false, false);
 385 }
 386
 387 static inline struct reset_control *
 388 devm_reset_control_array_get_shared(struct device *dev)
 389 {
 390         return devm_reset_control_array_get(dev, true, false);
 391 }
 392
 393 static inline struct reset_control *
 394 devm_reset_control_array_get_optional_exclusive(struct device *dev)
 395 {
 396         return devm_reset_control_array_get(dev, false, true);
 397 }
 398
 399 static inline struct reset_control *
 400 devm_reset_control_array_get_optional_shared(struct device *dev)
 401 {
 402         return devm_reset_control_array_get(dev, true, true);
 403 }
 404
 405 static inline struct reset_control *
 406 of_reset_control_array_get_exclusive(struct device_node *node)
 407 {
 408         return of_reset_control_array_get(node, false, false);
 409 }
 410
 411 static inline struct reset_control *
 412 of_reset_control_array_get_shared(struct device_node *node)
 413 {
 414         return of_reset_control_array_get(node, true, false);
 415 }
 416
 417 static inline struct reset_control *
 418 of_reset_control_array_get_optional_exclusive(struct device_node *node)
 419 {
 420         return of_reset_control_array_get(node, false, true);
 421 }
 422
 423 static inline struct reset_control *
 424 of_reset_control_array_get_optional_shared(struct device_node *node)
 425 {
 426         return of_reset_control_array_get(node, true, true);
 427 }
 428 #endif