~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/firewire/motu/motu-pcm.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * motu-pcm.c - a part of driver for MOTU FireWire series
  3  *
  4  * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>
  5  *
  6  * Licensed under the terms of the GNU General Public License, version 2.
  7  */
  8 
  9 #include <sound/pcm_params.h>
 10 #include "motu.h"
 11 
 12 static int motu_rate_constraint(struct snd_pcm_hw_params *params,
 13                                 struct snd_pcm_hw_rule *rule)
 14 {
 15         struct snd_motu_packet_format *formats = rule->private;
 16 
 17         const struct snd_interval *c =
 18                 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 19         struct snd_interval *r =
 20                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
 21         struct snd_interval rates = {
 22                 .min = UINT_MAX, .max = 0, .integer = 1
 23         };
 24         unsigned int i, pcm_channels, rate, mode;
 25 
 26         for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
 27                 rate = snd_motu_clock_rates[i];
 28                 mode = i / 2;
 29 
 30                 pcm_channels = formats->fixed_part_pcm_chunks[mode] +
 31                                formats->differed_part_pcm_chunks[mode];
 32                 if (!snd_interval_test(c, pcm_channels))
 33                         continue;
 34 
 35                 rates.min = min(rates.min, rate);
 36                 rates.max = max(rates.max, rate);
 37         }
 38 
 39         return snd_interval_refine(r, &rates);
 40 }
 41 
 42 static int motu_channels_constraint(struct snd_pcm_hw_params *params,
 43                                     struct snd_pcm_hw_rule *rule)
 44 {
 45         struct snd_motu_packet_format *formats = rule->private;
 46 
 47         const struct snd_interval *r =
 48                 hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
 49         struct snd_interval *c =
 50                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 51         struct snd_interval channels = {
 52                 .min = UINT_MAX, .max = 0, .integer = 1
 53         };
 54         unsigned int i, pcm_channels, rate, mode;
 55 
 56         for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
 57                 rate = snd_motu_clock_rates[i];
 58                 mode = i / 2;
 59 
 60                 if (!snd_interval_test(r, rate))
 61                         continue;
 62 
 63                 pcm_channels = formats->fixed_part_pcm_chunks[mode] +
 64                                formats->differed_part_pcm_chunks[mode];
 65                 channels.min = min(channels.min, pcm_channels);
 66                 channels.max = max(channels.max, pcm_channels);
 67         }
 68 
 69         return snd_interval_refine(c, &channels);
 70 }
 71 
 72 static void limit_channels_and_rates(struct snd_motu *motu,
 73                                      struct snd_pcm_runtime *runtime,
 74                                      struct snd_motu_packet_format *formats)
 75 {
 76         struct snd_pcm_hardware *hw = &runtime->hw;
 77         unsigned int i, pcm_channels, rate, mode;
 78 
 79         hw->channels_min = UINT_MAX;
 80         hw->channels_max = 0;
 81 
 82         for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {
 83                 rate = snd_motu_clock_rates[i];
 84                 mode = i / 2;
 85 
 86                 pcm_channels = formats->fixed_part_pcm_chunks[mode] +
 87                                formats->differed_part_pcm_chunks[mode];
 88                 if (pcm_channels == 0)
 89                         continue;
 90 
 91                 hw->rates |= snd_pcm_rate_to_rate_bit(rate);
 92                 hw->channels_min = min(hw->channels_min, pcm_channels);
 93                 hw->channels_max = max(hw->channels_max, pcm_channels);
 94         }
 95 
 96         snd_pcm_limit_hw_rates(runtime);
 97 }
 98 
 99 static int init_hw_info(struct snd_motu *motu,
100                         struct snd_pcm_substream *substream)
101 {
102         struct snd_pcm_runtime *runtime = substream->runtime;
103         struct snd_pcm_hardware *hw = &runtime->hw;
104         struct amdtp_stream *stream;
105         struct snd_motu_packet_format *formats;
106         int err;
107 
108         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
109                 hw->formats = SNDRV_PCM_FMTBIT_S32;
110                 stream = &motu->tx_stream;
111                 formats = &motu->tx_packet_formats;
112         } else {
113                 hw->formats = SNDRV_PCM_FMTBIT_S32;
114                 stream = &motu->rx_stream;
115                 formats = &motu->rx_packet_formats;
116         }
117 
118         limit_channels_and_rates(motu, runtime, formats);
119 
120         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
121                                   motu_rate_constraint, formats,
122                                   SNDRV_PCM_HW_PARAM_CHANNELS, -1);
123         if (err < 0)
124                 return err;
125         err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
126                                   motu_channels_constraint, formats,
127                                   SNDRV_PCM_HW_PARAM_RATE, -1);
128         if (err < 0)
129                 return err;
130 
131         return amdtp_motu_add_pcm_hw_constraints(stream, runtime);
132 }
133 
134 static int pcm_open(struct snd_pcm_substream *substream)
135 {
136         struct snd_motu *motu = substream->private_data;
137         const struct snd_motu_protocol *const protocol = motu->spec->protocol;
138         enum snd_motu_clock_source src;
139         unsigned int rate;
140         int err;
141 
142         err = snd_motu_stream_lock_try(motu);
143         if (err < 0)
144                 return err;
145 
146         mutex_lock(&motu->mutex);
147 
148         err = snd_motu_stream_cache_packet_formats(motu);
149         if (err < 0)
150                 goto err_locked;
151 
152         err = init_hw_info(motu, substream);
153         if (err < 0)
154                 goto err_locked;
155 
156         /*
157          * When source of clock is not internal or any PCM streams are running,
158          * available sampling rate is limited at current sampling rate.
159          */
160         err = protocol->get_clock_source(motu, &src);
161         if (err < 0)
162                 goto err_locked;
163         if (src != SND_MOTU_CLOCK_SOURCE_INTERNAL ||
164             amdtp_stream_pcm_running(&motu->tx_stream) ||
165             amdtp_stream_pcm_running(&motu->rx_stream)) {
166                 err = protocol->get_clock_rate(motu, &rate);
167                 if (err < 0)
168                         goto err_locked;
169                 substream->runtime->hw.rate_min = rate;
170                 substream->runtime->hw.rate_max = rate;
171         }
172 
173         snd_pcm_set_sync(substream);
174 
175         mutex_unlock(&motu->mutex);
176 
177         return err;
178 err_locked:
179         mutex_unlock(&motu->mutex);
180         snd_motu_stream_lock_release(motu);
181         return err;
182 }
183 
184 static int pcm_close(struct snd_pcm_substream *substream)
185 {
186         struct snd_motu *motu = substream->private_data;
187 
188         snd_motu_stream_lock_release(motu);
189 
190         return 0;
191 }
192 
193 static int capture_hw_params(struct snd_pcm_substream *substream,
194                              struct snd_pcm_hw_params *hw_params)
195 {
196         struct snd_motu *motu = substream->private_data;
197         int err;
198 
199         err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
200                                                params_buffer_bytes(hw_params));
201         if (err < 0)
202                 return err;
203 
204         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
205                 mutex_lock(&motu->mutex);
206                 motu->capture_substreams++;
207                 mutex_unlock(&motu->mutex);
208         }
209 
210         return 0;
211 }
212 static int playback_hw_params(struct snd_pcm_substream *substream,
213                               struct snd_pcm_hw_params *hw_params)
214 {
215         struct snd_motu *motu = substream->private_data;
216         int err;
217 
218         err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
219                                                params_buffer_bytes(hw_params));
220         if (err < 0)
221                 return err;
222 
223         if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
224                 mutex_lock(&motu->mutex);
225                 motu->playback_substreams++;
226                 mutex_unlock(&motu->mutex);
227         }
228 
229         return 0;
230 }
231 
232 static int capture_hw_free(struct snd_pcm_substream *substream)
233 {
234         struct snd_motu *motu = substream->private_data;
235 
236         mutex_lock(&motu->mutex);
237 
238         if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
239                 motu->capture_substreams--;
240 
241         snd_motu_stream_stop_duplex(motu);
242 
243         mutex_unlock(&motu->mutex);
244 
245         return snd_pcm_lib_free_vmalloc_buffer(substream);
246 }
247 
248 static int playback_hw_free(struct snd_pcm_substream *substream)
249 {
250         struct snd_motu *motu = substream->private_data;
251 
252         mutex_lock(&motu->mutex);
253 
254         if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
255                 motu->playback_substreams--;
256 
257         snd_motu_stream_stop_duplex(motu);
258 
259         mutex_unlock(&motu->mutex);
260 
261         return snd_pcm_lib_free_vmalloc_buffer(substream);
262 }
263 
264 static int capture_prepare(struct snd_pcm_substream *substream)
265 {
266         struct snd_motu *motu = substream->private_data;
267         int err;
268 
269         mutex_lock(&motu->mutex);
270         err = snd_motu_stream_start_duplex(motu, substream->runtime->rate);
271         mutex_unlock(&motu->mutex);
272         if (err >= 0)
273                 amdtp_stream_pcm_prepare(&motu->tx_stream);
274 
275         return 0;
276 }
277 static int playback_prepare(struct snd_pcm_substream *substream)
278 {
279         struct snd_motu *motu = substream->private_data;
280         int err;
281 
282         mutex_lock(&motu->mutex);
283         err = snd_motu_stream_start_duplex(motu, substream->runtime->rate);
284         mutex_unlock(&motu->mutex);
285         if (err >= 0)
286                 amdtp_stream_pcm_prepare(&motu->rx_stream);
287 
288         return err;
289 }
290 
291 static int capture_trigger(struct snd_pcm_substream *substream, int cmd)
292 {
293         struct snd_motu *motu = substream->private_data;
294 
295         switch (cmd) {
296         case SNDRV_PCM_TRIGGER_START:
297                 amdtp_stream_pcm_trigger(&motu->tx_stream, substream);
298                 break;
299         case SNDRV_PCM_TRIGGER_STOP:
300                 amdtp_stream_pcm_trigger(&motu->tx_stream, NULL);
301                 break;
302         default:
303                 return -EINVAL;
304         }
305 
306         return 0;
307 }
308 static int playback_trigger(struct snd_pcm_substream *substream, int cmd)
309 {
310         struct snd_motu *motu = substream->private_data;
311 
312         switch (cmd) {
313         case SNDRV_PCM_TRIGGER_START:
314                 amdtp_stream_pcm_trigger(&motu->rx_stream, substream);
315                 break;
316         case SNDRV_PCM_TRIGGER_STOP:
317                 amdtp_stream_pcm_trigger(&motu->rx_stream, NULL);
318                 break;
319         default:
320                 return -EINVAL;
321         }
322 
323         return 0;
324 }
325 
326 static snd_pcm_uframes_t capture_pointer(struct snd_pcm_substream *substream)
327 {
328         struct snd_motu *motu = substream->private_data;
329 
330         return amdtp_stream_pcm_pointer(&motu->tx_stream);
331 }
332 static snd_pcm_uframes_t playback_pointer(struct snd_pcm_substream *substream)
333 {
334         struct snd_motu *motu = substream->private_data;
335 
336         return amdtp_stream_pcm_pointer(&motu->rx_stream);
337 }
338 
339 static int capture_ack(struct snd_pcm_substream *substream)
340 {
341         struct snd_motu *motu = substream->private_data;
342 
343         return amdtp_stream_pcm_ack(&motu->tx_stream);
344 }
345 
346 static int playback_ack(struct snd_pcm_substream *substream)
347 {
348         struct snd_motu *motu = substream->private_data;
349 
350         return amdtp_stream_pcm_ack(&motu->rx_stream);
351 }
352 
353 int snd_motu_create_pcm_devices(struct snd_motu *motu)
354 {
355         static const struct snd_pcm_ops capture_ops = {
356                 .open      = pcm_open,
357                 .close     = pcm_close,
358                 .ioctl     = snd_pcm_lib_ioctl,
359                 .hw_params = capture_hw_params,
360                 .hw_free   = capture_hw_free,
361                 .prepare   = capture_prepare,
362                 .trigger   = capture_trigger,
363                 .pointer   = capture_pointer,
364                 .ack       = capture_ack,
365                 .page      = snd_pcm_lib_get_vmalloc_page,
366                 .mmap      = snd_pcm_lib_mmap_vmalloc,
367         };
368         static const struct snd_pcm_ops playback_ops = {
369                 .open      = pcm_open,
370                 .close     = pcm_close,
371                 .ioctl     = snd_pcm_lib_ioctl,
372                 .hw_params = playback_hw_params,
373                 .hw_free   = playback_hw_free,
374                 .prepare   = playback_prepare,
375                 .trigger   = playback_trigger,
376                 .pointer   = playback_pointer,
377                 .ack       = playback_ack,
378                 .page      = snd_pcm_lib_get_vmalloc_page,
379                 .mmap      = snd_pcm_lib_mmap_vmalloc,
380         };
381         struct snd_pcm *pcm;
382         int err;
383 
384         err = snd_pcm_new(motu->card, motu->card->driver, 0, 1, 1, &pcm);
385         if (err < 0)
386                 return err;
387         pcm->private_data = motu;
388         strcpy(pcm->name, motu->card->shortname);
389 
390         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);
391         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);
392 
393         return 0;
394 }
395 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp