mfd: intel-lpss: Avoid resuming runtime-suspended lpss unnecessarily
Subsystems (5)
PATCH v3 1/1 mfd: intel-lpss: Avoid resuming runtime-suspended lpss unnecessarily
We have report that the intel_lpss_prepare() takes too much time during suspend, and this is because we first resume the devices from runtime suspend by resume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSS devices(PCI power state from D3_cold to D0). And since resume_lpss_device() resumes the devices synchronously, we might get huge latency if we have many LPSS devices.
So first try is to use pm_request_resume() instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies on pm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e., intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.
--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)
drivers/mfd/intel-lpss.c +9 -0
@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */
include/linux/pm.h +7 -0
@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, }; +/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */
Signature · 1 line
2.7.4
Rafael J. Wysocki
maintainerHi Lee,
Quoted 17 lines · Chen Yu
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.
Quoted 8 lines
Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>
If this is fine with you and you'd like to apply it, please feel free to add my ACK to it.
Alternatively, if you'd prefer me to apply it, please let me know.
Quoted 32 lines
--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +0
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, };
include/linux/pm.h enum dpm_order {
Quoted 10 lines
include/linux/pm.h +7
-1+/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */ --
Thanks,
Rafael
Quoted 29 lines · Rafael J. Wysocki
Hi Lee,
Quoted 17 lines · Chen Yu
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.Quoted 8 lines
Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>
Quoted 4 lines
If this is fine with you and you'd like to apply it, please feel free to add my ACK to it.
Alternatively, if you'd prefer me to apply it, please let me know.
You want this in for v3.9?
I just started applying patches for v3.10.
If you're certain there are 0% chance of regressions, I will still apply this for v3.9 with your Ack.
Quoted 45 lines
Quoted 32 lines
--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +0
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, };include/linux/pm.h enum dpm_order {
Quoted 10 lines
include/linux/pm.h +7
-1+/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */ --Thanks,
Rafael
Signature · 4 lines
Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog
Rafael J. Wysocki
maintainerQuoted 31 lines · Lee Jones
Quoted 29 lines · Rafael J. Wysocki
Hi Lee,
Quoted 25 lines · Chen Yu
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>
Quoted 6 lines
Quoted 4 lines
If this is fine with you and you'd like to apply it, please feel free to add my ACK to it.
Alternatively, if you'd prefer me to apply it, please let me know.
You want this in for v3.9?
I'd rather queue it up for 4.10 (assuming that the above and below major version numbers are simply off by one by mistake).
Quoted 4 lines
I just started applying patches for v3.10.
If you're certain there are 0% chance of regressions, I will still apply this for v3.9 with your Ack.
4.10 should be fine.
Quoted 33 lines
Quoted 33 lines
Quoted 33 lines
--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +0
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, };
Quoted 9 lines
Quoted 9 lines
include/linux/pm.h enum dpm_order {
Quoted 9 lines
include/linux/pm.h +7
-1+/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */ --
Thanks,
Rafael
Quoted 35 lines · Rafael J. Wysocki
Quoted 34 lines · Lee Jones
Quoted 32 lines · Rafael J. Wysocki
Hi Lee,
Quoted 17 lines · Chen Yu
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.Quoted 8 lines
Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>If this is fine with you and you'd like to apply it, please feel free to add my ACK to it.
Quoted 6 lines
Quoted 3 lines
Quoted 1 line
Alternatively, if you'd prefer me to apply it, please let me know.
You want this in for v3.9?
I'd rather queue it up for 4.10 (assuming that the above and below major version numbers are simply off by one by mistake).
Yes, of course they are off by one.
This is what happens when you conduct mail duties with jetlag. :)
Quoted 6 lines
Quoted 4 lines
I just started applying patches for v3.10.
If you're certain there are 0% chance of regressions, I will still apply this for v3.9 with your Ack.
4.10 should be fine.
Great.
Quoted 45 lines
Quoted 33 lines
Quoted 33 lines
Quoted 33 lines
--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +0
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, };Quoted 9 lines
Quoted 9 lines
include/linux/pm.h enum dpm_order {
Quoted 9 lines
include/linux/pm.h +7
-1+/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */ --Thanks,
Rafael
Signature · 4 lines
Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog
Quoted 25 lines · Chen Yu
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>
Quoted 4 lines
--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)
Applied for v4.10, thanks.
Quoted 36 lines
drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +7
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, }; +/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */
Signature · 4 lines
Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog
Hi Lee,
you wrote on Oct 4 that you applied the below patch for v4.10. However I don't see the patch on your for-mfd-next branch. Maybe the patch slipped between the cracks, please double-check. I would like to use the DPM_DIRECT_COMPLETE macro introduced by it in a patch of my own.
I also don't see a pull from you in Linus' tree yet. Please note that this merge window will be shorter than usual and pulls should be sent out before coming Friday.
Thanks,
Lukas
Quoted 66 lines · Chen Yu
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +7
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, }; +/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */
Quoted 5 lines · Lukas Wunner
you wrote on Oct 4 that you applied the below patch for v4.10. However I don't see the patch on your for-mfd-next branch. Maybe the patch slipped between the cracks, please double-check. I would like to use the
DPM_DIRECT_COMPLETEmacro introduced by it in a patch of my own.
Chen asked me to remove the patch.
Quoted 3 lines
I also don't see a pull from you in Linus' tree yet. Please note that this merge window will be shorter than usual and pulls should be sent out before coming Friday.
Right, I was on vacation. All sorted now.
Quoted 67 lines · Chen Yu
Quoted 66 lines
We have report that the
intel_lpss_prepare()takes too much time during suspend, and this is because we first resume the devices from runtime suspend byresume_lpss_device(), to make sure they are in proper state before system suspend, which takes 100ms for each LPSSdevices(PCI power state from D3_cold to D0). And sinceresume_lpss_device()resumes the devices synchronously, we might get huge latency if we have many LPSS devices.So first try is to use
pm_request_resume()instead, to make the runtime resume process asynchronously. Unfortunately the asynchronous runtime resume relies onpm_wq, which is freezed at early stage. So we choose another method, that is to avoid resuming runtime-suspended devices, if they are already runtime suspended. This is safe because for LPSS driver, the runtime suspend and system suspend are of the same hook - i.e.,intel_lpss_suspend(). And moreover, this device is neither runtime wakeup source nor system wakeup source.Suggested-by Rafael J. Wysocki <[email protected]>Acked-by Mika Westerberg <[email protected]>Reviewed-by Andy Shevchenko <[email protected]>Cc Andy Shevchenko <[email protected]>Cc Mika Westerberg <[email protected]>Cc Rafael J. Wysocki <[email protected]>Cc Lee Jones <[email protected]>Signed-off-by Chen Yu <[email protected]>--- drivers/mfd/intel-lpss.c | 9 +++++++++ include/linux/pm.h | 7 +++++++ 2 files changed, 16 insertions(+)drivers/mfd/intel-lpss.c +9
-0@@ -485,6 +485,15 @@ static int resume_lpss_device(struct device *dev, void *data)int intel_lpss_prepare (struct device *dev) {/* +* This is safe because: +* 1. The runtime suspend and system suspend +* are of the same hook. +* 2. This device is neither runtime wakeup source +* nor system wakeup source. +*/ +if (pm_runtime_status_suspended (dev)) +return DPM_DIRECT_COMPLETE ; +/* * Resume both child devices before entering system sleep. This * ensures that they are in proper state before they get suspended. */ include/linux/pm.h +7
-0@@ -786,4 +786,11 @@ enum dpm_order { DPM_ORDER_DEV_LAST, }; +/* +* Return this from system suspend/hibernation ->prepare() callback to +* request the core to leave the device runtime-suspended during system +* suspend if possible. +*/ +#define DPM_DIRECT_COMPLETE 1 +#endif /* _LINUX_PM_H */
Signature · 4 lines
Lee Jones Linaro STMicroelectronics Landing Team Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog