ALSA: usx2y: Don't peep the card internal object

Avoid traversing the device object list of the card instance just for
checking the PCM streams.  The driver's private object already
contains the array of substream pointers, so it can be simply looked
through.  The card internal may be restructured in future, thus better
not to rely on it.

Also, this fixes the possible deadlocks in PCM mutex.  Instead of
taking multiple PCM mutexes, just take the common mutex in all
places.  Along with it, rename prepare_mutex as pcm_mutex.

Signed-off-by: Takashi Iwai <tiwai@suse.de>

1 files changed, 34 insertions, 26 deletions

diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c
index 6234a51625b1..a63330dd1407 100644
--- a/sound/usb/usx2y/usbusx2yaudio.c
+++ b/sound/usb/usx2y/usbusx2yaudio.c
@@ -752,36 +752,44 @@ static int snd_usX2Y_pcm_hw_params(struct snd_pcm_substream *substream,
         unsigned int            rate = params_rate(hw_params);
         snd_pcm_format_t        format = params_format(hw_params);
         struct snd_card *card = substream->pstr->pcm->card;
-        struct list_head *list;
+        struct usX2Ydev *dev = usX2Y(card);
+        int i;
 
+        mutex_lock(&usX2Y(card)->pcm_mutex);
         snd_printdd("snd_usX2Y_hw_params(%p, %p)\n", substream, hw_params);
-        // all pcm substreams off one usX2Y have to operate at the same rate & format
-        list_for_each(list, &card->devices) {
-                struct snd_device *dev;
-                struct snd_pcm *pcm;
-                int s;
-                dev = snd_device(list);
-                if (dev->type != SNDRV_DEV_PCM)
+        /* all pcm substreams off one usX2Y have to operate at the same
+         * rate & format
+         */
+        for (i = 0; i < dev->pcm_devs * 2; i++) {
+                struct snd_usX2Y_substream *subs = dev->subs[i];
+                struct snd_pcm_substream *test_substream;
+
+                if (!subs)
+                        continue;
+                test_substream = subs->pcm_substream;
+                if (!test_substream || test_substream == substream ||
+                    !test_substream->runtime)
                         continue;
-                pcm = dev->device_data;
-                for (s = 0; s < 2; ++s) {
-                        struct snd_pcm_substream *test_substream;
-                        test_substream = pcm->streams[s].substream;
-                        if (test_substream && test_substream != substream  &&
-                            test_substream->runtime &&
-                            ((test_substream->runtime->format &&
-                              test_substream->runtime->format != format) ||
-                             (test_substream->runtime->rate &&
-                              test_substream->runtime->rate != rate)))
-                                return -EINVAL;
+                if ((test_substream->runtime->format &&
+                     test_substream->runtime->format != format) ||
+                    (test_substream->runtime->rate &&
+                     test_substream->runtime->rate != rate)) {
+                        err = -EINVAL;
+                        goto error;
                 }
         }
-        if (0 > (err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)))) {
+
+        err = snd_pcm_lib_malloc_pages(substream,
+                                       params_buffer_bytes(hw_params));
+        if (err < 0) {
                 snd_printk(KERN_ERR "snd_pcm_lib_malloc_pages(%p, %i) returned %i\n",
                            substream, params_buffer_bytes(hw_params), err);
-                return err;
+                goto error;
         }
-        return 0;
+
+ error:
+        mutex_unlock(&usX2Y(card)->pcm_mutex);
+        return err;
 }
 
 /*
@@ -791,7 +799,7 @@ static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_usX2Y_substream *subs = runtime->private_data;
-        mutex_lock(&subs->usX2Y->prepare_mutex);
+        mutex_lock(&subs->usX2Y->pcm_mutex);
         snd_printdd("snd_usX2Y_hw_free(%p)\n", substream);
 
         if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
@@ -812,7 +820,7 @@ static int snd_usX2Y_pcm_hw_free(struct snd_pcm_substream *substream)
                         usX2Y_urbs_release(subs);
                 }
         }
-        mutex_unlock(&subs->usX2Y->prepare_mutex);
+        mutex_unlock(&subs->usX2Y->pcm_mutex);
         return snd_pcm_lib_free_pages(substream);
 }
 /*
@@ -829,7 +837,7 @@ static int snd_usX2Y_pcm_prepare(struct snd_pcm_substream *substream)
         int err = 0;
         snd_printdd("snd_usX2Y_pcm_prepare(%p)\n", substream);
 
-        mutex_lock(&usX2Y->prepare_mutex);
+        mutex_lock(&usX2Y->pcm_mutex);
         usX2Y_subs_prepare(subs);
 // Start hardware streams
 // SyncStream first....
@@ -849,7 +857,7 @@ static int snd_usX2Y_pcm_prepare(struct snd_pcm_substream *substream)
                 err = usX2Y_urbs_start(subs);
 
  up_prepare_mutex:
-        mutex_unlock(&usX2Y->prepare_mutex);
+        mutex_unlock(&usX2Y->pcm_mutex);
         return err;
 }