ASoC: SOF: ipc4-pcm: fix delay calculation when DSP resamples

When the sampling rates going in (host) and out (dai) from the DSP
are different, the IPC4 delay reporting does not work correctly.
Add support for this case by scaling the host position values to
a common timebase before calculating real-time delay for the PCM.

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

Author: kv2019i

sound/soc/sof/ipc4-pcm.c

@@ -19,12 +19,15 @@
  * struct sof_ipc4_timestamp_info - IPC4 timestamp info
  * @host_copier: the host copier of the pcm stream
  * @dai_copier: the dai copier of the pcm stream
- * @stream_start_offset: reported by fw in memory window (converted to frames)
- * @stream_end_offset: reported by fw in memory window (converted to frames)
+ * @stream_start_offset: reported by fw in memory window (converted to
+ *                       frames at dai_copier sampling rate)
+ * @stream_end_offset: reported by fw in memory window (converted to
+ *                     frames at dai_copier sampling rate)
  * @llp_offset: llp offset in memory window
  * @boundary: wrap boundary should be used for the LLP frame counter
  * @delay: Calculated and stored in pointer callback. The stored value is
- *	   returned in the delay callback.
+ *         returned in the delay callback. Expressed in frames at host copier
+ *         sampling rate.
  */
 struct sof_ipc4_timestamp_info {
 	struct sof_ipc4_copier *host_copier;
@@ -1113,6 +1116,53 @@ static int sof_ipc4_get_stream_start_offset(struct snd_sof_dev *sdev,
 	return 0;
 }
 
+static u64 sof_ipc4_time_scale(struct sof_ipc4_timestamp_info *time_info, u64 value, bool dai_to_host)
+{
+	u64 dai_rate, host_rate, mul, div;
+
+	if (!time_info->dai_copier || !time_info->host_copier)
+		return value;
+
+	/*
+	 * copiers do not change sampling rate, so we can use the
+	 * out_format independently of stream direction
+	 */
+	dai_rate = time_info->dai_copier->data.out_format.sampling_frequency;
+	host_rate = time_info->host_copier->data.out_format.sampling_frequency;
+
+	if (!dai_rate || !host_rate)
+		return value;
+
+	if (dai_to_host) {
+		mul = host_rate;
+		div = dai_rate;
+	} else {
+		mul = dai_rate;
+		div = host_rate;
+	}
+
+	/* take care not to overflow u64, div/mul can be upto 768000 */
+	if (value > U32_MAX) {
+		value = DIV64_U64_ROUND_CLOSEST(value, div);
+		value *= mul;
+	} else {
+		value *= mul;
+		value = DIV64_U64_ROUND_CLOSEST(value, div);
+	}
+
+	return value;
+}
+
+static u64 sof_ipc4_time_dai_to_host(struct sof_ipc4_timestamp_info *time_info, u64 dai_time)
+{
+	return sof_ipc4_time_scale(time_info, dai_time, true);
+}
+
+static u64 sof_ipc4_time_host_to_dai(struct sof_ipc4_timestamp_info *time_info, u64 host_time)
+{
+	return sof_ipc4_time_scale(time_info, host_time, false);
+}
+
 static int sof_ipc4_pcm_pointer(struct snd_soc_component *component,
 				struct snd_pcm_substream *substream,
 				snd_pcm_uframes_t *pointer)
@@ -1149,8 +1199,13 @@ static int sof_ipc4_pcm_pointer(struct snd_soc_component *component,
 
 	/* For delay calculation we need the host counter */
 	host_cnt = snd_sof_pcm_get_host_byte_counter(sdev, component, substream);
+
+	/* Store the original value to host_ptr */
 	host_ptr = host_cnt;
 
+	/* Scale value to DAI time in case DAI running at different rate */
+	host_cnt = sof_ipc4_time_host_to_dai(time_info, host_cnt);
+
 	/* convert the host_cnt to frames */
 	host_cnt = div64_u64(host_cnt, frames_to_bytes(substream->runtime, 1));
 
@@ -1212,11 +1267,16 @@ static int sof_ipc4_pcm_pointer(struct snd_soc_component *component,
 	}
 
 	if (head_cnt < tail_cnt) {
+		/* TODO: is this correct in the SRC case? */
 		time_info->delay = time_info->boundary - tail_cnt + head_cnt;
 		goto out;
 	}
 
-	time_info->delay =  head_cnt - tail_cnt;
+	/* delay in DAI time */
+	time_info->delay = head_cnt - tail_cnt;
+
+	/* convert delay to host time */
+	time_info->delay = sof_ipc4_time_dai_to_host(time_info, time_info->delay);
 
 out:
 	/*