uaol: add UAOL feedback support

This extends UAOL functionality to support audio rate adjustment based on
the "desired" clock reported by the USB playback device via the USB
feedback endpoint. The firmware calculates drift from this feedback and
instructs UAOL hardware to increase or decrease the transfer rate
accordingly.

A DSRC (Drift-compensating adaptive Sample Rate Converter) is used when
necessary to perform audio resampling and compensate for small dynamic
drift.

Signed-off-by: Serhiy Katsyuba <serhiy.katsyuba@intel.com>

Author: serhiy-katsyuba-intel

src/audio/CMakeLists.txt

@@ -127,7 +127,7 @@ if(NOT CONFIG_COMP_MODULE_SHARED_LIBRARY_BUILD)
 		add_subdirectory(tone)
 	endif()
 	if(CONFIG_DAI_INTEL_UAOL)
-		add_local_sources(sof uaol.c)
+		add_local_sources(sof uaol.c dsrc.c)
 	endif()
 	if(CONFIG_ZEPHYR_NATIVE_DRIVERS)
 		list(APPEND base_files host-zephyr.c)

src/audio/dai-zephyr.c

@@ -46,6 +46,10 @@
 
 #include <zephyr/device.h>
 #include <zephyr/drivers/dai.h>
+#ifdef CONFIG_DAI_INTEL_UAOL
+#include <zephyr/drivers/uaol.h>
+#include <sof/audio/uaol.h>
+#endif
 
 #include <sof/debug/telemetry/performance_monitor.h>
 
@@ -352,8 +356,14 @@ dai_dma_cb(struct dai_data *dd, struct comp_dev *dev, uint32_t bytes,
 			}
 		}
 #endif
-		ret = dma_buffer_copy_to(dd->local_buffer, dd->dma_buffer,
-					 dd->process, bytes, dd->chmap);
+
+#ifdef CONFIG_DAI_INTEL_UAOL
+		if (dd->uaol.feedback_drift)
+			uaol_dma_buffer_copy_to(dd, bytes);
+		else
+#endif /* CONFIG_DAI_INTEL_UAOL */
+			ret = dma_buffer_copy_to(dd->local_buffer, dd->dma_buffer,
+				     dd->process, bytes, dd->chmap);
 	} else {
 		audio_stream_invalidate(&dd->dma_buffer->stream, bytes);
 		/*
@@ -435,6 +445,12 @@ dai_dma_cb(struct dai_data *dd, struct comp_dev *dev, uint32_t bytes,
 		/* update host position (in bytes offset) for drivers */
 		dd->total_data_processed += bytes;
 	}
+
+#ifdef CONFIG_DAI_INTEL_UAOL
+	if (dd->uaol.fb_chan_idx >= 0)
+		process_uaol_feedback(dev, dd);
+#endif	/* CONFIG_DAI_INTEL_UAOL */
+
 #ifdef CONFIG_SOF_TELEMETRY_IO_PERFORMANCE_MEASUREMENTS
 	/* Increment performance counters */
 	io_perf_monitor_update_data(dd->io_perf_dai_byte_count, bytes);
@@ -593,6 +609,75 @@ __cold int dai_common_new(struct dai_data *dd, struct comp_dev *dev,
 	return 0;
 }
 
+static void dai_dma_release_channel(struct dai_data *dd)
+{
+	if (dd->chan_index >= 0) {
+		sof_dma_release_channel(dd->dma, dd->chan_index);
+		dd->chan_index = -EINVAL;
+	}
+
+#if CONFIG_UAOL_INTEL_ADSP
+	if (dd->uaol.fb_chan_idx >= 0) {
+		sof_dma_release_channel(dd->dma, dd->uaol.fb_chan_idx);
+		dd->uaol.fb_chan_idx = -EINVAL;
+	}
+#endif
+}
+
+static int dai_dma_config(struct dai_data *dd)
+{
+	int ret = sof_dma_config(dd->dma, dd->chan_index, dd->z_config);
+	if (ret < 0)
+		return ret;
+
+#if CONFIG_UAOL_INTEL_ADSP
+	if (dd->uaol.fb_chan_idx >= 0)
+		ret = sof_dma_config(dd->dma, dd->uaol.fb_chan_idx, dd->uaol.fb_z_config);
+#endif
+
+	return ret;
+}
+
+static int dai_dma_start(struct dai_data *dd)
+{
+	int ret = sof_dma_start(dd->dma, dd->chan_index);
+	if (ret < 0)
+		return ret;
+
+#if CONFIG_UAOL_INTEL_ADSP
+	if (dd->uaol.fb_chan_idx >= 0)
+		ret = sof_dma_start(dd->dma, dd->uaol.fb_chan_idx);
+#endif
+
+	return ret;
+}
+
+static int dai_dma_stop(struct dai_data *dd)
+{
+	int ret = sof_dma_stop(dd->dma, dd->chan_index);
+
+#if CONFIG_UAOL_INTEL_ADSP
+	/* seems it's better to stop feedback even when the above fails */
+	if (dd->uaol.fb_chan_idx >= 0)
+		sof_dma_stop(dd->dma, dd->uaol.fb_chan_idx);
+#endif
+
+	return ret;
+}
+
+static int dai_dma_suspend(struct dai_data *dd)
+{
+	int ret = sof_dma_suspend(dd->dma, dd->chan_index);
+
+#if CONFIG_UAOL_INTEL_ADSP
+	/* seems it's better to suspend feedback even when the above fails */
+	if (dd->uaol.fb_chan_idx >= 0)
+		sof_dma_suspend(dd->dma, dd->uaol.fb_chan_idx);
+#endif
+
+	return ret;
+}
+
 __cold static struct comp_dev *dai_new(const struct comp_driver *drv,
 				       const struct comp_ipc_config *config,
 				       const void *spec)
