[thirdparty/kernel/stable.git] / include / sound / pcm-indirect.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Helper functions for indirect PCM data transfer
 *
 *  Copyright (c) by Takashi Iwai <tiwai@suse.de>
 *                   Jaroslav Kysela <perex@perex.cz>
 */

#ifndef __SOUND_PCM_INDIRECT_H
#define __SOUND_PCM_INDIRECT_H

#include <sound/pcm.h>

struct snd_pcm_indirect {
	unsigned int hw_buffer_size;	/* Byte size of hardware buffer */
	unsigned int hw_queue_size;	/* Max queue size of hw buffer (0 = buffer size) */
	unsigned int hw_data;	/* Offset to next dst (or src) in hw ring buffer */
	unsigned int hw_io;	/* Ring buffer hw pointer */
	int hw_ready;		/* Bytes ready for play (or captured) in hw ring buffer */
	unsigned int sw_buffer_size;	/* Byte size of software buffer */
	unsigned int sw_data;	/* Offset to next dst (or src) in sw ring buffer */
	unsigned int sw_io;	/* Current software pointer in bytes */
	int sw_ready;		/* Bytes ready to be transferred to/from hw */
	snd_pcm_uframes_t appl_ptr;	/* Last seen appl_ptr */
};

typedef void (*snd_pcm_indirect_copy_t)(struct snd_pcm_substream *substream,
					struct snd_pcm_indirect *rec, size_t bytes);

/*
 * helper function for playback ack callback
 */
static inline int
snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream,
				   struct snd_pcm_indirect *rec,
				   snd_pcm_indirect_copy_t copy)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
	snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;
	int qsize;

	if (diff) {
		if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
			diff += runtime->boundary;
		if (diff < 0)
			return -EINVAL;
		rec->sw_ready += (int)frames_to_bytes(runtime, diff);
		rec->appl_ptr = appl_ptr;
	}
	qsize = rec->hw_queue_size ? rec->hw_queue_size : rec->hw_buffer_size;
	while (rec->hw_ready < qsize && rec->sw_ready > 0) {
		unsigned int hw_to_end = rec->hw_buffer_size - rec->hw_data;
		unsigned int sw_to_end = rec->sw_buffer_size - rec->sw_data;
		unsigned int bytes = qsize - rec->hw_ready;
		if (rec->sw_ready < (int)bytes)
			bytes = rec->sw_ready;
		if (hw_to_end < bytes)
			bytes = hw_to_end;
		if (sw_to_end < bytes)
			bytes = sw_to_end;
		if (! bytes)
			break;
		copy(substream, rec, bytes);
		rec->hw_data += bytes;
		if (rec->hw_data == rec->hw_buffer_size)
			rec->hw_data = 0;
		rec->sw_data += bytes;
		if (rec->sw_data == rec->sw_buffer_size)
			rec->sw_data = 0;
		rec->hw_ready += bytes;
		rec->sw_ready -= bytes;
	}
	return 0;
}

/*
 * helper function for playback pointer callback
 * ptr = current byte pointer
 */
static inline snd_pcm_uframes_t
snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream,
				  struct snd_pcm_indirect *rec, unsigned int ptr)
{
	int bytes = ptr - rec->hw_io;
	if (bytes < 0)
		bytes += rec->hw_buffer_size;
	rec->hw_io = ptr;
	rec->hw_ready -= bytes;
	rec->sw_io += bytes;
	if (rec->sw_io >= rec->sw_buffer_size)
		rec->sw_io -= rec->sw_buffer_size;
	if (substream->ops->ack)
		substream->ops->ack(substream);
	return bytes_to_frames(substream->runtime, rec->sw_io);
}


/*
 * helper function for capture ack callback
 */
