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