scheduling: add Data Processing scheduler type

The DP scheduler is a scheduler based on Zephyr preemptible
threads. It will start each SOF task as a separate Zephyr
thread.
At current implementation the scheduler can trigger each
task/thread periodically or on demand.
TODO: more sophisticated scheduling decisions, with deadline
and task budgets calculations.

Signed-off-by: Marcin Szkudlinski <marcin.szkudlinski@intel.com>

Author: marcinszkudlinski

src/include/sof/schedule/dp_schedule.h

@@ -0,0 +1,94 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Copyright(c) 2023 Intel Corporation. All rights reserved.
+ *
+ * Author: Marcin Szkudlinski
+ */
+
+#ifndef __SOF_SCHEDULE_DP_SCHEDULE_H__
+#define __SOF_SCHEDULE_DP_SCHEDULE_H__
+
+#include <rtos/task.h>
+#include <sof/trace/trace.h>
+#include <user/trace.h>
+#include <stdint.h>
+
+/**
+ *
+ * DP scheduler is a scheduler that creates a separate preemptible Zephyr thread for each SOF task
+ *   There's only one instance of DP in the system, however, threads can be assigned and pinned
+ *   to any core in the system for its execution, there's no SMP processing.
+ *
+ * The task execution may be delayed and task may be re-scheduled periodically
+ * NOTE: delayed start and rescheduling takes place in sync with LL scheduler, meaning the
+ *   DP scheduler is triggered as the last task of LL running on a primary core.
+ *   That implies a limitation: LL scheduler MUST be running on primary core in order to have
+ *   this feature working.
+ *   It is fine, because rescheduling is a feature used for data processing when a pipeline is
+ *   running.
+ *
+ * Other possible usage of DP scheduler is to schedule task with DP_SCHEDULER_RUN_TASK_IMMEDIATELY
+ *   as start parameter. It will force the task to work without any delays and async to LL.
+ *   This kind of scheduling may be used for staring regular zephyr tasks using SOF api
+ *
+ * Task run() may return:
+ *  SOF_TASK_STATE_RESCHEDULE - the task will be rescheduled as specified in scheduler period
+ *				note that task won't ever be rescheduled if LL is not running
+ *  SOF_TASK_STATE_COMPLETED  - the task will be removed from scheduling,
+ *				calling schedule_task will add the task to processing again
+ *				task_complete() will be called
+ *  SOF_TASK_STATE_CANCEL     - the task will be removed from scheduling,
+ *				calling schedule_task will add the task to processing again
+ *				task_complete() won't be called
+ *  other statuses - assert will go off
+ *
+ * NOTE: task - means a SOF task
+ *	 thread - means a Zephyr preemptible thread
+ *
+ * TODO  - EDF:
+ * Threads run on the same priority, lower than thread running LL tasks. Zephyr EDF mechanism
+ * is used for decision which thread/task is to be scheduled next. The DP scheduler calculates
+ * the task deadline and set it in Zephyr thread properties, the final scheduling decision is made
+ * by Zephyr.
+ *
+ * Each time tick the scheduler iterates through the list of all active tasks and calculates
+ * a deadline based on
+ *  - knowledge how the modules are bound
+ *  - declared time required by a task to complete processing
+ *  - the deadline of the last module
+ *
+ */
+
+/** \brief tell the scheduler to run the task immediately, even if LL tick is not yet running */
+#define SCHEDULER_DP_RUN_TASK_IMMEDIATELY ((uint64_t)-1)
+
+/**
+ * \brief Init the Data Processing scheduler
+ */
+int scheduler_dp_init(void);
+
+/**
+ * \brief Set the Data Processing scheduler to be accessible at secondary cores
+ */
+int scheduler_dp_init_secondary_core(void);
+
+/**
+ * \brief initialize a DP task and add it to scheduling
+ *
+ * \param[out] task pointer, pointer to allocated task structure will be return
+ * \param[in] uid pointer to UUID of the task
+ * \param[in] ops pointer to task functions
+ * \param[in] data pointer to the thread private data
+ * \param[in] core CPU the thread should run on
+ * \param[in] stack_size size of stack for a zephyr task
+ * \param[in] task_priority priority of the zephyr task
+ */
+int scheduler_dp_task_init(struct task **task,
+			   const struct sof_uuid_entry *uid,
+			   const struct task_ops *ops,
+			   void *data,
+			   uint16_t core,
+			   size_t stack_size,
+			   uint32_t task_priority);
+
+#endif /* __SOF_SCHEDULE_DP_SCHEDULE_H__ */

