Skip to contentSkip to conversation

ACPI: Move check for _DSD StorageD3Enable property to acpi

PATCH In review Mario Limonciello 3 participants 5 messages Jun 8, 2021 – Jun 9, 2021

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH v7 1/2 ACPI: Move check for _DSD StorageD3Enable property to acpi

Although first implemented for NVME, this check may be usable by other drivers as well. Microsoft's specification explicitly mentions that is may be usable by SATA and AHCI devices. Google also indicates that they have used this with SDHCI in a downstream kernel tree that a user can plug a storage device into.

---
 drivers/acpi/device_pm.c | 25 +++++++++++++++++++++++++
 drivers/nvme/host/pci.c  | 28 +---------------------------
 include/linux/acpi.h     |  5 +++++
 3 files changed, 31 insertions(+), 27 deletions(-)

Changes from v4->v5:
* Correct extra "Link:" word in commit message
Changes from v5->v6:
* Add in commit message tags from Raul, Rafael and Keith
Changes from v6->v7:
* Update kerneldoc comments per suggestsions.
* Drop all Acked/Reviewed tags

drivers/acpi/device_pm.c +25 -0
index d260bc1f3e6e..c45f2d76b67e 100644
@@ -1340,4 +1340,29 @@ int acpi_dev_pm_attach(struct device *dev, bool power_on)
 	return 1;
 }
 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
+
+/**
+ * acpi_storage_d3 - Check if a storage device should use D3 in the suspend path
+ * @dev: Device to check
+ *
+ * Return %true if the platform firmware wants @dev to be programmed
+ * into D3hot or D3cold (if supported) in the suspend path, or %false
+ * when there is no specific preference. On some platforms, if this
+ * hint is ignored, @dev may remain unresponsive after suspending the
+ * platform as a whole.
+ */
+bool acpi_storage_d3(struct device *dev)
+{
+	struct acpi_device *adev = ACPI_COMPANION(dev);
+	u8 val;
+
+	if (!adev)
+		return false;
+	if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
+			&val))
+		return false;
+	return val == 1;
+}
+EXPORT_SYMBOL_GPL(acpi_storage_d3);
+
 #endif /* CONFIG_PM */
drivers/nvme/host/pci.c +1 -27
index 3aa7245a505f..8fbc4c87a0d8 100644
@@ -2828,32 +2828,6 @@ static unsigned long check_vendor_combination_bug(struct pci_dev *pdev)
 	return 0;
 }
 
