1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/*
3 * Helper functions for indirect PCM data transfer
4 *
5 *  Copyright (c) by Takashi Iwai <tiwai@suse.de>
6 *                   Jaroslav Kysela <perex@perex.cz>
7 */
8
9#ifndef __SOUND_PCM_INDIRECT_H
10#define __SOUND_PCM_INDIRECT_H
11
12#include <sound/pcm.h>
13
14struct snd_pcm_indirect {
15	unsigned int hw_buffer_size;	/* Byte size of hardware buffer */
16	unsigned int hw_queue_size;	/* Max queue size of hw buffer (0 = buffer size) */
17	unsigned int hw_data;	/* Offset to next dst (or src) in hw ring buffer */
18	unsigned int hw_io;	/* Ring buffer hw pointer */
19	int hw_ready;		/* Bytes ready for play (or captured) in hw ring buffer */
20	unsigned int sw_buffer_size;	/* Byte size of software buffer */
21	unsigned int sw_data;	/* Offset to next dst (or src) in sw ring buffer */
22	unsigned int sw_io;	/* Current software pointer in bytes */
23	int sw_ready;		/* Bytes ready to be transferred to/from hw */
24	snd_pcm_uframes_t appl_ptr;	/* Last seen appl_ptr */
25};
26
27typedef void (*snd_pcm_indirect_copy_t)(struct snd_pcm_substream *substream,
28					struct snd_pcm_indirect *rec, size_t bytes);
29
30/*
31 * helper function for playback ack callback
32 */
33static inline int
34snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream,
35				   struct snd_pcm_indirect *rec,
36				   snd_pcm_indirect_copy_t copy)
37{
38	struct snd_pcm_runtime *runtime = substream->runtime;
39	snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
40	snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;
41	int qsize;
42
43	if (diff) {
44		if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
45			diff += runtime->boundary;
46		if (diff < 0)
47			return -EPIPE;
48		rec->sw_ready += (int)frames_to_bytes(runtime, diff);
49		rec->appl_ptr = appl_ptr;
50	}
51	qsize = rec->hw_queue_size ? rec->hw_queue_size : rec->hw_buffer_size;
52	while (rec->hw_ready < qsize && rec->sw_ready > 0) {
53		unsigned int hw_to_end = rec->hw_buffer_size - rec->hw_data;
54		unsigned int sw_to_end = rec->sw_buffer_size - rec->sw_data;
55		unsigned int bytes = qsize - rec->hw_ready;
56		if (rec->sw_ready < (int)bytes)
57			bytes = rec->sw_ready;
58		if (hw_to_end < bytes)
59			bytes = hw_to_end;
60		if (sw_to_end < bytes)
61			bytes = sw_to_end;
62		if (! bytes)
63			break;
64		copy(substream, rec, bytes);
65		rec->hw_data += bytes;
66		if (rec->hw_data == rec->hw_buffer_size)
67			rec->hw_data = 0;
68		rec->sw_data += bytes;
69		if (rec->sw_data == rec->sw_buffer_size)
70			rec->sw_data = 0;
71		rec->hw_ready += bytes;
72		rec->sw_ready -= bytes;
73	}
74	return 0;
75}
76
77/*
78 * helper function for playback pointer callback
79 * ptr = current byte pointer
80 */
81static inline snd_pcm_uframes_t
82snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream,
83				  struct snd_pcm_indirect *rec, unsigned int ptr)
84{
85	int bytes = ptr - rec->hw_io;
86	int err;
87
88	if (bytes < 0)
89		bytes += rec->hw_buffer_size;
90	rec->hw_io = ptr;
91	rec->hw_ready -= bytes;
92	rec->sw_io += bytes;
93	if (rec->sw_io >= rec->sw_buffer_size)
94		rec->sw_io -= rec->sw_buffer_size;
95	if (substream->ops->ack) {
96		err = substream->ops->ack(substream);
97		if (err == -EPIPE)
98			return SNDRV_PCM_POS_XRUN;
99	}
100	return bytes_to_frames(substream->runtime, rec->sw_io);
101}
102
103
104/*
105 * helper function for capture ack callback
106 */
107static inline int
108snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream,
109				  struct snd_pcm_indirect *rec,
110				  snd_pcm_indirect_copy_t copy)
111{
112	struct snd_pcm_runtime *runtime = substream->runtime;
113	snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
114	snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;
115
116	if (diff) {
117		if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
118			diff += runtime->boundary;
119		if (diff < 0)
120			return -EPIPE;
121		rec->sw_ready -= frames_to_bytes(runtime, diff);
122		rec->appl_ptr = appl_ptr;
123	}
124	while (rec->hw_ready > 0 &&
125	       rec->sw_ready < (int)rec->sw_buffer_size) {
126		size_t hw_to_end = rec->hw_buffer_size - rec->hw_data;
127		size_t sw_to_end = rec->sw_buffer_size - rec->sw_data;
128		size_t bytes = rec->sw_buffer_size - rec->sw_ready;
129		if (rec->hw_ready < (int)bytes)
130			bytes = rec->hw_ready;
131		if (hw_to_end < bytes)
132			bytes = hw_to_end;
133		if (sw_to_end < bytes)
134			bytes = sw_to_end;
135		if (! bytes)
136			break;
137		copy(substream, rec, bytes);
138		rec->hw_data += bytes;
139		if ((int)rec->hw_data == rec->hw_buffer_size)
140			rec->hw_data = 0;
141		rec->sw_data += bytes;
142		if (rec->sw_data == rec->sw_buffer_size)
143			rec->sw_data = 0;
144		rec->hw_ready -= bytes;
145		rec->sw_ready += bytes;
146	}
147	return 0;
148}
149
150/*
151 * helper function for capture pointer callback,
152 * ptr = current byte pointer
153 */
154static inline snd_pcm_uframes_t
155snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream,
156				 struct snd_pcm_indirect *rec, unsigned int ptr)
157{
158	int qsize;
159	int bytes = ptr - rec->hw_io;
160	int err;
161
162	if (bytes < 0)
163		bytes += rec->hw_buffer_size;
164	rec->hw_io = ptr;
165	rec->hw_ready += bytes;
166	qsize = rec->hw_queue_size ? rec->hw_queue_size : rec->hw_buffer_size;
167	if (rec->hw_ready > qsize)
168		return SNDRV_PCM_POS_XRUN;
169	rec->sw_io += bytes;
170	if (rec->sw_io >= rec->sw_buffer_size)
171		rec->sw_io -= rec->sw_buffer_size;
172	if (substream->ops->ack) {
173		err = substream->ops->ack(substream);
174		if (err == -EPIPE)
175			return SNDRV_PCM_POS_XRUN;
176	}
177	return bytes_to_frames(substream->runtime, rec->sw_io);
178}
179
180#endif /* __SOUND_PCM_INDIRECT_H */
181