Skip to contentSkip to conversation

platform: unify the platform_pm_* suspend/resume dispatch

PATCH In review KrisPoint 2 participants 2 messages Aug 20 Driver core

lore
Share & tools
lore

KrisPoint

author
#0 lore raw

PATCH 1/1 platform: unify the platform_pm_* suspend/resume dispatch

The six platform_pm_suspend()/platform_pm_resume()/platform_pm_freeze()/ platform_pm_thaw()/platform_pm_poweroff()/platform_pm_restore() callbacks all follow the same pattern: return early when the device has no driver, call the matching dev_pm_ops callback when one is present, and otherwise fall back to the legacy platform suspend/resume callbacks. This skeleton is currently open-coded in each of the six functions, leaving about 110 lines of near-identical logic that must be kept in sync by hand.

Add a common platform_pm_dispatch() helper that implements the shared logic, driven by the dev_pm_ops callback, the legacy callback and the pm message to pass, and turn the six callbacks into thin wrappers around it. A platform_legacy_resume_state() adapter is added so the legacy callbacks share a single signature.

No functional change intended.

---
 drivers/base/platform.c | 109 ++++++++++++++--------------------------
 1 file changed, 38 insertions(+), 71 deletions(-)
drivers/base/platform.c +38 -71
index 66f9ec73d..f02b44937 100644
@@ -1248,44 +1248,47 @@ static int platform_legacy_resume(struct device *dev)
 	return ret;
 }
 
-#endif /* CONFIG_PM_SLEEP */
-
-#ifdef CONFIG_SUSPEND
+static int platform_legacy_resume_state(struct device *dev, pm_message_t state)
+{
+	return platform_legacy_resume(dev);
+}
 
-int platform_pm_suspend(struct device *dev)
+static int platform_pm_dispatch(struct device *dev,
+				int (*pm_op)(struct device *),
+				int (*legacy_op)(struct device *, pm_message_t),
+				pm_message_t legacy_state)
 {
 	const struct device_driver *drv = dev->driver;
-	int ret = 0;
 
 	if (!drv)
 		return 0;
 
-	if (drv->pm) {
-		if (drv->pm->suspend)
-			ret = drv->pm->suspend(dev);
-	} else {
-		ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
-	}
+	if (drv->pm)
+		return pm_op ? pm_op(dev) : 0;
 
-	return ret;
+	return legacy_op(dev, legacy_state);
 }
 
-int platform_pm_resume(struct device *dev)
+#endif /* CONFIG_PM_SLEEP */
+
+#ifdef CONFIG_SUSPEND
+
+int platform_pm_suspend(struct device *dev)
 {
 	const struct device_driver *drv = dev->driver;
-	int ret = 0;
 
-	if (!drv)
-		return 0;
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->suspend : NULL,
+				    platform_legacy_suspend, PMSG_SUSPEND);
+}
 
-	if (drv->pm) {
-		if (drv->pm->resume)
-			ret = drv->pm->resume(dev);
-	} else {
-		ret = platform_legacy_resume(dev);
-	}
+int platform_pm_resume(struct device *dev)
+{
+	const struct device_driver *drv = dev->driver;
 
-	return ret;
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->resume : NULL,
+				    platform_legacy_resume_state, PMSG_RESUME);
 }
 
 #endif /* CONFIG_SUSPEND */
@@ -1295,73 +1298,37 @@ int platform_pm_resume(struct device *dev)
 int platform_pm_freeze(struct device *dev)
 {
 	const struct device_driver *drv = dev->driver;
-	int ret = 0;
-
-	if (!drv)
-		return 0;
-
-	if (drv->pm) {
-		if (drv->pm->freeze)
-			ret = drv->pm->freeze(dev);
-	} else {
-		ret = platform_legacy_suspend(dev, PMSG_FREEZE);
-	}
 
-	return ret;
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->freeze : NULL,
+				    platform_legacy_suspend, PMSG_FREEZE);
 }
 
 int platform_pm_thaw(struct device *dev)
 {
 	const struct device_driver *drv = dev->driver;
-	int ret = 0;
 
-	if (!drv)
-		return 0;
-
-	if (drv->pm) {
-		if (drv->pm->thaw)
-			ret = drv->pm->thaw(dev);
-	} else {
-		ret = platform_legacy_resume(dev);
-	}
-
-	return ret;
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->thaw : NULL,
+				    platform_legacy_resume_state, PMSG_RESUME);
 }
 
 int platform_pm_poweroff(struct device *dev)
 {
 	const struct device_driver *drv = dev->driver;
-	int ret = 0;
 
-	if (!drv)
-		return 0;
-
-	if (drv->pm) {
-		if (drv->pm->poweroff)
-			ret = drv->pm->poweroff(dev);
-	} else {
-		ret = platform_legacy_suspend(dev, PMSG_HIBERNATE);
-	}
-
-	return ret;
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->poweroff : NULL,
+				    platform_legacy_suspend, PMSG_HIBERNATE);
 }
 
 int platform_pm_restore(struct device *dev)
 {
 	const struct device_driver *drv = dev->driver;
-	int ret = 0;
 
-	if (!drv)
-		return 0;
-
-	if (drv->pm) {
-		if (drv->pm->restore)
-			ret = drv->pm->restore(dev);
-	} else {
-		ret = platform_legacy_resume(dev);
-	}
-
-	return ret;
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->restore : NULL,
+				    platform_legacy_resume_state, PMSG_RESUME);
 }
 
 #endif /* CONFIG_HIBERNATE_CALLBACKS */
Signature · 1 line
2.53.0
maintainer
#1 lore raw
Quoted 14 lines · KrisPoint

The six platform_pm_suspend()/platform_pm_resume()/platform_pm_freeze()/ platform_pm_thaw()/platform_pm_poweroff()/platform_pm_restore() callbacks all follow the same pattern: return early when the device has no driver, call the matching dev_pm_ops callback when one is present, and otherwise fall back to the legacy platform suspend/resume callbacks. This skeleton is currently open-coded in each of the six functions, leaving about 110 lines of near-identical logic that must be kept in sync by hand.

Add a common platform_pm_dispatch() helper that implements the shared logic, driven by the dev_pm_ops callback, the legacy callback and the pm message to pass, and turn the six callbacks into thin wrappers around it. A platform_legacy_resume_state() adapter is added so the legacy callbacks share a single signature.

Quoted 3 lines

No functional change intended.

Real name please.

While I appreciate the goal of making code smaller, you have to admit, these lines:

drivers/base/platform.c static int platform_legacy_resume(struct device *dev) · line 1282

Quoted 3 lines
drivers/base/platform.c +3 -0
+	return platform_pm_dispatch(dev,
+				    drv && drv->pm ? drv->pm->suspend : NULL,
+				    platform_legacy_suspend, PMSG_SUSPEND);

Are pretty unreadable.

Now we need to go look up the platform_pm_dispatch parameters each time and try to figure out the suspend vs. NULL mess.

We write code for people first, compilers second. And this feels to me, like making it harder for people to understand.

thanks,

greg k-h