-#ifdef CONFIG_ACPI
-static bool nvme_acpi_storage_d3(struct pci_dev *dev)
-{
-	struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
-	u8 val;
-
-	/*
-	 * Look for _DSD property specifying that the storage device on the port
-	 * must use D3 to support deep platform power savings during
-	 * suspend-to-idle.
-	 */
-
-	if (!adev)
-		return false;
-	if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
-			&val))
-		return false;
-	return val == 1;
-}
-#else
-static inline bool nvme_acpi_storage_d3(struct pci_dev *dev)
-{
-	return false;
-}
-#endif /* CONFIG_ACPI */
-
 static void nvme_async_probe(void *data, async_cookie_t cookie)
 {
 	struct nvme_dev *dev = data;
@@ -2903,7 +2877,7 @@ static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 
 	quirks |= check_vendor_combination_bug(pdev);
 
-	if (!noacpi && nvme_acpi_storage_d3(pdev)) {
+	if (!noacpi && acpi_storage_d3(&pdev->dev)) {
 		/*
 		 * Some systems use a bios work around to ask for D3 on
 		 * platforms that support kernel managed suspend.
include/linux/acpi.h +5 -0
index c60745f657e9..dd0dafd21e33 100644
@@ -1004,6 +1004,7 @@ int acpi_dev_resume(struct device *dev);
 int acpi_subsys_runtime_suspend(struct device *dev);
 int acpi_subsys_runtime_resume(struct device *dev);
 int acpi_dev_pm_attach(struct device *dev, bool power_on);
+bool acpi_storage_d3(struct device *dev);
 #else
 static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
 static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
@@ -1011,6 +1012,10 @@ static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
 {
 	return 0;
 }
+static inline bool acpi_storage_d3(struct device *dev)
+{
+	return false;
+}
 #endif
 
 #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
Signature · 1 line
2.25.1
#1 lore raw

PATCH v7 2/2 ACPI: Add quirks for AMD Renoir/Lucienne CPUs to force the D3 hint

AMD systems from Renoir and Lucienne require that the NVME controller is put into D3 over a Modern Standby / suspend-to-idle cycle. This is "typically" accomplished using the StorageD3Enable property in the _DSD, but this property was introduced after many of these systems launched and most OEM systems don't have it in their BIOS.

On AMD Renoir without these drives going into D3 over suspend-to-idle the resume will fail with the NVME controller being reset and a trace like this in the kernel logs:

```
[   83.556118] nvme nvme0: I/O 161 QID 2 timeout, aborting
[   83.556178] nvme nvme0: I/O 162 QID 2 timeout, aborting
[   83.556187] nvme nvme0: I/O 163 QID 2 timeout, aborting
[   83.556196] nvme nvme0: I/O 164 QID 2 timeout, aborting
[   95.332114] nvme nvme0: I/O 25 QID 0 timeout, reset controller
[   95.332843] nvme nvme0: Abort status: 0x371
[   95.332852] nvme nvme0: Abort status: 0x371
[   95.332856] nvme nvme0: Abort status: 0x371
[   95.332859] nvme nvme0: Abort status: 0x371
[   95.332909] PM: dpm_run_callback(): pci_pm_resume+0x0/0xe0 returns -16
[   95.332936] nvme 0000:03:00.0: PM: failed to resume async: error -16
```

The Microsoft documentation for StorageD3Enable mentioned that Windows has a hardcoded allowlist for D3 support, which was used for these platforms. Introduce quirks to hardcode them for Linux as well.

As this property is now "standardized", OEM systems using AMD Cezanne and newer APU's have adopted this property, and quirks like this should not be necessary.

---
 drivers/acpi/device_pm.c |  3 +++
 drivers/acpi/internal.h  |  9 +++++++++
 drivers/acpi/x86/utils.c | 25 +++++++++++++++++++++++++
 3 files changed, 37 insertions(+)

Changes from v4->v5:
* Add this patch back in as it's been made apparent that the system needs to be hardcoded for these.
Changes:
- Drop Cezanne - it's now covered by StorageD3Enable
- Rebase ontop of acpi_storage_d3 outside of NVME
Changes from v5->v6:
* Move the quirk check into drivers/acpi/x86/ as suggested by Rafael.
Changes from v6->v7:
* Move header location
* Optimization of force function

drivers/acpi/device_pm.c +3 -0
index c45f2d76b67e..31e0025a913e 100644
@@ -1356,6 +1356,9 @@ bool acpi_storage_d3(struct device *dev)
 	struct acpi_device *adev = ACPI_COMPANION(dev);
 	u8 val;
 
+	if (force_storage_d3())
+		return true;
+
 	if (!adev)
 		return false;
 	if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
drivers/acpi/internal.h +9 -0
index f973bbe90e5e..e29ec463bb07 100644
@@ -236,6 +236,15 @@ static inline int suspend_nvs_save(void) { return 0; }
 static inline void suspend_nvs_restore(void) {}
 #endif
 
+#ifdef CONFIG_X86
+bool force_storage_d3(void);
+#else
+static inline bool force_storage_d3(void)
+{
+	return false;
+}
+#endif
+
 /*--------------------------------------------------------------------------
 				Device properties
   -------------------------------------------------------------------------- */
drivers/acpi/x86/utils.c +25 -0
index bdc1ba00aee9..5298bb4d81fe 100644
@@ -135,3 +135,28 @@ bool acpi_device_always_present(struct acpi_device *adev)
 
 	return ret;
 }
+
+/*
+ * AMD systems from Renoir and Lucienne *require* that the NVME controller
+ * is put into D3 over a Modern Standby / suspend-to-idle cycle.
+ *
+ * This is "typically" accomplished using the `StorageD3Enable`
+ * property in the _DSD that is checked via the `acpi_storage_d3` function
+ * but this property was introduced after many of these systems launched
+ * and most OEM systems don't have it in their BIOS.
+ *
+ * The Microsoft documentation for StorageD3Enable mentioned that Windows has
+ * a hardcoded allowlist for D3 support, which was used for these platforms.
+ *
+ * This allows quirking on Linux in a similar fashion.
+ */
+const struct x86_cpu_id storage_d3_cpu_ids[] = {
+	X86_MATCH_VENDOR_FAM_MODEL(AMD, 23, 96, NULL),	/* Renoir */
+	X86_MATCH_VENDOR_FAM_MODEL(AMD, 23, 104, NULL),	/* Lucienne */
+	{}
+};
+
+bool force_storage_d3(void)
+{
+	return x86_match_cpu(storage_d3_cpu_ids);
+}
Signature · 1 line
2.25.1
Tested-by on v7 2/2
#2 lore raw

Re: [PATCH v7 2/2] ACPI: Add quirks for AMD Renoir/Lucienne CPUs to force the D3 hint

W dniu 08.06.2021 o 17:42, Mario Limonciello pisze:

Quoted 116 lines

AMD systems from Renoir and Lucienne require that the NVME controller is put into D3 over a Modern Standby / suspend-to-idle cycle. This is "typically" accomplished using the StorageD3Enable property in the _DSD, but this property was introduced after many of these systems launched and most OEM systems don't have it in their BIOS.

On AMD Renoir without these drives going into D3 over suspend-to-idle the resume will fail with the NVME controller being reset and a trace like this in the kernel logs:

```
[   83.556118] nvme nvme0: I/O 161 QID 2 timeout, aborting
[   83.556178] nvme nvme0: I/O 162 QID 2 timeout, aborting
[   83.556187] nvme nvme0: I/O 163 QID 2 timeout, aborting
[   83.556196] nvme nvme0: I/O 164 QID 2 timeout, aborting
[   95.332114] nvme nvme0: I/O 25 QID 0 timeout, reset controller
[   95.332843] nvme nvme0: Abort status: 0x371
[   95.332852] nvme nvme0: Abort status: 0x371
[   95.332856] nvme nvme0: Abort status: 0x371
[   95.332859] nvme nvme0: Abort status: 0x371
[   95.332909] PM: dpm_run_callback(): pci_pm_resume+0x0/0xe0 returns -16
[   95.332936] nvme 0000:03:00.0: PM: failed to resume async: error -16
```

The Microsoft documentation for StorageD3Enable mentioned that Windows has a hardcoded allowlist for D3 support, which was used for these platforms. Introduce quirks to hardcode them for Linux as well.

As this property is now "standardized", OEM systems using AMD Cezanne and newer APU's have adopted this property, and quirks like this should not be necessary.

---
  drivers/acpi/device_pm.c |  3 +++
  drivers/acpi/internal.h  |  9 +++++++++
  drivers/acpi/x86/utils.c | 25 +++++++++++++++++++++++++
  3 files changed, 37 insertions(+)

Changes from v4->v5:
* Add this patch back in as it's been made apparent that the system needs to be hardcoded for these.
Changes:
- Drop Cezanne - it's now covered by StorageD3Enable
- Rebase ontop of acpi_storage_d3 outside of NVME
Changes from v5->v6:
* Move the quirk check into drivers/acpi/x86/ as suggested by Rafael.
Changes from v6->v7:
* Move header location
* Optimization of force function

drivers/acpi/device_pm.c +3 -0
index c45f2d76b67e..31e0025a913e 100644
@@ -1356,6 +1356,9 @@ bool acpi_storage_d3(struct device *dev)
  	struct acpi_device *adev = ACPI_COMPANION(dev);
  	u8 val;
 
+	if (force_storage_d3())
+		return true;
+
  	if (!adev)
  		return false;
  	if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
drivers/acpi/internal.h +9 -0
index f973bbe90e5e..e29ec463bb07 100644
@@ -236,6 +236,15 @@ static inline int suspend_nvs_save(void) { return 0; }
  static inline void suspend_nvs_restore(void) {}
  #endif
 
+#ifdef CONFIG_X86
+bool force_storage_d3(void);
+#else
+static inline bool force_storage_d3(void)
+{
+	return false;
+}
+#endif
+
  /*--------------------------------------------------------------------------
  				Device properties
    -------------------------------------------------------------------------- */
drivers/acpi/x86/utils.c +15 -0
index bdc1ba00aee9..5298bb4d81fe 100644
@@ -135,3 +135,28 @@ bool acpi_device_always_present(struct acpi_device *adev)
 
  	return ret;
  }
+
+/*
+ * AMD systems from Renoir and Lucienne *require* that the NVME controller
+ * is put into D3 over a Modern Standby / suspend-to-idle cycle.
+ *
+ * This is "typically" accomplished using the `StorageD3Enable`
+ * property in the _DSD that is checked via the `acpi_storage_d3` function
+ * but this property was introduced after many of these systems launched
+ * and most OEM systems don't have it in their BIOS.
+ *
+ * The Microsoft documentation for StorageD3Enable mentioned that Windows has
+ * a hardcoded allowlist for D3 support, which was used for these platforms.
+ *
+ * This allows quirking on Linux in a similar fashion.
+ */

drivers/acpi/x86/utils.c bool acpi_device_always_present(struct acpi_device *adev) · line 162

Quoted 10 lines
drivers/acpi/x86/utils.c +10 -0
+const struct x86_cpu_id storage_d3_cpu_ids[] = {
+	X86_MATCH_VENDOR_FAM_MODEL(AMD, 23, 96, NULL),	/* Renoir */
+	X86_MATCH_VENDOR_FAM_MODEL(AMD, 23, 104, NULL),	/* Lucienne */
+	{}
+};
+
+bool force_storage_d3(void)
+{
+	return x86_match_cpu(storage_d3_cpu_ids);
+}
maintainer Acked-by on v7 2/2
#3 lore raw

Re: [PATCH v7 2/2] ACPI: Add quirks for AMD Renoir/Lucienne CPUs to force the D3 hint

In reply to Mario Limonciello
Quoted 33 lines · Mario Limonciello

AMD systems from Renoir and Lucienne require that the NVME controller is put into D3 over a Modern Standby / suspend-to-idle cycle. This is "typically" accomplished using the StorageD3Enable property in the _DSD, but this property was introduced after many of these systems launched and most OEM systems don't have it in their BIOS.

On AMD Renoir without these drives going into D3 over suspend-to-idle the resume will fail with the NVME controller being reset and a trace like this in the kernel logs:

```
[   83.556118] nvme nvme0: I/O 161 QID 2 timeout, aborting
[   83.556178] nvme nvme0: I/O 162 QID 2 timeout, aborting
[   83.556187] nvme nvme0: I/O 163 QID 2 timeout, aborting
[   83.556196] nvme nvme0: I/O 164 QID 2 timeout, aborting
[   95.332114] nvme nvme0: I/O 25 QID 0 timeout, reset controller
[   95.332843] nvme nvme0: Abort status: 0x371
[   95.332852] nvme nvme0: Abort status: 0x371
[   95.332856] nvme nvme0: Abort status: 0x371
[   95.332859] nvme nvme0: Abort status: 0x371
[   95.332909] PM: dpm_run_callback(): pci_pm_resume+0x0/0xe0 returns -16
[   95.332936] nvme 0000:03:00.0: PM: failed to resume async: error -16
```

The Microsoft documentation for StorageD3Enable mentioned that Windows has a hardcoded allowlist for D3 support, which was used for these platforms. Introduce quirks to hardcode them for Linux as well.

As this property is now "standardized", OEM systems using AMD Cezanne and newer APU's have adopted this property, and quirks like this should not be necessary.

Quoted 7 lines
Quoted 89 lines
---
 drivers/acpi/device_pm.c |  3 +++
 drivers/acpi/internal.h  |  9 +++++++++
 drivers/acpi/x86/utils.c | 25 +++++++++++++++++++++++++
 3 files changed, 37 insertions(+)

Changes from v4->v5:
* Add this patch back in as it's been made apparent that the system needs to be hardcoded for these.
Changes:
- Drop Cezanne - it's now covered by StorageD3Enable
- Rebase ontop of acpi_storage_d3 outside of NVME
Changes from v5->v6:
* Move the quirk check into drivers/acpi/x86/ as suggested by Rafael.
Changes from v6->v7:
* Move header location
* Optimization of force function

drivers/acpi/device_pm.c +3 -0
index c45f2d76b67e..31e0025a913e 100644
@@ -1356,6 +1356,9 @@ bool acpi_storage_d3(struct device *dev)
        struct acpi_device *adev = ACPI_COMPANION(dev);
        u8 val;
 
+       if (force_storage_d3())
+               return true;
+
        if (!adev)
                return false;
        if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
drivers/acpi/internal.h +9 -0
index f973bbe90e5e..e29ec463bb07 100644
@@ -236,6 +236,15 @@ static inline int suspend_nvs_save(void) { return 0; }
 static inline void suspend_nvs_restore(void) {}
 #endif
 
+#ifdef CONFIG_X86
+bool force_storage_d3(void);
+#else
+static inline bool force_storage_d3(void)
+{
+       return false;
+}
+#endif
+
 /*--------------------------------------------------------------------------
                                Device properties
   -------------------------------------------------------------------------- */
drivers/acpi/x86/utils.c +25 -1
index bdc1ba00aee9..5298bb4d81fe 100644
@@ -135,3 +135,28 @@ bool acpi_device_always_present(struct acpi_device *adev)
 
        return ret;
 }
+
+/*
+ * AMD systems from Renoir and Lucienne *require* that the NVME controller
+ * is put into D3 over a Modern Standby / suspend-to-idle cycle.
+ *
+ * This is "typically" accomplished using the `StorageD3Enable`
+ * property in the _DSD that is checked via the `acpi_storage_d3` function
+ * but this property was introduced after many of these systems launched
+ * and most OEM systems don't have it in their BIOS.
+ *
+ * The Microsoft documentation for StorageD3Enable mentioned that Windows has
+ * a hardcoded allowlist for D3 support, which was used for these platforms.
+ *
+ * This allows quirking on Linux in a similar fashion.
+ */
+const struct x86_cpu_id storage_d3_cpu_ids[] = {
+       X86_MATCH_VENDOR_FAM_MODEL(AMD, 23, 96, NULL),  /* Renoir */
+       X86_MATCH_VENDOR_FAM_MODEL(AMD, 23, 104, NULL), /* Lucienne */
+       {}
+};
+
+bool force_storage_d3(void)
+{
+       return x86_match_cpu(storage_d3_cpu_ids);
+}
--

2.25.1

maintainer Reviewed-by on v7 1/2
#4 lore raw
In reply to Mario Limonciello
Quoted 14 lines · Mario Limonciello

Although first implemented for NVME, this check may be usable by other drivers as well. Microsoft's specification explicitly mentions that is may be usable by SATA and AHCI devices. Google also indicates that they have used this with SDHCI in a downstream kernel tree that a user can plug a storage device into.

