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