@@ -649,18 +734,18 @@ __cold void dai_common_free(struct dai_data *dd)
 	if (dd->group)
 		dai_group_put(dd->group);
 
-	if (dd->chan_index >= 0) {
-		sof_dma_release_channel(dd->dma, dd->chan_index);
-		dd->chan_index = -EINVAL;
-	}
-
+	dai_dma_release_channel(dd);
 	sof_dma_put(dd->dma);
 
 	dai_release_llp_slot(dd);
 
 	dai_put(dd->dai);
 
 	sof_heap_free(dd->alloc_ctx.heap, dd->dai_spec_config);
+
+#if CONFIG_UAOL_INTEL_ADSP
+	uaol_free(dd);
+#endif
 }
 
 __cold static void dai_free(struct comp_dev *dev)
@@ -1143,8 +1228,33 @@ int dai_common_params(struct dai_data *dd, struct comp_dev *dev,
 	}
 
 	err = dai_set_dma_config(dd, dev);
-	if (err < 0)
+	if (err < 0) {
 		comp_err(dev, "set dma config failed.");
+		goto out;
+	}
+
+	/* Ideally, this should be moved into setup_uaol_feedback_dma() in uaol.c, but
+	 * there is no easy access to "params" there to set up the buffer format.
+	 */
+#ifdef CONFIG_DAI_INTEL_UAOL
+	/* create DSRC output buffer (if needed) */
+	if (dd->ipc_config.type == SOF_DAI_INTEL_UAOL &&
+			dd->ipc_config.direction == SOF_IPC_STREAM_PLAYBACK) {
+		/* resampling might generate 1 extra frame; DSRC only works with 32-bit data */
+		size_t dsrc_buf_size = (dev->frames + 1) * dd->ipc_config.gtw_fmt->channels_count * 4;
+		dd->uaol.dsrc_buf = buffer_alloc_range(NULL, dsrc_buf_size, dsrc_buf_size,
+					       SOF_MEM_FLAG_USER, PLATFORM_DCACHE_ALIGN,
+					       BUFFER_USAGE_NOT_SHARED);
+		if (!dd->uaol.dsrc_buf) {
+			comp_err(dev, "failed to alloc dsrc buffer");
+			goto out;
+		}
+
+		/* params should be same as local_buffer's */
+		buffer_set_params(dd->uaol.dsrc_buf, &params, BUFFER_UPDATE_FORCE);
+	}
+#endif	/* CONFIG_DAI_INTEL_UAOL */
+
 out:
 	/*
 	 * Make sure to free all allocated items, all functions
@@ -1210,6 +1320,11 @@ int dai_common_config_prepare(struct dai_data *dd, struct comp_dev *dev)
 	comp_dbg(dev, "new configured dma channel index %d",
 		 dd->chan_index);
 
+#ifdef CONFIG_DAI_INTEL_UAOL
+	/* Does nothing if feedback DMA is not needed */
+	setup_uaol_feedback_dma(dd, dev);
+#endif	/* CONFIG_DAI_INTEL_UAOL */
+
 	return 0;
 }
 
@@ -1233,6 +1348,10 @@ int dai_common_prepare(struct dai_data *dd, struct comp_dev *dev)
 
 	/* clear dma buffer to avoid pop noise */
 	buffer_zero(dd->dma_buffer);
+#ifdef CONFIG_DAI_INTEL_UAOL
+	if (dd->uaol.fb_dma_buf)
+		memset(dd->uaol.fb_dma_buf, 0, dd->uaol.fb_dma_buf_size);
+#endif	/* CONFIG_DAI_INTEL_UAOL */
 
 	/* dma reconfig not required if XRUN handling */
 	if (dd->xrun) {
@@ -1241,7 +1360,7 @@ int dai_common_prepare(struct dai_data *dd, struct comp_dev *dev)
 		return 0;
 	}
 
