edf_schedule: implement the new version of EDF scheduler

This patch implements the new version of EDF scheduler.
This is the first basic implementation, which can be easily extended
in the future.

Previous implementation had two major flaws:
- Tasks could only be preempted based on the interrupt level on which
they have been scheduled, so it was limited based on the hardware.
- This led to the system not fully utilized, so we could never achieve
full EDF functionality.

The new implementation uses only one software interrupt and allows for
dynamic context switching between different tasks based on the deadline.
Also for some cases priority is taken into consideration e.g. for idle
and almost idle tasks, which don't have deadline at all and should be
executed only if the system is free. All other normal tasks should have
the same priority. Task chosen to be run is executed on passive level,
so automatically can be preempted by every interrupt. Every task has
its own private stack on which current context is saved and restored
if needed. Note that main firmware loop is task scheduled with
idle priority, so it will be executed only after every other task
is completed.

Signed-off-by: Tomasz Lauda <tomasz.lauda@linux.intel.com>

Author: tlauda

Kconfig

@@ -38,14 +38,6 @@ config HOST_PTABLE
 	bool
 	default n
 
-config TASK_HAVE_PRIORITY_MEDIUM
-	bool
-	default n
-
-config TASK_HAVE_PRIORITY_LOW
-	bool
-	default n
-
 config BOOT_LOADER
 	bool
 	default n

src/arch/host/include/arch/schedule/task.h

@@ -16,25 +16,6 @@
 #ifndef __ARCH_SCHEDULE_TASK_H__
 #define __ARCH_SCHEDULE_TASK_H__
 
-struct task;
-
-/**
- * \brief Allocates IRQ tasks.
- */
-static inline int arch_allocate_tasks(void)
-{
-	return 0;
-}
-
-/**
- * \brief Runs task.
- * \param[in,out] task Task data.
- */
-static inline int arch_run_task(struct task *task)
-{
-	return 0;
-}
-
 #endif /* __ARCH_SCHEDULE_TASK_H__ */
 
 #else

src/arch/xtensa/drivers/idc.c

@@ -18,6 +18,7 @@
 #include <sof/lib/notifier.h>
 #include <sof/lib/shim.h>
 #include <sof/platform.h>
+#include <sof/schedule/edf_schedule.h>
 #include <sof/schedule/schedule.h>
 #include <sof/schedule/task.h>
 #include <ipc/control.h>
@@ -166,6 +167,8 @@ static int idc_pipeline_trigger(uint32_t cmd)
 	struct ipc *ipc = cache_to_uncache(_ipc);
 	struct sof_ipc_stream *data = ipc->comp_data;
 	struct ipc_comp_dev *pcm_dev;
+	struct edf_task_pdata *edf_pdata;
+	struct task *task;
 	int ret;
 
 	/* invalidate stream data */
@@ -183,6 +186,17 @@ static int idc_pipeline_trigger(uint32_t cmd)
 
 		pipeline_cache(pcm_dev->cd->pipeline,
 			       pcm_dev->cd, CACHE_INVALIDATE);
+
+		/* TODO: Temporary W/A for task sharing between cores.
+		 * Should be removed after changing memory management for
+		 * slave cores.
+		 */
+		if (pcm_dev->cd->pipeline->pipe_task.type == SOF_SCHEDULE_EDF) {
+			task = &pcm_dev->cd->pipeline->pipe_task;
+			edf_pdata = edf_sch_get_pdata(task);
+			dcache_invalidate_region(edf_pdata, sizeof(*edf_pdata));
+			task_context_cache(edf_pdata->ctx, CACHE_INVALIDATE);
+		}
 	}
 
 	/* check whether we are executing from the right core */
@@ -193,9 +207,22 @@ static int idc_pipeline_trigger(uint32_t cmd)
 	ret = pipeline_trigger(pcm_dev->cd->pipeline, pcm_dev->cd, cmd);
 
 	/* writeback pipeline on stop */
-	if (cmd == COMP_TRIGGER_STOP)
+	if (cmd == COMP_TRIGGER_STOP) {
+		/* TODO: Temporary W/A for task sharing between cores.
+		 * Should be removed after changing memory management for
+		 * slave cores.
+		 */
+		if (pcm_dev->cd->pipeline->pipe_task.type == SOF_SCHEDULE_EDF) {
+			task = &pcm_dev->cd->pipeline->pipe_task;
+			edf_pdata = edf_sch_get_pdata(task);
+			task_context_cache(edf_pdata->ctx, CACHE_WRITEBACK_INV);
+			dcache_writeback_invalidate_region(edf_pdata,
+							   sizeof(*edf_pdata));
+		}
+
 		pipeline_cache(pcm_dev->cd->pipeline,
 			       pcm_dev->cd, CACHE_WRITEBACK_INV);
+	}
 
 	return ret;
 }