Quoted 3 lines
---
 drivers/acpi/device_pm.c | 25 +++++++++++++++++++++++++
 drivers/nvme/host/pci.c  | 28 +---------------------------

This appears to be based on an nvme commit that is not there in the mainline, so I cannot apply it as is.

If you change the subject to something like

"ACPI: Check StorageD3Enable _DSD property in ACPI code"

and modify the acpi_storage_d3() kerneldoc as per the remark below, please feel free to add

to it and route it via nvme.

Quoted 16 lines
 include/linux/acpi.h     |  5 +++++
 3 files changed, 31 insertions(+), 27 deletions(-)

Changes from v4->v5:
* Correct extra "Link:" word in commit message
Changes from v5->v6:
* Add in commit message tags from Raul, Rafael and Keith
Changes from v6->v7:
* Update kerneldoc comments per suggestsions.
* Drop all Acked/Reviewed tags

drivers/acpi/device_pm.c +0 -0
index d260bc1f3e6e..c45f2d76b67e 100644

drivers/acpi/device_pm.c int acpi_dev_pm_attach(struct device *dev, bool power_on) · line 1345

Quoted 6 lines
drivers/acpi/device_pm.c +3 -0
@@ -1340,4 +1340,29 @@ int acpi_dev_pm_attach(struct device *dev, bool power_on)
        return 1;
 }
 EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