-	ret = sof_dma_config(dd->dma, dd->chan_index, dd->z_config);
+	ret = dai_dma_config(dd);
 	if (ret < 0)
 		comp_set_state(dev, COMP_TRIGGER_RESET);
 
@@ -1292,6 +1411,10 @@ void dai_common_reset(struct dai_data *dd, struct comp_dev *dev)
 		dd->dma_buffer = NULL;
 	}
 
+#ifdef CONFIG_DAI_INTEL_UAOL
+	uaol_free(dd);
+#endif	/* CONFIG_DAI_INTEL_UAOL */
+
 	dd->wallclock = 0;
 	dd->total_data_processed = 0;
 	dd->xrun = 0;
@@ -1328,7 +1451,7 @@ static int dai_comp_trigger_internal(struct dai_data *dd, struct comp_dev *dev,
 
 		/* only start the DAI if we are not XRUN handling */
 		if (dd->xrun == 0) {
-			ret = sof_dma_start(dd->dma, dd->chan_index);
+			ret = dai_dma_start(dd);
 			if (ret < 0)
 				return ret;
 
@@ -1349,6 +1472,14 @@ static int dai_comp_trigger_internal(struct dai_data *dd, struct comp_dev *dev,
 			buffer_zero(dd->dma_buffer);
 		}
 
+#ifdef CONFIG_DAI_INTEL_UAOL
+		/* It might be beneficial to clear any old obsolete feedback value to prevent
+		 * it from being used to adjust the rate immediately after resume. A feedback
+		 * value of 0 will be rejected by the sanity check. */
+		if (dd->uaol.fb_dma_buf)
+			memset(dd->uaol.fb_dma_buf, 0, dd->uaol.fb_dma_buf_size);
+#endif	/* CONFIG_DAI_INTEL_UAOL */
+
 		/* DMA driver and SOF's view of the DMA buffer's
 		 * read and write cursors must be the same to
 		 * avoid scenarios in which the DMA driver
@@ -1366,16 +1497,16 @@ static int dai_comp_trigger_internal(struct dai_data *dd, struct comp_dev *dev,
 		/* only start the DAI if we are not XRUN handling */
 		if (dd->xrun == 0) {
 			/* recover valid start position */
-			ret = sof_dma_stop(dd->dma, dd->chan_index);
+			ret = dai_dma_stop(dd);
 			if (ret < 0)
 				return ret;
 
 			/* dma_config needed after stop */
-			ret = sof_dma_config(dd->dma, dd->chan_index, dd->z_config);
+			ret = dai_dma_config(dd);
 			if (ret < 0)
 				return ret;
 
-			ret = sof_dma_start(dd->dma, dd->chan_index);
+			ret = dai_dma_start(dd);
 			if (ret < 0)
 				return ret;
 
@@ -1403,11 +1534,11 @@ static int dai_comp_trigger_internal(struct dai_data *dd, struct comp_dev *dev,
  * as soon as possible.
  */
 #if CONFIG_COMP_DAI_STOP_TRIGGER_ORDER_REVERSE
-		ret = sof_dma_stop(dd->dma, dd->chan_index);
+		ret = dai_dma_stop(dd);
 		dai_trigger_op(dd->dai, cmd, dev->direction);
 #else
 		dai_trigger_op(dd->dai, cmd, dev->direction);
-		ret = sof_dma_stop(dd->dma, dd->chan_index);
+		ret = dai_dma_stop(dd);
 		if (ret) {
 			comp_warn(dev, "dma was stopped earlier");
 			ret = 0;
@@ -1417,11 +1548,11 @@ static int dai_comp_trigger_internal(struct dai_data *dd, struct comp_dev *dev,
 	case COMP_TRIGGER_PAUSE:
 		comp_dbg(dev, "PAUSE");
 #if CONFIG_COMP_DAI_STOP_TRIGGER_ORDER_REVERSE
-		ret = sof_dma_suspend(dd->dma, dd->chan_index);
+		ret = dai_dma_suspend(dd);
 		dai_trigger_op(dd->dai, cmd, dev->direction);
 #else
 		dai_trigger_op(dd->dai, cmd, dev->direction);
-		ret = sof_dma_suspend(dd->dma, dd->chan_index);
+		ret = dai_dma_suspend(dd);
 #endif
 		break;
 	case COMP_TRIGGER_PRE_START:
@@ -1852,7 +1983,7 @@ int dai_common_copy(struct dai_data *dd, struct comp_dev *dev, pcm_converter_fun
 		comp_warn(dev, "dai trigger copy failed");
 
 	if (dai_dma_cb(dd, dev, copy_bytes, converter) == SOF_DMA_CB_STATUS_END)
-		sof_dma_stop(dd->dma, dd->chan_index);
+		dai_dma_stop(dd);
 
 	ret = sof_dma_reload(dd->dma, dd->chan_index, copy_bytes);
 	if (ret < 0) {