History

Merge branches 'pm-cpuidle', 'pm-core' and 'pm-sleep'

Merge cpuidle updates, PM core updates and one hiberation-related update for 5.17-rc1: - Make cpuidle use default_groups in kobj_type (Greg Kroah-Hartman). - Fix two comments in cpuidle code (Jason Wang, Yang Li). - Simplify locking in pm_runtime_put_suppliers() (Rafael Wysocki). - Add safety net to supplier device release in the runtime PM core code (Rafael Wysocki). - Capture device status before disabling runtime PM for it (Rafael Wysocki). - Add new macros for declaring PM operations to allow drivers to avoid guarding them with CONFIG_PM #ifdefs or __maybe_unused and update some drivers to use these macros (Paul Cercueil). - Allow ACPI hardware signature to be honoured during restore from hibernation (David Woodhouse). * pm-cpuidle: cpuidle: use default_groups in kobj_type cpuidle: Fix cpuidle_remove_state_sysfs() kerneldoc comment cpuidle: menu: Fix typo in a comment * pm-core: PM: runtime: Simplify locking in pm_runtime_put_suppliers() mmc: mxc: Use the new PM macros mmc: jz4740: Use the new PM macros PM: runtime: Add safety net to supplier device release PM: runtime: Capture device status before disabling runtime PM PM: core: Add new *_PM_OPS macros, deprecate old ones PM: core: Redefine pm_ptr() macro r8169: Avoid misuse of pm_ptr() macro * pm-sleep: PM: hibernate: Allow ACPI hardware signature to be honoured

Rafael J. Wysocki committed 4 years ago

Commit c001a524 parents 5561f25 7dfc5b6 50a4606 74d955517 files · +198 −95Browse files

Unified · Split

17 files
  1. Documentation/admin-guide/kernel-parameters.txt +12 −3
  2. Documentation/power/runtime_pm.rst +10 −4
  3. arch/x86/kernel/acpi/sleep.c +3 −1
  4. drivers/acpi/sleep.c +21 −5
  5. drivers/base/core.c +1 −2
  6. drivers/base/power/runtime.c +63 −35
  7. drivers/cpuidle/governors/menu.c +1 −1
  8. drivers/cpuidle/sysfs.c +5 −3
  9. drivers/mmc/host/jz4740_mmc.c +4 −4
  10. drivers/mmc/host/mxcmmc.c +2 −4
  11. drivers/net/ethernet/realtek/r8169_main.c +3 −1
  12. include/linux/acpi.h +1 −1
  13. include/linux/pm.h +53 −29
  14. include/linux/pm_runtime.h +3 −0
  15. include/linux/suspend.h +1 −0
  16. kernel/power/power.h +1 −0
  17. kernel/power/swap.c +14 −2
