[deliverable/linux.git] / sound / firewire / digi00x / digi00x-pcm.c

/*
 * digi00x-pcm.c - a part of driver for Digidesign Digi 002/003 family
 *
 * Copyright (c) 2014-2015 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include "digi00x.h"

static int hw_rule_rate(struct snd_pcm_hw_params *params,
			struct snd_pcm_hw_rule *rule)
{
	struct snd_interval *r =
		hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
	const struct snd_interval *c =
		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	struct snd_interval t = {
		.min = UINT_MAX, .max = 0, .integer = 1,
	};
	unsigned int i;

	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
		if (!snd_interval_test(c,
				       snd_dg00x_stream_pcm_channels[i]))
			continue;

		t.min = min(t.min, snd_dg00x_stream_rates[i]);
		t.max = max(t.max, snd_dg00x_stream_rates[i]);
	}

	return snd_interval_refine(r, &t);
}

static int hw_rule_channels(struct snd_pcm_hw_params *params,
			    struct snd_pcm_hw_rule *rule)
{
	struct snd_interval *c =
		hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	const struct snd_interval *r =
		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
	struct snd_interval t = {
		.min = UINT_MAX, .max = 0, .integer = 1,
	};
	unsigned int i;

	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
		if (!snd_interval_test(r, snd_dg00x_stream_rates[i]))
			continue;

		t.min = min(t.min, snd_dg00x_stream_pcm_channels[i]);
		t.max = max(t.max, snd_dg00x_stream_pcm_channels[i]);
	}

	return snd_interval_refine(c, &t);
}

static int pcm_init_hw_params(struct snd_dg00x *dg00x,
			      struct snd_pcm_substream *substream)
{
	static const struct snd_pcm_hardware hardware = {
		.info = SNDRV_PCM_INFO_BATCH |
			SNDRV_PCM_INFO_BLOCK_TRANSFER |
			SNDRV_PCM_INFO_INTERLEAVED |
			SNDRV_PCM_INFO_JOINT_DUPLEX |
			SNDRV_PCM_INFO_MMAP |
			SNDRV_PCM_INFO_MMAP_VALID,
		.rates = SNDRV_PCM_RATE_44100 |
			 SNDRV_PCM_RATE_48000 |
			 SNDRV_PCM_RATE_88200 |
			 SNDRV_PCM_RATE_96000,
		.rate_min = 44100,
		.rate_max = 96000,
		.channels_min = 10,
		.channels_max = 18,
		.period_bytes_min = 4 * 18,
		.period_bytes_max = 4 * 18 * 2048,
		.buffer_bytes_max = 4 * 18 * 2048 * 2,
		.periods_min = 2,
		.periods_max = UINT_MAX,
	};
	struct amdtp_stream *s;
	int err;

	substream->runtime->hw = hardware;

	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
		substream->runtime->hw.formats = SNDRV_PCM_FMTBIT_S32;
		s = &dg00x->tx_stream;
	} else {
		substream->runtime->hw.formats = SNDRV_PCM_FMTBIT_S16 |
						 SNDRV_PCM_FMTBIT_S32;
		s = &dg00x->rx_stream;
	}

	err = snd_pcm_hw_rule_add(substream->runtime, 0,
				  SNDRV_PCM_HW_PARAM_CHANNELS,
				  hw_rule_channels, NULL,
				  SNDRV_PCM_HW_PARAM_RATE, -1);
	if (err < 0)
		return err;

	err = snd_pcm_hw_rule_add(substream->runtime, 0,
				  SNDRV_PCM_HW_PARAM_RATE,
				  hw_rule_rate, NULL,
				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
	if (err < 0)
		return err;

	return amdtp_dot_add_pcm_hw_constraints(s, substream->runtime);
}

static int pcm_open(struct snd_pcm_substream *substream)
{
	struct snd_dg00x *dg00x = substream->private_data;
	enum snd_dg00x_clock clock;
	bool detect;
	unsigned int rate;
	int err;

	err = snd_dg00x_stream_lock_try(dg00x);
	if (err < 0)
		goto end;

	err = pcm_init_hw_params(dg00x, substream);
	if (err < 0)
		goto err_locked;

	/* Check current clock source. */
	err = snd_dg00x_stream_get_clock(dg00x, &clock);
	if (err < 0)
		goto err_locked;
	if (clock != SND_DG00X_CLOCK_INTERNAL) {
		err = snd_dg00x_stream_check_external_clock(dg00x, &detect);
		if (err < 0)
			goto err_locked;
		if (!detect) {
			err = -EBUSY;
			goto err_locked;
		}
	}

	if ((clock != SND_DG00X_CLOCK_INTERNAL) ||
	    amdtp_stream_pcm_running(&dg00x->rx_stream) ||
	    amdtp_stream_pcm_running(&dg00x->tx_stream)) {
		err = snd_dg00x_stream_get_external_rate(dg00x, &rate);
		if (err < 0)
			goto err_locked;
		substream->runtime->hw.rate_min = rate;
		substream->runtime->hw.rate_max = rate;
	}

	snd_pcm_set_sync(substream);
