forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-09 b22da3d8526a935aa31e086e63f60ff3246cb61c 
 kernel/include/linux/pm_runtime.h
....@@ -1,9 +1,8 @@
1
+/* SPDX-License-Identifier: GPL-2.0-only */
12 /*
23  * pm_runtime.h - Device run-time power management helper functions.
34  *
45  * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>
5
- *
6
- * This file is released under the GPLv2.
76  */
87 
98 #ifndef _LINUX_PM_RUNTIME_H
....@@ -39,7 +38,7 @@
3938 extern int __pm_runtime_idle(struct device *dev, int rpmflags);
4039 extern int __pm_runtime_suspend(struct device *dev, int rpmflags);
4140 extern int __pm_runtime_resume(struct device *dev, int rpmflags);
42
-extern int pm_runtime_get_if_in_use(struct device *dev);
41
+extern int pm_runtime_get_if_active(struct device *dev, bool ign_usage_count);
4342 extern int pm_schedule_suspend(struct device *dev, unsigned int delay);
4443 extern int __pm_runtime_set_status(struct device *dev, unsigned int status);
4544 extern int pm_runtime_barrier(struct device *dev);
....@@ -51,67 +50,167 @@
5150 extern void pm_runtime_irq_safe(struct device *dev);
5251 extern void __pm_runtime_use_autosuspend(struct device *dev, bool use);
5352 extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
54
-extern unsigned long pm_runtime_autosuspend_expiration(struct device *dev);
53
+extern u64 pm_runtime_autosuspend_expiration(struct device *dev);
5554 extern void pm_runtime_update_max_time_suspended(struct device *dev,
5655 						 s64 delta_ns);
5756 extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
58
-extern void pm_runtime_clean_up_links(struct device *dev);
5957 extern void pm_runtime_get_suppliers(struct device *dev);
6058 extern void pm_runtime_put_suppliers(struct device *dev);
6159 extern void pm_runtime_new_link(struct device *dev);
62
-extern void pm_runtime_drop_link(struct device *dev);
60
+extern void pm_runtime_drop_link(struct device_link *link);
61
+extern void pm_runtime_release_supplier(struct device_link *link);
6362 
63
+/**
64
+ * pm_runtime_get_if_in_use - Conditionally bump up runtime PM usage counter.
65
+ * @dev: Target device.
66
+ *
67
+ * Increment the runtime PM usage counter of @dev if its runtime PM status is
68
+ * %RPM_ACTIVE and its runtime PM usage counter is greater than 0.
69
+ */
70
+static inline int pm_runtime_get_if_in_use(struct device *dev)
71
+{
72
+	return pm_runtime_get_if_active(dev, false);
73
+}
74
+
75
+/**
76
+ * pm_suspend_ignore_children - Set runtime PM behavior regarding children.
77
+ * @dev: Target device.
78
+ * @enable: Whether or not to ignore possible dependencies on children.
79
+ *
80
+ * The dependencies of @dev on its children will not be taken into account by
81
+ * the runtime PM framework going forward if @enable is %true, or they will
82
+ * be taken into account otherwise.
83
+ */
6484 static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
6585 {
6686 	dev->power.ignore_children = enable;
6787 }
6888 
89
+/**
90
+ * pm_runtime_get_noresume - Bump up runtime PM usage counter of a device.
91
+ * @dev: Target device.
92
+ */
6993 static inline void pm_runtime_get_noresume(struct device *dev)
7094 {
7195 	atomic_inc(&dev->power.usage_count);
7296 }
7397 
98
+/**
99
+ * pm_runtime_put_noidle - Drop runtime PM usage counter of a device.
100
+ * @dev: Target device.
101
+ *
102
+ * Decrement the runtime PM usage counter of @dev unless it is 0 already.
103
+ */
74104 static inline void pm_runtime_put_noidle(struct device *dev)
75105 {
76106 	atomic_add_unless(&dev->power.usage_count, -1, 0);
77107 }
78108 
109
+/**
110
+ * pm_runtime_suspended - Check whether or not a device is runtime-suspended.
111
+ * @dev: Target device.
112
+ *
113
+ * Return %true if runtime PM is enabled for @dev and its runtime PM status is
114
+ * %RPM_SUSPENDED, or %false otherwise.
115
+ *
116
+ * Note that the return value of this function can only be trusted if it is
117
+ * called under the runtime PM lock of @dev or under conditions in which
118
+ * runtime PM cannot be either disabled or enabled for @dev and its runtime PM
119
+ * status cannot change.
120
+ */
79121 static inline bool pm_runtime_suspended(struct device *dev)
80122 {
81123 	return dev->power.runtime_status == RPM_SUSPENDED
82124 		&& !dev->power.disable_depth;
83125 }
84126 
127
+/**
128
+ * pm_runtime_active - Check whether or not a device is runtime-active.
129
+ * @dev: Target device.
130
+ *
131
+ * Return %true if runtime PM is disabled for @dev or its runtime PM status is
132
+ * %RPM_ACTIVE, or %false otherwise.
133
+ *
134
+ * Note that the return value of this function can only be trusted if it is
135
+ * called under the runtime PM lock of @dev or under conditions in which
136
+ * runtime PM cannot be either disabled or enabled for @dev and its runtime PM
137
+ * status cannot change.
138
+ */
85139 static inline bool pm_runtime_active(struct device *dev)
86140 {
87141 	return dev->power.runtime_status == RPM_ACTIVE
88142 		|| dev->power.disable_depth;
89143 }
90144 
145
+/**
146
+ * pm_runtime_status_suspended - Check if runtime PM status is "suspended".
147
+ * @dev: Target device.
148
+ *
149
+ * Return %true if the runtime PM status of @dev is %RPM_SUSPENDED, or %false
150
+ * otherwise, regardless of whether or not runtime PM has been enabled for @dev.
151
+ *
152
+ * Note that the return value of this function can only be trusted if it is
153
+ * called under the runtime PM lock of @dev or under conditions in which the
154
+ * runtime PM status of @dev cannot change.
155
+ */
91156 static inline bool pm_runtime_status_suspended(struct device *dev)
92157 {
93158 	return dev->power.runtime_status == RPM_SUSPENDED;
94159 }
95160 
161
+/**
162
+ * pm_runtime_enabled - Check if runtime PM is enabled.
163
+ * @dev: Target device.
164
+ *
165
+ * Return %true if runtime PM is enabled for @dev or %false otherwise.
166
+ *
167
+ * Note that the return value of this function can only be trusted if it is
168
+ * called under the runtime PM lock of @dev or under conditions in which
169
+ * runtime PM cannot be either disabled or enabled for @dev.
170
+ */
96171 static inline bool pm_runtime_enabled(struct device *dev)
97172 {
98173 	return !dev->power.disable_depth;
99174 }
100175 
101
-static inline bool pm_runtime_callbacks_present(struct device *dev)
176
+/**
177
+ * pm_runtime_has_no_callbacks - Check if runtime PM callbacks may be present.
178
+ * @dev: Target device.
179
+ *
180
+ * Return %true if @dev is a special device without runtime PM callbacks or
181
+ * %false otherwise.
182
+ */
183
+static inline bool pm_runtime_has_no_callbacks(struct device *dev)
102184 {
103
-	return !dev->power.no_callbacks;
185
+	return dev->power.no_callbacks;
104186 }
105187 
188
+/**
189
+ * pm_runtime_mark_last_busy - Update the last access time of a device.
190
+ * @dev: Target device.
191
+ *
192
+ * Update the last access time of @dev used by the runtime PM autosuspend
193
+ * mechanism to the current time as returned by ktime_get_mono_fast_ns().
194
+ */
106195 static inline void pm_runtime_mark_last_busy(struct device *dev)
107196 {
108
-	WRITE_ONCE(dev->power.last_busy, jiffies);
197
+	WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
109198 }
110199 
200
+/**
201
+ * pm_runtime_is_irq_safe - Check if runtime PM can work in interrupt context.
202
+ * @dev: Target device.
203
+ *
204
+ * Return %true if @dev has been marked as an "IRQ-safe" device (with respect
205
+ * to runtime PM), in which case its runtime PM callabcks can be expected to
206
+ * work correctly when invoked from interrupt handlers.
207
+ */
111208 static inline bool pm_runtime_is_irq_safe(struct device *dev)
112209 {
113210 	return dev->power.irq_safe;
114211 }
212
+
213
+extern u64 pm_runtime_suspended_time(struct device *dev);
115214 
116215 #else /* !CONFIG_PM */
117216 
....@@ -142,6 +241,11 @@
142241 {
143242 	return -EINVAL;
144243 }
244
+static inline int pm_runtime_get_if_active(struct device *dev,
245
+					   bool ign_usage_count)
246
+{
247
+	return -EINVAL;
248
+}
145249 static inline int __pm_runtime_set_status(struct device *dev,
146250 					    unsigned int status) { return 0; }
147251 static inline int pm_runtime_barrier(struct device *dev) { return 0; }
....@@ -162,115 +266,289 @@
162266 static inline void pm_runtime_irq_safe(struct device *dev) {}
163267 static inline bool pm_runtime_is_irq_safe(struct device *dev) { return false; }
164268 
165
-static inline bool pm_runtime_callbacks_present(struct device *dev) { return false; }
269
+static inline bool pm_runtime_has_no_callbacks(struct device *dev) { return false; }
166270 static inline void pm_runtime_mark_last_busy(struct device *dev) {}
167271 static inline void __pm_runtime_use_autosuspend(struct device *dev,
168272 						bool use) {}
169273 static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
170274 						int delay) {}
171
-static inline unsigned long pm_runtime_autosuspend_expiration(
275
+static inline u64 pm_runtime_autosuspend_expiration(
172276 				struct device *dev) { return 0; }
173277 static inline void pm_runtime_set_memalloc_noio(struct device *dev,
174278 						bool enable){}
175
-static inline void pm_runtime_clean_up_links(struct device *dev) {}
176279 static inline void pm_runtime_get_suppliers(struct device *dev) {}
177280 static inline void pm_runtime_put_suppliers(struct device *dev) {}
178281 static inline void pm_runtime_new_link(struct device *dev) {}
179
-static inline void pm_runtime_drop_link(struct device *dev) {}
282
+static inline void pm_runtime_drop_link(struct device_link *link) {}
283
+static inline void pm_runtime_release_supplier(struct device_link *link) {}
180284 
181285 #endif /* !CONFIG_PM */
182286 
287
+/**
288
+ * pm_runtime_idle - Conditionally set up autosuspend of a device or suspend it.
289
+ * @dev: Target device.
290
+ *
291
+ * Invoke the "idle check" callback of @dev and, depending on its return value,
292
+ * set up autosuspend of @dev or suspend it (depending on whether or not
293
+ * autosuspend has been enabled for it).
294
+ */
183295 static inline int pm_runtime_idle(struct device *dev)
184296 {
185297 	return __pm_runtime_idle(dev, 0);
186298 }
187299 
300
+/**
301
+ * pm_runtime_suspend - Suspend a device synchronously.
302
+ * @dev: Target device.
303
+ */
188304 static inline int pm_runtime_suspend(struct device *dev)
189305 {
190306 	return __pm_runtime_suspend(dev, 0);
191307 }
192308 
309
+/**
310
+ * pm_runtime_autosuspend - Set up autosuspend of a device or suspend it.
311
+ * @dev: Target device.
312
+ *
313
+ * Set up autosuspend of @dev or suspend it (depending on whether or not
314
+ * autosuspend is enabled for it) without engaging its "idle check" callback.
315
+ */
193316 static inline int pm_runtime_autosuspend(struct device *dev)
194317 {
195318 	return __pm_runtime_suspend(dev, RPM_AUTO);
196319 }
197320 
321
+/**
322
+ * pm_runtime_resume - Resume a device synchronously.
323
+ * @dev: Target device.
324
+ */
198325 static inline int pm_runtime_resume(struct device *dev)
199326 {
200327 	return __pm_runtime_resume(dev, 0);
201328 }
202329 
330
+/**
331
+ * pm_request_idle - Queue up "idle check" execution for a device.
332
+ * @dev: Target device.
333
+ *
334
+ * Queue up a work item to run an equivalent of pm_runtime_idle() for @dev
335
+ * asynchronously.
336
+ */
203337 static inline int pm_request_idle(struct device *dev)
204338 {
205339 	return __pm_runtime_idle(dev, RPM_ASYNC);
206340 }
207341 
342
+/**
343
+ * pm_request_resume - Queue up runtime-resume of a device.
344
+ * @dev: Target device.
345
+ */
208346 static inline int pm_request_resume(struct device *dev)
209347 {
210348 	return __pm_runtime_resume(dev, RPM_ASYNC);
211349 }
212350 
351
+/**
352
+ * pm_request_autosuspend - Queue up autosuspend of a device.
353
+ * @dev: Target device.
354
+ *
355
+ * Queue up a work item to run an equivalent pm_runtime_autosuspend() for @dev
356
+ * asynchronously.
357
+ */
213358 static inline int pm_request_autosuspend(struct device *dev)
214359 {
215360 	return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
216361 }
217362 
363
+/**
364
+ * pm_runtime_get - Bump up usage counter and queue up resume of a device.
365
+ * @dev: Target device.
366
+ *
367
+ * Bump up the runtime PM usage counter of @dev and queue up a work item to
368
+ * carry out runtime-resume of it.
369
+ */
218370 static inline int pm_runtime_get(struct device *dev)
219371 {
220372 	return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
221373 }
222374 
375
+/**
376
+ * pm_runtime_get_sync - Bump up usage counter of a device and resume it.
377
+ * @dev: Target device.
378
+ *
379
+ * Bump up the runtime PM usage counter of @dev and carry out runtime-resume of
380
+ * it synchronously.
381
+ *
382
+ * The possible return values of this function are the same as for
383
+ * pm_runtime_resume() and the runtime PM usage counter of @dev remains
384
+ * incremented in all cases, even if it returns an error code.
385
+ */
223386 static inline int pm_runtime_get_sync(struct device *dev)
224387 {
225388 	return __pm_runtime_resume(dev, RPM_GET_PUT);
226389 }
227390 
391
+/**
392
+ * pm_runtime_resume_and_get - Bump up usage counter of a device and resume it.
393
+ * @dev: Target device.
394
+ *
395
+ * Resume @dev synchronously and if that is successful, increment its runtime
396
+ * PM usage counter. Return 0 if the runtime PM usage counter of @dev has been
397
+ * incremented or a negative error code otherwise.
398
+ */
399
+static inline int pm_runtime_resume_and_get(struct device *dev)
400
+{
401
+	int ret;
402
+
403
+	ret = __pm_runtime_resume(dev, RPM_GET_PUT);
404
+	if (ret < 0) {
405
+		pm_runtime_put_noidle(dev);
406
+		return ret;
407
+	}
408
+
409
+	return 0;
410
+}
411
+
412
+/**
413
+ * pm_runtime_put - Drop device usage counter and queue up "idle check" if 0.
414
+ * @dev: Target device.
415
+ *
416
+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
417
+ * equal to 0, queue up a work item for @dev like in pm_request_idle().
418
+ */
228419 static inline int pm_runtime_put(struct device *dev)
229420 {
230421 	return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
231422 }
232423 
424
+/**
425
+ * pm_runtime_put_autosuspend - Drop device usage counter and queue autosuspend if 0.
426
+ * @dev: Target device.
427
+ *
428
+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
429
+ * equal to 0, queue up a work item for @dev like in pm_request_autosuspend().
430
+ */
233431 static inline int pm_runtime_put_autosuspend(struct device *dev)
234432 {
235433 	return __pm_runtime_suspend(dev,
236434 	    RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
237435 }
238436 
437
+/**
438
+ * pm_runtime_put_sync - Drop device usage counter and run "idle check" if 0.
439
+ * @dev: Target device.
440
+ *
441
+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
442
+ * equal to 0, invoke the "idle check" callback of @dev and, depending on its
443
+ * return value, set up autosuspend of @dev or suspend it (depending on whether
444
+ * or not autosuspend has been enabled for it).
445
+ *
446
+ * The possible return values of this function are the same as for
447
+ * pm_runtime_idle() and the runtime PM usage counter of @dev remains
448
+ * decremented in all cases, even if it returns an error code.
449
+ */
239450 static inline int pm_runtime_put_sync(struct device *dev)
240451 {
241452 	return __pm_runtime_idle(dev, RPM_GET_PUT);
242453 }
243454 
455
+/**
456
+ * pm_runtime_put_sync_suspend - Drop device usage counter and suspend 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, carry out runtime-suspend of @dev synchronously.
461
+ *
462
+ * The possible return values of this function are the same as for
463
+ * pm_runtime_suspend() and the runtime PM usage counter of @dev remains
464
+ * decremented in all cases, even if it returns an error code.
465
+ */
244466 static inline int pm_runtime_put_sync_suspend(struct device *dev)
245467 {
246468 	return __pm_runtime_suspend(dev, RPM_GET_PUT);
247469 }
248470 
471
+/**
472
+ * pm_runtime_put_sync_autosuspend - Drop device usage counter and 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, set up autosuspend of @dev or suspend it synchronously (depending
477
+ * on whether or not autosuspend has been enabled for it).
478
+ *
479
+ * The possible return values of this function are the same as for
480
+ * pm_runtime_autosuspend() and the runtime PM usage counter of @dev remains
481
+ * decremented in all cases, even if it returns an error code.
482
+ */
249483 static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
250484 {
251485 	return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
252486 }
253487 
488
+/**
489
+ * pm_runtime_set_active - Set runtime PM status to "active".
490
+ * @dev: Target device.
491
+ *
492
+ * Set the runtime PM status of @dev to %RPM_ACTIVE and ensure that dependencies
493
+ * of it will be taken into account.
494
+ *
495
+ * It is not valid to call this function for devices with runtime PM enabled.
496
+ */
254497 static inline int pm_runtime_set_active(struct device *dev)
255498 {
256499 	return __pm_runtime_set_status(dev, RPM_ACTIVE);
257500 }
258501 
502
+/**
503
+ * pm_runtime_set_suspended - Set runtime PM status to "suspended".
504
+ * @dev: Target device.
505
+ *
506
+ * Set the runtime PM status of @dev to %RPM_SUSPENDED and ensure that
507
+ * dependencies of it will be taken into account.
508
+ *
509
+ * It is not valid to call this function for devices with runtime PM enabled.
510
+ */
259511 static inline int pm_runtime_set_suspended(struct device *dev)
260512 {
261513 	return __pm_runtime_set_status(dev, RPM_SUSPENDED);
262514 }
263515 
516
+/**
517
+ * pm_runtime_disable - Disable runtime PM for a device.
518
+ * @dev: Target device.
519
+ *
520
+ * Prevent the runtime PM framework from working with @dev (by incrementing its
521
+ * "blocking" counter).
522
+ *
523
+ * For each invocation of this function for @dev there must be a matching
524
+ * pm_runtime_enable() call in order for runtime PM to be enabled for it.
525
+ */
264526 static inline void pm_runtime_disable(struct device *dev)
265527 {
266528 	__pm_runtime_disable(dev, true);
267529 }
268530 
531
+/**
532
+ * pm_runtime_use_autosuspend - Allow autosuspend to be used for a device.
533
+ * @dev: Target device.
534
+ *
535
+ * Allow the runtime PM autosuspend mechanism to be used for @dev whenever
536
+ * requested (or "autosuspend" will be handled as direct runtime-suspend for
537
+ * it).
538
+ */
269539 static inline void pm_runtime_use_autosuspend(struct device *dev)
270540 {
271541 	__pm_runtime_use_autosuspend(dev, true);
272542 }
273543 
544
+/**
545
+ * pm_runtime_dont_use_autosuspend - Prevent autosuspend from being used.
546
+ * @dev: Target device.
547
+ *
548
+ * Prevent the runtime PM autosuspend mechanism from being used for @dev which
549
+ * means that "autosuspend" will be handled as direct runtime-suspend for it
550
+ * going forward.
551
+ */
274552 static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
275553 {
276554 	__pm_runtime_use_autosuspend(dev, false);