12 files changed, 192 insertions, 134 deletions

diff --git a/sound/usb/6fire/chip.c b/sound/usb/6fire/chip.c
index 66edc4a7917f..e0fe0d92db8c 100644
--- a/sound/usb/6fire/chip.c
+++ b/sound/usb/6fire/chip.c
@@ -124,8 +124,8 @@ static int usb6fire_chip_probe(struct usb_interface *intf,
                 snd_printk(KERN_ERR PREFIX "can't set first interface.\n");
                 return -EIO;
         }
-        ret = snd_card_create(index[regidx], id[regidx], THIS_MODULE,
-                        sizeof(struct sfire_chip), &card);
+        ret = snd_card_new(&intf->dev, index[regidx], id[regidx],
+                           THIS_MODULE, sizeof(struct sfire_chip), &card);
         if (ret < 0) {
                 snd_printk(KERN_ERR PREFIX "cannot create alsa card.\n");
                 return ret;
@@ -134,7 +134,6 @@ static int usb6fire_chip_probe(struct usb_interface *intf,
         strcpy(card->shortname, "TerraTec DMX6FireUSB");
         sprintf(card->longname, "%s at %d:%d", card->shortname,
                         device->bus->busnum, device->devnum);
-        snd_card_set_dev(card, &intf->dev);
 
         chip = card->private_data;
         chips[regidx] = chip;
diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c
index bc55f708a696..b871ba407e4e 100644
--- a/sound/usb/caiaq/device.c
+++ b/sound/usb/caiaq/device.c
@@ -418,8 +418,9 @@ static int create_card(struct usb_device *usb_dev,
         if (devnum >= SNDRV_CARDS)
                 return -ENODEV;
 
-        err = snd_card_create(index[devnum], id[devnum], THIS_MODULE,
-                              sizeof(struct snd_usb_caiaqdev), &card);
+        err = snd_card_new(&intf->dev,
+                           index[devnum], id[devnum], THIS_MODULE,
+                           sizeof(struct snd_usb_caiaqdev), &card);
         if (err < 0)
                 return err;
 
@@ -429,7 +430,6 @@ static int create_card(struct usb_device *usb_dev,
         cdev->chip.usb_id = USB_ID(le16_to_cpu(usb_dev->descriptor.idVendor),
                                   le16_to_cpu(usb_dev->descriptor.idProduct));
         spin_lock_init(&cdev->spinlock);
-        snd_card_set_dev(card, &intf->dev);
 
         *cardp = card;
         return 0;
diff --git a/sound/usb/card.c b/sound/usb/card.c
index d979050e6a6a..0cfdc2d3b631 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -328,7 +328,8 @@ static void remove_trailing_spaces(char *str)
 /*
  * create a chip instance and set its names.
  */
-static int snd_usb_audio_create(struct usb_device *dev, int idx,
+static int snd_usb_audio_create(struct usb_interface *intf,
+                                struct usb_device *dev, int idx,
                                 const struct snd_usb_audio_quirk *quirk,
                                 struct snd_usb_audio **rchip)
 {
@@ -354,7 +355,8 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
                 return -ENXIO;
         }
 
-        err = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card);
+        err = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE,
+                           0, &card);
         if (err < 0) {
                 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
                 return err;
@@ -513,10 +515,10 @@ snd_usb_audio_probe(struct usb_device *dev,
                         if (enable[i] && ! usb_chip[i] &&
                             (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
                             (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
-                                if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
+                                if (snd_usb_audio_create(intf, dev, i, quirk,
+                                                         &chip) < 0) {
                                         goto __error;
                                 }
-                                snd_card_set_dev(chip->card, &intf->dev);
                                 chip->pm_intf = intf;
                                 break;
                         }
@@ -691,12 +693,12 @@ static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
         }
 
         list_for_each_entry(mixer, &chip->mixer_list, list)
-                snd_usb_mixer_inactivate(mixer);
+                snd_usb_mixer_suspend(mixer);
 
         return 0;
 }
 
-static int usb_audio_resume(struct usb_interface *intf)
+static int __usb_audio_resume(struct usb_interface *intf, bool reset_resume)
 {
         struct snd_usb_audio *chip = usb_get_intfdata(intf);
         struct usb_mixer_interface *mixer;
@@ -711,7 +713,7 @@ static int usb_audio_resume(struct usb_interface *intf)
          * we just notify and restart the mixers
          */
         list_for_each_entry(mixer, &chip->mixer_list, list) {
-                err = snd_usb_mixer_activate(mixer);
+                err = snd_usb_mixer_resume(mixer, reset_resume);
                 if (err < 0)
                         goto err_out;
         }
@@ -723,9 +725,20 @@ static int usb_audio_resume(struct usb_interface *intf)
 err_out:
         return err;
 }
+
+static int usb_audio_resume(struct usb_interface *intf)
+{
+        return __usb_audio_resume(intf, false);
+}
+
+static int usb_audio_reset_resume(struct usb_interface *intf)
+{
+        return __usb_audio_resume(intf, true);
+}
 #else
 #define usb_audio_suspend       NULL
 #define usb_audio_resume        NULL
+#define usb_audio_reset_resume  NULL
 #endif          /* CONFIG_PM */
 
 static struct usb_device_id usb_audio_ids [] = {
@@ -747,6 +760,7 @@ static struct usb_driver usb_audio_driver = {
         .disconnect =   usb_audio_disconnect,
         .suspend =      usb_audio_suspend,
         .resume =       usb_audio_resume,
+        .reset_resume = usb_audio_reset_resume,
         .id_table =     usb_audio_ids,
         .supports_autosuspend = 1,
 };
diff --git a/sound/usb/hiface/chip.c b/sound/usb/hiface/chip.c
index b0dcb3924ce5..2670d646bda9 100644
--- a/sound/usb/hiface/chip.c
+++ b/sound/usb/hiface/chip.c
@@ -64,7 +64,8 @@ struct hiface_vendor_quirk {
         u8 extra_freq;
 };
 
-static int hiface_chip_create(struct usb_device *device, int idx,
+static int hiface_chip_create(struct usb_interface *intf,
+                              struct usb_device *device, int idx,
                               const struct hiface_vendor_quirk *quirk,
                               struct hiface_chip **rchip)
 {
@@ -76,7 +77,8 @@ static int hiface_chip_create(struct usb_device *device, int idx,
         *rchip = NULL;
 
         /* if we are here, card can be registered in alsa. */
-        ret = snd_card_create(index[idx], id[idx], THIS_MODULE, sizeof(*chip), &card);
+        ret = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE,
+                           sizeof(*chip), &card);
         if (ret < 0) {
                 dev_err(&device->dev, "cannot create alsa card.\n");
                 return ret;
@@ -132,12 +134,10 @@ static int hiface_chip_probe(struct usb_interface *intf,
                 goto err;
         }
 
-        ret = hiface_chip_create(device, i, quirk, &chip);
+        ret = hiface_chip_create(intf, device, i, quirk, &chip);
         if (ret < 0)
                 goto err;
 
-        snd_card_set_dev(chip->card, &intf->dev);
-
         ret = hiface_pcm_init(chip, quirk ? quirk->extra_freq : 0);
         if (ret < 0)
                 goto err_chip_destroy;
diff --git a/sound/usb/misc/ua101.c b/sound/usb/misc/ua101.c
index 509315937f25..a1bab149df4d 100644
--- a/sound/usb/misc/ua101.c
+++ b/sound/usb/misc/ua101.c
@@ -1243,8 +1243,9 @@ static int ua101_probe(struct usb_interface *interface,
                 mutex_unlock(&devices_mutex);
                 return -ENOENT;
         }
-        err = snd_card_create(index[card_index], id[card_index], THIS_MODULE,
-                              sizeof(*ua), &card);
+        err = snd_card_new(&interface->dev,
+                           index[card_index], id[card_index], THIS_MODULE,
+                           sizeof(*ua), &card);
         if (err < 0) {
                 mutex_unlock(&devices_mutex);
                 return err;
@@ -1283,8 +1284,6 @@ static int ua101_probe(struct usb_interface *interface,
                 }
         }
 
-        snd_card_set_dev(card, &interface->dev);
-
         err = detect_usb_format(ua);
         if (err < 0)
                 goto probe_error;
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 44b0ba4feab3..8c152b02da5a 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -2299,26 +2299,6 @@ requeue:
         }
 }
 
-/* stop any bus activity of a mixer */
-void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
-{
-        usb_kill_urb(mixer->urb);
-        usb_kill_urb(mixer->rc_urb);
-}
-
-int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
-{
-        int err;
-
-        if (mixer->urb) {
-                err = usb_submit_urb(mixer->urb, GFP_NOIO);
-                if (err < 0)
-                        return err;
-        }
-
-        return 0;
-}
-
 /* create the handler for the optional status interrupt endpoint */
 static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
 {
@@ -2393,7 +2373,7 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
 
         snd_usb_mixer_apply_create_quirk(mixer);
 
-        err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
+        err = snd_device_new(chip->card, SNDRV_DEV_CODEC, mixer, &dev_ops);
         if (err < 0)
                 goto _error;
 
@@ -2417,3 +2397,82 @@ void snd_usb_mixer_disconnect(struct list_head *p)
         usb_kill_urb(mixer->urb);
         usb_kill_urb(mixer->rc_urb);
 }
+
+#ifdef CONFIG_PM
+/* stop any bus activity of a mixer */
+static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
+{
+        usb_kill_urb(mixer->urb);
+        usb_kill_urb(mixer->rc_urb);
+}
+
+static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
+{
+        int err;
+
+        if (mixer->urb) {
+                err = usb_submit_urb(mixer->urb, GFP_NOIO);
+                if (err < 0)
+                        return err;
+        }
+
+        return 0;
+}
+
+int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
+{
+        snd_usb_mixer_inactivate(mixer);
+        return 0;
+}
+
+static int restore_mixer_value(struct usb_mixer_elem_info *cval)
+{
+        int c, err, idx;
+
+        if (cval->cmask) {
+                idx = 0;
+                for (c = 0; c < MAX_CHANNELS; c++) {
+                        if (!(cval->cmask & (1 << c)))
+                                continue;
+                        if (cval->cached & (1 << c)) {
+                                err = set_cur_mix_value(cval, c + 1, idx,
+                                                        cval->cache_val[idx]);
+                                if (err < 0)
+                                        return err;
+                        }
+                        idx++;
+                }
+        } else {
+                /* master */
+                if (cval->cached) {
+                        err = set_cur_mix_value(cval, 0, 0, *cval->cache_val);
+                        if (err < 0)
+                                return err;
+                }
+        }
+
+        return 0;
+}
+
+int snd_usb_mixer_resume(struct usb_mixer_interface *mixer, bool reset_resume)
+{
+        struct usb_mixer_elem_info *cval;
+        int id, err;
+
+        /* FIXME: any mixer quirks? */
+
+        if (reset_resume) {
+                /* restore cached mixer values */
+                for (id = 0; id < MAX_ID_ELEMS; id++) {
+                        for (cval = mixer->id_elems[id]; cval;
+                             cval = cval->next_id_elem) {
+                                err = restore_mixer_value(cval);
+                                if (err < 0)
+                                        return err;
+                        }
+                }
+        }
+
+        return snd_usb_mixer_activate(mixer);
+}
+#endif
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index aab80df201bd..73b1f649447b 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -63,8 +63,6 @@ void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid);
 
 int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
                                 int request, int validx, int value_set);
-void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer);
-int snd_usb_mixer_activate(struct usb_mixer_interface *mixer);
 
 int snd_usb_mixer_add_control(struct usb_mixer_interface *mixer,
                               struct snd_kcontrol *kctl);
@@ -72,4 +70,9 @@ int snd_usb_mixer_add_control(struct usb_mixer_interface *mixer,
 int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                           unsigned int size, unsigned int __user *_tlv);
 
+#ifdef CONFIG_PM
+int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer);
+int snd_usb_mixer_resume(struct usb_mixer_interface *mixer, bool reset_resume);
+#endif
+
 #endif /* __USBMIXER_H */
diff --git a/sound/usb/usx2y/us122l.c b/sound/usb/usx2y/us122l.c
index 999550bbad40..cf5dc33f4a6d 100644
--- a/sound/usb/usx2y/us122l.c
+++ b/sound/usb/usx2y/us122l.c
@@ -535,7 +535,9 @@ static void snd_us122l_free(struct snd_card *card)
                 snd_us122l_card_used[index] = 0;
 }
 
-static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
+static int usx2y_create_card(struct usb_device *device,
+                             struct usb_interface *intf,
+                             struct snd_card **cardp)
 {
         int             dev;
         struct snd_card *card;
@@ -546,8 +548,8 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
                         break;
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
-        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
-                              sizeof(struct us122l), &card);
+        err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE,
+                           sizeof(struct us122l), &card);
         if (err < 0)
                 return err;
         snd_us122l_card_used[US122L(card)->card_index = dev] = 1;
@@ -578,11 +580,10 @@ static int us122l_usb_probe(struct usb_interface *intf,
         struct snd_card *card;
         int err;
 
-        err = usx2y_create_card(device, &card);
+        err = usx2y_create_card(device, intf, &card);
         if (err < 0)
                 return err;
 
-        snd_card_set_dev(card, &intf->dev);
         if (!us122l_create_card(card)) {
                 snd_card_free(card);
                 return -EINVAL;
diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c
index 5a51b18c50fe..91e0e2a4808c 100644
--- a/sound/usb/usx2y/usbusx2y.c
+++ b/sound/usb/usx2y/usbusx2y.c
@@ -332,7 +332,9 @@ static struct usb_device_id snd_usX2Y_usb_id_table[] = {
         { /* terminator */ }
 };
 
-static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
+static int usX2Y_create_card(struct usb_device *device,
+                             struct usb_interface *intf,
+                             struct snd_card **cardp)
 {
         int             dev;
         struct snd_card *       card;
@@ -343,15 +345,15 @@ static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
                         break;
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
-        err = snd_card_create(index[dev], id[dev], THIS_MODULE,
-                              sizeof(struct usX2Ydev), &card);
+        err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE,
+                           sizeof(struct usX2Ydev), &card);
         if (err < 0)
                 return err;
         snd_usX2Y_card_used[usX2Y(card)->card_index = dev] = 1;
         card->private_free = snd_usX2Y_card_private_free;
         usX2Y(card)->dev = device;
         init_waitqueue_head(&usX2Y(card)->prepare_wait_queue);
-        mutex_init(&usX2Y(card)->prepare_mutex);
+        mutex_init(&usX2Y(card)->pcm_mutex);
         INIT_LIST_HEAD(&usX2Y(card)->midi_list);
         strcpy(card->driver, "USB "NAME_ALLCAPS"");
         sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
@@ -382,10 +384,9 @@ static int usX2Y_usb_probe(struct usb_device *device,
              le16_to_cpu(device->descriptor.idProduct) != USB_ID_US428))
                 return -EINVAL;
 
-        err = usX2Y_create_card(device, &card);
+        err = usX2Y_create_card(device, intf, &card);
         if (err < 0)
                 return err;
-        snd_card_set_dev(card, &intf->dev);
         if ((err = usX2Y_hwdep_new(card, device)) < 0  ||
             (err = snd_card_register(card)) < 0) {
                 snd_card_free(card);
diff --git a/sound/usb/usx2y/usbusx2y.h b/sound/usb/usx2y/usbusx2y.h
index e43c0a86441a..6ae6b0806938 100644
--- a/sound/usb/usx2y/usbusx2y.h
+++ b/sound/usb/usx2y/usbusx2y.h
@@ -36,7 +36,7 @@ struct usX2Ydev {
         unsigned int            rate,
                                 format;
         int                     chip_status;
-        struct mutex            prepare_mutex;
+        struct mutex            pcm_mutex;
         struct us428ctls_sharedmem      *us428ctls_sharedmem;
         int                     wait_iso_frame;
         wait_queue_head_t       us428ctls_wait_queue_head;
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;
 }
 
diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c
index 814d0e887c62..90766a92e7fd 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.c
+++ b/sound/usb/usx2y/usx2yhwdeppcm.c
@@ -358,7 +358,7 @@ static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream)
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_usX2Y_substream *subs = runtime->private_data,
                 *cap_subs2 = subs->usX2Y->subs[SNDRV_PCM_STREAM_CAPTURE + 2];
-        mutex_lock(&subs->usX2Y->prepare_mutex);
+        mutex_lock(&subs->usX2Y->pcm_mutex);
         snd_printdd("snd_usX2Y_usbpcm_hw_free(%p)\n", substream);
 
         if (SNDRV_PCM_STREAM_PLAYBACK == substream->stream) {
@@ -387,7 +387,7 @@ static int snd_usX2Y_usbpcm_hw_free(struct snd_pcm_substream *substream)
                                 usX2Y_usbpcm_urbs_release(cap_subs2);
                 }
         }
-        mutex_unlock(&subs->usX2Y->prepare_mutex);
+        mutex_unlock(&subs->usX2Y->pcm_mutex);
         return snd_pcm_lib_free_pages(substream);
 }
 
