[DRAFT] userspace LL/audio test PR

posix/include/rtos/alloc.h

@@ -97,29 +97,6 @@ static inline void *rballoc(uint32_t flags, size_t bytes)
 	return rballoc_align(flags, bytes, PLATFORM_DCACHE_ALIGN);
 }
 
-/**
- * Changes size of the memory block allocated.
- * @param ptr Address of the block to resize.
- * @param flags Flags, see SOF_MEM_FLAG_...
- * @param bytes New size in bytes.
- * @param old_bytes Old size in bytes.
- * @param alignment Alignment in bytes.
- * @return Pointer to the resized memory of NULL if failed.
- */
-void *rbrealloc_align(void *ptr, uint32_t flags, size_t bytes,
-		      size_t old_bytes, uint32_t alignment);
-
-/**
- * Similar to rballoc_align(), returns resized buffer aligned to
- * PLATFORM_DCACHE_ALIGN.
- */
-static inline void *rbrealloc(void *ptr, uint32_t flags,
-			      size_t bytes, size_t old_bytes)
-{
-	return rbrealloc_align(ptr, flags, bytes, old_bytes,
-			       PLATFORM_DCACHE_ALIGN);
-}
-
 /**
  * Frees the memory block.
  * @param ptr Pointer to the memory block.
@@ -141,6 +118,7 @@ void *sof_heap_alloc(struct k_heap *heap, uint32_t flags, size_t bytes,
 		     size_t alignment);
 void sof_heap_free(struct k_heap *heap, void *addr);
 struct k_heap *sof_sys_heap_get(void);
+struct k_heap *sof_sys_user_heap_get(void);
 
 /**
  * Calculates length of the null-terminated string.

posix/include/rtos/mutex.h

@@ -40,4 +40,26 @@ static inline int k_mutex_unlock(struct k_mutex *mutex)
 	return 0;
 }
 
+/* provide a no-op implementation for zephyr/sys/mutex.h */
+
+struct sys_mutex {
+};
+
+#define SYS_MUTEX_DEFINE(name) \
+	struct sys_mutex name
+
+static inline void sys_mutex_init(struct sys_mutex *mutex)
+{
+}
+
+static inline int sys_mutex_lock(struct sys_mutex *mutex, k_timeout_t timeout)
+{
+	return 0;
+}
+
+static inline int sys_mutex_unlock(struct sys_mutex *mutex)
+{
+	return 0;
+}
+
 #endif

posix/include/rtos/sof.h

@@ -110,11 +110,6 @@ struct sof {
 	struct ext_library *ext_library;
 #endif
 
-#if CONFIG_IPC_MAJOR_4
-	/* lock for fw_reg access */
-	struct k_spinlock fw_reg_lock;
-#endif
-
 	__aligned(PLATFORM_DCACHE_ALIGN) int alignment[0];
 } __aligned(PLATFORM_DCACHE_ALIGN);
 

posix/include/sof/lib/dma.h

@@ -35,6 +35,7 @@
 
 struct comp_buffer;
 struct comp_dev;
+struct k_heap;
 
 /** \addtogroup sof_dma_drivers DMA Drivers
  *  DMA Drivers API specification.
@@ -511,13 +512,14 @@ static inline void dma_sg_init(struct dma_sg_elem_array *ea)
 	ea->elems = NULL;
 }
 
-int dma_sg_alloc(struct dma_sg_elem_array *ea,
+int dma_sg_alloc(struct k_heap *heap,
+		 struct dma_sg_elem_array *ea,
 		 uint32_t flags,
 		 uint32_t direction,
 		 uint32_t buffer_count, uint32_t buffer_bytes,
 		 uintptr_t dma_buffer_addr, uintptr_t external_addr);
 
-void dma_sg_free(struct dma_sg_elem_array *ea);
+void dma_sg_free(struct k_heap *heap, struct dma_sg_elem_array *ea);
 
 /**
  * \brief Get the total size of SG buffer

src/audio/Kconfig

@@ -42,6 +42,14 @@ config HOST_DMA_STREAM_SYNCHRONIZATION
 	  for each group, different than the default one determined by the system tick frequency.
 	  This feature will allow host lower power consumption in scenarios with deep buffering.
 
+config HOST_DMA_IPC_POSITION_UPDATES
+	bool "Support for stream position updates via IPC messages"
+	default y if IPC_MAJOR_3
+	help
+	  Support firmware functionality to report stream position updates
+	  by sending a IPC message whenever one period of audio is transfferred.
+	  Most platforms provide more efficient ways to query the DMA status.
+
 config COMP_CHAIN_DMA
 	  bool "Chain DMA component"
 	  depends on IPC_MAJOR_4

src/audio/buffers/comp_buffer.c

@@ -16,7 +16,6 @@
 #include <rtos/interrupt.h>
 #include <rtos/alloc.h>
 #include <rtos/cache.h>
-#include <sof/lib/notifier.h>
 #include <sof/list.h>
 #include <sof/schedule/dp_schedule.h>
 #include <rtos/spinlock.h>
@@ -147,28 +146,17 @@ static void comp_buffer_free(struct sof_audio_buffer *audio_buffer)
 
 	struct comp_buffer *buffer = container_of(audio_buffer, struct comp_buffer, audio_buffer);
 
-	struct buffer_cb_free cb_data = {
-		.buffer = buffer,
-	};
-
 	buf_dbg(buffer, "buffer_free()");
 
-	notifier_event(buffer, NOTIFIER_ID_BUFFER_FREE,
-		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
-
-	/* In case some listeners didn't unregister from buffer's callbacks */
-	notifier_unregister_all(NULL, buffer);
+#if CONFIG_PROBE
+	if (buffer->probe_cb_free)
+		buffer->probe_cb_free(buffer->probe_cb_arg);
+#endif
 
 	struct k_heap *heap = buffer->audio_buffer.heap;
 
