1/*
2 * oxfw_pcm.c - a part of driver for OXFW970/971 based devices
3 *
4 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5 * Licensed under the terms of the GNU General Public License, version 2.
6 */
7
8#include "oxfw.h"
9
10static int hw_rule_rate(struct snd_pcm_hw_params *params,
11			struct snd_pcm_hw_rule *rule)
12{
13	u8 **formats = rule->private;
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	struct snd_oxfw_stream_formation formation;
22	int i, err;
23
24	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
25		if (formats[i] == NULL)
26			continue;
27
28		err = snd_oxfw_stream_parse_format(formats[i], &formation);
29		if (err < 0)
30			continue;
31		if (!snd_interval_test(c, formation.pcm))
32			continue;
33
34		t.min = min(t.min, formation.rate);
35		t.max = max(t.max, formation.rate);
36
37	}
38	return snd_interval_refine(r, &t);
39}
40
41static int hw_rule_channels(struct snd_pcm_hw_params *params,
42			    struct snd_pcm_hw_rule *rule)
43{
44	u8 **formats = rule->private;
45	struct snd_interval *c =
46		hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
47	const struct snd_interval *r =
48		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
49	struct snd_oxfw_stream_formation formation;
50	int i, j, err;
51	unsigned int count, list[SND_OXFW_STREAM_FORMAT_ENTRIES] = {0};
52
53	count = 0;
54	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
55		if (formats[i] == NULL)
56			break;
57
58		err = snd_oxfw_stream_parse_format(formats[i], &formation);
59		if (err < 0)
60			continue;
61		if (!snd_interval_test(r, formation.rate))
62			continue;
63		if (list[count] == formation.pcm)
64			continue;
65
66		for (j = 0; j < ARRAY_SIZE(list); j++) {
67			if (list[j] == formation.pcm)
68				break;
69		}
70		if (j == ARRAY_SIZE(list)) {
71			list[count] = formation.pcm;
72			if (++count == ARRAY_SIZE(list))
73				break;
74		}
75	}
76
77	return snd_interval_list(c, count, list, 0);
78}
79
80static void limit_channels_and_rates(struct snd_pcm_hardware *hw, u8 **formats)
81{
82	struct snd_oxfw_stream_formation formation;
83	int i, err;
84
85	hw->channels_min = UINT_MAX;
86	hw->channels_max = 0;
87
88	hw->rate_min = UINT_MAX;
89	hw->rate_max = 0;
90	hw->rates = 0;
91
92	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
93		if (formats[i] == NULL)
94			break;
95
96		err = snd_oxfw_stream_parse_format(formats[i], &formation);
97		if (err < 0)
98			continue;
99
100		hw->channels_min = min(hw->channels_min, formation.pcm);
101		hw->channels_max = max(hw->channels_max, formation.pcm);
102
103		hw->rate_min = min(hw->rate_min, formation.rate);
104		hw->rate_max = max(hw->rate_max, formation.rate);
105		hw->rates |= snd_pcm_rate_to_rate_bit(formation.rate);
106	}
107}
108
109static void limit_period_and_buffer(struct snd_pcm_hardware *hw)
110{
111	hw->periods_min = 2;		/* SNDRV_PCM_INFO_BATCH */
112	hw->periods_max = UINT_MAX;
113
114	hw->period_bytes_min = 4 * hw->channels_max;	/* bytes for a frame */
115
116	/* Just to prevent from allocating much pages. */
117	hw->period_bytes_max = hw->period_bytes_min * 2048;
118	hw->buffer_bytes_max = hw->period_bytes_max * hw->periods_min;
119}
120
121static int init_hw_params(struct snd_oxfw *oxfw,
122			  struct snd_pcm_substream *substream)
123{
124	struct snd_pcm_runtime *runtime = substream->runtime;
125	u8 **formats;
126	struct amdtp_stream *stream;
127	int err;
128
129	runtime->hw.info = SNDRV_PCM_INFO_BATCH |
130			   SNDRV_PCM_INFO_BLOCK_TRANSFER |
131			   SNDRV_PCM_INFO_INTERLEAVED |
132			   SNDRV_PCM_INFO_JOINT_DUPLEX |
133			   SNDRV_PCM_INFO_MMAP |
134			   SNDRV_PCM_INFO_MMAP_VALID;
135
136	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
137		runtime->hw.formats = AMDTP_IN_PCM_FORMAT_BITS;
138		stream = &oxfw->tx_stream;
139		formats = oxfw->tx_stream_formats;
140	} else {
141		runtime->hw.formats = AMDTP_OUT_PCM_FORMAT_BITS;
142		stream = &oxfw->rx_stream;
143		formats = oxfw->rx_stream_formats;
144	}
145
146	limit_channels_and_rates(&runtime->hw, formats);
147	limit_period_and_buffer(&runtime->hw);
148
149	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
150				  hw_rule_channels, formats,
151				  SNDRV_PCM_HW_PARAM_RATE, -1);
152	if (err < 0)
153		goto end;
154
155	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
156				  hw_rule_rate, formats,
157				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
158	if (err < 0)
159		goto end;
160
161	err = amdtp_stream_add_pcm_hw_constraints(stream, runtime);
162end:
163	return err;
164}
165
166static int limit_to_current_params(struct snd_pcm_substream *substream)
167{
168	struct snd_oxfw *oxfw = substream->private_data;
169	struct snd_oxfw_stream_formation formation;
170	enum avc_general_plug_dir dir;
171	int err;
172
173	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
174		dir = AVC_GENERAL_PLUG_DIR_OUT;
175	else
176		dir = AVC_GENERAL_PLUG_DIR_IN;
177
178	err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
179	if (err < 0)
180		goto end;
181
182	substream->runtime->hw.channels_min = formation.pcm;
183	substream->runtime->hw.channels_max = formation.pcm;
184	substream->runtime->hw.rate_min = formation.rate;
185	substream->runtime->hw.rate_max = formation.rate;
186end:
187	return err;
188}
189
190static int pcm_open(struct snd_pcm_substream *substream)
191{
192	struct snd_oxfw *oxfw = substream->private_data;
193	int err;
194
195	err = snd_oxfw_stream_lock_try(oxfw);
196	if (err < 0)
197		goto end;
198
199	err = init_hw_params(oxfw, substream);
200	if (err < 0)
201		goto err_locked;
202
203	/*
204	 * When any PCM streams are already running, the available sampling
205	 * rate is limited at current value.
206	 */
207	if (amdtp_stream_pcm_running(&oxfw->tx_stream) ||
208	    amdtp_stream_pcm_running(&oxfw->rx_stream)) {
209		err = limit_to_current_params(substream);
210		if (err < 0)
211			goto end;
212	}
213
214	snd_pcm_set_sync(substream);
215end:
216	return err;
217err_locked:
218	snd_oxfw_stream_lock_release(oxfw);
219	return err;
220}
221
222static int pcm_close(struct snd_pcm_substream *substream)
223{
224	struct snd_oxfw *oxfw = substream->private_data;
225
226	snd_oxfw_stream_lock_release(oxfw);
227	return 0;
228}
229
230static int pcm_capture_hw_params(struct snd_pcm_substream *substream,
231				 struct snd_pcm_hw_params *hw_params)
232{
233	struct snd_oxfw *oxfw = substream->private_data;
234
235
236	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
237		mutex_lock(&oxfw->mutex);
238		oxfw->capture_substreams++;
239		mutex_unlock(&oxfw->mutex);
240	}
241
242	amdtp_stream_set_pcm_format(&oxfw->tx_stream, params_format(hw_params));
243
244	return snd_pcm_lib_alloc_vmalloc_buffer(substream,
245						params_buffer_bytes(hw_params));
246}
247static int pcm_playback_hw_params(struct snd_pcm_substream *substream,
248				  struct snd_pcm_hw_params *hw_params)
249{
250	struct snd_oxfw *oxfw = substream->private_data;
251
252	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
253		mutex_lock(&oxfw->mutex);
254		oxfw->playback_substreams++;
255		mutex_unlock(&oxfw->mutex);
256	}
257
258	amdtp_stream_set_pcm_format(&oxfw->rx_stream, params_format(hw_params));
259
260	return snd_pcm_lib_alloc_vmalloc_buffer(substream,
261						params_buffer_bytes(hw_params));
262}
263
264static int pcm_capture_hw_free(struct snd_pcm_substream *substream)
265{
266	struct snd_oxfw *oxfw = substream->private_data;
267
268	mutex_lock(&oxfw->mutex);
269
270	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
271		oxfw->capture_substreams--;
272
273	snd_oxfw_stream_stop_simplex(oxfw, &oxfw->tx_stream);
274
275	mutex_unlock(&oxfw->mutex);
276
277	return snd_pcm_lib_free_vmalloc_buffer(substream);
278}
279static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
280{
281	struct snd_oxfw *oxfw = substream->private_data;
282
283	mutex_lock(&oxfw->mutex);
284
285	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
286		oxfw->playback_substreams--;
287
288	snd_oxfw_stream_stop_simplex(oxfw, &oxfw->rx_stream);
289
290	mutex_unlock(&oxfw->mutex);
291
292	return snd_pcm_lib_free_vmalloc_buffer(substream);
293}
294
295static int pcm_capture_prepare(struct snd_pcm_substream *substream)
296{
297	struct snd_oxfw *oxfw = substream->private_data;
298	struct snd_pcm_runtime *runtime = substream->runtime;
299	int err;
300
301	mutex_lock(&oxfw->mutex);
302	err = snd_oxfw_stream_start_simplex(oxfw, &oxfw->tx_stream,
303					    runtime->rate, runtime->channels);
304	mutex_unlock(&oxfw->mutex);
305	if (err < 0)
306		goto end;
307
308	amdtp_stream_pcm_prepare(&oxfw->tx_stream);
309end:
310	return err;
311}
312static int pcm_playback_prepare(struct snd_pcm_substream *substream)
313{
314	struct snd_oxfw *oxfw = substream->private_data;
315	struct snd_pcm_runtime *runtime = substream->runtime;
316	int err;
317
318	mutex_lock(&oxfw->mutex);
319	err = snd_oxfw_stream_start_simplex(oxfw, &oxfw->rx_stream,
320					    runtime->rate, runtime->channels);
321	mutex_unlock(&oxfw->mutex);
322	if (err < 0)
323		goto end;
324
325	amdtp_stream_pcm_prepare(&oxfw->rx_stream);
326end:
327	return err;
328}
329
330static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
331{
332	struct snd_oxfw *oxfw = substream->private_data;
333	struct snd_pcm_substream *pcm;
334
335	switch (cmd) {
336	case SNDRV_PCM_TRIGGER_START:
337		pcm = substream;
338		break;
339	case SNDRV_PCM_TRIGGER_STOP:
340		pcm = NULL;
341		break;
342	default:
343		return -EINVAL;
344	}
345	amdtp_stream_pcm_trigger(&oxfw->tx_stream, pcm);
346	return 0;
347}
348static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
349{
350	struct snd_oxfw *oxfw = substream->private_data;
351	struct snd_pcm_substream *pcm;
352
353	switch (cmd) {
354	case SNDRV_PCM_TRIGGER_START:
355		pcm = substream;
356		break;
357	case SNDRV_PCM_TRIGGER_STOP:
358		pcm = NULL;
359		break;
360	default:
361		return -EINVAL;
362	}
363	amdtp_stream_pcm_trigger(&oxfw->rx_stream, pcm);
364	return 0;
365}
366
367static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstm)
368{
369	struct snd_oxfw *oxfw = sbstm->private_data;
370
371	return amdtp_stream_pcm_pointer(&oxfw->tx_stream);
372}
373static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstm)
374{
375	struct snd_oxfw *oxfw = sbstm->private_data;
376
377	return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
378}
379
380int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
381{
382	static struct snd_pcm_ops capture_ops = {
383		.open      = pcm_open,
384		.close     = pcm_close,
385		.ioctl     = snd_pcm_lib_ioctl,
386		.hw_params = pcm_capture_hw_params,
387		.hw_free   = pcm_capture_hw_free,
388		.prepare   = pcm_capture_prepare,
389		.trigger   = pcm_capture_trigger,
390		.pointer   = pcm_capture_pointer,
391		.page      = snd_pcm_lib_get_vmalloc_page,
392		.mmap      = snd_pcm_lib_mmap_vmalloc,
393	};
394	static struct snd_pcm_ops playback_ops = {
395		.open      = pcm_open,
396		.close     = pcm_close,
397		.ioctl     = snd_pcm_lib_ioctl,
398		.hw_params = pcm_playback_hw_params,
399		.hw_free   = pcm_playback_hw_free,
400		.prepare   = pcm_playback_prepare,
401		.trigger   = pcm_playback_trigger,
402		.pointer   = pcm_playback_pointer,
403		.page      = snd_pcm_lib_get_vmalloc_page,
404		.mmap      = snd_pcm_lib_mmap_vmalloc,
405	};
406	struct snd_pcm *pcm;
407	unsigned int cap = 0;
408	int err;
409
410	if (oxfw->has_output)
411		cap = 1;
412
413	err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, cap, &pcm);
414	if (err < 0)
415		return err;
416
417	pcm->private_data = oxfw;
418	strcpy(pcm->name, oxfw->card->shortname);
419	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);
420	if (cap > 0)
421		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);
422
423	return 0;
424}
425