static inline int
snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream,
				  struct snd_pcm_indirect *rec,
				  snd_pcm_indirect_copy_t copy)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
	snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;

	if (diff) {
		if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
			diff += runtime->boundary;
		if (diff < 0)
			return -EINVAL;
		rec->sw_ready -= frames_to_bytes(runtime, diff);
		rec->appl_ptr = appl_ptr;
	}
	while (rec->hw_ready > 0 && 
	       rec->sw_ready < (int)rec->sw_buffer_size) {
		size_t hw_to_end = rec->hw_buffer_size - rec->hw_data;
		size_t sw_to_end = rec->sw_buffer_size - rec->sw_data;
		size_t bytes = rec->sw_buffer_size - rec->sw_ready;
		if (rec->hw_ready < (int)bytes)
			bytes = rec->hw_ready;
		if (hw_to_end < bytes)
			bytes = hw_to_end;
		if (sw_to_end < bytes)
			bytes = sw_to_end;
		if (! bytes)
			break;
		copy(substream, rec, bytes);
		rec->hw_data += bytes;
		if ((int)rec->hw_data == rec->hw_buffer_size)
			rec->hw_data = 0;
		rec->sw_data += bytes;
		if (rec->sw_data == rec->sw_buffer_size)
			rec->sw_data = 0;
		rec->hw_ready -= bytes;
		rec->sw_ready += bytes;
	}
	return 0;
}

/*
 * helper function for capture pointer callback,
 * ptr = current byte pointer
 */
static inline snd_pcm_uframes_t
snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream,
				 struct snd_pcm_indirect *rec, unsigned int ptr)
{
	int qsize;
	int bytes = ptr - rec->hw_io;
	if (bytes < 0)
		bytes += rec->hw_buffer_size;
	rec->hw_io = ptr;
	rec->hw_ready += bytes;
	qsize = rec->hw_queue_size ? rec->hw_queue_size : rec->hw_buffer_size;
	if (rec->hw_ready > qsize)
		return SNDRV_PCM_POS_XRUN;
	rec->sw_io += bytes;
	if (rec->sw_io >= rec->sw_buffer_size)
		rec->sw_io -= rec->sw_buffer_size;
	if (substream->ops->ack)
		substream->ops->ack(substream);
	return bytes_to_frames(substream->runtime, rec->sw_io);
}

#endif /* __SOUND_PCM_INDIRECT_H */
Commit	Line	Data
74ba9207	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
1da177e4 LT	2	/*
	3	* Helper functions for indirect PCM data transfer
	4	*
	5	* Copyright (c) by Takashi Iwai <tiwai@suse.de>
c1017a4c	6	* Jaroslav Kysela <perex@perex.cz>
1da177e4 LT	7	*/
	8
	9	#ifndef __SOUND_PCM_INDIRECT_H
	10	#define __SOUND_PCM_INDIRECT_H
	11
	12	#include <sound/pcm.h>
	13
877211f5	14	struct snd_pcm_indirect {
1da177e4 LT	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 */
877211f5	25	};
1da177e4	26
877211f5 TI	27	typedef void (snd_pcm_indirect_copy_t)(struct snd_pcm_substream substream,
877211f5 TI	28	struct snd_pcm_indirect *rec, size_t bytes);
1da177e4 LT	29
	30	/*
	31	* helper function for playback ack callback
	32	*/
96295812	33	static inline int
877211f5 TI	34	snd_pcm_indirect_playback_transfer(struct snd_pcm_substream *substream,
877211f5 TI	35	struct snd_pcm_indirect *rec,
1da177e4 LT	36	snd_pcm_indirect_copy_t copy)
1da177e4 LT	37	{
877211f5	38	struct snd_pcm_runtime *runtime = substream->runtime;
1da177e4 LT	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;
96295812 TI	46	if (diff < 0)
96295812 TI	47	return -EINVAL;
1da177e4 LT	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	}
96295812	74	return 0;
1da177e4 LT	75	}
	76
	77	/*
	78	* helper function for playback pointer callback
	79	* ptr = current byte pointer
	80	*/
	81	static inline snd_pcm_uframes_t