+
+/**
+ * acpi_storage_d3 - Check if a storage device should use D3 in the suspend path

Please change this to something like "Check if D3 should be used in the suspend path" as this generally isn't about storage only.

Quoted 95 lines
drivers/acpi/device_pm.c +22 -0
+ * @dev: Device to check
+ *
+ * Return %true if the platform firmware wants @dev to be programmed
+ * into D3hot or D3cold (if supported) in the suspend path, or %false
+ * when there is no specific preference. On some platforms, if this
+ * hint is ignored, @dev may remain unresponsive after suspending the
+ * platform as a whole.
+ */
+bool acpi_storage_d3(struct device *dev)
+{
+       struct acpi_device *adev = ACPI_COMPANION(dev);
+       u8 val;
+
+       if (!adev)
+               return false;
+       if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
+                       &val))
+               return false;
+       return val == 1;
+}
+EXPORT_SYMBOL_GPL(acpi_storage_d3);
+
 #endif /* CONFIG_PM */
drivers/nvme/host/pci.c +1 -27
index 3aa7245a505f..8fbc4c87a0d8 100644
@@ -2828,32 +2828,6 @@ static unsigned long check_vendor_combination_bug(struct pci_dev *pdev)
        return 0;
 }
 
-#ifdef CONFIG_ACPI
-static bool nvme_acpi_storage_d3(struct pci_dev *dev)
-{
-       struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
-       u8 val;
-
-       /*
-        * Look for _DSD property specifying that the storage device on the port
-        * must use D3 to support deep platform power savings during
-        * suspend-to-idle.
-        */
-
-       if (!adev)
-               return false;
-       if (fwnode_property_read_u8(acpi_fwnode_handle(adev), "StorageD3Enable",
-                       &val))
-               return false;
-       return val == 1;
-}
-#else
-static inline bool nvme_acpi_storage_d3(struct pci_dev *dev)
-{
-       return false;
-}
-#endif /* CONFIG_ACPI */
-
 static void nvme_async_probe(void *data, async_cookie_t cookie)
 {
        struct nvme_dev *dev = data;
@@ -2903,7 +2877,7 @@ static int nvme_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 
        quirks |= check_vendor_combination_bug(pdev);
 
-       if (!noacpi && nvme_acpi_storage_d3(pdev)) {
+       if (!noacpi && acpi_storage_d3(&pdev->dev)) {
                /*
                 * Some systems use a bios work around to ask for D3 on
                 * platforms that support kernel managed suspend.
include/linux/acpi.h +5 -1
index c60745f657e9..dd0dafd21e33 100644
@@ -1004,6 +1004,7 @@ int acpi_dev_resume(struct device *dev);
 int acpi_subsys_runtime_suspend(struct device *dev);
 int acpi_subsys_runtime_resume(struct device *dev);
 int acpi_dev_pm_attach(struct device *dev, bool power_on);
+bool acpi_storage_d3(struct device *dev);
 #else
 static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
 static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
@@ -1011,6 +1012,10 @@ static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
 {
        return 0;
 }
+static inline bool acpi_storage_d3(struct device *dev)
+{
+       return false;
+}
 #endif
 
 #if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
--

2.25.1