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