notifier: Extend capabilities of notifier to serve as event hub for all callback types

src/arch/host/CMakeLists.txt

@@ -6,3 +6,5 @@ target_include_directories(sof_public_headers INTERFACE ${PROJECT_SOURCE_DIR}/sr
 
 # C & ASM flags
 target_compile_options(sof_options INTERFACE -g -O3 -Wall -Werror -Wl,-EL -Wmissing-prototypes -Wimplicit-fallthrough=3 -Wpointer-arith)
+
+add_subdirectory(lib)

src/arch/host/lib/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+add_local_sources(sof notifier.c)

src/arch/host/lib/notifier.c

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: BSD-3-Clause
+//
+// Copyright(c) 2019 Intel Corporation. All rights reserved.
+//
+// Author: Artur Kloniecki <arturx.kloniecki@linux.intel.com>
+
+/**
+ * \file arch/host/lib/notifier.c
+ * \brief Host notifier implementation file
+ * \authors Artur Kloniecki <arturx.kloniecki@linux.intel.com>
+ */
+
+#include <ipc/topology.h>
+#include <sof/lib/alloc.h>
+#include <sof/lib/notifier.h>
+
+static struct notify *host_notify;
+
+struct notify **arch_notify_get(void)
+{
+	if (!host_notify)
+		host_notify = rzalloc(RZONE_SYS, SOF_MEM_CAPS_RAM,
+				      sizeof(*host_notify));
+	return &host_notify;
+}

src/audio/buffer.c

@@ -11,6 +11,7 @@
 #include <sof/lib/alloc.h>
 #include <sof/lib/cache.h>
 #include <sof/lib/memory.h>
+#include <sof/lib/notifier.h>
 #include <sof/list.h>
 #include <ipc/topology.h>
 #include <errno.h>
@@ -107,8 +108,18 @@ int buffer_set_size(struct comp_buffer *buffer, uint32_t size)
 /* free component in the pipeline */
 void buffer_free(struct comp_buffer *buffer)
 {
+	struct buffer_cb_free cb_data = {
+		.buffer = buffer,
+	};
+
 	trace_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);
+
 	list_item_del(&buffer->source_list);
 	list_item_del(&buffer->sink_list);
 	rfree(buffer->addr);
@@ -118,6 +129,11 @@ void buffer_free(struct comp_buffer *buffer)
 void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 {
 	uint32_t flags;
+	struct buffer_cb_transact cb_data = {
+		.buffer = buffer,
+		.transaction_amount = bytes,
+		.transaction_begin_address = buffer->w_ptr,
+	};
 
 	/* return if no bytes */
 	if (!bytes) {
@@ -155,8 +171,8 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 	/* calculate free bytes */
 	buffer->free = buffer->size - buffer->avail;
 
-	if (buffer->cb && buffer->cb_type & BUFF_CB_TYPE_PRODUCE)
-		buffer->cb(buffer->cb_data, bytes);
+	notifier_event(buffer, NOTIFIER_ID_BUFFER_PRODUCE,
+		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
 
 	irq_local_enable(flags);
 
@@ -174,6 +190,11 @@ void comp_update_buffer_produce(struct comp_buffer *buffer, uint32_t bytes)
 void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
 {
 	uint32_t flags;
+	struct buffer_cb_transact cb_data = {
+		.buffer = buffer,
+		.transaction_amount = bytes,
+		.transaction_begin_address = buffer->r_ptr,
+	};
 
 	/* return if no bytes */
 	if (!bytes) {
@@ -207,8 +228,8 @@ void comp_update_buffer_consume(struct comp_buffer *buffer, uint32_t bytes)
 	/* calculate free bytes */
 	buffer->free = buffer->size - buffer->avail;
 
-	if (buffer->cb && buffer->cb_type & BUFF_CB_TYPE_CONSUME)
-		buffer->cb(buffer->cb_data, bytes);
+	notifier_event(buffer, NOTIFIER_ID_BUFFER_CONSUME,
+		       NOTIFIER_TARGET_CORE_LOCAL, &cb_data, sizeof(cb_data));
 
 	irq_local_enable(flags);
 

src/audio/dai.c

@@ -19,6 +19,7 @@
 #include <sof/lib/cache.h>
 #include <sof/lib/dai.h>
 #include <sof/lib/dma.h>
+#include <sof/lib/notifier.h>
 #include <sof/list.h>
 #include <sof/string.h>
 #include <sof/trace/trace.h>
@@ -76,9 +77,10 @@ struct dai_data {
 };
 
 /* this is called by DMA driver every time descriptor has completed */
-static void dai_dma_cb(void *data, uint32_t type, struct dma_cb_data *next)
+static void dai_dma_cb(void *arg, enum notify_id type, void *data)
 {
-	struct comp_dev *dev = (struct comp_dev *)data;
+	struct dma_cb_data *next = data;
+	struct comp_dev *dev = arg;
 	struct dai_data *dd = comp_get_drvdata(dev);
 	uint32_t bytes = next->elem.size;
 	uint32_t samples = bytes / sample_bytes(dd->frame_fmt);
@@ -540,6 +542,11 @@ static int dai_comp_trigger(struct comp_dev *dev, int cmd)
 	if (ret == COMP_STATUS_STATE_ALREADY_SET)
 		return PPL_STATUS_PATH_STOP;
 
+	/* setup callback */
+	notifier_unregister(dev, dd->chan, NOTIFIER_ID_DMA_COPY);
+	notifier_register(dev, dd->chan, NOTIFIER_ID_DMA_COPY,
+			  dai_dma_cb);
+
 	switch (cmd) {
 	case COMP_TRIGGER_START:
 		trace_dai_with_ids(dev, "dai_comp_trigger(), START");
@@ -786,9 +793,6 @@ static int dai_config(struct comp_dev *dev, struct sof_ipc_dai_config *config)
 			dd->chan = NULL;
 			return -EIO;
 		}
-
-		/* set up callback */
-		dma_set_cb(dd->chan, DMA_CB_TYPE_COPY, dai_dma_cb, dev);
 	}
 
 	return 0;

src/audio/detect_test.c

@@ -81,8 +81,6 @@ struct comp_data {
 	uint32_t history_depth; /** defines draining size in bytes. */
 
 	uint16_t sample_valid_bytes;
-
-	struct notify_data event;
 	struct kpb_event_data event_data;
 	struct kpb_client client_data;
 
@@ -146,11 +144,9 @@ static void notify_kpb(struct comp_dev *dev)
 	cd->event_data.event_id = KPB_EVENT_BEGIN_DRAINING;
 	cd->event_data.client_data = &cd->client_data;
 
-	cd->event.id = NOTIFIER_ID_KPB_CLIENT_EVT;
-	cd->event.target_core_mask = NOTIFIER_TARGET_CORE_ALL_MASK;
-	cd->event.data = &cd->event_data;
-
-	notifier_event(&cd->event);
+	notifier_event(dev, NOTIFIER_ID_KPB_CLIENT_EVT,
+		       NOTIFIER_TARGET_CORE_ALL_MASK, &cd->event_data,
+		       sizeof(cd->event_data));
 }
 
 static void detect_test_notify(struct comp_dev *dev)

src/audio/host.c

@@ -15,6 +15,7 @@
 #include <sof/lib/alloc.h>
 #include <sof/lib/cache.h>
 #include <sof/lib/dma.h>
+#include <sof/lib/notifier.h>
 #include <sof/list.h>
 #include <sof/math/numbers.h>
 #include <sof/string.h>
@@ -224,9 +225,10 @@ static void host_one_shot_cb(struct comp_dev *dev, uint32_t bytes)
 /* This is called by DMA driver every time when DMA completes its current
  * transfer between host and DSP.
  */
-static void host_dma_cb(void *data, uint32_t type, struct dma_cb_data *next)
+static void host_dma_cb(void *arg, enum notify_id type, void *data)
 {
-	struct comp_dev *dev = (struct comp_dev *)data;
+	struct dma_cb_data *next = data;
+	struct comp_dev *dev = arg;
 	struct host_data *hd = comp_get_drvdata(dev);
 	uint32_t bytes = next->elem.size;
 
@@ -305,6 +307,10 @@ static int host_trigger(struct comp_dev *dev, int cmd)
 		return ret;
 	}
 
+	/* set up callback */
+	notifier_unregister(dev, hd->chan, NOTIFIER_ID_DMA_COPY);
+	notifier_register(dev, hd->chan, NOTIFIER_ID_DMA_COPY, host_dma_cb);
+
 	/* we should ignore any trigger commands besides start
 	 * when doing one shot, because transfers will stop automatically
 	 */
@@ -597,9 +603,6 @@ static int host_params(struct comp_dev *dev,
 		return err;
 	}
 
-	/* set up callback */
-	dma_set_cb(hd->chan, DMA_CB_TYPE_COPY, host_dma_cb, dev);
-
 	/* set processing function */
 	hd->process = pcm_get_conversion_function(hd->local_buffer->frame_fmt,
 						  hd->local_buffer->frame_fmt);

src/audio/kpb.c

@@ -46,7 +46,6 @@ struct comp_data {
 	enum kpb_state state; /**< current state of KPB component */
 	uint32_t kpb_no_of_clients; /**< number of registered clients */
 	struct kpb_client clients[KPB_MAX_NO_OF_CLIENTS];
-	struct notifier kpb_events; /**< KPB events object */
 	struct task draining_task;
 	uint32_t source_period_bytes; /**< source number of period bytes */
 	uint32_t sink_period_bytes; /**< sink number of period bytes */
@@ -63,7 +62,7 @@ struct comp_data {
 };
 
 /*! KPB private functions */
-static void kpb_event_handler(int message, void *cb_data, void *event_data);
+static void kpb_event_handler(void *arg, enum notify_id type, void *event_data);
 static int kpb_register_client(struct comp_data *kpb, struct kpb_client *cli);
 static void kpb_init_draining(struct comp_dev *dev, struct kpb_client *cli);
 static enum task_state kpb_draining_task(void *arg);
@@ -312,8 +311,8 @@ static void kpb_free(struct comp_dev *dev)
 
 	trace_kpb_with_ids(dev, "kpb_free()");
 
-	/* Unregister KPB from async notification */
-	notifier_unregister(&kpb->kpb_events);
+	/* Unregister KPB from notifications */
+	notifier_unregister(dev, NULL, NOTIFIER_ID_KPB_CLIENT_EVT);
 
 	/* Reclaim memory occupied by history buffer */
 	kpb_free_history_buffer(kpb->history_buffer);
@@ -423,13 +422,14 @@ static int kpb_prepare(struct comp_dev *dev)
 		kpb->clients[i].r_ptr = NULL;
 	}
 
-	/* Initialize KPB events */
-	kpb->kpb_events.id = NOTIFIER_ID_KPB_CLIENT_EVT;
-	kpb->kpb_events.cb_data = dev;
-	kpb->kpb_events.cb = kpb_event_handler;
-
-	/* Register KPB for async notification */
-	notifier_register(&kpb->kpb_events);
+	/* Register KPB for notification */
+	ret = notifier_register(dev, NULL, NOTIFIER_ID_KPB_CLIENT_EVT,
+				kpb_event_handler);
+	if (ret < 0) {
+		kpb_free_history_buffer(kpb->history_buffer);
+		kpb->history_buffer = NULL;
+		return -ENOMEM;
+	}
 
 	/* Search for KPB related sinks.
 	 * NOTE! We assume here that channel selector component device
@@ -522,8 +522,8 @@ static int kpb_reset(struct comp_dev *dev)
 			kpb_reset_history_buffer(kpb->history_buffer);
 		}
 
-		/* Unregister KPB for async notification */
-		notifier_unregister(&kpb->kpb_events);
+		/* Unregister KPB from notifications */
+		notifier_unregister(dev, NULL, NOTIFIER_ID_KPB_CLIENT_EVT);
 		/* Finally KPB is ready after reset */
 		kpb_change_state(kpb, KPB_STATE_PREPARING);
 
@@ -800,18 +800,17 @@ static int kpb_buffer_data(struct comp_dev *dev, struct comp_buffer *source,
 
 /**
  * \brief Main event dispatcher.
- * \param[in] message - not used.
- * \param[in] cb_data - KPB component internal data.
+ * \param[in] arg - KPB component internal data.
+ * \param[in] type - notification type
  * \param[in] event_data - event specific data.
  * \return none.
  */
-static void kpb_event_handler(int message, void *cb_data, void *event_data)
+static void kpb_event_handler(void *arg, enum notify_id type, void *event_data)
 {
-	(void)message;
-	struct comp_dev *dev = (struct comp_dev *)cb_data;
+	struct comp_dev *dev = arg;
 	struct comp_data *kpb = comp_get_drvdata(dev);
-	struct kpb_event_data *evd = (struct kpb_event_data *)event_data;
-	struct kpb_client *cli = (struct kpb_client *)evd->client_data;
+	struct kpb_event_data *evd = event_data;
+	struct kpb_client *cli = evd->client_data;
 
 	trace_kpb_with_ids(dev, "kpb_event_handler(): "
 			   "received event with ID: %d ",