end:
	return err;
err_locked:
	snd_dg00x_stream_lock_release(dg00x);
	return err;
}

static int pcm_close(struct snd_pcm_substream *substream)
{
	struct snd_dg00x *dg00x = substream->private_data;

	snd_dg00x_stream_lock_release(dg00x);

	return 0;
}

static int pcm_capture_hw_params(struct snd_pcm_substream *substream,
				 struct snd_pcm_hw_params *hw_params)
{
	struct snd_dg00x *dg00x = substream->private_data;
	int err;

	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
					       params_buffer_bytes(hw_params));
	if (err < 0)
		return err;

	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
		mutex_lock(&dg00x->mutex);
		dg00x->substreams_counter++;
		mutex_unlock(&dg00x->mutex);
	}

	amdtp_dot_set_pcm_format(&dg00x->tx_stream, params_format(hw_params));

	return 0;
}

static int pcm_playback_hw_params(struct snd_pcm_substream *substream,
				  struct snd_pcm_hw_params *hw_params)
{
	struct snd_dg00x *dg00x = substream->private_data;
	int err;

	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
					       params_buffer_bytes(hw_params));
	if (err < 0)
		return err;

	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
		mutex_lock(&dg00x->mutex);
		dg00x->substreams_counter++;
		mutex_unlock(&dg00x->mutex);
	}

	amdtp_dot_set_pcm_format(&dg00x->rx_stream, params_format(hw_params));

	return 0;
}

static int pcm_capture_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_dg00x *dg00x = substream->private_data;

	mutex_lock(&dg00x->mutex);

	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
		dg00x->substreams_counter--;

	snd_dg00x_stream_stop_duplex(dg00x);

	mutex_unlock(&dg00x->mutex);

	return snd_pcm_lib_free_vmalloc_buffer(substream);
}

static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_dg00x *dg00x = substream->private_data;

	mutex_lock(&dg00x->mutex);

	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
		dg00x->substreams_counter--;

	snd_dg00x_stream_stop_duplex(dg00x);

	mutex_unlock(&dg00x->mutex);

	return snd_pcm_lib_free_vmalloc_buffer(substream);
}

static int pcm_capture_prepare(struct snd_pcm_substream *substream)
{
	struct snd_dg00x *dg00x = substream->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
	int err;

	mutex_lock(&dg00x->mutex);

	err = snd_dg00x_stream_start_duplex(dg00x, runtime->rate);
	if (err >= 0)
		amdtp_stream_pcm_prepare(&dg00x->tx_stream);

	mutex_unlock(&dg00x->mutex);

	return err;
}

static int pcm_playback_prepare(struct snd_pcm_substream *substream)
{
	struct snd_dg00x *dg00x = substream->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
	int err;

	mutex_lock(&dg00x->mutex);

	err = snd_dg00x_stream_start_duplex(dg00x, runtime->rate);
	if (err >= 0) {
		amdtp_stream_pcm_prepare(&dg00x->rx_stream);
		amdtp_dot_reset(&dg00x->rx_stream);
	}

	mutex_unlock(&dg00x->mutex);

	return err;
}

