[linux-2.6-block.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 -EPIPE;
		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;
	int err;

	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) {
		err = substream->ops->ack(substream);
		if (err == -EPIPE)
			return SNDRV_PCM_POS_XRUN;
	}
	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 -EPIPE;
		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;
	int err;

	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) {
		err = substream->ops->ack(substream);
		if (err == -EPIPE)
			return SNDRV_PCM_POS_XRUN;
	}
	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	46	if (diff < 0)
0146878c	47	return -EPIPE;
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	{
1da177e4 LT	85	int bytes = ptr - rec->hw_io;
0146878c TI	86	int err;
0146878c TI	87
1da177e4 LT	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;
0146878c TI	95	if (substream->ops->ack) {
	96	err = substream->ops->ack(substream);
	97	if (err == -EPIPE)
	98	return SNDRV_PCM_POS_XRUN;
	99	}
1da177e4 LT	100	return bytes_to_frames(substream->runtime, rec->sw_io);
	101	}
	102
	103
	104	/*
	105	* helper function for capture ack callback
	106	*/
96295812	107	static inline int
877211f5 TI	108	snd_pcm_indirect_capture_transfer(struct snd_pcm_substream *substream,
877211f5 TI	109	struct snd_pcm_indirect *rec,
1da177e4 LT	110	snd_pcm_indirect_copy_t copy)
1da177e4 LT	111	{
877211f5	112	struct snd_pcm_runtime *runtime = substream->runtime;
1da177e4 LT	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;
96295812	119	if (diff < 0)
0146878c	120	return -EPIPE;
1da177e4 LT	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	}
96295812	147	return 0;
1da177e4 LT	148	}
	149
	150	/*
	151	* helper function for capture pointer callback,
	152	* ptr = current byte pointer
	153	*/
	154	static inline snd_pcm_uframes_t
877211f5 TI	155	snd_pcm_indirect_capture_pointer(struct snd_pcm_substream *substream,
877211f5 TI	156	struct snd_pcm_indirect *rec, unsigned int ptr)
1da177e4 LT	157	{
	158	int qsize;
	159	int bytes = ptr - rec->hw_io;
0146878c TI	160	int err;
0146878c TI	161
1da177e4 LT	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;
0146878c TI	172	if (substream->ops->ack) {
	173	err = substream->ops->ack(substream);
	174	if (err == -EPIPE)
	175	return SNDRV_PCM_POS_XRUN;
	176	}
1da177e4 LT	177	return bytes_to_frames(substream->runtime, rec->sw_io);
	178	}
	179
	180	#endif /* __SOUND_PCM_INDIRECT_H */