@@ -493,7 +493,7 @@ static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream)
                 memset(usX2Y->hwdep_pcm_shm, 0, sizeof(struct snd_usX2Y_hwdep_pcm_shm));
         }
 
-        mutex_lock(&usX2Y->prepare_mutex);
+        mutex_lock(&usX2Y->pcm_mutex);
         usX2Y_subs_prepare(subs);
 // Start hardware streams
 // SyncStream first....
@@ -534,7 +534,7 @@ static int snd_usX2Y_usbpcm_prepare(struct snd_pcm_substream *substream)
                 usX2Y->hwdep_pcm_shm->capture_iso_start = -1;
 
  up_prepare_mutex:
-        mutex_unlock(&usX2Y->prepare_mutex);
+        mutex_unlock(&usX2Y->pcm_mutex);
         return err;
 }
 
@@ -600,59 +600,30 @@ static struct snd_pcm_ops snd_usX2Y_usbpcm_ops =
 };
 
 
-static int usX2Y_pcms_lock_check(struct snd_card *card)
+static int usX2Y_pcms_busy_check(struct snd_card *card)
 {
-        struct list_head *list;
-        struct snd_device *dev;
-        struct snd_pcm *pcm;
-        int err = 0;
-        list_for_each(list, &card->devices) {
-                dev = snd_device(list);
-                if (dev->type != SNDRV_DEV_PCM)
-                        continue;
-                pcm = dev->device_data;
-                mutex_lock(&pcm->open_mutex);
-        }
-        list_for_each(list, &card->devices) {
-                int s;
-                dev = snd_device(list);
-                if (dev->type != SNDRV_DEV_PCM)
-                        continue;
-                pcm = dev->device_data;
-                for (s = 0; s < 2; ++s) {
-                        struct snd_pcm_substream *substream;
-                        substream = pcm->streams[s].substream;
-                        if (substream && SUBSTREAM_BUSY(substream))
-                                err = -EBUSY;
-                }
-        }
-        return err;
-}
-
+        struct usX2Ydev *dev = usX2Y(card);
+        int i;
 
