include/linux/pm_runtime.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * pm_runtime.h - Device run-time power management helper functions.
   4  *
   5  * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
   6  */
   7
   8 #ifndef _LINUX_PM_RUNTIME_H
   9 #define _LINUX_PM_RUNTIME_H
  10
  11 #include <linux/device.h>
  12 #include <linux/notifier.h>
  13 #include <linux/pm.h>
  14
  15 #include <linux/jiffies.h>
  16
  17 /* Runtime PM flag argument bits */
  18 #define RPM_ASYNC               0x01    /* Request is asynchronous */
  19 #define RPM_NOWAIT              0x02    /* Don't wait for concurrent
  20                                             state change */
  21 #define RPM_GET_PUT             0x04    /* Increment/decrement the
  22                                             usage_count */
  23 #define RPM_AUTO                0x08    /* Use autosuspend_delay */
  24
  25 /*
  26  * Use this for defining a set of PM operations to be used in all situations
  27  * (system suspend, hibernation or runtime PM).
  28  *
  29  * Note that the behaviour differs from the deprecated UNIVERSAL_DEV_PM_OPS()
  30  * macro, which uses the provided callbacks for both runtime PM and system
  31  * sleep, while DEFINE_RUNTIME_DEV_PM_OPS() uses pm_runtime_force_suspend()
  32  * and pm_runtime_force_resume() for its system sleep callbacks.
  33  *
  34  * If the underlying dev_pm_ops struct symbol has to be exported, use
  35  * EXPORT_RUNTIME_DEV_PM_OPS() or EXPORT_GPL_RUNTIME_DEV_PM_OPS() instead.
  36  */
  37 #define DEFINE_RUNTIME_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
  38         _DEFINE_DEV_PM_OPS(name, pm_runtime_force_suspend, \
  39                            pm_runtime_force_resume, suspend_fn, \
  40                            resume_fn, idle_fn)
  41
  42 #define EXPORT_RUNTIME_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
  43         _EXPORT_DEV_PM_OPS(name, pm_runtime_force_suspend, pm_runtime_force_resume, \
  44                            suspend_fn, resume_fn, idle_fn, "", "")
  45 #define EXPORT_GPL_RUNTIME_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
  46         _EXPORT_DEV_PM_OPS(name, pm_runtime_force_suspend, pm_runtime_force_resume, \
  47                            suspend_fn, resume_fn, idle_fn, "_gpl", "")
  48 #define EXPORT_NS_RUNTIME_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn, ns) \
  49         _EXPORT_DEV_PM_OPS(name, pm_runtime_force_suspend, pm_runtime_force_resume, \
  50                            suspend_fn, resume_fn, idle_fn, "", #ns)
  51 #define EXPORT_NS_GPL_RUNTIME_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn, ns) \
  52         _EXPORT_DEV_PM_OPS(name, pm_runtime_force_suspend, pm_runtime_force_resume, \
  53                            suspend_fn, resume_fn, idle_fn, "_gpl", #ns)
  54
  55 #ifdef CONFIG_PM
  56 extern struct workqueue_struct *pm_wq;
  57
  58 static inline bool queue_pm_work(struct work_struct *work)
  59 {
  60         return queue_work(pm_wq, work);
  61 }
  62
  63 extern int pm_generic_runtime_suspend(struct device *dev);
  64 extern int pm_generic_runtime_resume(struct device *dev);
  65 extern int pm_runtime_force_suspend(struct device *dev);
  66 extern int pm_runtime_force_resume(struct device *dev);
  67
  68 extern int __pm_runtime_idle(struct device *dev, int rpmflags);
  69 extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
  70 extern int __pm_runtime_resume(struct device *dev, int rpmflags);
  71 extern int pm_runtime_get_if_active(struct device *dev, bool ign_usage_count);
  72 extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
  73 extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
  74 extern int pm_runtime_barrier(struct device *dev);
  75 extern void pm_runtime_enable(struct device *dev);
  76 extern void __pm_runtime_disable(struct device *dev, bool check_resume);
  77 extern void pm_runtime_allow(struct device *dev);
  78 extern void pm_runtime_forbid(struct device *dev);
  79 extern void pm_runtime_no_callbacks(struct device *dev);
  80 extern void pm_runtime_irq_safe(struct device *dev);
  81 extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
  82 extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
  83 extern u64 pm_runtime_autosuspend_expiration(struct device *dev);
  84 extern void pm_runtime_update_max_time_suspended(struct device *dev,
  85                                                  s64 delta_ns);
  86 extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
  87 extern void pm_runtime_get_suppliers(struct device *dev);
  88 extern void pm_runtime_put_suppliers(struct device *dev);
  89 extern void pm_runtime_new_link(struct device *dev);
  90 extern void pm_runtime_drop_link(struct device_link *link);
  91 extern void pm_runtime_release_supplier(struct device_link *link, bool check_idle);
  92
  93 extern int devm_pm_runtime_enable(struct device *dev);
  94
  95 /**
  96  * pm_runtime_get_if_in_use - Conditionally bump up runtime PM usage counter.
  97  * @dev: Target device.
  98  *
  99  * Increment the runtime PM usage counter of @dev if its runtime PM status is
 100  * %RPM_ACTIVE and its runtime PM usage counter is greater than 0.
 101  */
 102 static inline int pm_runtime_get_if_in_use(struct device *dev)
 103 {
 104         return pm_runtime_get_if_active(dev, false);
 105 }
 106
 107 /**
 108  * pm_suspend_ignore_children - Set runtime PM behavior regarding children.
 109  * @dev: Target device.
 110  * @enable: Whether or not to ignore possible dependencies on children.
 111  *
 112  * The dependencies of @dev on its children will not be taken into account by
 113  * the runtime PM framework going forward if @enable is %true, or they will
 114  * be taken into account otherwise.
 115  */
 116 static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
 117 {
 118         dev->power.ignore_children = enable;
 119 }
 120
 121 /**
 122  * pm_runtime_get_noresume - Bump up runtime PM usage counter of a device.
 123  * @dev: Target device.
 124  */
 125 static inline void pm_runtime_get_noresume(struct device *dev)
 126 {
 127         atomic_inc(&dev->power.usage_count);
 128 }
 129
 130 /**
 131  * pm_runtime_put_noidle - Drop runtime PM usage counter of a device.
 132  * @dev: Target device.
 133  *
 134  * Decrement the runtime PM usage counter of @dev unless it is 0 already.
 135  */
 136 static inline void pm_runtime_put_noidle(struct device *dev)
 137 {
 138         atomic_add_unless(&dev->power.usage_count, -1, 0);
 139 }
 140
 141 /**
 142  * pm_runtime_suspended - Check whether or not a device is runtime-suspended.
 143  * @dev: Target device.
 144  *
 145  * Return %true if runtime PM is enabled for @dev and its runtime PM status is
 146  * %RPM_SUSPENDED, or %false otherwise.
 147  *
 148  * Note that the return value of this function can only be trusted if it is
 149  * called under the runtime PM lock of @dev or under conditions in which
 150  * runtime PM cannot be either disabled or enabled for @dev and its runtime PM
 151  * status cannot change.
 152  */
 153 static inline bool pm_runtime_suspended(struct device *dev)
 154 {
 155         return dev->power.runtime_status == RPM_SUSPENDED
 156                 && !dev->power.disable_depth;
 157 }
 158
 159 /**
 160  * pm_runtime_active - Check whether or not a device is runtime-active.
 161  * @dev: Target device.
 162  *
 163  * Return %true if runtime PM is disabled for @dev or its runtime PM status is
 164  * %RPM_ACTIVE, or %false otherwise.
 165  *
 166  * Note that the return value of this function can only be trusted if it is
 167  * called under the runtime PM lock of @dev or under conditions in which
 168  * runtime PM cannot be either disabled or enabled for @dev and its runtime PM
 169  * status cannot change.
 170  */
 171 static inline bool pm_runtime_active(struct device *dev)
 172 {
 173         return dev->power.runtime_status == RPM_ACTIVE
 174                 || dev->power.disable_depth;
 175 }
 176
 177 /**
 178  * pm_runtime_status_suspended - Check if runtime PM status is "suspended".
 179  * @dev: Target device.
 180  *
 181  * Return %true if the runtime PM status of @dev is %RPM_SUSPENDED, or %false
 182  * otherwise, regardless of whether or not runtime PM has been enabled for @dev.
 183  *
 184  * Note that the return value of this function can only be trusted if it is
 185  * called under the runtime PM lock of @dev or under conditions in which the
 186  * runtime PM status of @dev cannot change.
 187  */
 188 static inline bool pm_runtime_status_suspended(struct device *dev)
 189 {
 190         return dev->power.runtime_status == RPM_SUSPENDED;
 191 }
 192
 193 /**
 194  * pm_runtime_enabled - Check if runtime PM is enabled.
 195  * @dev: Target device.
 196  *
 197  * Return %true if runtime PM is enabled for @dev or %false otherwise.
 198  *
 199  * Note that the return value of this function can only be trusted if it is
 200  * called under the runtime PM lock of @dev or under conditions in which
 201  * runtime PM cannot be either disabled or enabled for @dev.
 202  */
 203 static inline bool pm_runtime_enabled(struct device *dev)
 204 {
 205         return !dev->power.disable_depth;
 206 }
 207
 208 /**
 209  * pm_runtime_has_no_callbacks - Check if runtime PM callbacks may be present.
 210  * @dev: Target device.
 211  *
 212  * Return %true if @dev is a special device without runtime PM callbacks or
 213  * %false otherwise.
 214  */
 215 static inline bool pm_runtime_has_no_callbacks(struct device *dev)
 216 {
 217         return dev->power.no_callbacks;
 218 }
 219
 220 /**
 221  * pm_runtime_mark_last_busy - Update the last access time of a device.
 222  * @dev: Target device.
 223  *
 224  * Update the last access time of @dev used by the runtime PM autosuspend
 225  * mechanism to the current time as returned by ktime_get_mono_fast_ns().
 226  */
 227 static inline void pm_runtime_mark_last_busy(struct device *dev)
 228 {
 229         WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
 230 }
 231
 232 /**
 233  * pm_runtime_is_irq_safe - Check if runtime PM can work in interrupt context.
 234  * @dev: Target device.
 235  *
 236  * Return %true if @dev has been marked as an "IRQ-safe" device (with respect
 237  * to runtime PM), in which case its runtime PM callabcks can be expected to
 238  * work correctly when invoked from interrupt handlers.
 239  */
 240 static inline bool pm_runtime_is_irq_safe(struct device *dev)
 241 {
 242         return dev->power.irq_safe;
 243 }
 244
 245 extern u64 pm_runtime_suspended_time(struct device *dev);
 246
 247 #else /* !CONFIG_PM */
 248
 249 static inline bool queue_pm_work(struct work_struct *work) { return false; }
 250
 251 static inline int pm_generic_runtime_suspend(struct device *dev) { return 0; }
 252 static inline int pm_generic_runtime_resume(struct device *dev) { return 0; }
 253 static inline int pm_runtime_force_suspend(struct device *dev) { return 0; }
 254 static inline int pm_runtime_force_resume(struct device *dev) { return 0; }
 255
 256 static inline int __pm_runtime_idle(struct device *dev, int rpmflags)
 257 {
 258         return -ENOSYS;
 259 }
 260 static inline int __pm_runtime_suspend(struct device *dev, int rpmflags)
 261 {
 262         return -ENOSYS;
 263 }
 264 static inline int __pm_runtime_resume(struct device *dev, int rpmflags)
 265 {
 266         return 1;
 267 }
 268 static inline int pm_schedule_suspend(struct device *dev, unsigned int delay)
 269 {
 270         return -ENOSYS;
 271 }
 272 static inline int pm_runtime_get_if_in_use(struct device *dev)
 273 {
 274         return -EINVAL;
 275 }
 276 static inline int pm_runtime_get_if_active(struct device *dev,
 277                                            bool ign_usage_count)
 278 {
 279         return -EINVAL;
 280 }
 281 static inline int __pm_runtime_set_status(struct device *dev,
 282                                             unsigned int status) { return 0; }
 283 static inline int pm_runtime_barrier(struct device *dev) { return 0; }
 284 static inline void pm_runtime_enable(struct device *dev) {}
 285 static inline void __pm_runtime_disable(struct device *dev, bool c) {}
 286 static inline void pm_runtime_allow(struct device *dev) {}
 287 static inline void pm_runtime_forbid(struct device *dev) {}
 288
 289 static inline int devm_pm_runtime_enable(struct device *dev) { return 0; }
 290
 291 static inline void pm_suspend_ignore_children(struct device *dev, bool enable) {}
 292 static inline void pm_runtime_get_noresume(struct device *dev) {}
 293 static inline void pm_runtime_put_noidle(struct device *dev) {}
 294 static inline bool pm_runtime_suspended(struct device *dev) { return false; }
 295 static inline bool pm_runtime_active(struct device *dev) { return true; }
 296 static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
 297 static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 298
 299 static inline void pm_runtime_no_callbacks(struct device *dev) {}
 300 static inline void pm_runtime_irq_safe(struct device *dev) {}
 301 static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }
 302
 303 static inline bool pm_runtime_has_no_callbacks(struct device *dev) { return false; }
 304 static inline void pm_runtime_mark_last_busy(struct device *dev) {}
 305 static inline void __pm_runtime_use_autosuspend(struct device *dev,
 306                                                 bool use) {}
 307 static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
 308                                                 int delay) {}
 309 static inline u64 pm_runtime_autosuspend_expiration(
 310                                 struct device *dev) { return 0; }
 311 static inline void pm_runtime_set_memalloc_noio(struct device *dev,
 312                                                 bool enable){}
 313 static inline void pm_runtime_get_suppliers(struct device *dev) {}
 314 static inline void pm_runtime_put_suppliers(struct device *dev) {}
 315 static inline void pm_runtime_new_link(struct device *dev) {}
 316 static inline void pm_runtime_drop_link(struct device_link *link) {}
 317 static inline void pm_runtime_release_supplier(struct device_link *link,
 318                                                bool check_idle) {}
 319
 320 #endif /* !CONFIG_PM */
 321
 322 /**
 323  * pm_runtime_idle - Conditionally set up autosuspend of a device or suspend it.
 324  * @dev: Target device.
 325  *
 326  * Invoke the "idle check" callback of @dev and, depending on its return value,
 327  * set up autosuspend of @dev or suspend it (depending on whether or not
 328  * autosuspend has been enabled for it).
 329  */
 330 static inline int pm_runtime_idle(struct device *dev)
 331 {
 332         return __pm_runtime_idle(dev, 0);
 333 }
 334
 335 /**
 336  * pm_runtime_suspend - Suspend a device synchronously.
 337  * @dev: Target device.
 338  */
 339 static inline int pm_runtime_suspend(struct device *dev)
 340 {
 341         return __pm_runtime_suspend(dev, 0);
 342 }
 343
 344 /**
 345  * pm_runtime_autosuspend - Set up autosuspend of a device or suspend it.
 346  * @dev: Target device.
 347  *
 348  * Set up autosuspend of @dev or suspend it (depending on whether or not
 349  * autosuspend is enabled for it) without engaging its "idle check" callback.
 350  */
 351 static inline int pm_runtime_autosuspend(struct device *dev)
 352 {
 353         return __pm_runtime_suspend(dev, RPM_AUTO);
 354 }
 355
 356 /**
 357  * pm_runtime_resume - Resume a device synchronously.
 358  * @dev: Target device.
 359  */
 360 static inline int pm_runtime_resume(struct device *dev)
 361 {
 362         return __pm_runtime_resume(dev, 0);
 363 }
 364
 365 /**
 366  * pm_request_idle - Queue up "idle check" execution for a device.
 367  * @dev: Target device.
 368  *
 369  * Queue up a work item to run an equivalent of pm_runtime_idle() for @dev
 370  * asynchronously.
 371  */
 372 static inline int pm_request_idle(struct device *dev)
 373 {
 374         return __pm_runtime_idle(dev, RPM_ASYNC);
 375 }
 376
 377 /**
 378  * pm_request_resume - Queue up runtime-resume of a device.
 379  * @dev: Target device.
 380  */
 381 static inline int pm_request_resume(struct device *dev)
 382 {
 383         return __pm_runtime_resume(dev, RPM_ASYNC);
 384 }
 385
 386 /**
 387  * pm_request_autosuspend - Queue up autosuspend of a device.
 388  * @dev: Target device.
 389  *
 390  * Queue up a work item to run an equivalent pm_runtime_autosuspend() for @dev
 391  * asynchronously.
 392  */
 393 static inline int pm_request_autosuspend(struct device *dev)
 394 {
 395         return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
 396 }
 397
 398 /**
 399  * pm_runtime_get - Bump up usage counter and queue up resume of a device.
 400  * @dev: Target device.
 401  *
 402  * Bump up the runtime PM usage counter of @dev and queue up a work item to
 403  * carry out runtime-resume of it.
 404  */
 405 static inline int pm_runtime_get(struct device *dev)
 406 {
 407         return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
 408 }
 409
 410 /**
 411  * pm_runtime_get_sync - Bump up usage counter of a device and resume it.
 412  * @dev: Target device.
 413  *
 414  * Bump up the runtime PM usage counter of @dev and carry out runtime-resume of
 415  * it synchronously.
 416  *
 417  * The possible return values of this function are the same as for
 418  * pm_runtime_resume() and the runtime PM usage counter of @dev remains
 419  * incremented in all cases, even if it returns an error code.
 420  * Consider using pm_runtime_resume_and_get() instead of it, especially
 421  * if its return value is checked by the caller, as this is likely to result
 422  * in cleaner code.
 423  */
 424 static inline int pm_runtime_get_sync(struct device *dev)
 425 {
 426         return __pm_runtime_resume(dev, RPM_GET_PUT);
 427 }
 428
 429 /**
 430  * pm_runtime_resume_and_get - Bump up usage counter of a device and resume it.
 431  * @dev: Target device.
 432  *
 433  * Resume @dev synchronously and if that is successful, increment its runtime
 434  * PM usage counter. Return 0 if the runtime PM usage counter of @dev has been
 435  * incremented or a negative error code otherwise.
 436  */
 437 static inline int pm_runtime_resume_and_get(struct device *dev)
 438 {
 439         int ret;
 440
 441         ret = __pm_runtime_resume(dev, RPM_GET_PUT);
 442         if (ret < 0) {
 443                 pm_runtime_put_noidle(dev);
 444                 return ret;
 445         }
 446
 447         return 0;
 448 }
 449
 450 /**
 451  * pm_runtime_put - Drop device usage counter and queue up "idle check" if 0.
 452  * @dev: Target device.
 453  *
 454  * Decrement the runtime PM usage counter of @dev and if it turns out to be
 455  * equal to 0, queue up a work item for @dev like in pm_request_idle().
 456  */
 457 static inline int pm_runtime_put(struct device *dev)
 458 {
 459         return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
 460 }
 461
 462 /**
 463  * pm_runtime_put_autosuspend - Drop device usage counter and queue autosuspend if 0.
 464  * @dev: Target device.
 465  *
 466  * Decrement the runtime PM usage counter of @dev and if it turns out to be
 467  * equal to 0, queue up a work item for @dev like in pm_request_autosuspend().
 468  */
 469 static inline int pm_runtime_put_autosuspend(struct device *dev)
 470 {
 471         return __pm_runtime_suspend(dev,
 472             RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
 473 }
 474
 475 /**
 476  * pm_runtime_put_sync - Drop device usage counter and run "idle check" if 0.
 477  * @dev: Target device.
 478  *
 479  * Decrement the runtime PM usage counter of @dev and if it turns out to be
 480  * equal to 0, invoke the "idle check" callback of @dev and, depending on its
 481  * return value, set up autosuspend of @dev or suspend it (depending on whether
 482  * or not autosuspend has been enabled for it).
 483  *
 484  * The possible return values of this function are the same as for
 485  * pm_runtime_idle() and the runtime PM usage counter of @dev remains
 486  * decremented in all cases, even if it returns an error code.
 487  */
 488 static inline int pm_runtime_put_sync(struct device *dev)
 489 {
 490         return __pm_runtime_idle(dev, RPM_GET_PUT);
 491 }
 492
 493 /**
 494  * pm_runtime_put_sync_suspend - Drop device usage counter and suspend if 0.
 495  * @dev: Target device.
 496  *
 497  * Decrement the runtime PM usage counter of @dev and if it turns out to be
 498  * equal to 0, carry out runtime-suspend of @dev synchronously.
 499  *
 500  * The possible return values of this function are the same as for
 501  * pm_runtime_suspend() and the runtime PM usage counter of @dev remains
 502  * decremented in all cases, even if it returns an error code.
 503  */
 504 static inline int pm_runtime_put_sync_suspend(struct device *dev)
 505 {
 506         return __pm_runtime_suspend(dev, RPM_GET_PUT);
 507 }
 508
 509 /**
 510  * pm_runtime_put_sync_autosuspend - Drop device usage counter and autosuspend if 0.
 511  * @dev: Target device.
 512  *
 513  * Decrement the runtime PM usage counter of @dev and if it turns out to be
 514  * equal to 0, set up autosuspend of @dev or suspend it synchronously (depending
 515  * on whether or not autosuspend has been enabled for it).
 516  *
 517  * The possible return values of this function are the same as for
 518  * pm_runtime_autosuspend() and the runtime PM usage counter of @dev remains
 519  * decremented in all cases, even if it returns an error code.
 520  */
 521 static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
 522 {
 523         return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
 524 }
 525
 526 /**
 527  * pm_runtime_set_active - Set runtime PM status to "active".
 528  * @dev: Target device.
 529  *
 530  * Set the runtime PM status of @dev to %RPM_ACTIVE and ensure that dependencies
 531  * of it will be taken into account.
 532  *
 533  * It is not valid to call this function for devices with runtime PM enabled.
 534  */
 535 static inline int pm_runtime_set_active(struct device *dev)
 536 {
 537         return __pm_runtime_set_status(dev, RPM_ACTIVE);
 538 }
 539
 540 /**
 541  * pm_runtime_set_suspended - Set runtime PM status to "suspended".
 542  * @dev: Target device.
 543  *
 544  * Set the runtime PM status of @dev to %RPM_SUSPENDED and ensure that
 545  * dependencies of it will be taken into account.
 546  *
 547  * It is not valid to call this function for devices with runtime PM enabled.
 548  */
 549 static inline int pm_runtime_set_suspended(struct device *dev)
 550 {
 551         return __pm_runtime_set_status(dev, RPM_SUSPENDED);
 552 }
 553
 554 /**
 555  * pm_runtime_disable - Disable runtime PM for a device.
 556  * @dev: Target device.
 557  *
 558  * Prevent the runtime PM framework from working with @dev (by incrementing its
 559  * "blocking" counter).
 560  *
 561  * For each invocation of this function for @dev there must be a matching
 562  * pm_runtime_enable() call in order for runtime PM to be enabled for it.
 563  */
 564 static inline void pm_runtime_disable(struct device *dev)
 565 {
 566         __pm_runtime_disable(dev, true);
 567 }
 568
 569 /**
 570  * pm_runtime_use_autosuspend - Allow autosuspend to be used for a device.
 571  * @dev: Target device.
 572  *
 573  * Allow the runtime PM autosuspend mechanism to be used for @dev whenever
 574  * requested (or "autosuspend" will be handled as direct runtime-suspend for
 575  * it).
 576  *
 577  * NOTE: It's important to undo this with pm_runtime_dont_use_autosuspend()
 578  * at driver exit time unless your driver initially enabled pm_runtime
 579  * with devm_pm_runtime_enable() (which handles it for you).
 580  */
 581 static inline void pm_runtime_use_autosuspend(struct device *dev)
 582 {
 583         __pm_runtime_use_autosuspend(dev, true);
 584 }
 585
 586 /**
 587  * pm_runtime_dont_use_autosuspend - Prevent autosuspend from being used.
 588  * @dev: Target device.
 589  *
 590  * Prevent the runtime PM autosuspend mechanism from being used for @dev which
 591  * means that "autosuspend" will be handled as direct runtime-suspend for it
 592  * going forward.
 593  */
 594 static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
 595 {
 596         __pm_runtime_use_autosuspend(dev, false);
 597 }
 598
 599 #endif