src/arch/xtensa/include/arch/schedule/task.h

@@ -3,75 +3,59 @@
  * Copyright(c) 2017 Intel Corporation. All rights reserved.
  *
  * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
+ *         Tomasz Lauda <tomasz.lauda@linux.intel.com>
  */
 
 /**
  * \file arch/xtensa/include/arch/schedule/task.h
  * \brief Arch task header file
  * \authors Liam Girdwood <liam.r.girdwood@linux.intel.com>
+ *          Tomasz Lauda <tomasz.lauda@linux.intel.com>
  */
 
 #ifdef __SOF_SCHEDULE_TASK_H__
 
 #ifndef __ARCH_SCHEDULE_TASK_H__
 #define __ARCH_SCHEDULE_TASK_H__
 
-#include <sof/list.h>
-#include <config.h>
-
-/** \brief IRQ task data. */
-struct irq_task {
-	struct list_item list;	/**< list of tasks */
-	int irq;		/**< IRQ level */
-};
-
-struct sof;
 struct task;
 
-#if CONFIG_SMP
-
-/**
- * \brief Starts slave core main task.
- * \param[in,out] sof Main context.
- * \return Error code.
- */
-int do_task_slave_core(struct sof *sof);
-
-#endif
-
 /**
- * \brief Returns IRQ low task data.
- * \return Pointer to pointer of IRQ low task data.
+ * \brief Returns main task data.
+ * \return Pointer to pointer of main task data.
  */
-struct irq_task **task_irq_low_get(void);
+struct task **task_main_get(void);
 
 /**
- * \brief Returns IRQ medium task data.
- * \return Pointer to pointer of IRQ medium task data.
+ * \brief Returns current system context.
  */
-struct irq_task **task_irq_med_get(void);
+volatile void *task_context_get(void);
 
 /**
- * \brief Returns IRQ high task data.
- * \return Pointer to pointer of IRQ high task data.
+ * \brief Switches system context.
+ * \param[in,out] task Task context to be set.
  */
-struct irq_task **task_irq_high_get(void);
+void task_context_set(void *task_ctx);
 
 /**
- * \brief Runs task.
- * \param[in,out] task Task data.
+ * \brief Initializes task context.
+ * \param[in,out] task Task with context to be initialized.
+ * \param[in,out] entry Entry point for task execution.
  */
-int arch_run_task(struct task *task);
+int task_context_init(struct task *task, void *entry);
 
 /**
- * \brief Allocates IRQ tasks.
+ * \brief Frees task context.
+ * \param[in,out] task Task with context to be freed.
  */
-int arch_allocate_tasks(void);
+void task_context_free(struct task *task);
 
 /**
- * \brief Frees IRQ tasks.
+ * \brief Performs cache operation on task's context.
+ * \param[in,out] task_ctx Context to be wtb/inv.
+ * \param[in] cmd Cache operation to be performed.
  */
-void arch_free_tasks(void);
+void task_context_cache(void *task_ctx, int cmd);
 
 #endif /* __ARCH_SCHEDULE_TASK_H__ */
 

src/arch/xtensa/include/arch/sof.h

@@ -11,6 +11,10 @@
 #ifndef __ARCH_SOF_H__
 #define __ARCH_SOF_H__
 
+#include <sof/schedule/task.h>
+#include <xtensa/xtruntime-frames.h>
+#include <stdint.h>
+
 /* entry point to main firmware */
 void _ResetVector(void);
 
@@ -28,6 +32,20 @@ static inline void *arch_get_stack_ptr(void)
 	return ptr;
 }
 
+static inline void *arch_get_stack_entry(void)
+{
+	volatile xtos_task_context *task_ctx = task_context_get();
+
+	return task_ctx->stack_base;
+}
+
+static inline uint32_t arch_get_stack_size(void)
+{
+	volatile xtos_task_context *task_ctx = task_context_get();
+
+	return task_ctx->stack_size;
+}
+
 #endif /* __ARCH_SOF_H__ */
 
 #else

src/arch/xtensa/init.c

@@ -130,8 +130,8 @@ int slave_core_init(struct sof *sof)
 
 	trace_point(TRACE_BOOT_PLATFORM);
 
-	/* should not return */
-	err = do_task_slave_core(sof);
+	/* task initialized in edf_scheduler_init */
+	schedule_task(*task_main_get(), 0, UINT64_MAX);
 
 	return err;
 }