Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 109 insertions, 29 deletions

diff --git a/sound/usb/card.c b/sound/usb/card.c
index 4eabafa5b037..220c6167dd86 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -41,12 +41,14 @@
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/string.h>
+#include <linux/ctype.h>
 #include <linux/usb.h>
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
 #include <linux/usb/audio.h>
 #include <linux/usb/audio-v2.h>
 
+#include <sound/control.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/pcm.h>
@@ -65,6 +67,7 @@
 #include "pcm.h"
 #include "urb.h"
 #include "format.h"
+#include "power.h"
 
 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
 MODULE_DESCRIPTION("USB Audio");
@@ -282,6 +285,15 @@ static int snd_usb_audio_dev_free(struct snd_device *device)
         return snd_usb_audio_free(chip);
 }
 
+static void remove_trailing_spaces(char *str)
+{
+        char *p;
+
+        if (!*str)
+                return;
+        for (p = str + strlen(str) - 1; p >= str && isspace(*p); p--)
+                *p = 0;
+}
 
 /*
  * create a chip instance and set its names.
@@ -300,9 +312,13 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
 
         *rchip = NULL;
 
-        if (snd_usb_get_speed(dev) != USB_SPEED_LOW &&
-            snd_usb_get_speed(dev) != USB_SPEED_FULL &&
-            snd_usb_get_speed(dev) != USB_SPEED_HIGH) {
+        switch (snd_usb_get_speed(dev)) {
+        case USB_SPEED_LOW:
+        case USB_SPEED_FULL:
+        case USB_SPEED_HIGH:
+        case USB_SPEED_SUPER:
+                break;
+        default:
                 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
                 return -ENXIO;
         }
@@ -319,12 +335,14 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
                 return -ENOMEM;
         }
 
+        mutex_init(&chip->shutdown_mutex);
         chip->index = idx;
         chip->dev = dev;
         chip->card = card;
         chip->setup = device_setup[idx];
         chip->nrpacks = nrpacks;
         chip->async_unlink = async_unlink;
+        chip->probing = 1;
 
         chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
                               le16_to_cpu(dev->descriptor.idProduct));
@@ -344,7 +362,7 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
         snd_component_add(card, component);
 
         /* retrieve the device string as shortname */
-        if (quirk && quirk->product_name) {
+        if (quirk && quirk->product_name && *quirk->product_name) {
                 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
         } else {
                 if (!dev->descriptor.iProduct ||
@@ -356,9 +374,10 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
                                 USB_ID_PRODUCT(chip->usb_id));
                 }
         }
+        remove_trailing_spaces(card->shortname);
 
         /* retrieve the vendor and device strings as longname */
-        if (quirk && quirk->vendor_name) {
+        if (quirk && quirk->vendor_name && *quirk->vendor_name) {
                 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
         } else {
                 if (dev->descriptor.iManufacturer)
@@ -368,8 +387,11 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
                         len = 0;
                 /* we don't really care if there isn't any vendor string */
         }
-        if (len > 0)
-                strlcat(card->longname, " ", sizeof(card->longname));
+        if (len > 0) {
+                remove_trailing_spaces(card->longname);
+                if (*card->longname)
+                        strlcat(card->longname, " ", sizeof(card->longname));
+        }
 
         strlcat(card->longname, card->shortname, sizeof(card->longname));
 
@@ -378,11 +400,22 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
         if (len < sizeof(card->longname))
                 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
 
-        strlcat(card->longname,
-                snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" :
-                snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" :
-                ", high speed",
-                sizeof(card->longname));
+        switch (snd_usb_get_speed(dev)) {
+        case USB_SPEED_LOW:
+                strlcat(card->longname, ", low speed", sizeof(card->longname));
+                break;
+        case USB_SPEED_FULL:
+                strlcat(card->longname, ", full speed", sizeof(card->longname));
+                break;
+        case USB_SPEED_HIGH:
+                strlcat(card->longname, ", high speed", sizeof(card->longname));
+                break;
+        case USB_SPEED_SUPER:
+                strlcat(card->longname, ", super speed", sizeof(card->longname));
+                break;
+        default:
+                break;
+        }
 
         snd_usb_audio_create_proc(chip);
 
@@ -435,6 +468,7 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                                 goto __error;
                         }
                         chip = usb_chip[i];
+                        chip->probing = 1;
                         break;
                 }
         }
@@ -450,6 +484,7 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                                         goto __error;
                                 }
                                 snd_card_set_dev(chip->card, &intf->dev);
+                                chip->pm_intf = intf;
                                 break;
                         }
                 if (!chip) {
@@ -458,14 +493,6 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                 }
         }
 