-static void usX2Y_pcms_unlock(struct snd_card *card)
-{
-        struct list_head *list;
-        struct snd_device *dev;
-        struct snd_pcm *pcm;
-        list_for_each(list, &card->devices) {
-                dev = snd_device(list);
-                if (dev->type != SNDRV_DEV_PCM)
-                        continue;
-                pcm = dev->device_data;
-                mutex_unlock(&pcm->open_mutex);
+        for (i = 0; i < dev->pcm_devs * 2; i++) {
+                struct snd_usX2Y_substream *subs = dev->subs[i];
+                if (subs && subs->pcm_substream &&
+                    SUBSTREAM_BUSY(subs->pcm_substream))
+                        return -EBUSY;
         }
+        return 0;
 }
 
-
 static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file)
 {
-        // we need to be the first 
         struct snd_card *card = hw->card;
-        int err = usX2Y_pcms_lock_check(card);
-        if (0 == err)
+        int err;
+
+        mutex_lock(&usX2Y(card)->pcm_mutex);
+        err = usX2Y_pcms_busy_check(card);
+        if (!err)
                 usX2Y(card)->chip_status |= USX2Y_STAT_CHIP_MMAP_PCM_URBS;
-        usX2Y_pcms_unlock(card);
+        mutex_unlock(&usX2Y(card)->pcm_mutex);
         return err;
 }
 
@@ -660,10 +631,13 @@ static int snd_usX2Y_hwdep_pcm_open(struct snd_hwdep *hw, struct file *file)
 static int snd_usX2Y_hwdep_pcm_release(struct snd_hwdep *hw, struct file *file)
 {
         struct snd_card *card = hw->card;
-        int err = usX2Y_pcms_lock_check(card);
-        if (0 == err)
+        int err;
+
+        mutex_lock(&usX2Y(card)->pcm_mutex);
+        err = usX2Y_pcms_busy_check(card);
+        if (!err)
                 usX2Y(hw->card)->chip_status &= ~USX2Y_STAT_CHIP_MMAP_PCM_URBS;
-        usX2Y_pcms_unlock(card);
+        mutex_unlock(&usX2Y(card)->pcm_mutex);
         return err;
 }