1 // SPDX-License-Identifier: GPL-2.0-only
3 * dice_pcm.c - a part of driver for DICE based devices
5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
6 * Copyright (c) 2014 Takashi Sakamoto <o-takashi@sakamocchi.jp>
11 static int dice_rate_constraint(struct snd_pcm_hw_params *params,
12 struct snd_pcm_hw_rule *rule)
14 struct snd_pcm_substream *substream = rule->private;
15 struct snd_dice *dice = substream->private_data;
16 unsigned int index = substream->pcm->device;
18 const struct snd_interval *c =
19 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
20 struct snd_interval *r =
21 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
22 struct snd_interval rates = {
23 .min = UINT_MAX, .max = 0, .integer = 1
25 unsigned int *pcm_channels;
26 enum snd_dice_rate_mode mode;
29 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
30 pcm_channels = dice->tx_pcm_chs[index];
32 pcm_channels = dice->rx_pcm_chs[index];
34 for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
35 rate = snd_dice_rates[i];
36 if (snd_dice_stream_get_rate_mode(dice, rate, &mode) < 0)
39 if (!snd_interval_test(c, pcm_channels[mode]))
42 rates.min = min(rates.min, rate);
43 rates.max = max(rates.max, rate);
46 return snd_interval_refine(r, &rates);
49 static int dice_channels_constraint(struct snd_pcm_hw_params *params,
50 struct snd_pcm_hw_rule *rule)
52 struct snd_pcm_substream *substream = rule->private;
53 struct snd_dice *dice = substream->private_data;
54 unsigned int index = substream->pcm->device;
56 const struct snd_interval *r =
57 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
58 struct snd_interval *c =
59 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
60 struct snd_interval channels = {
61 .min = UINT_MAX, .max = 0, .integer = 1
63 unsigned int *pcm_channels;
64 enum snd_dice_rate_mode mode;
67 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
68 pcm_channels = dice->tx_pcm_chs[index];
70 pcm_channels = dice->rx_pcm_chs[index];
72 for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
73 rate = snd_dice_rates[i];
74 if (snd_dice_stream_get_rate_mode(dice, rate, &mode) < 0)
77 if (!snd_interval_test(r, rate))
80 channels.min = min(channels.min, pcm_channels[mode]);
81 channels.max = max(channels.max, pcm_channels[mode]);
84 return snd_interval_refine(c, &channels);
87 static int limit_channels_and_rates(struct snd_dice *dice,
88 struct snd_pcm_runtime *runtime,
89 enum amdtp_stream_direction dir,
92 struct snd_pcm_hardware *hw = &runtime->hw;
93 unsigned int *pcm_channels;
96 if (dir == AMDTP_IN_STREAM)
97 pcm_channels = dice->tx_pcm_chs[index];
99 pcm_channels = dice->rx_pcm_chs[index];
101 hw->channels_min = UINT_MAX;
102 hw->channels_max = 0;
104 for (i = 0; i < ARRAY_SIZE(snd_dice_rates); ++i) {
105 enum snd_dice_rate_mode mode;
106 unsigned int rate, channels;
108 rate = snd_dice_rates[i];
109 if (snd_dice_stream_get_rate_mode(dice, rate, &mode) < 0)
111 hw->rates |= snd_pcm_rate_to_rate_bit(rate);
113 channels = pcm_channels[mode];
116 hw->channels_min = min(hw->channels_min, channels);
117 hw->channels_max = max(hw->channels_max, channels);
120 snd_pcm_limit_hw_rates(runtime);
125 static int init_hw_info(struct snd_dice *dice,
126 struct snd_pcm_substream *substream)
128 struct snd_pcm_runtime *runtime = substream->runtime;
129 struct snd_pcm_hardware *hw = &runtime->hw;
130 unsigned int index = substream->pcm->device;
131 enum amdtp_stream_direction dir;
132 struct amdtp_stream *stream;
135 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
136 hw->formats = AM824_IN_PCM_FORMAT_BITS;
137 dir = AMDTP_IN_STREAM;
138 stream = &dice->tx_stream[index];
140 hw->formats = AM824_OUT_PCM_FORMAT_BITS;
141 dir = AMDTP_OUT_STREAM;
142 stream = &dice->rx_stream[index];
145 err = limit_channels_and_rates(dice, substream->runtime, dir,
150 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
151 dice_rate_constraint, substream,
152 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
155 err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
156 dice_channels_constraint, substream,
157 SNDRV_PCM_HW_PARAM_RATE, -1);
161 return amdtp_am824_add_pcm_hw_constraints(stream, runtime);
164 static int pcm_open(struct snd_pcm_substream *substream)
166 struct snd_dice *dice = substream->private_data;
167 struct amdtp_domain *d = &dice->domain;
172 err = snd_dice_stream_lock_try(dice);
176 err = init_hw_info(dice, substream);
180 err = snd_dice_transaction_get_clock_source(dice, &source);
184 case CLOCK_SOURCE_AES1:
185 case CLOCK_SOURCE_AES2:
186 case CLOCK_SOURCE_AES3:
187 case CLOCK_SOURCE_AES4:
188 case CLOCK_SOURCE_AES_ANY:
189 case CLOCK_SOURCE_ADAT:
190 case CLOCK_SOURCE_TDIF:
191 case CLOCK_SOURCE_WC:
199 mutex_lock(&dice->mutex);
201 // When source of clock is not internal or any stream is reserved for
202 // transmission of PCM frames, the available sampling rate is limited
205 (dice->substreams_counter > 0 && d->events_per_period > 0)) {
206 unsigned int frames_per_period = d->events_per_period;
207 unsigned int frames_per_buffer = d->events_per_buffer;
210 err = snd_dice_transaction_get_rate(dice, &rate);
212 mutex_unlock(&dice->mutex);
216 substream->runtime->hw.rate_min = rate;
217 substream->runtime->hw.rate_max = rate;
219 if (frames_per_period > 0) {
220 // For double_pcm_frame quirk.
222 frames_per_period *= 2;
223 frames_per_buffer *= 2;
226 err = snd_pcm_hw_constraint_minmax(substream->runtime,
227 SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
228 frames_per_period, frames_per_period);
230 mutex_unlock(&dice->mutex);
234 err = snd_pcm_hw_constraint_minmax(substream->runtime,
235 SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
236 frames_per_buffer, frames_per_buffer);
238 mutex_unlock(&dice->mutex);
244 mutex_unlock(&dice->mutex);
246 snd_pcm_set_sync(substream);
250 snd_dice_stream_lock_release(dice);
254 static int pcm_close(struct snd_pcm_substream *substream)
256 struct snd_dice *dice = substream->private_data;
258 snd_dice_stream_lock_release(dice);
263 static int pcm_hw_params(struct snd_pcm_substream *substream,
264 struct snd_pcm_hw_params *hw_params)
266 struct snd_dice *dice = substream->private_data;
269 err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
270 params_buffer_bytes(hw_params));
274 if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
275 unsigned int rate = params_rate(hw_params);
276 unsigned int events_per_period = params_period_size(hw_params);
277 unsigned int events_per_buffer = params_buffer_size(hw_params);
279 mutex_lock(&dice->mutex);
280 // For double_pcm_frame quirk.
282 events_per_period /= 2;
283 events_per_buffer /= 2;
285 err = snd_dice_stream_reserve_duplex(dice, rate,
286 events_per_period, events_per_buffer);
288 ++dice->substreams_counter;
289 mutex_unlock(&dice->mutex);
295 static int pcm_hw_free(struct snd_pcm_substream *substream)
297 struct snd_dice *dice = substream->private_data;
299 mutex_lock(&dice->mutex);
301 if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
302 --dice->substreams_counter;
304 snd_dice_stream_stop_duplex(dice);
306 mutex_unlock(&dice->mutex);
308 return snd_pcm_lib_free_vmalloc_buffer(substream);
311 static int capture_prepare(struct snd_pcm_substream *substream)
313 struct snd_dice *dice = substream->private_data;
314 struct amdtp_stream *stream = &dice->tx_stream[substream->pcm->device];
317 mutex_lock(&dice->mutex);
318 err = snd_dice_stream_start_duplex(dice);
319 mutex_unlock(&dice->mutex);
321 amdtp_stream_pcm_prepare(stream);
325 static int playback_prepare(struct snd_pcm_substream *substream)
327 struct snd_dice *dice = substream->private_data;
328 struct amdtp_stream *stream = &dice->rx_stream[substream->pcm->device];
331 mutex_lock(&dice->mutex);
332 err = snd_dice_stream_start_duplex(dice);
333 mutex_unlock(&dice->mutex);
335 amdtp_stream_pcm_prepare(stream);
340 static int capture_trigger(struct snd_pcm_substream *substream, int cmd)
342 struct snd_dice *dice = substream->private_data;
343 struct amdtp_stream *stream = &dice->tx_stream[substream->pcm->device];
346 case SNDRV_PCM_TRIGGER_START:
347 amdtp_stream_pcm_trigger(stream, substream);
349 case SNDRV_PCM_TRIGGER_STOP:
350 amdtp_stream_pcm_trigger(stream, NULL);
358 static int playback_trigger(struct snd_pcm_substream *substream, int cmd)
360 struct snd_dice *dice = substream->private_data;
361 struct amdtp_stream *stream = &dice->rx_stream[substream->pcm->device];
364 case SNDRV_PCM_TRIGGER_START:
365 amdtp_stream_pcm_trigger(stream, substream);
367 case SNDRV_PCM_TRIGGER_STOP:
368 amdtp_stream_pcm_trigger(stream, NULL);
377 static snd_pcm_uframes_t capture_pointer(struct snd_pcm_substream *substream)
379 struct snd_dice *dice = substream->private_data;
380 struct amdtp_stream *stream = &dice->tx_stream[substream->pcm->device];
382 return amdtp_stream_pcm_pointer(stream);
384 static snd_pcm_uframes_t playback_pointer(struct snd_pcm_substream *substream)
386 struct snd_dice *dice = substream->private_data;
387 struct amdtp_stream *stream = &dice->rx_stream[substream->pcm->device];
389 return amdtp_stream_pcm_pointer(stream);
392 static int capture_ack(struct snd_pcm_substream *substream)
394 struct snd_dice *dice = substream->private_data;
395 struct amdtp_stream *stream = &dice->tx_stream[substream->pcm->device];
397 return amdtp_stream_pcm_ack(stream);
400 static int playback_ack(struct snd_pcm_substream *substream)
402 struct snd_dice *dice = substream->private_data;
403 struct amdtp_stream *stream = &dice->rx_stream[substream->pcm->device];
405 return amdtp_stream_pcm_ack(stream);
408 int snd_dice_create_pcm(struct snd_dice *dice)
410 static const struct snd_pcm_ops capture_ops = {
413 .ioctl = snd_pcm_lib_ioctl,
414 .hw_params = pcm_hw_params,
415 .hw_free = pcm_hw_free,
416 .prepare = capture_prepare,
417 .trigger = capture_trigger,
418 .pointer = capture_pointer,
420 .page = snd_pcm_lib_get_vmalloc_page,
422 static const struct snd_pcm_ops playback_ops = {
425 .ioctl = snd_pcm_lib_ioctl,
426 .hw_params = pcm_hw_params,
427 .hw_free = pcm_hw_free,
428 .prepare = playback_prepare,
429 .trigger = playback_trigger,
430 .pointer = playback_pointer,
432 .page = snd_pcm_lib_get_vmalloc_page,
435 unsigned int capture, playback;
439 for (i = 0; i < MAX_STREAMS; i++) {
440 capture = playback = 0;
441 for (j = 0; j < SND_DICE_RATE_MODE_COUNT; ++j) {
442 if (dice->tx_pcm_chs[i][j] > 0)
444 if (dice->rx_pcm_chs[i][j] > 0)
448 err = snd_pcm_new(dice->card, "DICE", i, playback, capture,
452 pcm->private_data = dice;
453 strcpy(pcm->name, dice->card->shortname);
456 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
460 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,