877211f5 TI	82	snd_pcm_indirect_playback_pointer(struct snd_pcm_substream *substream,
877211f5 TI	83	struct snd_pcm_indirect *rec, unsigned int ptr)
1da177e4 LT	84	{
	85	int bytes = ptr - rec->hw_io;
	86	if (bytes < 0)
	87	bytes += rec->hw_buffer_size;
	88	rec->hw_io = ptr;
	89	rec->hw_ready -= bytes;
	90	rec->sw_io += bytes;
	91	if (rec->sw_io >= rec->sw_buffer_size)
	92	rec->sw_io -= rec->sw_buffer_size;
	93	if (substream->ops->ack)
	94	substream->ops->ack(substream);
	95	return bytes_to_frames(substream->runtime, rec->sw_io);
	96	}
	97
	98
	99	/*
	100	* helper function for capture ack callback
	101	*/
96295812	102	static inline int
877211f5 TI	103	snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream,
877211f5 TI	104	struct snd_pcm_indirect *rec,
1da177e4 LT	105	snd_pcm_indirect_copy_t copy)
1da177e4 LT	106	{
877211f5	107	struct snd_pcm_runtime *runtime = substream->runtime;
1da177e4 LT	108	snd_pcm_uframes_t appl_ptr = runtime->control->appl_ptr;
	109	snd_pcm_sframes_t diff = appl_ptr - rec->appl_ptr;
	110
	111	if (diff) {
	112	if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2))
	113	diff += runtime->boundary;
96295812 TI	114	if (diff < 0)
96295812 TI	115	return -EINVAL;
1da177e4 LT	116	rec->sw_ready -= frames_to_bytes(runtime, diff);
	117	rec->appl_ptr = appl_ptr;
	118	}
	119	while (rec->hw_ready > 0 &&
	120	rec->sw_ready < (int)rec->sw_buffer_size) {
	121	size_t hw_to_end = rec->hw_buffer_size - rec->hw_data;
	122	size_t sw_to_end = rec->sw_buffer_size - rec->sw_data;
	123	size_t bytes = rec->sw_buffer_size - rec->sw_ready;
	124	if (rec->hw_ready < (int)bytes)
	125	bytes = rec->hw_ready;
	126	if (hw_to_end < bytes)
	127	bytes = hw_to_end;
	128	if (sw_to_end < bytes)
	129	bytes = sw_to_end;
	130	if (! bytes)
	131	break;
	132	copy(substream, rec, bytes);
	133	rec->hw_data += bytes;
	134	if ((int)rec->hw_data == rec->hw_buffer_size)
	135	rec->hw_data = 0;
	136	rec->sw_data += bytes;
	137	if (rec->sw_data == rec->sw_buffer_size)
	138	rec->sw_data = 0;
	139	rec->hw_ready -= bytes;
	140	rec->sw_ready += bytes;
	141	}
96295812	142	return 0;
1da177e4 LT	143	}
	144
	145	/*
	146	* helper function for capture pointer callback,
	147	* ptr = current byte pointer
	148	*/
	149	static inline snd_pcm_uframes_t
877211f5 TI	150	snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream,
877211f5 TI	151	struct snd_pcm_indirect *rec, unsigned int ptr)
1da177e4 LT	152	{
	153	int qsize;
	154	int bytes = ptr - rec->hw_io;
	155	if (bytes < 0)
	156	bytes += rec->hw_buffer_size;
	157	rec->hw_io = ptr;
	158	rec->hw_ready += bytes;
	159	qsize = rec->hw_queue_size ? rec->hw_queue_size : rec->hw_buffer_size;
	160	if (rec->hw_ready > qsize)
	161	return SNDRV_PCM_POS_XRUN;
	162	rec->sw_io += bytes;
	163	if (rec->sw_io >= rec->sw_buffer_size)
	164	rec->sw_io -= rec->sw_buffer_size;
	165	if (substream->ops->ack)
	166	substream->ops->ack(substream);
	167	return bytes_to_frames(substream->runtime, rec->sw_io);
	168	}
	169
	170	#endif /* __SOUND_PCM_INDIRECT_H */