Documentation/admin-guide/kernel-parameters.txt+12−3
@@ -225,14 +225,23 @@ · 224 unmodified lines
225225 For broken nForce2 BIOS resulting in XT-PIC timer.
226226
227227 acpi_sleep= [HW,ACPI] Sleep options
228− Format: { s3_bios, s3_mode, s3_beep, s4_nohwsig,
229− old_ordering, nonvs, sci_force_enable, nobl }
228+ Format: { s3_bios, s3_mode, s3_beep, s4_hwsig,
229+ s4_nohwsig, old_ordering, nonvs,
230+ sci_force_enable, nobl }
230231 See Documentation/power/video.rst for information on
231232 s3_bios and s3_mode.
232233 s3_beep is for debugging; it makes the PC's speaker beep
233234 as soon as the kernel's real-mode entry point is called.
235+ s4_hwsig causes the kernel to check the ACPI hardware
236+ signature during resume from hibernation, and gracefully
237+ refuse to resume if it has changed. This complies with
238+ the ACPI specification but not with reality, since
239+ Windows does not do this and many laptops do change it
240+ on docking. So the default behaviour is to allow resume
241+ and simply warn when the signature changes, unless the
242+ s4_hwsig option is enabled.
234243 s4_nohwsig prevents ACPI hardware signature from being
235− used during resume from hibernation.
244+ used (or even warned about) during resume.
236245 old_ordering causes the ACPI 1.0 ordering of the _PTS
237246 control method, with respect to putting devices into
238247 low power states, to be enforced (the ACPI 2.0 ordering
Documentation/power/runtime_pm.rst+10−4
@@ -265,6 +265,10 @@ defined in include/linux/pm.h: · 264 unmodified lines
265265 RPM_SUSPENDED, which means that each device is initially regarded by the
266266 PM core as 'suspended', regardless of its real hardware status
267267
268+ `enum rpm_status last_status;`
269+ - the last runtime PM status of the device captured before disabling runtime
270+ PM for it (invalid initially and when disable_depth is 0)
271+
268272 `unsigned int runtime_auto;`
269273 - if set, indicates that the user space has allowed the device driver to
270274 power manage the device at run time via the /sys/devices/.../power/control
@@ -333,10 +337,12 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: · 62 unmodified lines
333337
334338 `int pm_runtime_resume(struct device *dev);`
335339 - execute the subsystem-level resume callback for the device; returns 0 on
336− success, 1 if the device's runtime PM status was already 'active' or
337− error code on failure, where -EAGAIN means it may be safe to attempt to
338− resume the device again in future, but 'power.runtime_error' should be
339− checked additionally, and -EACCES means that 'power.disable_depth' is
340+ success, 1 if the device's runtime PM status is already 'active' (also if
341+ 'power.disable_depth' is nonzero, but the status was 'active' when it was
342+ changing from 0 to 1) or error code on failure, where -EAGAIN means it may
343+ be safe to attempt to resume the device again in future, but
344+ 'power.runtime_error' should be checked additionally, and -EACCES means
345+ that the callback could not be run, because 'power.disable_depth' was
340346 different from 0
341347
342348 `int pm_runtime_resume_and_get(struct device *dev);`
arch/x86/kernel/acpi/sleep.c+3−1
@@ -139,8 +139,10 @@ static int __init acpi_sleep_setup(char *str) · 138 unmodified lines
139139 if (strncmp(str, "s3_beep", 7) == 0)
140140 acpi_realmode_flags |= 4;
141141 #ifdef CONFIG_HIBERNATION
142+ if (strncmp(str, "s4_hwsig", 8) == 0)
143+ acpi_check_s4_hw_signature(1);
142144 if (strncmp(str, "s4_nohwsig", 10) == 0)
143− acpi_no_s4_hw_signature();
145+ acpi_check_s4_hw_signature(0);
144146 #endif
145147 if (strncmp(str, "nonvs", 5) == 0)
146148 acpi_nvs_nosave();
drivers/acpi/sleep.c+21−5
@@ -877,11 +877,11 @@ static inline void acpi_sleep_syscore_init(void) {} · 876 unmodified lines
877877 #ifdef CONFIG_HIBERNATION
878878 static unsigned long s4_hardware_signature;
879879 static struct acpi_table_facs *facs;
880−static bool nosigcheck;
880+static int sigcheck = -1; /* Default behaviour is just to warn */
881881
882−void __init acpi_no_s4_hw_signature(void)
882+void __init acpi_check_s4_hw_signature(int check)
883883 {
884− nosigcheck = true;
884+ sigcheck = check;
885885 }
886886
887887 static int acpi_hibernation_begin(pm_message_t stage)
@@ -1009,12 +1009,28 @@ static void acpi_sleep_hibernate_setup(void) · 121 unmodified lines
10091009 hibernation_set_ops(old_suspend_ordering ?
10101010 &acpi_hibernation_ops_old : &acpi_hibernation_ops);
10111011 sleep_states[ACPI_STATE_S4] = 1;
1012− if (nosigcheck)
1012+ if (!sigcheck)
10131013 return;
10141014
10151015 acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
1016− if (facs)
1016+ if (facs) {
1017+ /*
1018+ * s4_hardware_signature is the local variable which is just
1019+ * used to warn about mismatch after we're attempting to
1020+ * resume (in violation of the ACPI specification.)
1021+ */
10171022 s4_hardware_signature = facs->hardware_signature;
1023+
1024+ if (sigcheck > 0) {
1025+ /*
1026+ * If we're actually obeying the ACPI specification
1027+ * then the signature is written out as part of the
1028+ * swsusp header, in order to allow the boot kernel
1029+ * to gracefully decline to resume.
1030+ */
1031+ swsusp_hardware_signature = facs->hardware_signature;
1032+ }
1033+ }
10181034 }
10191035 #else /* !CONFIG_HIBERNATION */
10201036 static inline void acpi_sleep_hibernate_setup(void) {}
drivers/base/core.c+1−2
@@ -485,8 +485,7 @@ static void device_link_release_fn(struct work_struct *work) · 484 unmodified lines
485485 /* Ensure that all references to the link object have been dropped. */
486486 device_link_synchronize_removal();
487487
488− while (refcount_dec_not_one(&link->rpm_active))
489− pm_runtime_put(link->supplier);
488+ pm_runtime_release_supplier(link, true);
490489
491490 put_device(link->consumer);
492491 put_device(link->supplier);
drivers/base/power/runtime.c+63−35
@@ -305,19 +305,40 @@ static int rpm_get_suppliers(struct device *dev) · 304 unmodified lines
305305 return 0;
306306 }
307307
308+/**
309+ * pm_runtime_release_supplier - Drop references to device link's supplier.
310+ * @link: Target device link.
311+ * @check_idle: Whether or not to check if the supplier device is idle.
312+ *
313+ * Drop all runtime PM references associated with @link to its supplier device
314+ * and if @check_idle is set, check if that device is idle (and so it can be
315+ * suspended).
316+ */
317+void pm_runtime_release_supplier(struct device_link *link, bool check_idle)
318+{
319+ struct device *supplier = link->supplier;
320+
321+ /*
322+ * The additional power.usage_count check is a safety net in case
323+ * the rpm_active refcount becomes saturated, in which case
324+ * refcount_dec_not_one() would return true forever, but it is not
325+ * strictly necessary.
326+ */
327+ while (refcount_dec_not_one(&link->rpm_active) &&
328+ atomic_read(&supplier->power.usage_count) > 0)
329+ pm_runtime_put_noidle(supplier);
330+
331+ if (check_idle)
332+ pm_request_idle(supplier);
333+}
334+
308335 static void __rpm_put_suppliers(struct device *dev, bool try_to_suspend)
309336 {
310337 struct device_link *link;
311338
312339 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
313− device_links_read_lock_held()) {
314−
315− while (refcount_dec_not_one(&link->rpm_active))
316− pm_runtime_put_noidle(link->supplier);
317−
318− if (try_to_suspend)
319− pm_request_idle(link->supplier);
320− }
340+ device_links_read_lock_held())
341+ pm_runtime_release_supplier(link, try_to_suspend);
321342 }
322343
323344 static void rpm_put_suppliers(struct device *dev)
@@ -742,13 +763,15 @@ static int rpm_resume(struct device *dev, int rpmflags) · 418 unmodified lines
742763 trace_rpm_resume_rcuidle(dev, rpmflags);
743764
744765 repeat:
745− if (dev->power.runtime_error)
766+ if (dev->power.runtime_error) {
746767 retval = -EINVAL;
747− else if (dev->power.disable_depth == 1 && dev->power.is_suspended
748− && dev->power.runtime_status == RPM_ACTIVE)
749− retval = 1;
750− else if (dev->power.disable_depth > 0)
751− retval = -EACCES;
768+ } else if (dev->power.disable_depth > 0) {
769+ if (dev->power.runtime_status == RPM_ACTIVE &&
770+ dev->power.last_status == RPM_ACTIVE)
771+ retval = 1;
772+ else
773+ retval = -EACCES;
774+ }
752775 if (retval)
753776 goto out;
754777
@@ -1410,8 +1433,10 @@ void __pm_runtime_disable(struct device *dev, bool check_resume) · 655 unmodified lines
14101433 /* Update time accounting before disabling PM-runtime. */
14111434 update_pm_runtime_accounting(dev);
14121435
1413− if (!dev->power.disable_depth++)
1436+ if (!dev->power.disable_depth++) {
14141437 __pm_runtime_barrier(dev);
1438+ dev->power.last_status = dev->power.runtime_status;
1439+ }
14151440
14161441 out:
14171442 spin_unlock_irq(&dev->power.lock);
@@ -1428,23 +1453,23 @@ void pm_runtime_enable(struct device *dev) · 10 unmodified lines
14281453
14291454 spin_lock_irqsave(&dev->power.lock, flags);
14301455
1431− if (dev->power.disable_depth > 0) {
1432− dev->power.disable_depth--;
1433−
1434− /* About to enable runtime pm, set accounting_timestamp to now */
1435− if (!dev->power.disable_depth)
1436− dev->power.accounting_timestamp = ktime_get_mono_fast_ns();
1437− } else {
1456+ if (!dev->power.disable_depth) {
14381457 dev_warn(dev, "Unbalanced %s!\n", __func__);
1458+ goto out;
14391459 }
14401460
1441− WARN(!dev->power.disable_depth &&
1442− dev->power.runtime_status == RPM_SUSPENDED &&
1443− !dev->power.ignore_children &&
1444− atomic_read(&dev->power.child_count) > 0,
1445− "Enabling runtime PM for inactive device (%s) with active children\n",
1446− dev_name(dev));
1461+ if (--dev->power.disable_depth > 0)
1462+ goto out;
1463+
1464+ dev->power.last_status = RPM_INVALID;
1465+ dev->power.accounting_timestamp = ktime_get_mono_fast_ns();
1466+
1467+ if (dev->power.runtime_status == RPM_SUSPENDED &&
1468+ !dev->power.ignore_children &&
1469+ atomic_read(&dev->power.child_count) > 0)
1470+ dev_warn(dev, "Enabling runtime PM for inactive device with active children\n");
14471471
1472+out:
14481473 spin_unlock_irqrestore(&dev->power.lock, flags);
14491474 }
14501475 EXPORT_SYMBOL_GPL(pm_runtime_enable);
@@ -1640,6 +1665,7 @@ EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend); · 189 unmodified lines
16401665 void pm_runtime_init(struct device *dev)
16411666 {
16421667 dev->power.runtime_status = RPM_SUSPENDED;
1668+ dev->power.last_status = RPM_INVALID;
16431669 dev->power.idle_notification = false;
16441670
16451671 dev->power.disable_depth = 1;
@@ -1722,8 +1748,6 @@ void pm_runtime_get_suppliers(struct device *dev) · 76 unmodified lines
17221748 void pm_runtime_put_suppliers(struct device *dev)
17231749 {
17241750 struct device_link *link;
1725− unsigned long flags;
1726− bool put;
17271751 int idx;
17281752
17291753 idx = device_links_read_lock();
@@ -1731,11 +1755,17 @@ void pm_runtime_put_suppliers(struct device *dev) · 1 unmodified line
17311755 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
17321756 device_links_read_lock_held())
17331757 if (link->supplier_preactivated) {
1758+ bool put;
1759+
17341760 link->supplier_preactivated = false;
1735− spin_lock_irqsave(&dev->power.lock, flags);
1761+
1762+ spin_lock_irq(&dev->power.lock);
1763+
17361764 put = pm_runtime_status_suspended(dev) &&
17371765 refcount_dec_not_one(&link->rpm_active);
1738− spin_unlock_irqrestore(&dev->power.lock, flags);
1766+
1767+ spin_unlock_irq(&dev->power.lock);
1768+
17391769 if (put)
17401770 pm_runtime_put(link->supplier);
17411771 }
@@ -1772,9 +1802,7 @@ void pm_runtime_drop_link(struct device_link *link) · 30 unmodified lines
17721802 return;
17731803
17741804 pm_runtime_drop_link_count(link->consumer);
1775−
1776− while (refcount_dec_not_one(&link->rpm_active))
1777− pm_runtime_put(link->supplier);
1805+ pm_runtime_release_supplier(link, true);
17781806 }
17791807
17801808 static bool pm_runtime_need_not_resume(struct device *dev)
drivers/cpuidle/governors/menu.c+1−1
@@ -34,7 +34,7 @@ · 33 unmodified lines
3434 * 1) Energy break even point
3535 * 2) Performance impact
3636 * 3) Latency tolerance (from pmqos infrastructure)
37− * These these three factors are treated independently.
37+ * These three factors are treated independently.
3838 *
3939 * Energy break even point
4040 * -----------------------
drivers/cpuidle/sysfs.c+5−3
@@ -335,6 +335,7 @@ static struct attribute *cpuidle_state_default_attrs[] = { · 334 unmodified lines
335335 &attr_default_status.attr,
336336 NULL
337337 };
338+ATTRIBUTE_GROUPS(cpuidle_state_default);
338339
339340 struct cpuidle_state_kobj {
340341 struct cpuidle_state *state;
@@ -448,7 +449,7 @@ static void cpuidle_state_sysfs_release(struct kobject *kobj) · 107 unmodified lines
448449
449450 static struct kobj_type ktype_state_cpuidle = {
450451 .sysfs_ops = &cpuidle_state_sysfs_ops,
451− .default_attrs = cpuidle_state_default_attrs,
452+ .default_groups = cpuidle_state_default_groups,
452453 .release = cpuidle_state_sysfs_release,
453454 };
454455
@@ -505,7 +506,7 @@ error_state: · 50 unmodified lines
505506 }
506507
507508 /**
508− * cpuidle_remove_driver_sysfs - removes the cpuidle states sysfs attributes
509+ * cpuidle_remove_state_sysfs - removes the cpuidle states sysfs attributes
509510 * @device: the target device
510511 */
511512 static void cpuidle_remove_state_sysfs(struct cpuidle_device *device)
@@ -591,10 +592,11 @@ static struct attribute *cpuidle_driver_default_attrs[] = { · 79 unmodified lines
591592 &attr_driver_name.attr,
592593 NULL
593594 };
595+ATTRIBUTE_GROUPS(cpuidle_driver_default);
594596
595597 static struct kobj_type ktype_driver_cpuidle = {
596598 .sysfs_ops = &cpuidle_driver_sysfs_ops,
597− .default_attrs = cpuidle_driver_default_attrs,
599+ .default_groups = cpuidle_driver_default_groups,
598600 .release = cpuidle_driver_sysfs_release,
599601 };
600602
drivers/mmc/host/jz4740_mmc.c+4−4
@@ -1103,17 +1103,17 @@ static int jz4740_mmc_remove(struct platform_device *pdev) · 1102 unmodified lines
11031103 return 0;
11041104 }
11051105
1106−static int __maybe_unused jz4740_mmc_suspend(struct device *dev)
1106+static int jz4740_mmc_suspend(struct device *dev)
11071107 {
11081108 return pinctrl_pm_select_sleep_state(dev);
11091109 }
11101110
1111−static int __maybe_unused jz4740_mmc_resume(struct device *dev)
1111+static int jz4740_mmc_resume(struct device *dev)
11121112 {
11131113 return pinctrl_select_default_state(dev);
11141114 }
11151115
1116−static SIMPLE_DEV_PM_OPS(jz4740_mmc_pm_ops, jz4740_mmc_suspend,
1116+DEFINE_SIMPLE_DEV_PM_OPS(jz4740_mmc_pm_ops, jz4740_mmc_suspend,
11171117 jz4740_mmc_resume);
11181118
11191119 static struct platform_driver jz4740_mmc_driver = {
@@ -1123,7 +1123,7 @@ static struct platform_driver jz4740_mmc_driver = { · 3 unmodified lines
11231123 .name = "jz4740-mmc",
11241124 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
11251125 .of_match_table = of_match_ptr(jz4740_mmc_of_match),
1126− .pm = pm_ptr(&jz4740_mmc_pm_ops),
1126+ .pm = pm_sleep_ptr(&jz4740_mmc_pm_ops),
11271127 },
11281128 };
11291129
drivers/mmc/host/mxcmmc.c+2−4
@@ -1183,7 +1183,6 @@ static int mxcmci_remove(struct platform_device *pdev) · 1182 unmodified lines
11831183 return 0;
11841184 }
11851185
1186−#ifdef CONFIG_PM_SLEEP
11871186 static int mxcmci_suspend(struct device *dev)
11881187 {
11891188 struct mmc_host *mmc = dev_get_drvdata(dev);
@@ -1210,9 +1209,8 @@ static int mxcmci_resume(struct device *dev) · 20 unmodified lines
12101209
12111210 return ret;
12121211 }
1213−#endif
12141212
1215−static SIMPLE_DEV_PM_OPS(mxcmci_pm_ops, mxcmci_suspend, mxcmci_resume);
1213+DEFINE_SIMPLE_DEV_PM_OPS(mxcmci_pm_ops, mxcmci_suspend, mxcmci_resume);
12161214
12171215 static struct platform_driver mxcmci_driver = {
12181216 .probe = mxcmci_probe,
@@ -1220,7 +1218,7 @@ static struct platform_driver mxcmci_driver = { · 1 unmodified line
12201218 .driver = {
12211219 .name = DRIVER_NAME,
12221220 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1223− .pm = &mxcmci_pm_ops,
1221+ .pm = pm_sleep_ptr(&mxcmci_pm_ops),
12241222 .of_match_table = mxcmci_of_match,
12251223 }
12261224 };
drivers/net/ethernet/realtek/r8169_main.c+3−1
@@ -5441,7 +5441,9 @@ static struct pci_driver rtl8169_pci_driver = { · 5440 unmodified lines
54415441 .probe = rtl_init_one,
54425442 .remove = rtl_remove_one,
54435443 .shutdown = rtl_shutdown,
5444− .driver.pm = pm_ptr(&rtl8169_pm_ops),
5444+#ifdef CONFIG_PM
5445+ .driver.pm = &rtl8169_pm_ops,
5446+#endif
54455447 };
54465448
54475449 module_pci_driver(rtl8169_pci_driver);
include/linux/acpi.h+1−1
@@ -506,7 +506,7 @@ acpi_status acpi_release_memory(acpi_handle handle, struct resource *res, · 505 unmodified lines
506506 int acpi_resources_are_enforced(void);
507507
508508 #ifdef CONFIG_HIBERNATION
509−void __init acpi_no_s4_hw_signature(void);
509+void __init acpi_check_s4_hw_signature(int check);
510510 #endif
511511
512512 #ifdef CONFIG_PM_SLEEP
include/linux/pm.h+53−29
@@ -300,47 +300,59 @@ struct dev_pm_ops { · 299 unmodified lines
300300 int (*runtime_idle)(struct device *dev);
301301 };
302302
303+#define SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
304+ .suspend = pm_sleep_ptr(suspend_fn), \
305+ .resume = pm_sleep_ptr(resume_fn), \
306+ .freeze = pm_sleep_ptr(suspend_fn), \
307+ .thaw = pm_sleep_ptr(resume_fn), \
308+ .poweroff = pm_sleep_ptr(suspend_fn), \
309+ .restore = pm_sleep_ptr(resume_fn),
310+
311+#define LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
312+ .suspend_late = pm_sleep_ptr(suspend_fn), \
313+ .resume_early = pm_sleep_ptr(resume_fn), \
314+ .freeze_late = pm_sleep_ptr(suspend_fn), \
315+ .thaw_early = pm_sleep_ptr(resume_fn), \
316+ .poweroff_late = pm_sleep_ptr(suspend_fn), \
317+ .restore_early = pm_sleep_ptr(resume_fn),
318+
319+#define NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
320+ .suspend_noirq = pm_sleep_ptr(suspend_fn), \
321+ .resume_noirq = pm_sleep_ptr(resume_fn), \
322+ .freeze_noirq = pm_sleep_ptr(suspend_fn), \
323+ .thaw_noirq = pm_sleep_ptr(resume_fn), \
324+ .poweroff_noirq = pm_sleep_ptr(suspend_fn), \
325+ .restore_noirq = pm_sleep_ptr(resume_fn),
326+
327+#define RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
328+ .runtime_suspend = suspend_fn, \
329+ .runtime_resume = resume_fn, \
330+ .runtime_idle = idle_fn,
331+
303332 #ifdef CONFIG_PM_SLEEP
304333 #define SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
305− .suspend = suspend_fn, \
306− .resume = resume_fn, \
307− .freeze = suspend_fn, \
308− .thaw = resume_fn, \
309− .poweroff = suspend_fn, \
310− .restore = resume_fn,
334+ SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
311335 #else
312336 #define SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
313337 #endif
314338
315339 #ifdef CONFIG_PM_SLEEP
316340 #define SET_LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
317− .suspend_late = suspend_fn, \
318− .resume_early = resume_fn, \
319− .freeze_late = suspend_fn, \
320− .thaw_early = resume_fn, \
321− .poweroff_late = suspend_fn, \
322− .restore_early = resume_fn,
341+ LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
323342 #else
324343 #define SET_LATE_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
325344 #endif
326345
327346 #ifdef CONFIG_PM_SLEEP
328347 #define SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
329− .suspend_noirq = suspend_fn, \
330− .resume_noirq = resume_fn, \
331− .freeze_noirq = suspend_fn, \
332− .thaw_noirq = resume_fn, \
333− .poweroff_noirq = suspend_fn, \
334− .restore_noirq = resume_fn,
348+ NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
335349 #else
336350 #define SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn)
337351 #endif
338352
339353 #ifdef CONFIG_PM
340354 #define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
341− .runtime_suspend = suspend_fn, \
342− .runtime_resume = resume_fn, \
343− .runtime_idle = idle_fn,
355+ RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn)
344356 #else
345357 #define SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn)
346358 #endif
@@ -349,9 +361,9 @@ struct dev_pm_ops { · 2 unmodified lines
349361 * Use this if you want to use the same suspend and resume callbacks for suspend
350362 * to RAM and hibernation.
351363 */
352−#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \
353−const struct dev_pm_ops __maybe_unused name = { \
354− SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
364+#define DEFINE_SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \
365+static const struct dev_pm_ops name = { \
366+ SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
355367 }
356368
357369 /*
@@ -367,17 +379,27 @@ const struct dev_pm_ops __maybe_unused name = { \ · 9 unmodified lines
367379 * .resume_early(), to the same routines as .runtime_suspend() and
368380 * .runtime_resume(), respectively (and analogously for hibernation).
369381 */
382+#define DEFINE_UNIVERSAL_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
383+static const struct dev_pm_ops name = { \
384+ SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
385+ RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
386+}
387+
388+/* Deprecated. Use DEFINE_SIMPLE_DEV_PM_OPS() instead. */
389+#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \
390+const struct dev_pm_ops __maybe_unused name = { \
391+ SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
392+}
393+
394+/* Deprecated. Use DEFINE_UNIVERSAL_DEV_PM_OPS() instead. */
370395 #define UNIVERSAL_DEV_PM_OPS(name, suspend_fn, resume_fn, idle_fn) \
371396 const struct dev_pm_ops __maybe_unused name = { \
372397 SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \
373398 SET_RUNTIME_PM_OPS(suspend_fn, resume_fn, idle_fn) \
374399 }
375400
376−#ifdef CONFIG_PM
377−#define pm_ptr(_ptr) (_ptr)
378−#else
379−#define pm_ptr(_ptr) NULL
380−#endif
401+#define pm_ptr(_ptr) PTR_IF(IS_ENABLED(CONFIG_PM), (_ptr))
402+#define pm_sleep_ptr(_ptr) PTR_IF(IS_ENABLED(CONFIG_PM_SLEEP), (_ptr))
381403
382404 /*
383405 * PM_EVENT_ messages
@@ -499,6 +521,7 @@ const struct dev_pm_ops __maybe_unused name = { \ · 115 unmodified lines
499521 */
500522
501523 enum rpm_status {
524+ RPM_INVALID = -1,
502525 RPM_ACTIVE = 0,
503526 RPM_RESUMING,
504527 RPM_SUSPENDED,
@@ -612,6 +635,7 @@ struct dev_pm_info { · 107 unmodified lines
612635 unsigned int links_count;
613636 enum rpm_request request;
614637 enum rpm_status runtime_status;
638+ enum rpm_status last_status;
615639 int runtime_error;
616640 int autosuspend_delay;
617641 u64 last_busy;
include/linux/pm_runtime.h+3−0
@@ -58,6 +58,7 @@ extern void pm_runtime_get_suppliers(struct device *dev); · 57 unmodified lines
5858 extern void pm_runtime_put_suppliers(struct device *dev);
5959 extern void pm_runtime_new_link(struct device *dev);
6060 extern void pm_runtime_drop_link(struct device_link *link);
61+extern void pm_runtime_release_supplier(struct device_link *link, bool check_idle);
6162
6263 extern int devm_pm_runtime_enable(struct device *dev);
6364
@@ -283,6 +284,8 @@ static inline void pm_runtime_get_suppliers(struct device *dev) {} · 219 unmodified lines
283284 static inline void pm_runtime_put_suppliers(struct device *dev) {}
284285 static inline void pm_runtime_new_link(struct device *dev) {}
285286 static inline void pm_runtime_drop_link(struct device_link *link) {}
287+static inline void pm_runtime_release_supplier(struct device_link *link,
288+ bool check_idle) {}
286289
287290 #endif /* !CONFIG_PM */
288291
include/linux/suspend.h+1−0
@@ -446,6 +446,7 @@ extern unsigned long get_safe_page(gfp_t gfp_mask); · 445 unmodified lines
446446 extern asmlinkage int swsusp_arch_suspend(void);
447447 extern asmlinkage int swsusp_arch_resume(void);
448448
449+extern u32 swsusp_hardware_signature;
449450 extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
450451 extern int hibernate(void);
451452 extern bool system_entering_hibernation(void);
kernel/power/power.h+1−0
@@ -170,6 +170,7 @@ extern int swsusp_swap_in_use(void); · 169 unmodified lines
170170 #define SF_PLATFORM_MODE 1
171171 #define SF_NOCOMPRESS_MODE 2
172172 #define SF_CRC32_MODE 4
173+#define SF_HW_SIG 8
173174
174175 /* kernel/power/hibernate.c */
175176 extern int swsusp_check(void);
kernel/power/swap.c+14−2
@@ -36,6 +36,8 @@ · 35 unmodified lines
3636
3737 #define HIBERNATE_SIG "S1SUSPEND"
3838
39+u32 swsusp_hardware_signature;
40+
3941 /*
4042 * When reading an {un,}compressed image, we may restore pages in place,
4143 * in which case some architectures need these pages cleaning before they
@@ -104,7 +106,8 @@ struct swap_map_handle { · 62 unmodified lines
104106
105107 struct swsusp_header {
106108 char reserved[PAGE_SIZE - 20 - sizeof(sector_t) - sizeof(int) -
107− sizeof(u32)];
109+ sizeof(u32) - sizeof(u32)];
110+ u32 hw_sig;
108111 u32 crc32;
109112 sector_t image;
110113 unsigned int flags; /* Flags to pass to the "boot" kernel */
@@ -312,7 +315,6 @@ static int hib_wait_io(struct hib_bio_batch *hb) · 201 unmodified lines
312315 /*
313316 * Saving part
314317 */
315−
316318 static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags)
317319 {
318320 int error;
@@ -324,6 +326,10 @@ static int mark_swapfiles(struct swap_map_handle *handle, unsigned int flags) · 5 unmodified lines
324326 memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
325327 memcpy(swsusp_header->sig, HIBERNATE_SIG, 10);
326328 swsusp_header->image = handle->first_sector;
329+ if (swsusp_hardware_signature) {
330+ swsusp_header->hw_sig = swsusp_hardware_signature;
331+ flags |= SF_HW_SIG;
332+ }
327333 swsusp_header->flags = flags;
328334 if (flags & SF_CRC32_MODE)
329335 swsusp_header->crc32 = handle->crc32;
@@ -1537,6 +1543,12 @@ int swsusp_check(void) · 1207 unmodified lines
15371543 } else {
15381544 error = -EINVAL;
15391545 }
1546+ if (!error && swsusp_header->flags & SF_HW_SIG &&
1547+ swsusp_header->hw_sig != swsusp_hardware_signature) {
1548+ pr_info("Suspend image hardware signature mismatch (%08x now %08x); aborting resume.\n",
1549+ swsusp_header->hw_sig, swsusp_hardware_signature);
1550+ error = -EINVAL;
1551+ }
15401552
15411553 put:
15421554 if (error)