History

Merge tag 'pm-5.9-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull more power management updates from Rafael Wysocki: "These are mostly ARM cpufreq driver updates plus a cpufreq core cleanup, an ARM-wide change to make schedutil the default scaling governor, an intel_pstate driver fix and some runtime PM changes regarding kerneldoc comments. Specifics: - Add adaptive voltage scaling (AVS) support to the brcmstb cpufreq driver and clean it up (Florian Fainelli, Markus Mayer). - Add a new Tegra cpufreq driver and clean up the existing one (Jon Hunter, Sumit Gupta). - Add bandwidth level support to the Qcom cpufreq driver along with OPP changes (Sibi Sankar). - Clean up the sti, cpufreq-dt, ap806, CPPC cpufreq drivers (Viresh Kumar, Lee Jones, Ivan Kokshaysky, Sven Auhagen, Xin Hao). - Make schedutil the default governor for ARM (Valentin Schneider). - Fix dependency issues for the imx cpufreq driver (Walter Lozano). - Clean up cached_resolved_idx handlihng in the cpufreq core (Viresh Kumar). - Fix the intel_pstate driver to use the correct maximum frequency value when MSR_TURBO_RATIO_LIMIT is 0 (Srinivas Pandruvada). - Provide kenrneldoc comments for multiple runtime PM helpers and improve the pm_runtime_get_if_active() kerneldoc (Rafael Wysocki)" * tag 'pm-5.9-rc1-2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (22 commits) cpufreq: intel_pstate: Fix cpuinfo_max_freq when MSR_TURBO_RATIO_LIMIT is 0 PM: runtime: Improve kerneldoc of pm_runtime_get_if_active() PM: runtime: Add kerneldoc comments to multiple helpers cpufreq: make schedutil the default for arm and arm64 cpufreq: cached_resolved_idx can not be negative cpufreq: Add Tegra194 cpufreq driver dt-bindings: arm: Add NVIDIA Tegra194 CPU Complex binding cpufreq: imx: Select NVMEM_IMX_OCOTP cpufreq: sti-cpufreq: Fix some formatting and misspelling issues cpufreq: tegra186: Simplify probe return path cpufreq: CPPC: Reuse caps variable in few routines cpufreq: ap806: fix cpufreq driver needs ap cpu clk cpufreq: cppc: Reorder code and remove apply_hisi_workaround variable cpufreq: dt: fix oops on armada37xx cpufreq: brcmstb-avs-cpufreq: send S2_ENTER / S2_EXIT commands to AVS cpufreq: brcmstb-avs-cpufreq: Support polling AVS firmware cpufreq: brcmstb-avs-cpufreq: more flexible interface for __issue_avs_command() cpufreq: qcom: Disable fast switch when scaling DDR/L3 cpufreq: qcom: Update the bandwidth levels on frequency change OPP: Add and export helper to set bandwidth ...

Linus Torvalds committed 6 years ago

Commit f6235eb2 parents 2f12d44 0873ad919 files · +963 −114Browse files

Showing the changes to include/linux (3 of 19 files). Show all

Unified · Split

3 files
  1. include/linux/cpufreq.h +1 −1
  2. include/linux/pm_opp.h +6 −0
  3. include/linux/pm_runtime.h +246 −0