static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_dg00x *dg00x = substream->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		amdtp_stream_pcm_trigger(&dg00x->tx_stream, substream);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		amdtp_stream_pcm_trigger(&dg00x->tx_stream, NULL);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_dg00x *dg00x = substream->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		amdtp_stream_pcm_trigger(&dg00x->rx_stream, substream);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		amdtp_stream_pcm_trigger(&dg00x->rx_stream, NULL);
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstrm)
{
	struct snd_dg00x *dg00x = sbstrm->private_data;

	return amdtp_stream_pcm_pointer(&dg00x->tx_stream);
}

static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstrm)
{
	struct snd_dg00x *dg00x = sbstrm->private_data;

	return amdtp_stream_pcm_pointer(&dg00x->rx_stream);
}

static const struct snd_pcm_ops pcm_capture_ops = {
	.open		= pcm_open,
	.close		= pcm_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= pcm_capture_hw_params,
	.hw_free	= pcm_capture_hw_free,
	.prepare	= pcm_capture_prepare,
	.trigger	= pcm_capture_trigger,
	.pointer	= pcm_capture_pointer,
	.page		= snd_pcm_lib_get_vmalloc_page,
};

static const struct snd_pcm_ops pcm_playback_ops = {
	.open		= pcm_open,
	.close		= pcm_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= pcm_playback_hw_params,
	.hw_free	= pcm_playback_hw_free,
	.prepare	= pcm_playback_prepare,
	.trigger	= pcm_playback_trigger,
	.pointer	= pcm_playback_pointer,
	.page		= snd_pcm_lib_get_vmalloc_page,
	.mmap		= snd_pcm_lib_mmap_vmalloc,
};

