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_callbacks_present(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 */ 384 static inline int pm_runtime_get_sync(struct device *dev) 385 { 386 return __pm_runtime_resume(dev, RPM_GET_PUT); 387 } 388 389 /** 390 * pm_runtime_put - Drop device usage counter and queue up "idle check" if 0. 391 * @dev: Target device. 392 * 393 * Decrement the runtime PM usage counter of @dev and if it turns out to be 394 * equal to 0, queue up a work item for @dev like in pm_request_idle(). 395 */ 396 static inline int pm_runtime_put(struct device *dev) 397 { 398 return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC); 399 } 400 401 /** 402 * pm_runtime_put_autosuspend - Drop device usage counter and queue autosuspend if 0. 403 * @dev: Target device. 404 * 405 * Decrement the runtime PM usage counter of @dev and if it turns out to be 406 * equal to 0, queue up a work item for @dev like in pm_request_autosuspend(). 407 */ 408 static inline int pm_runtime_put_autosuspend(struct device *dev) 409 { 410 return __pm_runtime_suspend(dev, 411 RPM_GET_PUT | RPM_ASYNC | RPM_AUTO); 412 } 413 414 /** 415 * pm_runtime_put_sync - Drop device usage counter and run "idle check" if 0. 416 * @dev: Target device. 417 * 418 * Decrement the runtime PM usage counter of @dev and if it turns out to be 419 * equal to 0, invoke the "idle check" callback of @dev and, depending on its 420 * return value, set up autosuspend of @dev or suspend it (depending on whether 421 * or not autosuspend has been enabled for it). 422 * 423 * The possible return values of this function are the same as for 424 * pm_runtime_idle() and the runtime PM usage counter of @dev remains 425 * decremented in all cases, even if it returns an error code. 426 */ 427 static inline int pm_runtime_put_sync(struct device *dev) 428 { 429 return __pm_runtime_idle(dev, RPM_GET_PUT); 430 } 431 432 /** 433 * pm_runtime_put_sync_suspend - Drop device usage counter and suspend if 0. 434 * @dev: Target device. 435 * 436 * Decrement the runtime PM usage counter of @dev and if it turns out to be 437 * equal to 0, carry out runtime-suspend of @dev synchronously. 438 * 439 * The possible return values of this function are the same as for 440 * pm_runtime_suspend() and the runtime PM usage counter of @dev remains 441 * decremented in all cases, even if it returns an error code. 442 */ 443 static inline int pm_runtime_put_sync_suspend(struct device *dev) 444 { 445 return __pm_runtime_suspend(dev, RPM_GET_PUT); 446 } 447 448 /** 449 * pm_runtime_put_sync_autosuspend - Drop device usage counter and autosuspend if 0. 450 * @dev: Target device. 451 * 452 * Decrement the runtime PM usage counter of @dev and if it turns out to be 453 * equal to 0, set up autosuspend of @dev or suspend it synchronously (depending 454 * on whether or not autosuspend has been enabled for it). 455 * 456 * The possible return values of this function are the same as for 457 * pm_runtime_autosuspend() and the runtime PM usage counter of @dev remains 458 * decremented in all cases, even if it returns an error code. 459 */ 460 static inline int pm_runtime_put_sync_autosuspend(struct device *dev) 461 { 462 return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO); 463 } 464 465 /** 466 * pm_runtime_set_active - Set runtime PM status to "active". 467 * @dev: Target device. 468 * 469 * Set the runtime PM status of @dev to %RPM_ACTIVE and ensure that dependencies 470 * of it will be taken into account. 471 * 472 * It is not valid to call this function for devices with runtime PM enabled. 473 */ 474 static inline int pm_runtime_set_active(struct device *dev) 475 { 476 return __pm_runtime_set_status(dev, RPM_ACTIVE); 477 } 478 479 /** 480 * pm_runtime_set_suspended - Set runtime PM status to "suspended". 481 * @dev: Target device. 482 * 483 * Set the runtime PM status of @dev to %RPM_SUSPENDED and ensure that 484 * dependencies of it will be taken into account. 485 * 486 * It is not valid to call this function for devices with runtime PM enabled. 487 */ 488 static inline int pm_runtime_set_suspended(struct device *dev) 489 { 490 return __pm_runtime_set_status(dev, RPM_SUSPENDED); 491 } 492 493 /** 494 * pm_runtime_disable - Disable runtime PM for a device. 495 * @dev: Target device. 496 * 497 * Prevent the runtime PM framework from working with @dev (by incrementing its 498 * "blocking" counter). 499 * 500 * For each invocation of this function for @dev there must be a matching 501 * pm_runtime_enable() call in order for runtime PM to be enabled for it. 502 */ 503 static inline void pm_runtime_disable(struct device *dev) 504 { 505 __pm_runtime_disable(dev, true); 506 } 507 508 /** 509 * pm_runtime_use_autosuspend - Allow autosuspend to be used for a device. 510 * @dev: Target device. 511 * 512 * Allow the runtime PM autosuspend mechanism to be used for @dev whenever 513 * requested (or "autosuspend" will be handled as direct runtime-suspend for 514 * it). 515 */ 516 static inline void pm_runtime_use_autosuspend(struct device *dev) 517 { 518 __pm_runtime_use_autosuspend(dev, true); 519 } 520 521 /** 522 * pm_runtime_dont_use_autosuspend - Prevent autosuspend from being used. 523 * @dev: Target device. 524 * 525 * Prevent the runtime PM autosuspend mechanism from being used for @dev which 526 * means that "autosuspend" will be handled as direct runtime-suspend for it 527 * going forward. 528 */ 529 static inline void pm_runtime_dont_use_autosuspend(struct device *dev) 530 { 531 __pm_runtime_use_autosuspend(dev, false); 532 } 533 534 #endif 535