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