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 static inline struct reset_control *reset_control_get_optional_exclusive(
 207                                         struct device *dev, const char *id)
 208 {
 209         return __reset_control_get(dev, id, 0, false, true, true);
 210 }
 211
 212 static inline struct reset_control *reset_control_get_optional_shared(
 213                                         struct device *dev, const char *id)
 214 {
 215         return __reset_control_get(dev, id, 0, true, true, false);
 216 }
 217
 218 /**
 219  * of_reset_control_get_exclusive - Lookup and obtain an exclusive reference
 220  *                                  to a reset controller.
 221  * @node: device to be reset by the controller
 222  * @id: reset line name
 223  *
 224  * Returns a struct reset_control or IS_ERR() condition containing errno.
 225  *
 226  * Use of id names is optional.
 227  */
 228 static inline struct reset_control *of_reset_control_get_exclusive(
 229                                 struct device_node *node, const char *id)
 230 {
 231         return __of_reset_control_get(node, id, 0, false, false, true);
 232 }
 233
 234 /**
 235  * of_reset_control_get_shared - Lookup and obtain a shared reference
 236  *                               to a reset controller.
 237  * @node: device to be reset by the controller
 238  * @id: reset line name
 239  *
 240  * When a reset-control is shared, the behavior of reset_control_assert /
 241  * deassert is changed, the reset-core will keep track of a deassert_count
 242  * and only (re-)assert the reset after reset_control_assert has been called
 243  * as many times as reset_control_deassert was called. Also see the remark
 244  * about shared reset-controls in the reset_control_assert docs.
 245  *
 246  * Calling reset_control_assert without first calling reset_control_deassert
 247  * is not allowed on a shared reset control. Calling reset_control_reset is
 248  * also not allowed on a shared reset control.
 249  * Returns a struct reset_control or IS_ERR() condition containing errno.
 250  *
 251  * Use of id names is optional.
 252  */
 253 static inline struct reset_control *of_reset_control_get_shared(
 254                                 struct device_node *node, const char *id)
 255 {
 256         return __of_reset_control_get(node, id, 0, true, false, false);
 257 }
 258
 259 /**
 260  * of_reset_control_get_exclusive_by_index - Lookup and obtain an exclusive
 261  *                                           reference to a reset controller
 262  *                                           by index.
 263  * @node: device to be reset by the controller
 264  * @index: index of the reset controller
 265  *
 266  * This is to be used to perform a list of resets for a device or power domain
 267  * in whatever order. Returns a struct reset_control or IS_ERR() condition
 268  * containing errno.
 269  */
 270 static inline struct reset_control *of_reset_control_get_exclusive_by_index(
 271                                         struct device_node *node, int index)
 272 {
 273         return __of_reset_control_get(node, NULL, index, false, false, true);
 274 }
 275
 276 /**
 277  * of_reset_control_get_shared_by_index - Lookup and obtain a shared
 278  *                                        reference to a reset controller
 279  *                                        by index.
 280  * @node: device to be reset by the controller
 281  * @index: index of the reset controller
 282  *
 283  * When a reset-control is shared, the behavior of reset_control_assert /
 284  * deassert is changed, the reset-core will keep track of a deassert_count
 285  * and only (re-)assert the reset after reset_control_assert has been called
 286  * as many times as reset_control_deassert was called. Also see the remark
 287  * about shared reset-controls in the reset_control_assert docs.
 288  *
 289  * Calling reset_control_assert without first calling reset_control_deassert
 290  * is not allowed on a shared reset control. Calling reset_control_reset is
 291  * also not allowed on a shared reset control.
 292  * Returns a struct reset_control or IS_ERR() condition containing errno.
 293  *
 294  * This is to be used to perform a list of resets for a device or power domain
 295  * in whatever order. Returns a struct reset_control or IS_ERR() condition
 296  * containing errno.
 297  */
 298 static inline struct reset_control *of_reset_control_get_shared_by_index(
 299                                         struct device_node *node, int index)
 300 {
 301         return __of_reset_control_get(node, NULL, index, true, false, false);
 302 }
 303
 304 /**
 305  * devm_reset_control_get_exclusive - resource managed
 306  *                                    reset_control_get_exclusive()
 307  * @dev: device to be reset by the controller
 308  * @id: reset line name
 309  *
 310  * Managed reset_control_get_exclusive(). For reset controllers returned
 311  * from this function, reset_control_put() is called automatically on driver
 312  * detach.
 313  *
 314  * See reset_control_get_exclusive() for more information.
 315  */
 316 static inline struct reset_control *
 317 __must_check devm_reset_control_get_exclusive(struct device *dev,
 318                                               const char *id)
 319 {
 320         return __devm_reset_control_get(dev, id, 0, false, false, true);
 321 }
 322
 323 /**
 324  * devm_reset_control_get_exclusive_released - resource managed
 325  *                                             reset_control_get_exclusive_released()
 326  * @dev: device to be reset by the controller
 327  * @id: reset line name
 328  *
 329  * Managed reset_control_get_exclusive_released(). For reset controllers
 330  * returned from this function, reset_control_put() is called automatically on
 331  * driver detach.
 332  *
 333  * See reset_control_get_exclusive_released() for more information.
 334  */
 335 static inline struct reset_control *
 336 __must_check devm_reset_control_get_exclusive_released(struct device *dev,
 337                                                        const char *id)
 338 {
 339         return __devm_reset_control_get(dev, id, 0, false, false, false);
 340 }
 341
 342 /**
 343  * devm_reset_control_get_shared - resource managed reset_control_get_shared()
 344  * @dev: device to be reset by the controller
 345  * @id: reset line name
 346  *
 347  * Managed reset_control_get_shared(). For reset controllers returned from
 348  * this function, reset_control_put() is called automatically on driver detach.
 349  * See reset_control_get_shared() for more information.
 350  */
 351 static inline struct reset_control *devm_reset_control_get_shared(
 352                                         struct device *dev, const char *id)
 353 {
 354         return __devm_reset_control_get(dev, id, 0, true, false, false);
 355 }
 356
 357 static inline struct reset_control *devm_reset_control_get_optional_exclusive(
 358                                         struct device *dev, const char *id)
 359 {
 360         return __devm_reset_control_get(dev, id, 0, false, true, true);
 361 }
 362
 363 static inline struct reset_control *devm_reset_control_get_optional_shared(
 364                                         struct device *dev, const char *id)
 365 {
 366         return __devm_reset_control_get(dev, id, 0, true, true, false);
 367 }
 368
 369 /**
 370  * devm_reset_control_get_exclusive_by_index - resource managed
 371  *                                             reset_control_get_exclusive()
 372  * @dev: device to be reset by the controller
 373  * @index: index of the reset controller
 374  *
 375  * Managed reset_control_get_exclusive(). For reset controllers returned from
 376  * this function, reset_control_put() is called automatically on driver
 377  * detach.
 378  *
 379  * See reset_control_get_exclusive() for more information.
 380  */
 381 static inline struct reset_control *
 382 devm_reset_control_get_exclusive_by_index(struct device *dev, int index)
 383 {
 384         return __devm_reset_control_get(dev, NULL, index, false, false, true);
 385 }
 386
 387 /**
 388  * devm_reset_control_get_shared_by_index - resource managed
 389  *                                          reset_control_get_shared
 390  * @dev: device to be reset by the controller
 391  * @index: index of the reset controller
 392  *
 393  * Managed reset_control_get_shared(). For reset controllers returned from
 394  * this function, reset_control_put() is called automatically on driver detach.
 395  * See reset_control_get_shared() for more information.
 396  */
 397 static inline struct reset_control *
 398 devm_reset_control_get_shared_by_index(struct device *dev, int index)
 399 {
 400         return __devm_reset_control_get(dev, NULL, index, true, false, false);
 401 }
 402
 403 /*
 404  * TEMPORARY calls to use during transition:
 405  *
 406  *   of_reset_control_get() => of_reset_control_get_exclusive()
 407  *
 408  * These inline function calls will be removed once all consumers
 409  * have been moved over to the new explicit API.
 410  */
 411 static inline struct reset_control *of_reset_control_get(
 412                                 struct device_node *node, const char *id)
 413 {
 414         return of_reset_control_get_exclusive(node, id);
 415 }
 416
 417 static inline struct reset_control *of_reset_control_get_by_index(
 418                                 struct device_node *node, int index)
 419 {
 420         return of_reset_control_get_exclusive_by_index(node, index);
 421 }
 422
 423 static inline struct reset_control *devm_reset_control_get(
 424                                 struct device *dev, const char *id)
 425 {
 426         return devm_reset_control_get_exclusive(dev, id);
 427 }
 428
 429 static inline struct reset_control *devm_reset_control_get_optional(
 430                                 struct device *dev, const char *id)
 431 {
 432         return devm_reset_control_get_optional_exclusive(dev, id);
 433
 434 }
 435
 436 static inline struct reset_control *devm_reset_control_get_by_index(
 437                                 struct device *dev, int index)
 438 {
 439         return devm_reset_control_get_exclusive_by_index(dev, index);
 440 }
 441
 442 /*
 443  * APIs to manage a list of reset controllers
 444  */
 445 static inline struct reset_control *
 446 devm_reset_control_array_get_exclusive(struct device *dev)
 447 {
 448         return devm_reset_control_array_get(dev, false, false);
 449 }
 450
 451 static inline struct reset_control *
 452 devm_reset_control_array_get_shared(struct device *dev)
 453 {
 454         return devm_reset_control_array_get(dev, true, false);
 455 }
 456
 457 static inline struct reset_control *
 458 devm_reset_control_array_get_optional_exclusive(struct device *dev)
 459 {
 460         return devm_reset_control_array_get(dev, false, true);
 461 }
 462
 463 static inline struct reset_control *
 464 devm_reset_control_array_get_optional_shared(struct device *dev)
 465 {
 466         return devm_reset_control_array_get(dev, true, true);
 467 }
 468
 469 static inline struct reset_control *
 470 of_reset_control_array_get_exclusive(struct device_node *node)
 471 {
 472         return of_reset_control_array_get(node, false, false, true);
 473 }
 474
 475 static inline struct reset_control *
 476 of_reset_control_array_get_exclusive_released(struct device_node *node)
 477 {
 478         return of_reset_control_array_get(node, false, false, false);
 479 }
 480
 481 static inline struct reset_control *
 482 of_reset_control_array_get_shared(struct device_node *node)
 483 {
 484         return of_reset_control_array_get(node, true, false, true);
 485 }
 486
 487 static inline struct reset_control *
 488 of_reset_control_array_get_optional_exclusive(struct device_node *node)
 489 {
 490         return of_reset_control_array_get(node, false, true, true);
 491 }
 492
 493 static inline struct reset_control *
 494 of_reset_control_array_get_optional_shared(struct device_node *node)
 495 {
 496         return of_reset_control_array_get(node, true, true, true);
 497 }
 498 #endif