pm: device_runtime: Make async optional

Async now uses its own work queue, which means it consumes more
resources. Since not all applications need the async API, we can make
it optional without any penalty for those applications.

Signed-off-by: Flavio Ceolin <[email protected]>

Author: ceolin

include/zephyr/pm/device.h

@@ -170,8 +170,10 @@ struct pm_device {
 	struct k_sem lock;
 	/** Event var to listen to the sync request events */
 	struct k_event event;
+#if defined(CONFIG_PM_DEVICE_RUNTIME_ASYNC) || defined(__DOXYGEN__)
 	/** Work object for asynchronous calls */
 	struct k_work_delayable work;
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 #endif /* CONFIG_PM_DEVICE_RUNTIME */
 };
 

subsys/pm/Kconfig

@@ -102,6 +102,14 @@ config PM_DEVICE_RUNTIME
 	  usage even while the CPU or system is running.
 
 if PM_DEVICE_RUNTIME
+config PM_DEVICE_RUNTIME_ASYNC
+	bool "Enable support for async operation"
+	default y
+	help
+	  Use this option to enable support for asynchronous operation
+	  in the power management device runtime.
+
+if PM_DEVICE_RUNTIME_ASYNC
 config PM_DEVICE_RUNTIME_WQ_STACK_SIZE
 	int "Stack size for pm runtime async workqueue"
 	default 1024
@@ -119,6 +127,7 @@ config PM_DEVICE_RUNTIME_WQ_INIT_PRIO
 	default 50
 	help
 	  Init priority level to setup the device runtime workqueue.
+endif # PM_DEVICE_RUNTIME_ASYNC
 endif # PM_DEVICE_RUNTIME
 
 config PM_DEVICE_SHELL

subsys/pm/device_runtime.c

@@ -20,8 +20,10 @@ LOG_MODULE_DECLARE(pm_device, CONFIG_PM_DEVICE_LOG_LEVEL);
 #define PM_DOMAIN(_pm) NULL
 #endif
 
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 K_THREAD_STACK_DEFINE(pm_device_runtime_stack, CONFIG_PM_DEVICE_RUNTIME_WQ_STACK_SIZE);
 static struct k_work_q pm_device_runtime_wq;
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 
 #define EVENT_STATE_ACTIVE	BIT(PM_DEVICE_STATE_ACTIVE)
 #define EVENT_STATE_SUSPENDED	BIT(PM_DEVICE_STATE_SUSPENDED)