int snd_dg00x_create_pcm_devices(struct snd_dg00x *dg00x)
{
	struct snd_pcm *pcm;
	int err;

	err = snd_pcm_new(dg00x->card, dg00x->card->driver, 0, 1, 1, &pcm);
	if (err < 0)
		return err;

	pcm->private_data = dg00x;
	snprintf(pcm->name, sizeof(pcm->name),
		 "%s PCM", dg00x->card->shortname);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_playback_ops);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_capture_ops);

	return 0;
}
Commit	Line	Data
0120d0f1 TS	1	/*
	2	* digi00x-pcm.c - a part of driver for Digidesign Digi 002/003 family
	3	*
	4	* Copyright (c) 2014-2015 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	#include "digi00x.h"
	10
	11	static int hw_rule_rate(struct snd_pcm_hw_params *params,
	12	struct snd_pcm_hw_rule *rule)
	13	{
	14	struct snd_interval *r =
	15	hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
	16	const struct snd_interval *c =
	17	hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	18	struct snd_interval t = {
	19	.min = UINT_MAX, .max = 0, .integer = 1,
	20	};
	21	unsigned int i;
	22
	23	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
	24	if (!snd_interval_test(c,
	25	snd_dg00x_stream_pcm_channels[i]))
	26	continue;
	27
	28	t.min = min(t.min, snd_dg00x_stream_rates[i]);
	29	t.max = max(t.max, snd_dg00x_stream_rates[i]);
	30	}
	31
	32	return snd_interval_refine(r, &t);
	33	}
	34
	35	static int hw_rule_channels(struct snd_pcm_hw_params *params,
	36	struct snd_pcm_hw_rule *rule)
	37	{
	38	struct snd_interval *c =
	39	hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	40	const struct snd_interval *r =
	41	hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
	42	struct snd_interval t = {
	43	.min = UINT_MAX, .max = 0, .integer = 1,
	44	};
	45	unsigned int i;
	46
	47	for (i = 0; i < SND_DG00X_RATE_COUNT; i++) {
	48	if (!snd_interval_test(r, snd_dg00x_stream_rates[i]))
	49	continue;
	50
	51	t.min = min(t.min, snd_dg00x_stream_pcm_channels[i]);
	52	t.max = max(t.max, snd_dg00x_stream_pcm_channels[i]);
	53	}
	54
	55	return snd_interval_refine(c, &t);
	56	}
	57
	58	static int pcm_init_hw_params(struct snd_dg00x *dg00x,
	59	struct snd_pcm_substream *substream)
	60	{
	61	static const struct snd_pcm_hardware hardware = {
	62	.info = SNDRV_PCM_INFO_BATCH \|
	63	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	64	SNDRV_PCM_INFO_INTERLEAVED \|
65	SNDRV_PCM_INFO_JOINT_DUPLEX \|
66	SNDRV_PCM_INFO_MMAP \|
67	SNDRV_PCM_INFO_MMAP_VALID,
68	.rates = SNDRV_PCM_RATE_44100 \|
69	SNDRV_PCM_RATE_48000 \|
70	SNDRV_PCM_RATE_88200 \|
71	SNDRV_PCM_RATE_96000,
72	.rate_min = 44100,
73	.rate_max = 96000,
74	.channels_min = 10,
75	.channels_max = 18,
76	.period_bytes_min = 4 * 18,
77	.period_bytes_max = 4 * 18 * 2048,
78	.buffer_bytes_max = 4 * 18 * 2048 * 2,
79	.periods_min = 2,
80	.periods_max = UINT_MAX,
81	};
82	struct amdtp_stream *s;
83	int err;
84
85	substream->runtime->hw = hardware;
86
87	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
88	substream->runtime->hw.formats = SNDRV_PCM_FMTBIT_S32;
89	s = &dg00x->tx_stream;
90	} else {
91	substream->runtime->hw.formats = SNDRV_PCM_FMTBIT_S16 \|
92	SNDRV_PCM_FMTBIT_S32;
93	s = &dg00x->rx_stream;
94	}
95
96	err = snd_pcm_hw_rule_add(substream->runtime, 0,
97	SNDRV_PCM_HW_PARAM_CHANNELS,
98	hw_rule_channels, NULL,
99	SNDRV_PCM_HW_PARAM_RATE, -1);
100	if (err < 0)
101	return err;
102
103	err = snd_pcm_hw_rule_add(substream->runtime, 0,
104	SNDRV_PCM_HW_PARAM_RATE,
105	hw_rule_rate, NULL,
106	SNDRV_PCM_HW_PARAM_CHANNELS, -1);
107	if (err < 0)
108	return err;
109
110	return amdtp_dot_add_pcm_hw_constraints(s, substream->runtime);
111	}
112
113	static int pcm_open(struct snd_pcm_substream *substream)
114	{
115	struct snd_dg00x *dg00x = substream->private_data;
116	enum snd_dg00x_clock clock;
117	bool detect;
118	unsigned int rate;
119	int err;
120
660dd3d5 TS	121	err = snd_dg00x_stream_lock_try(dg00x);
	122	if (err < 0)
	123	goto end;
	124
0120d0f1 TS	125	err = pcm_init_hw_params(dg00x, substream);
0120d0f1 TS	126	if (err < 0)
660dd3d5	127	goto err_locked;
0120d0f1 TS	128
	129	/* Check current clock source. */
	130	err = snd_dg00x_stream_get_clock(dg00x, &clock);
	131	if (err < 0)