src/include/sof/schedule/schedule.h

@@ -31,14 +31,19 @@ enum {
 	SOF_SCHEDULE_LL_DMA,	/**< Low latency DMA, schedules immediately
 				  *  on scheduling component's DMA interrupt
 				  */
+	SOF_SCHEDULE_DP,	/**< DataProcessing scheduler
+				  *  Scheduler based on Zephyr peemptive threads
+				  *  TODO: DP will become the Zephyr EDF scheduler type
+				  *  and will be unified with SOF_SCHEDULE_EDF for Zephyr builds
+				  *  current implementation of Zephyr based EDF is depreciated now
+				  */
 	SOF_SCHEDULE_COUNT	/**< indicates number of scheduler types */
 };
 
 /** \brief Scheduler free available flags */
 #define SOF_SCHEDULER_FREE_IRQ_ONLY	BIT(0) /**< Free function disables only
 						 *  interrupts
 						 */
-
 /**
  * Scheduler operations.
  *

src/init/init.c

@@ -26,6 +26,7 @@
 #include <rtos/idc.h>
 #include <sof/schedule/schedule.h>
 #include <sof/schedule/edf_schedule.h>
+#include <sof/schedule/dp_schedule.h>
 #include <sof/schedule/ll_schedule.h>
 #include <sof/schedule/ll_schedule_domain.h>
 #include <ipc/trace.h>
@@ -183,6 +184,12 @@ int secondary_core_init(struct sof *sof)
 	if (dma_domain)
 		scheduler_init_ll(dma_domain);
 
+#if CONFIG_ZEPHYR_DP_SCHEDULER
+	err = scheduler_dp_init_secondary_core();
+	if (err < 0)
+		return err;
+#endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
+
 	/* initialize IDC mechanism */
 	trace_point(TRACE_BOOT_PLATFORM_IDC);
 	err = idc_init();

src/platform/intel/ace/platform.c

@@ -15,6 +15,7 @@
 #include <sof/lib/mm_heap.h>
 #include <sof/lib/watchdog.h>
 #include <sof/schedule/edf_schedule.h>
+#include <sof/schedule/dp_schedule.h>
 #include <sof/schedule/ll_schedule.h>
 #include <sof/schedule/ll_schedule_domain.h>
 #include <sof/trace/trace.h>
@@ -84,9 +85,17 @@ int platform_init(struct sof *sof)
 	trace_point(TRACE_BOOT_PLATFORM_SCHED);
 	scheduler_init_edf();
 
-	/* init low latency timer domain and scheduler */
+	/* init low latency timer domain and scheduler. Any failure is fatal */
 	sof->platform_timer_domain = zephyr_domain_init(PLATFORM_DEFAULT_CLOCK);
-	scheduler_init_ll(sof->platform_timer_domain);
+	ret = scheduler_init_ll(sof->platform_timer_domain);
+	if (ret < 0)
+		return ret;
+
+#if CONFIG_ZEPHYR_DP_SCHEDULER
+	ret = scheduler_dp_init();
+	if (ret < 0)
+		return ret;
+#endif /* CONFIG_ZEPHYR_DP_SCHEDULER */
 
 	/* init the system agent */
 	trace_point(TRACE_BOOT_PLATFORM_AGENT);