[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 = pcm_init_hw_params(dg00x, substream);
	if (err < 0)
		return err;

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

	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)
			return err;
		substream->runtime->hw.rate_min = rate;
		substream->runtime->hw.rate_max = rate;
	}

	snd_pcm_set_sync(substream);

	return err;
}

static int pcm_close(struct snd_pcm_substream *substream)
{
	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 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 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
121	err = pcm_init_hw_params(dg00x, substream);
122	if (err < 0)
123	return err;
124
125	/* Check current clock source. */
126	err = snd_dg00x_stream_get_clock(dg00x, &clock);
127	if (err < 0)
128	return err;
129	if (clock != SND_DG00X_CLOCK_INTERNAL) {
130	err = snd_dg00x_stream_check_external_clock(dg00x, &detect);
131	if (err < 0)
132	return err;
133	if (!detect) {
134	err = -EBUSY;
135	return err;
136	}
137	}
138
139	if ((clock != SND_DG00X_CLOCK_INTERNAL) \|\|
140	amdtp_stream_pcm_running(&dg00x->rx_stream) \|\|
141	amdtp_stream_pcm_running(&dg00x->tx_stream)) {
142	err = snd_dg00x_stream_get_external_rate(dg00x, &rate);
143	if (err < 0)
144	return err;
145	substream->runtime->hw.rate_min = rate;
146	substream->runtime->hw.rate_max = rate;
147	}
148
149	snd_pcm_set_sync(substream);
150
151	return err;
152	}
153
154	static int pcm_close(struct snd_pcm_substream *substream)
155	{
156	return 0;
157	}
158
159	static int pcm_capture_hw_params(struct snd_pcm_substream *substream,
160	struct snd_pcm_hw_params *hw_params)
161	{
162	struct snd_dg00x *dg00x = substream->private_data;
163	int err;
164
165	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
166	params_buffer_bytes(hw_params));
167	if (err < 0)
168	return err;
169
170	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
171	mutex_lock(&dg00x->mutex);
172	dg00x->substreams_counter++;
173	mutex_unlock(&dg00x->mutex);
174	}
175
176	amdtp_dot_set_pcm_format(&dg00x->tx_stream, params_format(hw_params));
177
178	return 0;
179	}
180
181	static int pcm_playback_hw_params(struct snd_pcm_substream *substream,
182	struct snd_pcm_hw_params *hw_params)
183	{
184	struct snd_dg00x *dg00x = substream->private_data;
185	int err;
186
187	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
188	params_buffer_bytes(hw_params));
189	if (err < 0)
190	return err;
191
192	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
193	mutex_lock(&dg00x->mutex);
194	dg00x->substreams_counter++;
195	mutex_unlock(&dg00x->mutex);
196	}
197
198	amdtp_dot_set_pcm_format(&dg00x->rx_stream, params_format(hw_params));
199
200	return 0;
201	}
202
203	static int pcm_capture_hw_free(struct snd_pcm_substream *substream)
204	{
205	struct snd_dg00x *dg00x = substream->private_data;
206
207	mutex_lock(&dg00x->mutex);
208
209	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
210	dg00x->substreams_counter--;
211
212	snd_dg00x_stream_stop_duplex(dg00x);
213
214	mutex_unlock(&dg00x->mutex);
215
216	return snd_pcm_lib_free_vmalloc_buffer(substream);
217	}
218
219	static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
220	{
221	struct snd_dg00x *dg00x = substream->private_data;
222
223	mutex_lock(&dg00x->mutex);
224
225	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
226	dg00x->substreams_counter--;
227
228	snd_dg00x_stream_stop_duplex(dg00x);
229
230	mutex_unlock(&dg00x->mutex);
231
232	return snd_pcm_lib_free_vmalloc_buffer(substream);
233	}
234
235	static int pcm_capture_prepare(struct snd_pcm_substream *substream)
236	{
237	struct snd_dg00x *dg00x = substream->private_data;
238	struct snd_pcm_runtime *runtime = substream->runtime;
239	int err;
240
241	mutex_lock(&dg00x->mutex);
242
243	err = snd_dg00x_stream_start_duplex(dg00x, runtime->rate);
244	if (err >= 0)
245	amdtp_stream_pcm_prepare(&dg00x->tx_stream);
246
247	mutex_unlock(&dg00x->mutex);
248
249	return err;
250	}
251
252	static int pcm_playback_prepare(struct snd_pcm_substream *substream)
253	{
254	struct snd_dg00x *dg00x = substream->private_data;
255	struct snd_pcm_runtime *runtime = substream->runtime;
256	int err;
257
258	mutex_lock(&dg00x->mutex);
259
260	err = snd_dg00x_stream_start_duplex(dg00x, runtime->rate);
261	if (err >= 0) {
262	amdtp_stream_pcm_prepare(&dg00x->rx_stream);
263	amdtp_dot_reset(&dg00x->rx_stream);
264	}
265
266	mutex_unlock(&dg00x->mutex);
267
268	return err;
269	}
270
271	static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
272	{
273	struct snd_dg00x *dg00x = substream->private_data;
274
275	switch (cmd) {
276	case SNDRV_PCM_TRIGGER_START:
277	amdtp_stream_pcm_trigger(&dg00x->tx_stream, substream);
278	break;
279	case SNDRV_PCM_TRIGGER_STOP:
280	amdtp_stream_pcm_trigger(&dg00x->tx_stream, NULL);
281	break;
282	default:
283	return -EINVAL;
284	}
285
286	return 0;
287	}
288
289	static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
290	{
291	struct snd_dg00x *dg00x = substream->private_data;
292
293	switch (cmd) {
294	case SNDRV_PCM_TRIGGER_START:
295	amdtp_stream_pcm_trigger(&dg00x->rx_stream, substream);
296	break;
297	case SNDRV_PCM_TRIGGER_STOP:
298	amdtp_stream_pcm_trigger(&dg00x->rx_stream, NULL);
299	break;
300	default:
301	return -EINVAL;
302	}
303
304	return 0;
305	}
306
307	static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstrm)
308	{
309	struct snd_dg00x *dg00x = sbstrm->private_data;
310
311	return amdtp_stream_pcm_pointer(&dg00x->tx_stream);
312	}
313
314	static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstrm)
315	{
316	struct snd_dg00x *dg00x = sbstrm->private_data;
317
318	return amdtp_stream_pcm_pointer(&dg00x->rx_stream);
319	}
320
321	static struct snd_pcm_ops pcm_capture_ops = {
322	.open = pcm_open,
323	.close = pcm_close,
324	.ioctl = snd_pcm_lib_ioctl,
325	.hw_params = pcm_capture_hw_params,
326	.hw_free = pcm_capture_hw_free,
327	.prepare = pcm_capture_prepare,
328	.trigger = pcm_capture_trigger,
329	.pointer = pcm_capture_pointer,
330	.page = snd_pcm_lib_get_vmalloc_page,
331	};
332
333	static struct snd_pcm_ops pcm_playback_ops = {
334	.open = pcm_open,
335	.close = pcm_close,
336	.ioctl = snd_pcm_lib_ioctl,
337	.hw_params = pcm_playback_hw_params,
338	.hw_free = pcm_playback_hw_free,
339	.prepare = pcm_playback_prepare,
340	.trigger = pcm_playback_trigger,
341	.pointer = pcm_playback_pointer,
342	.page = snd_pcm_lib_get_vmalloc_page,
343	.mmap = snd_pcm_lib_mmap_vmalloc,
344	};
345
346	int snd_dg00x_create_pcm_devices(struct snd_dg00x *dg00x)
347	{
348	struct snd_pcm *pcm;
349	int err;
350
351	err = snd_pcm_new(dg00x->card, dg00x->card->driver, 0, 1, 1, &pcm);
352	if (err < 0)
353	return err;
354
355	pcm->private_data = dg00x;
356	snprintf(pcm->name, sizeof(pcm->name),
357	"%s PCM", dg00x->card->shortname);
358	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_playback_ops);
359	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_capture_ops);
360
361	return 0;
362	}