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/err.h>
   6 #include <linux/errno.h>
   7 #include <linux/types.h>
   8
   9 struct device;
  10 struct device_node;
  11 struct reset_control;
  12
  13 #ifdef CONFIG_RESET_CONTROLLER
  14
  15 int reset_control_reset(struct reset_control *rstc);
  16 int reset_control_assert(struct reset_control *rstc);
  17 int reset_control_deassert(struct reset_control *rstc);
  18 int reset_control_status(struct reset_control *rstc);
  19 int reset_control_acquire(struct reset_control *rstc);
  20 void reset_control_release(struct reset_control *rstc);
  21
  22 struct reset_control *__of_reset_control_get(struct device_node *node,
  23                                      const char *id, int index, bool shared,
  24                                      bool optional, bool acquired);
  25 struct reset_control *__reset_control_get(struct device *dev, const char *id,
  26                                           int index, bool shared,
  27                                           bool optional, bool acquired);
  28 void reset_control_put(struct reset_control *rstc);
  29 int __device_reset(struct device *dev, bool optional);
  30 struct reset_control *__devm_reset_control_get(struct device *dev,
  31                                      const char *id, int index, bool shared,
  32                                      bool optional, bool acquired);
  33
  34 struct reset_control *devm_reset_control_array_get(struct device *dev,
  35                                                    bool shared, bool optional);
  36 struct reset_control *of_reset_control_array_get(struct device_node *np,
  37                                                  bool shared, bool optional,
  38                                                  bool acquired);
  39
  40 int reset_control_get_count(struct device *dev);
  41
  42 #else
  43
  44 static inline int reset_control_reset(struct reset_control *rstc)
  45 {
  46         return 0;
  47 }
  48
  49 static inline int reset_control_assert(struct reset_control *rstc)
  50 {
  51         return 0;
  52 }
  53
  54 static inline int reset_control_deassert(struct reset_control *rstc)
  55 {
  56         return 0;
  57 }
  58
  59 static inline int reset_control_status(struct reset_control *rstc)
  60 {
  61         return 0;
  62 }
  63
  64 static inline int reset_control_acquire(struct reset_control *rstc)
  65 {
  66         return 0;
  67 }
  68
  69 static inline void reset_control_release(struct reset_control *rstc)
  70 {
  71 }
  72
  73 static inline void reset_control_put(struct reset_control *rstc)
  74 {
  75 }
  76
  77 static inline int __device_reset(struct device *dev, bool optional)
  78 {
  79         return optional ? 0 : -ENOTSUPP;
  80 }
  81
  82 static inline struct reset_control *__of_reset_control_get(
  83                                         struct device_node *node,
  84                                         const char *id, int index, bool shared,
  85                                         bool optional, bool acquired)
  86 {
  87         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  88 }
  89
  90 static inline struct reset_control *__reset_control_get(
  91                                         struct device *dev, const char *id,
  92                                         int index, bool shared, bool optional,
  93                                         bool acquired)
  94 {
  95         return optional ? NULL : ERR_PTR(-ENOTSUPP);
  96 }
  97
  98 static inline struct reset_control *__devm_reset_control_get(
  99                                         struct device *dev, const char *id,
 100                                         int index, bool shared, bool optional,
 101                                         bool acquired)
 102 {
 103         return optional ? NULL : ERR_PTR(-ENOTSUPP);
 104 }
 105
 106 static inline struct reset_control *
 107 devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
 108 {
 109         return optional ? NULL : ERR_PTR(-ENOTSUPP);
 110 }
 111
 112 static inline struct reset_control *
 113 of_reset_control_array_get(struct device_node *np, bool shared, bool optional,
 114                            bool acquired)
 115 {
 116         return optional ? NULL : ERR_PTR(-ENOTSUPP);
 117 }
 118
 119 static inline int reset_control_get_count(struct device *dev)
 120 {
 121         return -ENOENT;
 122 }
 123
 124 #endif /* CONFIG_RESET_CONTROLLER */
 125
 126 static inline int __must_check device_reset(struct device *dev)
 127 {
 128         return __device_reset(dev, false);
 129 }
 130
 131 static inline int device_reset_optional(struct device *dev)
 132 {
 133         return __device_reset(dev, true);
 134 }
 135
 136 /**
 137  * reset_control_get_exclusive - Lookup and obtain an exclusive reference
 138  *                               to a reset controller.
 139  * @dev: device to be reset by the controller
 140  * @id: reset line name
 141  *
 142  * Returns a struct reset_control or IS_ERR() condition containing errno.
 143  * If this function is called more than once for the same reset_control it will
 144  * return -EBUSY.
 145  *
 146  * See reset_control_get_shared() for details on shared references to
 147  * reset-controls.
 148  *
 149  * Use of id names is optional.
 150  */
 151 static inline struct reset_control *
 152 __must_check reset_control_get_exclusive(struct device *dev, const char *id)
 153 {
 154         return __reset_control_get(dev, id, 0, false, false, true);
 155 }
 156
 157 /**
 158  * reset_control_get_exclusive_released - Lookup and obtain a temoprarily
 159  *                                        exclusive reference to a reset
 160  *                                        controller.
 161  * @dev: device to be reset by the controller
 162  * @id: reset line name
 163  *
 164  * Returns a struct reset_control or IS_ERR() condition containing errno.
 165  * reset-controls returned by this function must be acquired via
 166  * reset_control_acquire() before they can be used and should be released
 167  * via reset_control_release() afterwards.
 168  *
 169  * Use of id names is optional.
 170  */
 171 static inline struct reset_control *
 172 __must_check reset_control_get_exclusive_released(struct device *dev,
 173                                                   const char *id)
 174 {
 175         return __reset_control_get(dev, id, 0, false, false, false);
 176 }
 177
 178 /**
 179  * reset_control_get_shared - Lookup and obtain a shared reference to a
 180  *                            reset controller.
 181  * @dev: device to be reset by the controller
 182  * @id: reset line name
 183  *
 184  * Returns a struct reset_control or IS_ERR() condition containing errno.
 185  * This function is intended for use with reset-controls which are shared
 186  * between hardware blocks.
 187  *
 188  * When a reset-control is shared, the behavior of reset_control_assert /
 189  * deassert is changed, the reset-core will keep track of a deassert_count
 190  * and only (re-)assert the reset after reset_control_assert has been called
 191  * as many times as reset_control_deassert was called. Also see the remark
 192  * about shared reset-controls in the reset_control_assert docs.
 193  *
 194  * Calling reset_control_assert without first calling reset_control_deassert
 195  * is not allowed on a shared reset control. Calling reset_control_reset is
 196  * also not allowed on a shared reset control.
 197  *
 198  * Use of id names is optional.
 199  */
 200 static inline struct reset_control *reset_control_get_shared(
 201                                         struct device *dev, const char *id)
 202 {
 203         return __reset_control_get(dev, id, 0, true, false, false);
 204 }
 205
 206 /**
 207  * reset_control_get_optional_exclusive - optional reset_control_get_exclusive()
 208  * @dev: device to be reset by the controller
 209  * @id: reset line name
 210  *
 211  * Optional variant of reset_control_get_exclusive(). If the requested reset
 212  * is not specified in the device tree, this function returns NULL instead of
 213  * an error.
 214  *
 215  * See reset_control_get_exclusive() for more information.
 216  */
 217 static inline struct reset_control *reset_control_get_optional_exclusive(
 218                                         struct device *dev, const char *id)
 219 {
 220         return __reset_control_get(dev, id, 0, false, true, true);
 221 }
 222
 223 /**
 224  * reset_control_get_optional_shared - optional reset_control_get_shared()
 225  * @dev: device to be reset by the controller
 226  * @id: reset line name
 227  *
 228  * Optional variant of reset_control_get_shared(). If the requested reset
 229  * is not specified in the device tree, this function returns NULL instead of
 230  * an error.
 231  *
 232  * See reset_control_get_shared() for more information.
 233  */
 234 static inline struct reset_control *reset_control_get_optional_shared(
 235                                         struct device *dev, const char *id)
 236 {
 237         return __reset_control_get(dev, id, 0, true, true, false);
 238 }
 239
 240 /**
 241  * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
 242  *                                  to a reset controller.
 243  * @node: device to be reset by the controller
 244  * @id: reset line name
 245  *
 246  * Returns a struct reset_control or IS_ERR() condition containing errno.
 247  *
 248  * Use of id names is optional.
 249  */
 250 static inline struct reset_control *of_reset_control_get_exclusive(
 251                                 struct device_node *node, const char *id)
 252 {
 253         return __of_reset_control_get(node, id, 0, false, false, true);
 254 }
 255
 256 /**
 257  * of_reset_control_get_shared - Lookup and obtain a shared reference
 258  *                               to a reset controller.
 259  * @node: device to be reset by the controller
 260  * @id: reset line name
 261  *
 262  * When a reset-control is shared, the behavior of reset_control_assert /
 263  * deassert is changed, the reset-core will keep track of a deassert_count
 264  * and only (re-)assert the reset after reset_control_assert has been called
 265  * as many times as reset_control_deassert was called. Also see the remark
 266  * about shared reset-controls in the reset_control_assert docs.
 267  *
 268  * Calling reset_control_assert without first calling reset_control_deassert
 269  * is not allowed on a shared reset control. Calling reset_control_reset is
 270  * also not allowed on a shared reset control.
 271  * Returns a struct reset_control or IS_ERR() condition containing errno.
 272  *
 273  * Use of id names is optional.
 274  */
 275 static inline struct reset_control *of_reset_control_get_shared(
 276                                 struct device_node *node, const char *id)
 277 {
 278         return __of_reset_control_get(node, id, 0, true, false, false);
 279 }
 280
 281 /**
 282  * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
 283  *                                           reference to a reset controller
 284  *                                           by index.
 285  * @node: device to be reset by the controller
 286  * @index: index of the reset controller
 287  *
 288  * This is to be used to perform a list of resets for a device or power domain
 289  * in whatever order. Returns a struct reset_control or IS_ERR() condition
 290  * containing errno.
 291  */
 292 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
 293                                         struct device_node *node, int index)
 294 {
 295         return __of_reset_control_get(node, NULL, index, false, false, true);
 296 }
 297
 298 /**
 299  * of_reset_control_get_shared_by_index - Lookup and obtain a shared
 300  *                                        reference to a reset controller
 301  *                                        by index.
 302  * @node: device to be reset by the controller
 303  * @index: index of the reset controller
 304  *
 305  * When a reset-control is shared, the behavior of reset_control_assert /
 306  * deassert is changed, the reset-core will keep track of a deassert_count
 307  * and only (re-)assert the reset after reset_control_assert has been called
 308  * as many times as reset_control_deassert was called. Also see the remark
 309  * about shared reset-controls in the reset_control_assert docs.
 310  *
 311  * Calling reset_control_assert without first calling reset_control_deassert
 312  * is not allowed on a shared reset control. Calling reset_control_reset is
 313  * also not allowed on a shared reset control.
 314  * Returns a struct reset_control or IS_ERR() condition containing errno.
 315  *
 316  * This is to be used to perform a list of resets for a device or power domain
 317  * in whatever order. Returns a struct reset_control or IS_ERR() condition
 318  * containing errno.
 319  */
 320 static inline struct reset_control *of_reset_control_get_shared_by_index(
 321                                         struct device_node *node, int index)
 322 {
 323         return __of_reset_control_get(node, NULL, index, true, false, false);
 324 }
 325
 326 /**
 327  * devm_reset_control_get_exclusive - resource managed
 328  *                                    reset_control_get_exclusive()
 329  * @dev: device to be reset by the controller
 330  * @id: reset line name
 331  *
 332  * Managed reset_control_get_exclusive(). For reset controllers returned
 333  * from this function, reset_control_put() is called automatically on driver
 334  * detach.
 335  *
 336  * See reset_control_get_exclusive() for more information.
 337  */
 338 static inline struct reset_control *
 339 __must_check devm_reset_control_get_exclusive(struct device *dev,
 340                                               const char *id)
 341 {
 342         return __devm_reset_control_get(dev, id, 0, false, false, true);
 343 }
 344
 345 /**
 346  * devm_reset_control_get_exclusive_released - resource managed
 347  *                                             reset_control_get_exclusive_released()
 348  * @dev: device to be reset by the controller
 349  * @id: reset line name
 350  *
 351  * Managed reset_control_get_exclusive_released(). For reset controllers
 352  * returned from this function, reset_control_put() is called automatically on
 353  * driver detach.
 354  *
 355  * See reset_control_get_exclusive_released() for more information.
 356  */
 357 static inline struct reset_control *
 358 __must_check devm_reset_control_get_exclusive_released(struct device *dev,
 359                                                        const char *id)
 360 {
 361         return __devm_reset_control_get(dev, id, 0, false, false, false);
 362 }
 363
 364 /**
 365  * devm_reset_control_get_shared - resource managed reset_control_get_shared()
 366  * @dev: device to be reset by the controller
 367  * @id: reset line name
 368  *
 369  * Managed reset_control_get_shared(). For reset controllers returned from
 370  * this function, reset_control_put() is called automatically on driver detach.
 371  * See reset_control_get_shared() for more information.
 372  */
 373 static inline struct reset_control *devm_reset_control_get_shared(
 374                                         struct device *dev, const char *id)
 375 {
 376         return __devm_reset_control_get(dev, id, 0, true, false, false);
 377 }
 378
 379 /**
 380  * devm_reset_control_get_optional_exclusive - resource managed
 381  *                                             reset_control_get_optional_exclusive()
 382  * @dev: device to be reset by the controller
 383  * @id: reset line name
 384  *
 385  * Managed reset_control_get_optional_exclusive(). For reset controllers
 386  * returned from this function, reset_control_put() is called automatically on
 387  * driver detach.
 388  *
 389  * See reset_control_get_optional_exclusive() for more information.
 390  */
 391 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
 392                                         struct device *dev, const char *id)
 393 {
 394         return __devm_reset_control_get(dev, id, 0, false, true, true);
 395 }
 396
 397 /**
 398  * devm_reset_control_get_optional_shared - resource managed
 399  *                                          reset_control_get_optional_shared()
 400  * @dev: device to be reset by the controller
 401  * @id: reset line name
 402  *
 403  * Managed reset_control_get_optional_shared(). For reset controllers returned
 404  * from this function, reset_control_put() is called automatically on driver
 405  * detach.
 406  *
 407  * See reset_control_get_optional_shared() for more information.
 408  */
 409 static inline struct reset_control *devm_reset_control_get_optional_shared(
 410                                         struct device *dev, const char *id)
 411 {
 412         return __devm_reset_control_get(dev, id, 0, true, true, false);
 413 }
 414
 415 /**
 416  * devm_reset_control_get_exclusive_by_index - resource managed
 417  *                                             reset_control_get_exclusive()
 418  * @dev: device to be reset by the controller
 419  * @index: index of the reset controller
 420  *
 421  * Managed reset_control_get_exclusive(). For reset controllers returned from
 422  * this function, reset_control_put() is called automatically on driver
 423  * detach.
 424  *
 425  * See reset_control_get_exclusive() for more information.
 426  */
 427 static inline struct reset_control *
 428 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
 429 {
 430         return __devm_reset_control_get(dev, NULL, index, false, false, true);
 431 }
 432
 433 /**
 434  * devm_reset_control_get_shared_by_index - resource managed
 435  *                                          reset_control_get_shared
 436  * @dev: device to be reset by the controller
 437  * @index: index of the reset controller
 438  *
 439  * Managed reset_control_get_shared(). For reset controllers returned from
 440  * this function, reset_control_put() is called automatically on driver detach.
 441  * See reset_control_get_shared() for more information.
 442  */
 443 static inline struct reset_control *
 444 devm_reset_control_get_shared_by_index(struct device *dev, int index)
 445 {
 446         return __devm_reset_control_get(dev, NULL, index, true, false, false);
 447 }
 448
 449 /*
 450  * TEMPORARY calls to use during transition:
 451  *
 452  *   of_reset_control_get() => of_reset_control_get_exclusive()
 453  *
 454  * These inline function calls will be removed once all consumers
 455  * have been moved over to the new explicit API.
 456  */
 457 static inline struct reset_control *of_reset_control_get(
 458                                 struct device_node *node, const char *id)
 459 {
 460         return of_reset_control_get_exclusive(node, id);
 461 }
 462
 463 static inline struct reset_control *of_reset_control_get_by_index(
 464                                 struct device_node *node, int index)
 465 {
 466         return of_reset_control_get_exclusive_by_index(node, index);
 467 }
 468
 469 static inline struct reset_control *devm_reset_control_get(
 470                                 struct device *dev, const char *id)
 471 {
 472         return devm_reset_control_get_exclusive(dev, id);
 473 }
 474
 475 static inline struct reset_control *devm_reset_control_get_optional(
 476                                 struct device *dev, const char *id)
 477 {
 478         return devm_reset_control_get_optional_exclusive(dev, id);
 479
 480 }
 481
 482 static inline struct reset_control *devm_reset_control_get_by_index(
 483                                 struct device *dev, int index)
 484 {
 485         return devm_reset_control_get_exclusive_by_index(dev, index);
 486 }
 487
 488 /*
 489  * APIs to manage a list of reset controllers
 490  */
 491 static inline struct reset_control *
 492 devm_reset_control_array_get_exclusive(struct device *dev)
 493 {
 494         return devm_reset_control_array_get(dev, false, false);
 495 }
 496
 497 static inline struct reset_control *
 498 devm_reset_control_array_get_shared(struct device *dev)
 499 {
 500         return devm_reset_control_array_get(dev, true, false);
 501 }
 502
 503 static inline struct reset_control *
 504 devm_reset_control_array_get_optional_exclusive(struct device *dev)
 505 {
 506         return devm_reset_control_array_get(dev, false, true);
 507 }
 508
 509 static inline struct reset_control *
 510 devm_reset_control_array_get_optional_shared(struct device *dev)
 511 {
 512         return devm_reset_control_array_get(dev, true, true);
 513 }
 514
 515 static inline struct reset_control *
 516 of_reset_control_array_get_exclusive(struct device_node *node)
 517 {
 518         return of_reset_control_array_get(node, false, false, true);
 519 }
 520
 521 static inline struct reset_control *
 522 of_reset_control_array_get_exclusive_released(struct device_node *node)
 523 {
 524         return of_reset_control_array_get(node, false, false, false);
 525 }
 526
 527 static inline struct reset_control *
 528 of_reset_control_array_get_shared(struct device_node *node)
 529 {
 530         return of_reset_control_array_get(node, true, false, true);
 531 }
 532
 533 static inline struct reset_control *
 534 of_reset_control_array_get_optional_exclusive(struct device_node *node)
 535 {
 536         return of_reset_control_array_get(node, false, true, true);
 537 }
 538
 539 static inline struct reset_control *
 540 of_reset_control_array_get_optional_shared(struct device_node *node)
 541 {
 542         return of_reset_control_array_get(node, true, true, true);
 543 }
 544 #endif