@@ -82,8 +84,10 @@ static int runtime_suspend(const struct device *dev, bool async,
 
 	if (async) {
 		/* queue suspend */
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 		pm->base.state = PM_DEVICE_STATE_SUSPENDING;
 		(void)k_work_schedule_for_queue(&pm_device_runtime_wq, &pm->work, delay);
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 	} else {
 		/* suspend now */
 		ret = pm->base.action_cb(pm->dev, PM_DEVICE_ACTION_SUSPEND);
@@ -103,6 +107,7 @@ static int runtime_suspend(const struct device *dev, bool async,
 	return ret;
 }
 
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 static void runtime_suspend_work(struct k_work *work)
 {
 	int ret;
@@ -132,6 +137,7 @@ static void runtime_suspend_work(struct k_work *work)
 
 	__ASSERT(ret == 0, "Could not suspend device (%d)", ret);
 }
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 
 static int get_sync_locked(const struct device *dev)
 {
@@ -229,6 +235,7 @@ int pm_device_runtime_get(const struct device *dev)
 
 	pm->base.usage++;
 
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 	/*
 	 * Check if the device has a pending suspend operation (not started
 	 * yet) and cancel it. This way we avoid unnecessary operations because
@@ -254,6 +261,7 @@ int pm_device_runtime_get(const struct device *dev)
 			(void)k_sem_take(&pm->lock, K_FOREVER);
 		}
 	}
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 
 	if (pm->base.usage > 1U) {
 		goto unlock;
@@ -352,6 +360,7 @@ int pm_device_runtime_put(const struct device *dev)
 
 int pm_device_runtime_put_async(const struct device *dev, k_timeout_t delay)
 {
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 	int ret;
 
 	if (dev->pm_base == NULL) {
@@ -372,6 +381,9 @@ int pm_device_runtime_put_async(const struct device *dev, k_timeout_t delay)
 	SYS_PORT_TRACING_FUNC_EXIT(pm, device_runtime_put_async, dev, delay, ret);
 
 	return ret;
+#else
+	return -ENOSYS;
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 }
 
 __boot_func
@@ -443,7 +455,9 @@ int pm_device_runtime_enable(const struct device *dev)
 	/* lazy init of PM fields */
 	if (pm->dev == NULL) {
 		pm->dev = dev;
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 		k_work_init_delayable(&pm->work, runtime_suspend_work);
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 	}
 
 	if (pm->base.state == PM_DEVICE_STATE_ACTIVE) {
@@ -516,6 +530,7 @@ int pm_device_runtime_disable(const struct device *dev)
 		(void)k_sem_take(&pm->lock, K_FOREVER);
 	}
 
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 	if (!k_is_pre_kernel()) {
 		if ((pm->base.state == PM_DEVICE_STATE_SUSPENDING) &&
 			((k_work_cancel_delayable(&pm->work) & K_WORK_RUNNING) == 0)) {
@@ -533,6 +548,7 @@ int pm_device_runtime_disable(const struct device *dev)
 			(void)k_sem_take(&pm->lock, K_FOREVER);
 		}
 	}
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 
 	/* wake up the device if suspended */
 	if (pm->base.state == PM_DEVICE_STATE_SUSPENDED) {
@@ -543,8 +559,9 @@ int pm_device_runtime_disable(const struct device *dev)
 
 		pm->base.state = PM_DEVICE_STATE_ACTIVE;
 	}
-
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 clear_bit:
+#endif
 	atomic_clear_bit(&pm->base.flags, PM_DEVICE_FLAG_RUNTIME_ENABLED);
 
 unlock:
@@ -574,6 +591,8 @@ int pm_device_runtime_usage(const struct device *dev)
 	return dev->pm_base->usage;
 }
 
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
+
 static int pm_device_runtime_wq_init(void)
 {
 	const struct k_work_queue_config cfg = {.name = "PM DEVICE RUNTIME WQ"};
@@ -588,3 +607,5 @@ static int pm_device_runtime_wq_init(void)
 }
 
 SYS_INIT(pm_device_runtime_wq_init, POST_KERNEL, CONFIG_PM_DEVICE_RUNTIME_WQ_INIT_PRIO);
+
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */

tests/subsys/pm/device_runtime_api/src/main.c

@@ -10,7 +10,10 @@
 
 #include "test_driver.h"
 
+
 static const struct device *test_dev;
+
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 static struct k_thread get_runner_td;
 K_THREAD_STACK_DEFINE(get_runner_stack, 1024);
 
@@ -31,6 +34,7 @@ static void get_runner(void *arg1, void *arg2, void *arg3)
 	ret = pm_device_runtime_get(test_dev);
 	zassert_equal(ret, 0);
 }
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 
 void test_api_setup(void *data)
 {
@@ -43,7 +47,11 @@ void test_api_setup(void *data)
 	ret = pm_device_runtime_put(test_dev);
 	zassert_equal(ret, 0);
 	ret = pm_device_runtime_put_async(test_dev, K_NO_WAIT);
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 	zassert_equal(ret, 0);
+#else
+	zassert_equal(ret, -ENOSYS);
+#endif
 
 	/* enable runtime PM */
 	ret = pm_device_runtime_enable(test_dev);
@@ -130,6 +138,7 @@ ZTEST(device_runtime_api, test_api)
 	zassert_equal(ret, -EALREADY);
 	zassert_equal(pm_device_runtime_usage(test_dev), 0);
 
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
 	/*** get + asynchronous put until suspended ***/
 
 	/* usage: 0, +1, resume: yes */
@@ -259,6 +268,7 @@ ZTEST(device_runtime_api, test_api)
 	ret = pm_device_runtime_disable(test_dev);
 	zassert_equal(ret, 0);
 	zassert_equal(pm_device_runtime_usage(test_dev), -ENOTSUP);
+#endif /* CONFIG_PM_DEVICE_RUNTIME_ASYNC */
 }
 
 DEVICE_DEFINE(pm_unsupported_device, "PM Unsupported", NULL, NULL, NULL, NULL,
@@ -273,7 +283,11 @@ ZTEST(device_runtime_api, test_unsupported)
 	zassert_equal(pm_device_runtime_disable(dev), -ENOTSUP, "");
 	zassert_equal(pm_device_runtime_get(dev), 0, "");
 	zassert_equal(pm_device_runtime_put(dev), 0, "");
-	zassert_false(pm_device_runtime_put_async(dev, K_NO_WAIT),  "");
+#ifdef CONFIG_PM_DEVICE_RUNTIME_ASYNC
+	zassert_equal(pm_device_runtime_put_async(dev, K_NO_WAIT), 0, "");
+#else
+	zassert_equal(pm_device_runtime_put_async(dev, K_NO_WAIT), -ENOSYS, "");
+#endif
 }
 
 int dev_pm_control(const struct device *dev, enum pm_device_action action)

tests/subsys/pm/device_runtime_api/testcase.yaml

@@ -10,3 +10,8 @@ tests:
     - native_sim
     extra_configs:
     - CONFIG_TEST_PM_DEVICE_ISR_SAFE=y
+  pm.device_runtime.async_disabled.api:
+    platform_allow:
+    - native_sim
+    extra_configs:
+    - CONFIG_PM_DEVICE_RUNTIME_ASYNC=n