660dd3d5	132	goto err_locked;
0120d0f1 TS	133	if (clock != SND_DG00X_CLOCK_INTERNAL) {
	134	err = snd_dg00x_stream_check_external_clock(dg00x, &detect);
	135	if (err < 0)
660dd3d5	136	goto err_locked;
0120d0f1 TS	137	if (!detect) {
0120d0f1 TS	138	err = -EBUSY;
660dd3d5	139	goto err_locked;
0120d0f1 TS	140	}
	141	}
	142
	143	if ((clock != SND_DG00X_CLOCK_INTERNAL) \|\|
	144	amdtp_stream_pcm_running(&dg00x->rx_stream) \|\|
	145	amdtp_stream_pcm_running(&dg00x->tx_stream)) {
	146	err = snd_dg00x_stream_get_external_rate(dg00x, &rate);
	147	if (err < 0)
660dd3d5	148	goto err_locked;
0120d0f1 TS	149	substream->runtime->hw.rate_min = rate;
	150	substream->runtime->hw.rate_max = rate;
	151	}
	152
	153	snd_pcm_set_sync(substream);
660dd3d5 TS	154	end:
	155	return err;
	156	err_locked:
	157	snd_dg00x_stream_lock_release(dg00x);
0120d0f1 TS	158	return err;
	159	}
	160
	161	static int pcm_close(struct snd_pcm_substream *substream)
	162	{
660dd3d5 TS	163	struct snd_dg00x *dg00x = substream->private_data;
	164
	165	snd_dg00x_stream_lock_release(dg00x);
	166
0120d0f1 TS	167	return 0;
	168	}
	169
	170	static int pcm_capture_hw_params(struct snd_pcm_substream *substream,
	171	struct snd_pcm_hw_params *hw_params)
	172	{
	173	struct snd_dg00x *dg00x = substream->private_data;
	174	int err;
	175
	176	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	177	params_buffer_bytes(hw_params));
	178	if (err < 0)
	179	return err;
	180
	181	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
	182	mutex_lock(&dg00x->mutex);
	183	dg00x->substreams_counter++;
	184	mutex_unlock(&dg00x->mutex);
	185	}
	186
	187	amdtp_dot_set_pcm_format(&dg00x->tx_stream, params_format(hw_params));
	188
	189	return 0;
	190	}
	191
	192	static int pcm_playback_hw_params(struct snd_pcm_substream *substream,
	193	struct snd_pcm_hw_params *hw_params)
	194	{
	195	struct snd_dg00x *dg00x = substream->private_data;
	196	int err;
	197
	198	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	199	params_buffer_bytes(hw_params));
	200	if (err < 0)
	201	return err;
	202
	203	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
	204	mutex_lock(&dg00x->mutex);
	205	dg00x->substreams_counter++;
	206	mutex_unlock(&dg00x->mutex);
	207	}
	208
	209	amdtp_dot_set_pcm_format(&dg00x->rx_stream, params_format(hw_params));
	210
	211	return 0;
	212	}
	213
	214	static int pcm_capture_hw_free(struct snd_pcm_substream *substream)
	215	{
	216	struct snd_dg00x *dg00x = substream->private_data;
	217
	218	mutex_lock(&dg00x->mutex);
	219
	220	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
	221	dg00x->substreams_counter--;
	222
	223	snd_dg00x_stream_stop_duplex(dg00x);
	224
	225	mutex_unlock(&dg00x->mutex);
	226
	227	return snd_pcm_lib_free_vmalloc_buffer(substream);
	228	}
	229
	230	static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
