ALSA: bebob: use the same size of period for PCM substream in AMDTP streams

In current implementation, when opening a PCM substream, it's needed to
check whether the opposite PCM substream runs. This is to assign
effectual constraints (e.g. sampling rate) to opened PCM substream.

The number of PCM substreams and MIDI substreams on AMDTP streams in
domain is recorded in own structure. Usage of this count is an
alternative of the above check. This is better because the count is
incremented in pcm.hw_params earlier than pcm.trigger.

This idea has one issue because it's incremented for MIDI substreams as
well. In current implementation, for a case that any MIDI substream run
and a PCM substream is going to start, PCM application to start the PCM
substream can decide hardware parameters by restart packet streaming.
Just checking the substream count can brings regression.

Now AMDTP domain structure has a member for the size of PCM period in
PCM substream which starts AMDTP streams in domain. When the value has
zero and the substream count is greater than 1, it means that any MIDI
substream starts AMDTP streams in domain. Usage of the value can resolve
the above issue.

This commit replaces the check with the substream count and the value for
the size of PCM period.

Signed-off-by: Takashi Sakamoto <o-takashi@sakamocchi.jp>
Link: https://lore.kernel.org/r/20191007110532.30270-11-o-takashi@sakamocchi.jp
Signed-off-by: Takashi Iwai <tiwai@suse.de>

diff --git a/sound/firewire/bebob/bebob_pcm.c b/sound/firewire/bebob/bebob_pcm.c
index 3b2227abf8a901b08e1c01538ee0ef1eebc01f1e..516c9874f4a1b4271d1dd2d3fdaf782b58a0b69d 100644 (file)
--- a/sound/firewire/bebob/bebob_pcm.c
+++ b/sound/firewire/bebob/bebob_pcm.c
@@ -129,18 +129,17 @@ end:
        return err;
 }
 
-static int
-pcm_open(struct snd_pcm_substream *substream)
+static int pcm_open(struct snd_pcm_substream *substream)
 {
        struct snd_bebob *bebob = substream->private_data;
        const struct snd_bebob_rate_spec *spec = bebob->spec->rate;
-       unsigned int sampling_rate;
+       struct amdtp_domain *d = &bebob->domain;
        enum snd_bebob_clock_type src;
        int err;
 
        err = snd_bebob_stream_lock_try(bebob);
        if (err < 0)
-               goto end;
+               return err;
 
        err = pcm_init_hw_params(bebob, substream);
        if (err < 0)
@@ -150,15 +149,19 @@ pcm_open(struct snd_pcm_substream *substream)
        if (err < 0)
                goto err_locked;
 
-       /*
-        * When source of clock is internal or any PCM stream are running,
-        * the available sampling rate is limited at current sampling rate.
-        */
+       mutex_lock(&bebob->mutex);
+
+       // When source of clock is not internal or any stream is reserved for
+       // transmission of PCM frames, the available sampling rate is limited
+       // at current one.
        if (src == SND_BEBOB_CLOCK_TYPE_EXTERNAL ||
-           amdtp_stream_pcm_running(&bebob->tx_stream) ||
-           amdtp_stream_pcm_running(&bebob->rx_stream)) {
+           (bebob->substreams_counter > 0 && d->events_per_period > 0)) {
+               unsigned int frames_per_period = d->events_per_period;
+               unsigned int sampling_rate;
+
                err = spec->get(bebob, &sampling_rate);
                if (err < 0) {
+                       mutex_unlock(&bebob->mutex);
                        dev_err(&bebob->unit->device,
                                "fail to get sampling rate: %d\n", err);
                        goto err_locked;
@@ -166,11 +169,23 @@ pcm_open(struct snd_pcm_substream *substream)
 
                substream->runtime->hw.rate_min = sampling_rate;
                substream->runtime->hw.rate_max = sampling_rate;
+
+               if (frames_per_period > 0) {
+                       err = snd_pcm_hw_constraint_minmax(substream->runtime,
+                                       SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+                                       frames_per_period, frames_per_period);
+                       if (err < 0) {
+                               mutex_unlock(&bebob->mutex);
+                               goto err_locked;
+                       }
+               }
        }
 
+       mutex_unlock(&bebob->mutex);
+
        snd_pcm_set_sync(substream);
-end:
-       return err;
+
+       return 0;
 err_locked:
        snd_bebob_stream_lock_release(bebob);
        return err;