schedule: zephyr_ll: add user_ll_lock/unlock_sched()

Add new functions to lock/unlock the LL scheduler for a given
core. This is intended for audio application code that needs
to modify the audio pipelines and needs an interface to
get exclusive access to the pipelines on a particular core.

This interface is specific to SOF builds with CONFIG_SOF_USERSPACE_LL.
If LL scheduler is running in kernel space, there is option
to disable interrupts for similar effect. For now these code
paths are kept separate.

Signed-off-by: Kai Vehmanen <kai.vehmanen@linux.intel.com>

Author: kv2019i

src/include/sof/schedule/ll_schedule_domain.h

@@ -120,6 +120,8 @@ struct task *zephyr_ll_task_alloc(void);
 struct k_heap *zephyr_ll_user_heap(void);
 bool zephyr_ll_user_heap_verify(struct k_heap *heap);
 void zephyr_ll_user_resources_init(void);
+void user_ll_lock_sched(int core);
+void user_ll_unlock_sched(int core);
 #endif /* CONFIG_SOF_USERSPACE_LL */
 
 static inline struct ll_schedule_domain *domain_init

src/schedule/zephyr_ll.c

@@ -44,6 +44,15 @@ struct zephyr_ll_pdata {
 	struct k_sem sem;
 };
 
+#if CONFIG_SOF_USERSPACE_LL
+/*
+ * Mutex pointer in user-accessible partition so user-space threads
+ * can read the pointer for syscalls. The actual lock object resides
+ * in kernel memory, there are just handles!
+ */
+static APP_SYSUSER_BSS struct k_mutex *zephyr_ll_locks[CONFIG_CORE_COUNT];
+#endif
+
 static void zephyr_ll_lock(struct zephyr_ll *sch, uint32_t *flags)
 {
 #if CONFIG_SOF_USERSPACE_LL
@@ -561,6 +570,31 @@ struct task *zephyr_ll_task_alloc(void)
 
 	return task;
 }
+
+/**
+ * Lock the LL scheduler to prevent it from processing tasks.
+ *
+ * Uses the LL scheduler's own k_mutex which is re-entrant, so
+ * schedule_task() calls within the locked section will not deadlock.
+ * Must be paired with user_ll_unlock_sched().
+ */
+void user_ll_lock_sched(int core)
+{
+	assert(core < CONFIG_CORE_COUNT && zephyr_ll_locks[core] != NULL);
+	int __maybe_unused ret = k_mutex_lock(zephyr_ll_locks[core], K_FOREVER);
+	assert(!ret);
+}
+
+/**
+ * Unlock the LL scheduler after a previous user_ll_lock_sched() call.
+ */
+void user_ll_unlock_sched(int core)
+{
+	assert(core < CONFIG_CORE_COUNT && zephyr_ll_locks[core] != NULL);
+	int __maybe_unused ret = k_mutex_unlock(zephyr_ll_locks[core]);
+	assert(!ret);
+}
+
 #endif /* CONFIG_SOF_USERSPACE_LL */
 
 int zephyr_ll_task_init(struct task *task,
@@ -649,6 +683,8 @@ __cold int zephyr_ll_scheduler_init(struct ll_schedule_domain *domain)
 		sof_heap_free(sch->heap, sch);
 		return -ENOMEM;
 	}
+	assert(core < CONFIG_CORE_COUNT && zephyr_ll_locks[core] == NULL);
+	zephyr_ll_locks[core] = sch->lock;
 	k_mutex_init(sch->lock);
 
 	tr_dbg(&ll_tr, "ll-scheduler init done, sch %p sch->lock %p", sch, sch->lock);