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