-        chip->txfr_quirk = 0;
-        err = 1; /* continue */
-        if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
-                /* need some special handlings */
-                if ((err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk)) < 0)
-                        goto __error;
-        }
-
         /*
          * For devices with more than one control interface, we assume the
          * first contains the audio controls. We might need a more specific
@@ -474,6 +501,14 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
         if (!chip->ctrl_intf)
                 chip->ctrl_intf = alts;
 
+        chip->txfr_quirk = 0;
+        err = 1; /* continue */
+        if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
+                /* need some special handlings */
+                if ((err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk)) < 0)
+                        goto __error;
+        }
+
         if (err > 0) {
                 /* create normal USB audio interfaces */
                 if (snd_usb_create_streams(chip, ifnum) < 0 ||
@@ -489,6 +524,7 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
 
         usb_chip[chip->index] = chip;
         chip->num_interfaces++;
+        chip->probing = 0;
         mutex_unlock(&register_mutex);
         return chip;
 
@@ -516,6 +552,7 @@ static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
         chip = ptr;
         card = chip->card;
         mutex_lock(&register_mutex);
+        mutex_lock(&chip->shutdown_mutex);
         chip->shutdown = 1;
         chip->num_interfaces--;
         if (chip->num_interfaces <= 0) {
@@ -533,9 +570,11 @@ static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
                         snd_usb_mixer_disconnect(p);
                 }
                 usb_chip[chip->index] = NULL;
+                mutex_unlock(&chip->shutdown_mutex);
                 mutex_unlock(&register_mutex);
                 snd_card_free_when_closed(card);
         } else {
+                mutex_unlock(&chip->shutdown_mutex);
                 mutex_unlock(&register_mutex);
         }
 }
@@ -562,29 +601,61 @@ static void usb_audio_disconnect(struct usb_interface *intf)
 }
 
 #ifdef CONFIG_PM
+
+int snd_usb_autoresume(struct snd_usb_audio *chip)
+{
+        int err = -ENODEV;
+
+        if (!chip->shutdown && !chip->probing)
+                err = usb_autopm_get_interface(chip->pm_intf);
+
+        return err;
+}
+
+void snd_usb_autosuspend(struct snd_usb_audio *chip)
+{
+        if (!chip->shutdown && !chip->probing)
+                usb_autopm_put_interface(chip->pm_intf);
+}
+
 static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct snd_usb_audio *chip = usb_get_intfdata(intf);
         struct list_head *p;
         struct snd_usb_stream *as;
+        struct usb_mixer_interface *mixer;
 
         if (chip == (void *)-1L)
                 return 0;
 
-        snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
-        if (!chip->num_suspended_intf++) {
-                list_for_each(p, &chip->pcm_list) {
-                        as = list_entry(p, struct snd_usb_stream, list);
-                        snd_pcm_suspend_all(as->pcm);
-                }
+        if (!(message.event & PM_EVENT_AUTO)) {
+                snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
+                if (!chip->num_suspended_intf++) {
+                        list_for_each(p, &chip->pcm_list) {
+                                as = list_entry(p, struct snd_usb_stream, list);
+                                snd_pcm_suspend_all(as->pcm);
+                        }
+                }
+        } else {
+                /*
+                 * otherwise we keep the rest of the system in the dark
+                 * to keep this transparent
+                 */
+                if (!chip->num_suspended_intf++)
+                        chip->autosuspended = 1;
         }
 
+        list_for_each_entry(mixer, &chip->mixer_list, list)
+                snd_usb_mixer_inactivate(mixer);
+
         return 0;
 }
 
 static int usb_audio_resume(struct usb_interface *intf)
 {
         struct snd_usb_audio *chip = usb_get_intfdata(intf);
+        struct usb_mixer_interface *mixer;
+        int err = 0;
 
         if (chip == (void *)-1L)
                 return 0;
@@ -592,12 +663,20 @@ static int usb_audio_resume(struct usb_interface *intf)
                 return 0;
         /*
          * ALSA leaves material resumption to user space
-         * we just notify
+         * we just notify and restart the mixers
          */
+        list_for_each_entry(mixer, &chip->mixer_list, list) {
+                err = snd_usb_mixer_activate(mixer);
+                if (err < 0)
+                        goto err_out;
+        }
 
-        snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
+        if (!chip->autosuspended)
+                snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
+        chip->autosuspended = 0;
 
-        return 0;
+err_out:
+        return err;
 }
 #else
 #define usb_audio_suspend       NULL
@@ -625,6 +704,7 @@ static struct usb_driver usb_audio_driver = {
         .suspend =      usb_audio_suspend,
         .resume =       usb_audio_resume,
         .id_table =     usb_audio_ids,
+        .supports_autosuspend = 1,
 };
 
 static int __init snd_usb_audio_init(void)