-	rfree(buffer->stream.addr);
+	sof_heap_free(heap, buffer->stream.addr);
 	sof_heap_free(heap, buffer);
-	if (heap) {
-		struct dp_heap_user *mod_heap_user = container_of(heap, struct dp_heap_user, heap);
-
-		if (!--mod_heap_user->client_count)
-			rfree(mod_heap_user);
-	}
 }
 
 APP_TASK_DATA static const struct source_ops comp_buffer_source_ops = {
@@ -218,6 +206,7 @@ static struct comp_buffer *buffer_alloc_struct(struct k_heap *heap,
 
 	memset(buffer, 0, sizeof(*buffer));
 
+	buffer->heap = heap;
 	buffer->flags = flags;
 	/* Force channels to 2 for init to prevent bad call to clz in buffer_init_stream */
 	buffer->stream.runtime_stream_params.channels = 2;
@@ -254,7 +243,7 @@ struct comp_buffer *buffer_alloc(struct k_heap *heap, size_t size, uint32_t flag
 		return NULL;
 	}
 
-	stream_addr = rballoc_align(flags, size, align);
+	stream_addr = sof_heap_alloc(heap, flags, size, align);
 	if (!stream_addr) {
 		tr_err(&buffer_tr, "could not alloc size = %zu bytes of flags = 0x%x",
 		       size, flags);
@@ -264,9 +253,11 @@ struct comp_buffer *buffer_alloc(struct k_heap *heap, size_t size, uint32_t flag
 	buffer = buffer_alloc_struct(heap, stream_addr, size, flags, is_shared);
 	if (!buffer) {
 		tr_err(&buffer_tr, "could not alloc buffer structure");
-		rfree(stream_addr);
+		sof_heap_free(heap, stream_addr);
 	}
 
+	buffer->heap = heap;
+
 	return buffer;
 }
 
@@ -292,7 +283,7 @@ struct comp_buffer *buffer_alloc_range(struct k_heap *heap, size_t preferred_siz
 		preferred_size += minimum_size - preferred_size % minimum_size;
 
 	for (size = preferred_size; size >= minimum_size; size -= minimum_size) {
-		stream_addr = rballoc_align(flags, size, align);
+		stream_addr = sof_heap_alloc(heap, flags, size, align);
 		if (stream_addr)
 			break;
 	}
@@ -308,9 +299,11 @@ struct comp_buffer *buffer_alloc_range(struct k_heap *heap, size_t preferred_siz
 	buffer = buffer_alloc_struct(heap, stream_addr, size, flags, is_shared);
 	if (!buffer) {
 		tr_err(&buffer_tr, "could not alloc buffer structure");
-		rfree(stream_addr);
+		sof_heap_free(heap, stream_addr);
 	}
 
+	buffer->heap = heap;
+
 	return buffer;
 }
 
@@ -341,14 +334,8 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size, uint32_t alignmen
 	if (size == audio_stream_get_size(&buffer->stream))
 		return 0;
 
-	if (!alignment)
-		new_ptr = rbrealloc(audio_stream_get_addr(&buffer->stream),
-				    buffer->flags | SOF_MEM_FLAG_NO_COPY,
-				    size, audio_stream_get_size(&buffer->stream));
-	else
-		new_ptr = rbrealloc_align(audio_stream_get_addr(&buffer->stream),
-					  buffer->flags | SOF_MEM_FLAG_NO_COPY, size,
-					  audio_stream_get_size(&buffer->stream), alignment);
+	new_ptr = sof_heap_alloc(buffer->heap, buffer->flags, size, alignment);
+
 	/* we couldn't allocate bigger chunk */
 	if (!new_ptr && size > audio_stream_get_size(&buffer->stream)) {
 		buf_err(buffer, "resize can't alloc %u bytes of flags 0x%x",
@@ -357,8 +344,10 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size, uint32_t alignmen
 	}
 
 	/* use bigger chunk, else just use the old chunk but set smaller */
-	if (new_ptr)
+	if (new_ptr) {
+		sof_heap_free(buffer->heap, audio_stream_get_addr(&buffer->stream));
 		buffer->stream.addr = new_ptr;
+	}
 
 	buffer_init_stream(buffer, size);
 
@@ -389,22 +378,11 @@ int buffer_set_size_range(struct comp_buffer *buffer, size_t preferred_size, siz
 	if (preferred_size == actual_size)
 		return 0;
 
-	if (!alignment) {
-		for (new_size = preferred_size; new_size >= minimum_size;
-		     new_size -= minimum_size) {
-			new_ptr = rbrealloc(ptr, buffer->flags | SOF_MEM_FLAG_NO_COPY,
-					    new_size, actual_size);
-			if (new_ptr)
-				break;
-		}
-	} else {
-		for (new_size = preferred_size; new_size >= minimum_size;
-		     new_size -= minimum_size) {
-			new_ptr = rbrealloc_align(ptr, buffer->flags | SOF_MEM_FLAG_NO_COPY,
-						  new_size, actual_size, alignment);
-			if (new_ptr)
-				break;
-		}
+	for (new_size = preferred_size; new_size >= minimum_size;
+	     new_size -= minimum_size) {
+		new_ptr = sof_heap_alloc(buffer->heap, buffer->flags, new_size, alignment);
+		if (new_ptr)
+			break;
 	}
 
 	/* we couldn't allocate bigger chunk */
@@ -415,8 +393,10 @@ int buffer_set_size_range(struct comp_buffer *buffer, size_t preferred_size, siz
 	}
 
 	/* use bigger chunk, else just use the old chunk but set smaller */
-	if (new_ptr)
+	if (new_ptr) {
+		sof_heap_free(buffer->heap, audio_stream_get_addr(&buffer->stream));
 		buffer->stream.addr = new_ptr;
+	}
 
 	buffer_init_stream(buffer, new_size);
 
@@ -478,12 +458,6 @@ bool buffer_params_match(struct comp_buffer *buffer,
 
 void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 {
-	struct buffer_cb_transact cb_data = {
-		.buffer = buffer,
-		.transaction_amount = bytes,
-		.transaction_begin_address = audio_stream_get_wptr(&buffer->stream),
-	};
-
 	/* return if no bytes */
 	if (!bytes) {
 #if CONFIG_SOF_LOG_DBG_BUFFER
@@ -499,10 +473,19 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 		return;
 	}
 
-	audio_stream_produce(&buffer->stream, bytes);
+#if CONFIG_PROBE
+	if (buffer->probe_cb_produce) {
+		struct buffer_cb_transact cb_data = {
+			.buffer = buffer,
+			.transaction_amount = bytes,
+			.transaction_begin_address = audio_stream_get_wptr(&buffer->stream),
+		};
 
-	notifier_event(buffer, NOTIFIER_ID_BUFFER_PRODUCE,
-		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
+		buffer->probe_cb_produce(buffer->probe_cb_arg, &cb_data);
+	}
+#endif
+
+	audio_stream_produce(&buffer->stream, bytes);
 
 #if CONFIG_SOF_LOG_DBG_BUFFER
 	buf_dbg(buffer, "((buffer->avail << 16) | buffer->free) = %08x, ((buffer->id << 16) | buffer->size) = %08x",
@@ -519,12 +502,6 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 
 void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
 {
-	struct buffer_cb_transact cb_data = {
-		.buffer = buffer,
-		.transaction_amount = bytes,
-		.transaction_begin_address = audio_stream_get_rptr(&buffer->stream),
-	};
-
 	CORE_CHECK_STRUCT(&buffer->audio_buffer);
 
 	/* return if no bytes */
@@ -544,9 +521,6 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
 
 	audio_stream_consume(&buffer->stream, bytes);
 
-	notifier_event(buffer, NOTIFIER_ID_BUFFER_CONSUME,
-		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
-
 #if CONFIG_SOF_LOG_DBG_BUFFER
 	buf_dbg(buffer, "(buffer->avail << 16) | buffer->free = %08x, (buffer->id << 16) | buffer->size = %08x, (buffer->r_ptr - buffer->addr) << 16 | (buffer->w_ptr - buffer->addr)) = %08x",
 		(audio_stream_get_avail_bytes(&buffer->stream) << 16) |

src/audio/component.c

@@ -36,7 +36,7 @@
 
 LOG_MODULE_REGISTER(component, CONFIG_SOF_LOG_LEVEL);
 
-static SHARED_DATA struct comp_driver_list cd;
+static APP_SYSUSER_BSS SHARED_DATA struct comp_driver_list cd;
 
 SOF_DEFINE_REG_UUID(component);
 
@@ -699,3 +699,11 @@ void comp_update_ibs_obs_cpc(struct comp_dev *dev)
 #endif
 }
 
+#ifdef CONFIG_SOF_USERSPACE_LL
+void comp_grant_access_to_thread(const struct comp_dev *dev, struct k_thread *th)
+{
+	assert(dev->list_mutex);
+	tr_dbg(&ipc_tr, "grant access to mutex %p for thread %p", dev->list_mutex, th);
+	k_thread_access_grant(th, dev->list_mutex);
+}
+#endif