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
127 127
128 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */128 /* Cached frequency lookup from cpufreq_driver_resolve_freq. */
129 unsigned int cached_target_freq;129 unsigned int cached_target_freq;
130 int cached_resolved_idx;130 unsigned int cached_resolved_idx;
131 131
132 /* Synchronization for frequency transitions */132 /* Synchronization for frequency transitions */
133 bool transition_ongoing; /* Tracks transition status */133 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
152void dev_pm_opp_detach_genpd(struct opp_table *opp_table);152void dev_pm_opp_detach_genpd(struct opp_table *opp_table);
153int dev_pm_opp_xlate_performance_state(struct opp_table *src_table, struct opp_table *dst_table, unsigned int pstate);153int dev_pm_opp_xlate_performance_state(struct opp_table *src_table, struct opp_table *dst_table, unsigned int pstate);
154int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq);154int dev_pm_opp_set_rate(struct device *dev, unsigned long target_freq);
155int dev_pm_opp_set_bw(struct device *dev, struct dev_pm_opp *opp);
155int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask);156int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask);
156int dev_pm_opp_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask);157int dev_pm_opp_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask);
157void dev_pm_opp_remove_table(struct device *dev);158void 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
343 return -ENOTSUPP;344 return -ENOTSUPP;
344}345}
345 346
347static inline int dev_pm_opp_set_bw(struct device *dev, struct dev_pm_opp *opp)
348{
349 return -EOPNOTSUPP;
350}
351
346static inline int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask)352static inline int dev_pm_opp_set_sharing_cpus(struct device *cpu_dev, const struct cpumask *cpumask)
347{353{
348 return -ENOTSUPP;354 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
60extern void pm_runtime_new_link(struct device *dev);60extern void pm_runtime_new_link(struct device *dev);
61extern void pm_runtime_drop_link(struct device *dev);61extern void pm_runtime_drop_link(struct device *dev);
62 62
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 */
63static inline int pm_runtime_get_if_in_use(struct device *dev)70static inline int pm_runtime_get_if_in_use(struct device *dev)
64{71{
65 return pm_runtime_get_if_active(dev, false);72 return pm_runtime_get_if_active(dev, false);
66}73}
67 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 */
68static inline void pm_suspend_ignore_children(struct device *dev, bool enable)84static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
69{85{
70 dev->power.ignore_children = enable;86 dev->power.ignore_children = enable;
71}87}
72 88
89/**
90 * pm_runtime_get_noresume - Bump up runtime PM usage counter of a device.
91 * @dev: Target device.
92 */
73static inline void pm_runtime_get_noresume(struct device *dev)93static inline void pm_runtime_get_noresume(struct device *dev)
74{94{
75 atomic_inc(&dev->power.usage_count);95 atomic_inc(&dev->power.usage_count);
76}96}
77 97
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 */
78static inline void pm_runtime_put_noidle(struct device *dev)104static inline void pm_runtime_put_noidle(struct device *dev)
79{105{
80 atomic_add_unless(&dev->power.usage_count, -1, 0);106 atomic_add_unless(&dev->power.usage_count, -1, 0);
81}107}
82 108
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 */
83static inline bool pm_runtime_suspended(struct device *dev)121static inline bool pm_runtime_suspended(struct device *dev)
84{122{
85 return dev->power.runtime_status == RPM_SUSPENDED123 return dev->power.runtime_status == RPM_SUSPENDED
86 && !dev->power.disable_depth;124 && !dev->power.disable_depth;
87}125}
88 126
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 */
89static inline bool pm_runtime_active(struct device *dev)139static inline bool pm_runtime_active(struct device *dev)
90{140{
91 return dev->power.runtime_status == RPM_ACTIVE141 return dev->power.runtime_status == RPM_ACTIVE
92 || dev->power.disable_depth;142 || dev->power.disable_depth;
93}143}
94 144
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 */
95static inline bool pm_runtime_status_suspended(struct device *dev)156static inline bool pm_runtime_status_suspended(struct device *dev)
96{157{
97 return dev->power.runtime_status == RPM_SUSPENDED;158 return dev->power.runtime_status == RPM_SUSPENDED;
98}159}
99 160
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 */
100static inline bool pm_runtime_enabled(struct device *dev)171static inline bool pm_runtime_enabled(struct device *dev)
101{172{
102 return !dev->power.disable_depth;173 return !dev->power.disable_depth;
103}174}
104 175
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 */
105static inline bool pm_runtime_has_no_callbacks(struct device *dev)183static inline bool pm_runtime_has_no_callbacks(struct device *dev)
106{184{
107 return dev->power.no_callbacks;185 return dev->power.no_callbacks;
108}186}
109 187
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 */
110static inline void pm_runtime_mark_last_busy(struct device *dev)195static inline void pm_runtime_mark_last_busy(struct device *dev)
111{196{
112 WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());197 WRITE_ONCE(dev->power.last_busy, ktime_get_mono_fast_ns());
113}198}
114 199
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 */
115static inline bool pm_runtime_is_irq_safe(struct device *dev)208static inline bool pm_runtime_is_irq_safe(struct device *dev)
116{209{
117 return dev->power.irq_safe;210 return dev->power.irq_safe;
@@ -191,97 +284,250 @@ static inline void pm_runtime_drop_link(struct device *dev) {} · 73 unmodified lines
191 284
192#endif /* !CONFIG_PM */285#endif /* !CONFIG_PM */
193 286
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 */
194static inline int pm_runtime_idle(struct device *dev)295static inline int pm_runtime_idle(struct device *dev)
195{296{
196 return __pm_runtime_idle(dev, 0);297 return __pm_runtime_idle(dev, 0);
197}298}
198 299
300/**
301 * pm_runtime_suspend - Suspend a device synchronously.
302 * @dev: Target device.
303 */
199static inline int pm_runtime_suspend(struct device *dev)304static inline int pm_runtime_suspend(struct device *dev)
200{305{
201 return __pm_runtime_suspend(dev, 0);306 return __pm_runtime_suspend(dev, 0);
202}307}
203 308
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 */
204static inline int pm_runtime_autosuspend(struct device *dev)316static inline int pm_runtime_autosuspend(struct device *dev)
205{317{
206 return __pm_runtime_suspend(dev, RPM_AUTO);318 return __pm_runtime_suspend(dev, RPM_AUTO);
207}319}
208 320
321/**
322 * pm_runtime_resume - Resume a device synchronously.
323 * @dev: Target device.
324 */
209static inline int pm_runtime_resume(struct device *dev)325static inline int pm_runtime_resume(struct device *dev)
210{326{
211 return __pm_runtime_resume(dev, 0);327 return __pm_runtime_resume(dev, 0);
212}328}
213 329
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 */
214static inline int pm_request_idle(struct device *dev)337static inline int pm_request_idle(struct device *dev)
215{338{
216 return __pm_runtime_idle(dev, RPM_ASYNC);339 return __pm_runtime_idle(dev, RPM_ASYNC);
217}340}
218 341
342/**
343 * pm_request_resume - Queue up runtime-resume of a device.
344 * @dev: Target device.
345 */
219static inline int pm_request_resume(struct device *dev)346static inline int pm_request_resume(struct device *dev)
220{347{
221 return __pm_runtime_resume(dev, RPM_ASYNC);348 return __pm_runtime_resume(dev, RPM_ASYNC);
222}349}
223 350
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 */
224static inline int pm_request_autosuspend(struct device *dev)358static inline int pm_request_autosuspend(struct device *dev)
225{359{
226 return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);360 return __pm_runtime_suspend(dev, RPM_ASYNC | RPM_AUTO);
227}361}
228 362
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 */
229static inline int pm_runtime_get(struct device *dev)370static inline int pm_runtime_get(struct device *dev)
230{371{
231 return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);372 return __pm_runtime_resume(dev, RPM_GET_PUT | RPM_ASYNC);
232}373}
233 374
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 */
234static inline int pm_runtime_get_sync(struct device *dev)386static inline int pm_runtime_get_sync(struct device *dev)
235{387{
236 return __pm_runtime_resume(dev, RPM_GET_PUT);388 return __pm_runtime_resume(dev, RPM_GET_PUT);
237}389}
238 390
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 */
239static inline int pm_runtime_put(struct device *dev)398static inline int pm_runtime_put(struct device *dev)
240{399{
241 return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);400 return __pm_runtime_idle(dev, RPM_GET_PUT | RPM_ASYNC);
242}401}
243 402
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 */
244static inline int pm_runtime_put_autosuspend(struct device *dev)410static inline int pm_runtime_put_autosuspend(struct device *dev)
245{411{
246 return __pm_runtime_suspend(dev,412 return __pm_runtime_suspend(dev,
247 RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);413 RPM_GET_PUT | RPM_ASYNC | RPM_AUTO);
248}414}
249 415
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 */
250static inline int pm_runtime_put_sync(struct device *dev)429static inline int pm_runtime_put_sync(struct device *dev)
251{430{
252 return __pm_runtime_idle(dev, RPM_GET_PUT);431 return __pm_runtime_idle(dev, RPM_GET_PUT);
253}432}
254 433
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 */
255static inline int pm_runtime_put_sync_suspend(struct device *dev)445static inline int pm_runtime_put_sync_suspend(struct device *dev)
256{446{
257 return __pm_runtime_suspend(dev, RPM_GET_PUT);447 return __pm_runtime_suspend(dev, RPM_GET_PUT);
258}448}
259 449
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 */
260static inline int pm_runtime_put_sync_autosuspend(struct device *dev)462static inline int pm_runtime_put_sync_autosuspend(struct device *dev)
261{463{
262 return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);464 return __pm_runtime_suspend(dev, RPM_GET_PUT | RPM_AUTO);
263}465}
264 466
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 */
265static inline int pm_runtime_set_active(struct device *dev)476static inline int pm_runtime_set_active(struct device *dev)
266{477{
267 return __pm_runtime_set_status(dev, RPM_ACTIVE);478 return __pm_runtime_set_status(dev, RPM_ACTIVE);
268}479}
269 480
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 */
270static inline int pm_runtime_set_suspended(struct device *dev)490static inline int pm_runtime_set_suspended(struct device *dev)
271{491{
272 return __pm_runtime_set_status(dev, RPM_SUSPENDED);492 return __pm_runtime_set_status(dev, RPM_SUSPENDED);
273}493}
274 494
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 */
275static inline void pm_runtime_disable(struct device *dev)505static inline void pm_runtime_disable(struct device *dev)
276{506{
277 __pm_runtime_disable(dev, true);507 __pm_runtime_disable(dev, true);
278}508}
279 509
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 */
280static inline void pm_runtime_use_autosuspend(struct device *dev)518static inline void pm_runtime_use_autosuspend(struct device *dev)
281{519{
282 __pm_runtime_use_autosuspend(dev, true);520 __pm_runtime_use_autosuspend(dev, true);
283}521}
284 522
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 */
285static inline void pm_runtime_dont_use_autosuspend(struct device *dev)531static inline void pm_runtime_dont_use_autosuspend(struct device *dev)
286{532{
287 __pm_runtime_use_autosuspend(dev, false);533 __pm_runtime_use_autosuspend(dev, false);