231	{
232	struct snd_dg00x *dg00x = substream->private_data;
233
234	mutex_lock(&dg00x->mutex);
235
236	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
237	dg00x->substreams_counter--;
238
239	snd_dg00x_stream_stop_duplex(dg00x);
240
241	mutex_unlock(&dg00x->mutex);
242
243	return snd_pcm_lib_free_vmalloc_buffer(substream);
244	}
245
246	static int pcm_capture_prepare(struct snd_pcm_substream *substream)
247	{
248	struct snd_dg00x *dg00x = substream->private_data;
249	struct snd_pcm_runtime *runtime = substream->runtime;
250	int err;
251
252	mutex_lock(&dg00x->mutex);
253
254	err = snd_dg00x_stream_start_duplex(dg00x, runtime->rate);
255	if (err >= 0)
256	amdtp_stream_pcm_prepare(&dg00x->tx_stream);
257
258	mutex_unlock(&dg00x->mutex);
259
260	return err;
261	}
262
263	static int pcm_playback_prepare(struct snd_pcm_substream *substream)
264	{
265	struct snd_dg00x *dg00x = substream->private_data;
266	struct snd_pcm_runtime *runtime = substream->runtime;
267	int err;
268
269	mutex_lock(&dg00x->mutex);
270
271	err = snd_dg00x_stream_start_duplex(dg00x, runtime->rate);
272	if (err >= 0) {
273	amdtp_stream_pcm_prepare(&dg00x->rx_stream);
274	amdtp_dot_reset(&dg00x->rx_stream);
275	}
276
277	mutex_unlock(&dg00x->mutex);
278
279	return err;
280	}
281
282	static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
283	{
284	struct snd_dg00x *dg00x = substream->private_data;
285
286	switch (cmd) {
287	case SNDRV_PCM_TRIGGER_START:
288	amdtp_stream_pcm_trigger(&dg00x->tx_stream, substream);
289	break;
290	case SNDRV_PCM_TRIGGER_STOP:
291	amdtp_stream_pcm_trigger(&dg00x->tx_stream, NULL);
292	break;
293	default:
294	return -EINVAL;
295	}
296
297	return 0;
298	}
299
300	static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
301	{
302	struct snd_dg00x *dg00x = substream->private_data;
303
304	switch (cmd) {
305	case SNDRV_PCM_TRIGGER_START:
306	amdtp_stream_pcm_trigger(&dg00x->rx_stream, substream);
307	break;
308	case SNDRV_PCM_TRIGGER_STOP:
309	amdtp_stream_pcm_trigger(&dg00x->rx_stream, NULL);
310	break;
311	default:
312	return -EINVAL;
313	}
314
315	return 0;
316	}
317
318	static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstrm)
319	{
320	struct snd_dg00x *dg00x = sbstrm->private_data;
321
322	return amdtp_stream_pcm_pointer(&dg00x->tx_stream);
323	}
324
325	static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstrm)
326	{
327	struct snd_dg00x *dg00x = sbstrm->private_data;
328
329	return amdtp_stream_pcm_pointer(&dg00x->rx_stream);
330	}
331
5116ffc3	332	static const struct snd_pcm_ops pcm_capture_ops = {
0120d0f1 TS	333	.open = pcm_open,
	334	.close = pcm_close,
	335	.ioctl = snd_pcm_lib_ioctl,
	336	.hw_params = pcm_capture_hw_params,
	337	.hw_free = pcm_capture_hw_free,
	338	.prepare = pcm_capture_prepare,
	339	.trigger = pcm_capture_trigger,
	340	.pointer = pcm_capture_pointer,
	341	.page = snd_pcm_lib_get_vmalloc_page,
	342	};
	343
5116ffc3	344	static const struct snd_pcm_ops pcm_playback_ops = {
0120d0f1 TS	345	.open = pcm_open,
	346	.close = pcm_close,
	347	.ioctl = snd_pcm_lib_ioctl,
	348	.hw_params = pcm_playback_hw_params,
	349	.hw_free = pcm_playback_hw_free,
	350	.prepare = pcm_playback_prepare,
	351	.trigger = pcm_playback_trigger,
	352	.pointer = pcm_playback_pointer,
	353	.page = snd_pcm_lib_get_vmalloc_page,
	354	.mmap = snd_pcm_lib_mmap_vmalloc,
	355	};
	356
	357	int snd_dg00x_create_pcm_devices(struct snd_dg00x *dg00x)
	358	{
	359	struct snd_pcm *pcm;
	360	int err;
	361
	362	err = snd_pcm_new(dg00x->card, dg00x->card->driver, 0, 1, 1, &pcm);
	363	if (err < 0)
	364	return err;
	365
	366	pcm->private_data = dg00x;
	367	snprintf(pcm->name, sizeof(pcm->name),
	368	"%s PCM", dg00x->card->shortname);
	369	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_playback_ops);
	370	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_capture_ops);
	371
	372	return 0;
	373	}