include/linux/cpufreq.h+1−1
@@ -127,7 +127,7 @@ struct cpufreq_policy { · 126 unmodified lines
127127
128128 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */
129129 unsigned int cached_target_freq;
130− int cached_resolved_idx;
130+ unsigned int cached_resolved_idx;
131131
132132 /* Synchronization for frequency transitions */
133133 bool transition_ongoing; /* Tracks transition status */
include/linux/pm_opp.h+6−0
@@ -152,6 +152,7 @@ struct opp_table *dev_pm_opp_attach_genpd(struct device *dev, const char **names · 151 unmodified lines
152152 void dev_pm_opp_detach_genpd(struct opp_table *opp_table);
153153 int dev_pm_opp_xlate_performance_state(struct opp_table *src_table, struct opp_table *dst_table, unsigned int pstate);
154154 int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq);
155+int dev_pm_opp_set_bw(struct device *dev, struct dev_pm_opp *opp);
155156 int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask);
156157 int dev_pm_opp_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask);
157158 void dev_pm_opp_remove_table(struct device *dev);
@@ -343,6 +344,11 @@ static inline int dev_pm_opp_set_rate(struct device *dev, unsigned long target_f · 185 unmodified lines
343344 return -ENOTSUPP;
344345 }
345346
347+static inline int dev_pm_opp_set_bw(struct device *dev, struct dev_pm_opp *opp)
348+{
349+ return -EOPNOTSUPP;
350+}
351+
346352 static inline int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask)
347353 {
348354 return -ENOTSUPP;
include/linux/pm_runtime.h+246−0
@@ -60,58 +60,151 @@ extern void pm_runtime_put_suppliers(struct device *dev); · 59 unmodified lines
6060 extern void pm_runtime_new_link(struct device *dev);
6161 extern void pm_runtime_drop_link(struct device *dev);
6262
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+ */
6370 static inline int pm_runtime_get_if_in_use(struct device *dev)
6471 {
6572 return pm_runtime_get_if_active(dev, false);
6673 }
6774
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+ */
6884 static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
6985 {
7086 dev->power.ignore_children = enable;
7187 }
7288
89+/**
90+ * pm_runtime_get_noresume - Bump up runtime PM usage counter of a device.
91+ * @dev: Target device.
92+ */
7393 static inline void pm_runtime_get_noresume(struct device *dev)
7494 {
7595 atomic_inc(&dev->power.usage_count);
7696 }
7797
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+ */
78104 static inline void pm_runtime_put_noidle(struct device *dev)
79105 {
80106 atomic_add_unless(&dev->power.usage_count, -1, 0);
81107 }
82108
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+ */
83121 static inline bool pm_runtime_suspended(struct device *dev)
84122 {
85123 return dev->power.runtime_status == RPM_SUSPENDED
86124 && !dev->power.disable_depth;
87125 }
88126
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 enabled for @dev and 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+ */
89139 static inline bool pm_runtime_active(struct device *dev)
90140 {
91141 return dev->power.runtime_status == RPM_ACTIVE
92142 || dev->power.disable_depth;
93143 }
94144
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+ */
95156 static inline bool pm_runtime_status_suspended(struct device *dev)
96157 {
97158 return dev->power.runtime_status == RPM_SUSPENDED;
98159 }
99160
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+ */
100171 static inline bool pm_runtime_enabled(struct device *dev)
101172 {
102173 return !dev->power.disable_depth;
103174 }
104175
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+ */
105183 static inline bool pm_runtime_has_no_callbacks(struct device *dev)
106184 {
107185 return dev->power.no_callbacks;
108186 }
109187
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+ */
110195 static inline void pm_runtime_mark_last_busy(struct device *dev)
111196 {
112197 WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
113198 }
114199
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+ */
115208 static inline bool pm_runtime_is_irq_safe(struct device *dev)
116209 {
117210 return dev->power.irq_safe;
@@ -191,97 +284,250 @@ static inline void pm_runtime_drop_link(struct device *dev) {} · 73 unmodified lines
191284
192285 #endif /* !CONFIG_PM */
193286
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+ */
194295 static inline int pm_runtime_idle(struct device *dev)
195296 {
196297 return __pm_runtime_idle(dev, 0);
197298 }
198299
300+/**
301+ * pm_runtime_suspend - Suspend a device synchronously.
302+ * @dev: Target device.
303+ */
199304 static inline int pm_runtime_suspend(struct device *dev)
200305 {
201306 return __pm_runtime_suspend(dev, 0);
202307 }
203308
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+ */
204316 static inline int pm_runtime_autosuspend(struct device *dev)
205317 {
206318 return __pm_runtime_suspend(dev, RPM_AUTO);
207319 }
208320
321+/**
322+ * pm_runtime_resume - Resume a device synchronously.
323+ * @dev: Target device.
324+ */
209325 static inline int pm_runtime_resume(struct device *dev)
210326 {
211327 return __pm_runtime_resume(dev, 0);
212328 }
213329
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+ */
214337 static inline int pm_request_idle(struct device *dev)
215338 {
216339 return __pm_runtime_idle(dev, RPM_ASYNC);
217340 }
218341
342+/**
343+ * pm_request_resume - Queue up runtime-resume of a device.
344+ * @dev: Target device.
345+ */
219346 static inline int pm_request_resume(struct device *dev)
220347 {
221348 return __pm_runtime_resume(dev, RPM_ASYNC);
222349 }
223350
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+ */
224358 static inline int pm_request_autosuspend(struct device *dev)
225359 {
226360 return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
227361 }
228362
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+ */
229370 static inline int pm_runtime_get(struct device *dev)
230371 {
231372 return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
232373 }
233374
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+ */
234386 static inline int pm_runtime_get_sync(struct device *dev)
235387 {
236388 return __pm_runtime_resume(dev, RPM_GET_PUT);
237389 }
238390
391+/**
392+ * pm_runtime_put - Drop device usage counter and queue up "idle check" if 0.
393+ * @dev: Target device.
394+ *
395+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
396+ * equal to 0, queue up a work item for @dev like in pm_request_idle().
397+ */
239398 static inline int pm_runtime_put(struct device *dev)
240399 {
241400 return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
242401 }
243402
403+/**
404+ * pm_runtime_put_autosuspend - Drop device usage counter and queue autosuspend if 0.
405+ * @dev: Target device.
406+ *
407+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
408+ * equal to 0, queue up a work item for @dev like in pm_request_autosuspend().
409+ */
244410 static inline int pm_runtime_put_autosuspend(struct device *dev)
245411 {
246412 return __pm_runtime_suspend(dev,
247413 RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
248414 }
249415
416+/**
417+ * pm_runtime_put_sync - Drop device usage counter and run "idle check" if 0.
418+ * @dev: Target device.
419+ *
420+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
421+ * equal to 0, invoke the "idle check" callback of @dev and, depending on its
422+ * return value, set up autosuspend of @dev or suspend it (depending on whether
423+ * or not autosuspend has been enabled for it).
424+ *
425+ * The possible return values of this function are the same as for
426+ * pm_runtime_idle() and the runtime PM usage counter of @dev remains
427+ * decremented in all cases, even if it returns an error code.
428+ */
250429 static inline int pm_runtime_put_sync(struct device *dev)
251430 {
252431 return __pm_runtime_idle(dev, RPM_GET_PUT);
253432 }
254433
434+/**
435+ * pm_runtime_put_sync_suspend - Drop device usage counter and suspend if 0.
436+ * @dev: Target device.
437+ *
438+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
439+ * equal to 0, carry out runtime-suspend of @dev synchronously.
440+ *
441+ * The possible return values of this function are the same as for
442+ * pm_runtime_suspend() and the runtime PM usage counter of @dev remains
443+ * decremented in all cases, even if it returns an error code.
444+ */
255445 static inline int pm_runtime_put_sync_suspend(struct device *dev)
256446 {
257447 return __pm_runtime_suspend(dev, RPM_GET_PUT);
258448 }
259449
450+/**
451+ * pm_runtime_put_sync_autosuspend - Drop device usage counter and autosuspend if 0.
452+ * @dev: Target device.
453+ *
454+ * Decrement the runtime PM usage counter of @dev and if it turns out to be
455+ * equal to 0, set up autosuspend of @dev or suspend it synchronously (depending
456+ * on whether or not autosuspend has been enabled for it).
457+ *
458+ * The possible return values of this function are the same as for
459+ * pm_runtime_autosuspend() and the runtime PM usage counter of @dev remains
460+ * decremented in all cases, even if it returns an error code.
461+ */
260462 static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
261463 {
262464 return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
263465 }
264466
467+/**
468+ * pm_runtime_set_active - Set runtime PM status to "active".
469+ * @dev: Target device.
470+ *
471+ * Set the runtime PM status of @dev to %RPM_ACTIVE and ensure that dependencies
472+ * of it will be taken into account.
473+ *
474+ * It is not valid to call this function for devices with runtime PM enabled.
475+ */
265476 static inline int pm_runtime_set_active(struct device *dev)
266477 {
267478 return __pm_runtime_set_status(dev, RPM_ACTIVE);
268479 }
269480
481+/**
482+ * pm_runtime_set_suspended - Set runtime PM status to "active".
483+ * @dev: Target device.
484+ *
485+ * Set the runtime PM status of @dev to %RPM_SUSPENDED and ensure that
486+ * dependencies of it will be taken into account.
487+ *
488+ * It is not valid to call this function for devices with runtime PM enabled.
489+ */
270490 static inline int pm_runtime_set_suspended(struct device *dev)
271491 {
272492 return __pm_runtime_set_status(dev, RPM_SUSPENDED);
273493 }
274494
495+/**
496+ * pm_runtime_disable - Disable runtime PM for a device.
497+ * @dev: Target device.
498+ *
499+ * Prevent the runtime PM framework from working with @dev (by incrementing its
500+ * "blocking" counter).
501+ *
502+ * For each invocation of this function for @dev there must be a matching
503+ * pm_runtime_enable() call in order for runtime PM to be enabled for it.
504+ */
275505 static inline void pm_runtime_disable(struct device *dev)
276506 {
277507 __pm_runtime_disable(dev, true);
278508 }
279509
510+/**
511+ * pm_runtime_use_autosuspend - Allow autosuspend to be used for a device.
512+ * @dev: Target device.
513+ *
514+ * Allow the runtime PM autosuspend mechanism to be used for @dev whenever
515+ * requested (or "autosuspend" will be handled as direct runtime-suspend for
516+ * it).
517+ */
280518 static inline void pm_runtime_use_autosuspend(struct device *dev)
281519 {
282520 __pm_runtime_use_autosuspend(dev, true);
283521 }
284522
523+/**
524+ * pm_runtime_dont_use_autosuspend - Prevent autosuspend from being used.
525+ * @dev: Target device.
526+ *
527+ * Prevent the runtime PM autosuspend mechanism from being used for @dev which
528+ * means that "autosuspend" will be handled as direct runtime-suspend for it
529+ * going forward.
530+ */
285531 static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
286532 {
287533 __pm_runtime_use_autosuspend(dev, false);