audio: pipeline: use LL scheduler mutex for userspace pipeline triggers

In CONFIG_SOF_USERSPACE_LL builds, irq_local_disable() is not
available. Replace the no-op irq guard with the LL scheduler's own
k_mutex to prevent the scheduler from processing tasks while pipeline
state is being updated. The k_mutex is re-entrant so schedule_task()
calls inside the critical section are safe.

Add zephyr_ll_lock_sched() and zephyr_ll_unlock_sched() helpers that
acquire and release the scheduler mutex, and call them from
pipeline_schedule_triggered() under CONFIG_SOF_USERSPACE_LL.

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

Author: kv2019i

src/audio/pipeline/pipeline-schedule.c

@@ -13,6 +13,7 @@
 #include <sof/lib/agent.h>
 #include <sof/list.h>
 #include <sof/schedule/ll_schedule.h>
+#include <sof/schedule/ll_schedule_domain.h>
 #include <sof/schedule/dp_schedule.h>
 #include <sof/schedule/schedule.h>
 #include <sof/audio/module_adapter/module/generic.h>
@@ -282,6 +283,16 @@ void pipeline_schedule_triggered(struct pipeline_walk_context *ctx,
 	struct pipeline_data *ppl_data = ctx->comp_data;
 	struct list_item *tlist;
 	struct pipeline *p;
+
+#ifdef CONFIG_SOF_USERSPACE_LL
+	/*
+	 * In user-space irq_local_disable() is not available. Use the LL
+	 * scheduler mutex to prevent the scheduler from processing tasks
+	 * while pipeline state is being updated. The k_mutex is re-entrant
+	 * so schedule_task() calls inside the critical section are safe.
+	 */
+	zephyr_ll_lock_sched();
+#else
 	uint32_t flags;
 
 	/*
@@ -290,6 +301,7 @@ void pipeline_schedule_triggered(struct pipeline_walk_context *ctx,
 	 * immediately before all pipelines achieved a consistent state.
 	 */
 	irq_local_disable(flags);
+#endif
 
 	switch (cmd) {
 	case COMP_TRIGGER_PAUSE:
@@ -345,8 +357,11 @@ void pipeline_schedule_triggered(struct pipeline_walk_context *ctx,
 				p->xrun_bytes = 1;
 		}
 	}
-
+#ifdef CONFIG_SOF_USERSPACE_LL
+	zephyr_ll_unlock_sched();
+#else
 	irq_local_enable(flags);
+#endif
 }
 
 int pipeline_comp_ll_task_init(struct pipeline *p)

src/include/sof/schedule/ll_schedule_domain.h

@@ -117,6 +117,8 @@ void zephyr_ll_task_free(struct task *task);
 struct k_heap *zephyr_ll_user_heap(void);
 void zephyr_ll_user_resources_init(void);
 void zephyr_ll_grant_access(struct k_thread *thread);
+void zephyr_ll_lock_sched(void);
+void zephyr_ll_unlock_sched(void);
 #endif /* CONFIG_SOF_USERSPACE_LL */
 
 static inline struct ll_schedule_domain *domain_init

src/schedule/zephyr_ll.c

@@ -578,6 +578,30 @@ void zephyr_ll_grant_access(struct k_thread *thread)
 	k_thread_access_grant(thread, ll_sch->lock);
 }
 
+/**
+ * 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 zephyr_ll_unlock_sched().
+ */
+void zephyr_ll_lock_sched(void)
+{
+	struct zephyr_ll *sch = (struct zephyr_ll *)scheduler_get_data(SOF_SCHEDULE_LL_TIMER);
+
+	k_mutex_lock(sch->lock, K_FOREVER);
+}
+
+/**
+ * Unlock the LL scheduler after a previous zephyr_ll_lock_sched() call.
+ */
+void zephyr_ll_unlock_sched(void)
+{
+	struct zephyr_ll *sch = (struct zephyr_ll *)scheduler_get_data(SOF_SCHEDULE_LL_TIMER);
+
+	k_mutex_unlock(sch->lock);
+}
+
 #endif /* CONFIG_SOF_USERSPACE_LL */
 
 int zephyr_ll_task_init(struct task *task,