Merge branch 'topic/misc' into for-linus

author: Takashi Iwai <tiwai@suse.de> 2012-05-21 06:51:35 -0400
committer: Takashi Iwai <tiwai@suse.de> 2012-05-21 06:51:35 -0400
commit: 382e6a859e6622de0aa62c01976ae8ebd90e986d (patch)
tree: 2501c554c231c5d0fcda7ff2e6e055bf23134d6f /sound
parent: 6de15b2a9330aeb5df9b66545f67c6c6ad2c045a (diff)
parent: 97f8d3b6503082416898f893a442a78f8819c42a (diff)
75 files changed, 2148 insertions, 1646 deletions
diff --git a/sound/atmel/ac97c.c b/sound/atmel/ac97c.c
index 115313ef54d6..f5ded640b395 100644
--- a/sound/atmel/ac97c.c
+++ b/sound/atmel/ac97c.c
@@ -991,6 +991,8 @@ static int __devinit atmel_ac97c_probe(struct platform_device *pdev)
                        gpio_direction_output(pdata->reset_pin, 1);
                        chip->reset_pin = pdata->reset_pin;
                }
+        } else {
+                chip->reset_pin = -EINVAL;
        }
        snd_card_set_dev(card, &pdev->dev);
diff --git a/sound/core/jack.c b/sound/core/jack.c
index 471e1e3b0a99..a06b1651fcba 100644
--- a/sound/core/jack.c
+++ b/sound/core/jack.c
@@ -155,7 +155,7 @@ EXPORT_SYMBOL(snd_jack_new);
 * @jack:   The jack to configure
 * @parent: The device to set as parent for the jack.
 *
- * Set the parent for the jack input device in the device tree.  This
+ * Set the parent for the jack devices in the device tree.  This
 * function is only valid prior to registration of the jack.  If no
 * parent is configured then the parent device will be the sound card.
 */
@@ -179,6 +179,9 @@ EXPORT_SYMBOL(snd_jack_set_parent);
 * mapping is provided but keys are enabled in the jack type then
 * BTN_n numeric buttons will be reported.
 *
+ * If jacks are not reporting via the input API this call will have no
+ * effect.
+ *
 * Note that this is intended to be use by simple devices with small
 * numbers of keys that can be reported.  It is also possible to
 * access the input device directly - devices with complex input
diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c
index 4d18941178e6..faedb1481b24 100644
--- a/sound/core/pcm_lib.c
+++ b/sound/core/pcm_lib.c
@@ -1894,6 +1894,7 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
        struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_uframes_t xfer = 0;
        snd_pcm_uframes_t offset = 0;
+        snd_pcm_uframes_t avail;
        int err = 0;
        if (size == 0)
@@ -1917,13 +1918,12 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
        }
        runtime->twake = runtime->control->avail_min ? : 1;
+        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+                snd_pcm_update_hw_ptr(substream);
+        avail = snd_pcm_playback_avail(runtime);
        while (size > 0) {
                snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
-                snd_pcm_uframes_t avail;
                snd_pcm_uframes_t cont;
-                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
-                        snd_pcm_update_hw_ptr(substream);
-                avail = snd_pcm_playback_avail(runtime);
                if (!avail) {
                        if (nonblock) {
                                err = -EAGAIN;
@@ -1971,6 +1971,7 @@ static snd_pcm_sframes_t snd_pcm_lib_write1(struct snd_pcm_substream *substream,
                offset += frames;
                size -= frames;
                xfer += frames;
+                avail -= frames;
                if (runtime->status->state == SNDRV_PCM_STATE_PREPARED &&
                    snd_pcm_playback_hw_avail(runtime) >= (snd_pcm_sframes_t)runtime->start_threshold) {
                        err = snd_pcm_start(substream);
@@ -2111,6 +2112,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
        struct snd_pcm_runtime *runtime = substream->runtime;
        snd_pcm_uframes_t xfer = 0;
        snd_pcm_uframes_t offset = 0;
+        snd_pcm_uframes_t avail;
        int err = 0;
        if (size == 0)
@@ -2141,13 +2143,12 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
        }
        runtime->twake = runtime->control->avail_min ? : 1;
+        if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+                snd_pcm_update_hw_ptr(substream);
+        avail = snd_pcm_capture_avail(runtime);
        while (size > 0) {
                snd_pcm_uframes_t frames, appl_ptr, appl_ofs;
-                snd_pcm_uframes_t avail;
                snd_pcm_uframes_t cont;
-                if (runtime->status->state == SNDRV_PCM_STATE_RUNNING)
-                        snd_pcm_update_hw_ptr(substream);
-                avail = snd_pcm_capture_avail(runtime);
                if (!avail) {
                        if (runtime->status->state ==
                            SNDRV_PCM_STATE_DRAINING) {
@@ -2202,6 +2203,7 @@ static snd_pcm_sframes_t snd_pcm_lib_read1(struct snd_pcm_substream *substream,
                offset += frames;
                size -= frames;
                xfer += frames;
+                avail -= frames;
        }
 _end_unlock:
        runtime->twake = 0;
diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c
index 3fe99e644eb8..53b5ada8f7c3 100644
--- a/sound/core/pcm_native.c
+++ b/sound/core/pcm_native.c
@@ -1360,7 +1360,14 @@ static int snd_pcm_prepare(struct snd_pcm_substream *substream,
 static int snd_pcm_pre_drain_init(struct snd_pcm_substream *substream, int state)
 {
-        substream->runtime->trigger_master = substream;
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        switch (runtime->status->state) {
+        case SNDRV_PCM_STATE_OPEN:
+        case SNDRV_PCM_STATE_DISCONNECTED:
+        case SNDRV_PCM_STATE_SUSPENDED:
+                return -EBADFD;
+        }
+        runtime->trigger_master = substream;
        return 0;
 }
@@ -1379,6 +1386,9 @@ static int snd_pcm_do_drain_init(struct snd_pcm_substream *substream, int state)
                case SNDRV_PCM_STATE_RUNNING:
                        runtime->status->state = SNDRV_PCM_STATE_DRAINING;
                        break;
+                case SNDRV_PCM_STATE_XRUN:
+                        runtime->status->state = SNDRV_PCM_STATE_SETUP;
+                        break;
                default:
                        break;
                }
diff --git a/sound/core/sound_oss.c b/sound/core/sound_oss.c
index c70092043061..e9528333e36d 100644
--- a/sound/core/sound_oss.c
+++ b/sound/core/sound_oss.c
@@ -35,7 +35,7 @@
 #include <linux/sound.h>
 #include <linux/mutex.h>
-#define SNDRV_OSS_MINORS 128
+#define SNDRV_OSS_MINORS 256
 static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS];
 static DEFINE_MUTEX(sound_oss_mutex);
@@ -111,7 +111,7 @@ int snd_register_oss_device(int type, struct snd_card *card, int dev,
        int register1 = -1, register2 = -1;
        struct device *carddev = snd_card_get_device_link(card);
-        if (card && card->number >= 8)
+        if (card && card->number >= SNDRV_MINOR_OSS_DEVICES)
                return 0; /* ignore silently */
        if (minor < 0)
                return minor;
@@ -170,7 +170,7 @@ int snd_unregister_oss_device(int type, struct snd_card *card, int dev)
        int track2 = -1;
        struct snd_minor *mptr;
-        if (card && card->number >= 8)
+        if (card && card->number >= SNDRV_MINOR_OSS_DEVICES)
                return 0;
        if (minor < 0)
                return minor;
diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c
index ad079b63b8ba..8b5c36f4d303 100644
--- a/sound/drivers/aloop.c
+++ b/sound/drivers/aloop.c
@@ -117,6 +117,7 @@ struct loopback_pcm {
        /* timer stuff */
        unsigned int irq_pos;           /* fractional IRQ position */
        unsigned int period_size_frac;
+        unsigned int last_drift;
        unsigned long last_jiffies;
        struct timer_list timer;
 };
@@ -264,6 +265,7 @@ static int loopback_trigger(struct snd_pcm_substream *substream, int cmd)
                        return err;
                dpcm->last_jiffies = jiffies;
                dpcm->pcm_rate_shift = 0;
+                dpcm->last_drift = 0;
                spin_lock(&cable->lock);        
                cable->running |= stream;
                cable->pause &= ~stream;
@@ -444,34 +446,30 @@ static void copy_play_buf(struct loopback_pcm *play,
        }
 }
-#define BYTEPOS_UPDATE_POSONLY  0
+static inline unsigned int bytepos_delta(struct loopback_pcm *dpcm,
-#define BYTEPOS_UPDATE_CLEAR    1
+                                         unsigned int jiffies_delta)
-#define BYTEPOS_UPDATE_COPY     2
-static void loopback_bytepos_update(struct loopback_pcm *dpcm,
-                                    unsigned int delta,
-                                    unsigned int cmd)
 {
-        unsigned int count;
        unsigned long last_pos;
+        unsigned int delta;
        last_pos = byte_pos(dpcm, dpcm->irq_pos);
-        dpcm->irq_pos += delta * dpcm->pcm_bps;
+        dpcm->irq_pos += jiffies_delta * dpcm->pcm_bps;
-        count = byte_pos(dpcm, dpcm->irq_pos) - last_pos;
+        delta = byte_pos(dpcm, dpcm->irq_pos) - last_pos;
-        if (!count)
+        if (delta >= dpcm->last_drift)
-                return;
+                delta -= dpcm->last_drift;
-        if (cmd == BYTEPOS_UPDATE_CLEAR)
+        dpcm->last_drift = 0;
-                clear_capture_buf(dpcm, count);
-        else if (cmd == BYTEPOS_UPDATE_COPY)
-                copy_play_buf(dpcm->cable->streams[SNDRV_PCM_STREAM_PLAYBACK],
-                              dpcm->cable->streams[SNDRV_PCM_STREAM_CAPTURE],
-                              count);
-        dpcm->buf_pos += count;
-        dpcm->buf_pos %= dpcm->pcm_buffer_size;
        if (dpcm->irq_pos >= dpcm->period_size_frac) {
                dpcm->irq_pos %= dpcm->period_size_frac;
                dpcm->period_update_pending = 1;
        }
+        return delta;
+}
+static inline void bytepos_finish(struct loopback_pcm *dpcm,
+                                  unsigned int delta)
+{
+        dpcm->buf_pos += delta;
+        dpcm->buf_pos %= dpcm->pcm_buffer_size;
 }
 static unsigned int loopback_pos_update(struct loopback_cable *cable)
@@ -481,7 +479,7 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable)
        struct loopback_pcm *dpcm_capt =
                        cable->streams[SNDRV_PCM_STREAM_CAPTURE];
        unsigned long delta_play = 0, delta_capt = 0;
-        unsigned int running;
+        unsigned int running, count1, count2;
        unsigned long flags;
        spin_lock_irqsave(&cable->lock, flags);
@@ -500,12 +498,13 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable)
                goto unlock;
                
        if (delta_play > delta_capt) {
-                loopback_bytepos_update(dpcm_play, delta_play - delta_capt,
+                count1 = bytepos_delta(dpcm_play, delta_play - delta_capt);
-                                        BYTEPOS_UPDATE_POSONLY);
+                bytepos_finish(dpcm_play, count1);
                delta_play = delta_capt;
        } else if (delta_play < delta_capt) {
-                loopback_bytepos_update(dpcm_capt, delta_capt - delta_play,
+                count1 = bytepos_delta(dpcm_capt, delta_capt - delta_play);
-                                        BYTEPOS_UPDATE_CLEAR);
+                clear_capture_buf(dpcm_capt, count1);
+                bytepos_finish(dpcm_capt, count1);
                delta_capt = delta_play;
        }
@@ -513,8 +512,17 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable)
                goto unlock;
        /* note delta_capt == delta_play at this moment */
-        loopback_bytepos_update(dpcm_capt, delta_capt, BYTEPOS_UPDATE_COPY);
+        count1 = bytepos_delta(dpcm_play, delta_play);
-        loopback_bytepos_update(dpcm_play, delta_play, BYTEPOS_UPDATE_POSONLY);
+        count2 = bytepos_delta(dpcm_capt, delta_capt);
+        if (count1 < count2) {
+                dpcm_capt->last_drift = count2 - count1;
+                count1 = count2;
+        } else if (count1 > count2) {
+                dpcm_play->last_drift = count1 - count2;
+        }
+        copy_play_buf(dpcm_play, dpcm_capt, count1);
+        bytepos_finish(dpcm_play, count1);
+        bytepos_finish(dpcm_capt, count1);
 unlock:
        spin_unlock_irqrestore(&cable->lock, flags);
        return running;
diff --git a/sound/firewire/amdtp.c b/sound/firewire/amdtp.c
index 87657dd7714c..ea995af6d049 100644
--- a/sound/firewire/amdtp.c
+++ b/sound/firewire/amdtp.c
@@ -31,6 +31,8 @@
 #define INTERRUPT_INTERVAL      16
 #define QUEUE_LENGTH            48
+static void pcm_period_tasklet(unsigned long data);
 /**
 * amdtp_out_stream_init - initialize an AMDTP output stream structure
 * @s: the AMDTP output stream to initialize
@@ -47,6 +49,7 @@ int amdtp_out_stream_init(struct amdtp_out_stream *s, struct fw_unit *unit,
        s->flags = flags;
        s->context = ERR_PTR(-1);
        mutex_init(&s->mutex);
+        tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s);
        s->packet_index = 0;
        return 0;
@@ -164,6 +167,21 @@ void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
 }
 EXPORT_SYMBOL(amdtp_out_stream_set_pcm_format);
+/**
+ * amdtp_out_stream_pcm_prepare - prepare PCM device for running
+ * @s: the AMDTP output stream
+ *
+ * This function should be called from the PCM device's .prepare callback.
+ */
+void amdtp_out_stream_pcm_prepare(struct amdtp_out_stream *s)
+{
+        tasklet_kill(&s->period_tasklet);
+        s->pcm_buffer_pointer = 0;
+        s->pcm_period_pointer = 0;
+        s->pointer_flush = true;
+}
+EXPORT_SYMBOL(amdtp_out_stream_pcm_prepare);
 static unsigned int calculate_data_blocks(struct amdtp_out_stream *s)
 {
        unsigned int phase, data_blocks;
@@ -376,11 +394,21 @@ static void queue_out_packet(struct amdtp_out_stream *s, unsigned int cycle)
                s->pcm_period_pointer += data_blocks;
                if (s->pcm_period_pointer >= pcm->runtime->period_size) {
                        s->pcm_period_pointer -= pcm->runtime->period_size;
-                        snd_pcm_period_elapsed(pcm);
+                        s->pointer_flush = false;
+                        tasklet_hi_schedule(&s->period_tasklet);
                }
        }
 }
+static void pcm_period_tasklet(unsigned long data)
+{
+        struct amdtp_out_stream *s = (void *)data;
+        struct snd_pcm_substream *pcm = ACCESS_ONCE(s->pcm);
+        if (pcm)
+                snd_pcm_period_elapsed(pcm);
+}
 static void out_packet_callback(struct fw_iso_context *context, u32 cycle,
                                size_t header_length, void *header, void *data)
 {
@@ -506,6 +534,24 @@ err_unlock:
 EXPORT_SYMBOL(amdtp_out_stream_start);
 /**
+ * amdtp_out_stream_pcm_pointer - get the PCM buffer position
+ * @s: the AMDTP output stream that transports the PCM data
+ *
+ * Returns the current buffer position, in frames.
+ */
+unsigned long amdtp_out_stream_pcm_pointer(struct amdtp_out_stream *s)
+{
+        /* this optimization is allowed to be racy */
+        if (s->pointer_flush)
+                fw_iso_context_flush_completions(s->context);
+        else
+                s->pointer_flush = true;
+        return ACCESS_ONCE(s->pcm_buffer_pointer);
+}
+EXPORT_SYMBOL(amdtp_out_stream_pcm_pointer);
+/**
 * amdtp_out_stream_update - update the stream after a bus reset
 * @s: the AMDTP output stream
 */
@@ -532,6 +578,7 @@ void amdtp_out_stream_stop(struct amdtp_out_stream *s)
                return;
        }
+        tasklet_kill(&s->period_tasklet);
        fw_iso_context_stop(s->context);
        fw_iso_context_destroy(s->context);
        s->context = ERR_PTR(-1);
diff --git a/sound/firewire/amdtp.h b/sound/firewire/amdtp.h
index 537a9cb83581..b680c5ef01d6 100644
--- a/sound/firewire/amdtp.h
+++ b/sound/firewire/amdtp.h
@@ -1,6 +1,7 @@
 #ifndef SOUND_FIREWIRE_AMDTP_H_INCLUDED
 #define SOUND_FIREWIRE_AMDTP_H_INCLUDED
+#include <linux/interrupt.h>
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
 #include "packets-buffer.h"
@@ -55,6 +56,7 @@ struct amdtp_out_stream {
        struct iso_packets_buffer buffer;
        struct snd_pcm_substream *pcm;
+        struct tasklet_struct period_tasklet;
        int packet_index;
        unsigned int data_block_counter;
@@ -66,6 +68,7 @@ struct amdtp_out_stream {
        unsigned int pcm_buffer_pointer;
        unsigned int pcm_period_pointer;
+        bool pointer_flush;
 };
 int amdtp_out_stream_init(struct amdtp_out_stream *s, struct fw_unit *unit,
@@ -81,6 +84,8 @@ void amdtp_out_stream_stop(struct amdtp_out_stream *s);
 void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
                                     snd_pcm_format_t format);
+void amdtp_out_stream_pcm_prepare(struct amdtp_out_stream *s);
+unsigned long amdtp_out_stream_pcm_pointer(struct amdtp_out_stream *s);
 void amdtp_out_stream_pcm_abort(struct amdtp_out_stream *s);
 /**
@@ -123,18 +128,6 @@ static inline bool amdtp_out_streaming_error(struct amdtp_out_stream *s)
 }
 /**
- * amdtp_out_stream_pcm_prepare - prepare PCM device for running
- * @s: the AMDTP output stream
- *
- * This function should be called from the PCM device's .prepare callback.
- */
-static inline void amdtp_out_stream_pcm_prepare(struct amdtp_out_stream *s)
-{
-        s->pcm_buffer_pointer = 0;
-        s->pcm_period_pointer = 0;
-}
-/**
 * amdtp_out_stream_pcm_trigger - start/stop playback from a PCM device
 * @s: the AMDTP output stream
 * @pcm: the PCM device to be started, or %NULL to stop the current device
@@ -149,18 +142,6 @@ static inline void amdtp_out_stream_pcm_trigger(struct amdtp_out_stream *s,
        ACCESS_ONCE(s->pcm) = pcm;
 }
-/**
- * amdtp_out_stream_pcm_pointer - get the PCM buffer position
- * @s: the AMDTP output stream that transports the PCM data
- *
- * Returns the current buffer position, in frames.
- */
-static inline unsigned long
-amdtp_out_stream_pcm_pointer(struct amdtp_out_stream *s)
-{
-        return ACCESS_ONCE(s->pcm_buffer_pointer);
-}
 static inline bool cip_sfc_is_base_44100(enum cip_sfc sfc)
 {
        return sfc & 1;
diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index 5ca0939e4223..ff3af6e77d61 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -228,7 +228,7 @@ config SND_OXYGEN
          Say Y here to include support for sound cards based on the
          C-Media CMI8788 (Oxygen HD Audio) chip:
           * Asound A-8788
-           * Asus Xonar DG
+           * Asus Xonar DG/DGX
           * AuzenTech X-Meridian
           * AuzenTech X-Meridian 2G
           * Bgears b-Enspirer
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index 9d91d61902b4..e672ff4df2da 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -1062,17 +1062,4 @@ static struct pci_driver ad1889_pci_driver = {
        .remove = __devexit_p(snd_ad1889_remove),
 };
-static int __init
+module_pci_driver(ad1889_pci_driver);
-alsa_ad1889_init(void)
-{
-        return pci_register_driver(&ad1889_pci_driver);
-}
-static void __exit
-alsa_ad1889_fini(void)
-{
-        pci_unregister_driver(&ad1889_pci_driver);
-}
-module_init(alsa_ad1889_init);
-module_exit(alsa_ad1889_fini);
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index bdd6164e9c7e..9dfc27bf6cc6 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -2294,7 +2294,7 @@ static void __devexit snd_ali_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver ali5451_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_ali_ids,
        .probe = snd_ali_probe,
@@ -2305,15 +2305,4 @@ static struct pci_driver driver = {
 #endif
 };                                
-static int __init alsa_card_ali_init(void)
+module_pci_driver(ali5451_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_ali_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ali_init)
-module_exit(alsa_card_ali_exit)
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index 8196e229b2df..59d65388faf5 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -852,7 +852,7 @@ static int __devinit snd_als300_probe(struct pci_dev *pci,
        return 0;
 }
-static struct pci_driver driver = {
+static struct pci_driver als300_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_als300_ids,
        .probe = snd_als300_probe,
@@ -863,15 +863,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_als300_init(void)
+module_pci_driver(als300_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_als300_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_als300_init)
-module_exit(alsa_card_als300_exit)
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 3269b8011ea9..7d7f2598c748 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -1036,7 +1036,7 @@ static int snd_als4000_resume(struct pci_dev *pci)
 #endif /* CONFIG_PM */
-static struct pci_driver driver = {
+static struct pci_driver als4000_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_als4000_ids,
        .probe = snd_card_als4000_probe,
@@ -1047,15 +1047,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_als4000_init(void)
+module_pci_driver(als4000_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_als4000_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_als4000_init)
-module_exit(alsa_card_als4000_exit)
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 590682f115ef..156a94f8a123 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -1700,7 +1700,7 @@ static void __devexit snd_atiixp_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver atiixp_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_atiixp_ids,
        .probe = snd_atiixp_probe,
@@ -1711,16 +1711,4 @@ static struct pci_driver driver = {
 #endif
 };
+module_pci_driver(atiixp_driver);
-static int __init alsa_card_atiixp_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_atiixp_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_atiixp_init)
-module_exit(alsa_card_atiixp_exit)
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index 524d35f31232..30a4fd96ce73 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -1331,7 +1331,7 @@ static void __devexit snd_atiixp_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver atiixp_modem_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_atiixp_ids,
        .probe = snd_atiixp_probe,
@@ -1342,16 +1342,4 @@ static struct pci_driver driver = {
 #endif
 };
+module_pci_driver(atiixp_modem_driver);
-static int __init alsa_card_atiixp_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_atiixp_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_atiixp_init)
-module_exit(alsa_card_atiixp_exit)
diff --git a/sound/pci/au88x0/au88x0.c b/sound/pci/au88x0/au88x0.c
index f13ad536b2d5..ffc376f9f4e4 100644
--- a/sound/pci/au88x0/au88x0.c
+++ b/sound/pci/au88x0/au88x0.c
@@ -375,24 +375,11 @@ static void __devexit snd_vortex_remove(struct pci_dev *pci)
 }
 // pci_driver definition
-static struct pci_driver driver = {
+static struct pci_driver vortex_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_vortex_ids,
        .probe = snd_vortex_probe,
        .remove = __devexit_p(snd_vortex_remove),
 };
-// initialization of the module
+module_pci_driver(vortex_driver);
-static int __init alsa_card_vortex_init(void)
-{
-        return pci_register_driver(&driver);
-}
-// clean up the module
-static void __exit alsa_card_vortex_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_vortex_init)
-module_exit(alsa_card_vortex_exit)
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index 1c5231931462..0f804741825f 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -112,8 +112,6 @@ struct aw2 {
 /*********************************
 * FUNCTION DECLARATIONS
 ********************************/
-static int __init alsa_card_aw2_init(void);
-static void __exit alsa_card_aw2_exit(void);
 static int snd_aw2_dev_free(struct snd_device *device);
 static int __devinit snd_aw2_create(struct snd_card *card,
                                    struct pci_dev *pci, struct aw2 **rchip);
@@ -171,13 +169,15 @@ static DEFINE_PCI_DEVICE_TABLE(snd_aw2_ids) = {
 MODULE_DEVICE_TABLE(pci, snd_aw2_ids);
 /* pci_driver definition */
-static struct pci_driver driver = {
+static struct pci_driver aw2_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_aw2_ids,
        .probe = snd_aw2_probe,
        .remove = __devexit_p(snd_aw2_remove),
 };
+module_pci_driver(aw2_driver);
 /* operators for playback PCM alsa interface */
 static struct snd_pcm_ops snd_aw2_playback_ops = {
        .open = snd_aw2_pcm_playback_open,
@@ -217,23 +217,6 @@ static struct snd_kcontrol_new aw2_control __devinitdata = {
 * FUNCTION IMPLEMENTATIONS
 ********************************/
-/* initialization of the module */
-static int __init alsa_card_aw2_init(void)
-{
-        snd_printdd(KERN_DEBUG "aw2: Load aw2 module\n");
-        return pci_register_driver(&driver);
-}
-/* clean up the module */
-static void __exit alsa_card_aw2_exit(void)
-{
-        snd_printdd(KERN_DEBUG "aw2: Unload aw2 module\n");
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_aw2_init);
-module_exit(alsa_card_aw2_exit);
 /* component-destructor */
 static int snd_aw2_dev_free(struct snd_device *device)
 {
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index 496f14c1a731..f0b4d7493af5 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -2862,7 +2862,7 @@ snd_azf3328_resume(struct pci_dev *pci)
 #endif /* CONFIG_PM */
-static struct pci_driver driver = {
+static struct pci_driver azf3328_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_azf3328_ids,
        .probe = snd_azf3328_probe,
@@ -2873,23 +2873,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init
+module_pci_driver(azf3328_driver);
-alsa_card_azf3328_init(void)
-{
-        int err;
-        snd_azf3328_dbgcallenter();
-        err = pci_register_driver(&driver);
-        snd_azf3328_dbgcallleave();
-        return err;
-}
-static void __exit
-alsa_card_azf3328_exit(void)
-{
-        snd_azf3328_dbgcallenter();
-        pci_unregister_driver(&driver);
-        snd_azf3328_dbgcallleave();
-}
-module_init(alsa_card_azf3328_init)
-module_exit(alsa_card_azf3328_exit)
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index 62d6163fc9d9..b6a95eeca095 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -836,8 +836,6 @@ static struct {
        {0x7063, 0x2000}, /* pcHDTV HD-2000 TV */
 };
-static struct pci_driver driver;
 /* return the id of the card, or a negative value if it's blacklisted */
 static int __devinit snd_bt87x_detect_card(struct pci_dev *pci)
 {
@@ -964,24 +962,11 @@ static DEFINE_PCI_DEVICE_TABLE(snd_bt87x_default_ids) = {
        { }
 };
-static struct pci_driver driver = {
+static struct pci_driver bt87x_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_bt87x_ids,
        .probe = snd_bt87x_probe,
        .remove = __devexit_p(snd_bt87x_remove),
 };
-static int __init alsa_card_bt87x_init(void)
+module_pci_driver(bt87x_driver);
-{
-        if (load_all)
-                driver.id_table = snd_bt87x_default_ids;
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_bt87x_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_bt87x_init)
-module_exit(alsa_card_bt87x_exit)
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 08d6ebfe5a61..e76d68a7081f 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -1932,7 +1932,7 @@ static DEFINE_PCI_DEVICE_TABLE(snd_ca0106_ids) = {
 MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
 // pci_driver definition
-static struct pci_driver driver = {
+static struct pci_driver ca0106_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_ca0106_ids,
        .probe = snd_ca0106_probe,
@@ -1943,17 +1943,4 @@ static struct pci_driver driver = {
 #endif
 };
-// initialization of the module
+module_pci_driver(ca0106_driver);
-static int __init alsa_card_ca0106_init(void)
-{
-        return pci_register_driver(&driver);
-}
-// clean up the module
-static void __exit alsa_card_ca0106_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ca0106_init)
-module_exit(alsa_card_ca0106_exit)
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 19b06269adc2..3815bd4c6779 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -3398,7 +3398,7 @@ static int snd_cmipci_resume(struct pci_dev *pci)
 }
 #endif /* CONFIG_PM */
-static struct pci_driver driver = {
+static struct pci_driver cmipci_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_cmipci_ids,
        .probe = snd_cmipci_probe,
@@ -3409,15 +3409,4 @@ static struct pci_driver driver = {
 #endif
 };
        
-static int __init alsa_card_cmipci_init(void)
+module_pci_driver(cmipci_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_cmipci_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_cmipci_init)
-module_exit(alsa_card_cmipci_exit)
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index a9f368f60df6..33506ee569bd 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -2084,7 +2084,7 @@ static int cs4281_resume(struct pci_dev *pci)
 }
 #endif /* CONFIG_PM */
-static struct pci_driver driver = {
+static struct pci_driver cs4281_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_cs4281_ids,
        .probe = snd_cs4281_probe,
@@ -2095,15 +2095,4 @@ static struct pci_driver driver = {
 #endif
 };
        
-static int __init alsa_card_cs4281_init(void)
+module_pci_driver(cs4281_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_cs4281_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_cs4281_init)
-module_exit(alsa_card_cs4281_exit)
diff --git a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c
index 819d79d0586d..6cc7404e0e8f 100644
--- a/sound/pci/cs46xx/cs46xx.c
+++ b/sound/pci/cs46xx/cs46xx.c
@@ -161,7 +161,7 @@ static void __devexit snd_card_cs46xx_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver cs46xx_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_cs46xx_ids,
        .probe = snd_card_cs46xx_probe,
@@ -172,15 +172,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_cs46xx_init(void)
+module_pci_driver(cs46xx_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_cs46xx_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_cs46xx_init)
-module_exit(alsa_card_cs46xx_exit)
diff --git a/sound/pci/cs5530.c b/sound/pci/cs5530.c
index c47cabff2bfa..f1e4229993af 100644
--- a/sound/pci/cs5530.c
+++ b/sound/pci/cs5530.c
@@ -291,23 +291,11 @@ static int __devinit snd_cs5530_probe(struct pci_dev *pci,
        return 0;
 }
-static struct pci_driver driver = {
+static struct pci_driver cs5530_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_cs5530_ids,
        .probe = snd_cs5530_probe,
        .remove = __devexit_p(snd_cs5530_remove),
 };
-static int __init alsa_card_cs5530_init(void)
+module_pci_driver(cs5530_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_cs5530_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_cs5530_init)
-module_exit(alsa_card_cs5530_exit)
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index a2fb2173e980..2c9697cf0a1a 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -394,7 +394,7 @@ static void __devexit snd_cs5535audio_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver cs5535audio_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_cs5535audio_ids,
        .probe = snd_cs5535audio_probe,
@@ -405,18 +405,7 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_cs5535audio_init(void)
+module_pci_driver(cs5535audio_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_cs5535audio_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_cs5535audio_init)
-module_exit(alsa_card_cs5535audio_exit)
 MODULE_AUTHOR("Jaya Kumar");
 MODULE_LICENSE("GPL");
diff --git a/sound/pci/ctxfi/xfi.c b/sound/pci/ctxfi/xfi.c
index 15d95d2bacee..75aa2c338410 100644
--- a/sound/pci/ctxfi/xfi.c
+++ b/sound/pci/ctxfi/xfi.c
@@ -154,15 +154,4 @@ static struct pci_driver ct_driver = {
 #endif
 };
-static int __init ct_card_init(void)
+module_pci_driver(ct_driver);
-{
-        return pci_register_driver(&ct_driver);
-}
-static void __exit ct_card_exit(void)
-{
-        pci_unregister_driver(&ct_driver);
-}
-module_init(ct_card_init)
-module_exit(ct_card_exit)
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 595c11f904bb..0f8eda1dafdb 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -2328,7 +2328,7 @@ static void __devexit snd_echo_remove(struct pci_dev *pci)
 ******************************************************************************/
 /* pci_driver definition */
-static struct pci_driver driver = {
+static struct pci_driver echo_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_echo_ids,
        .probe = snd_echo_probe,
@@ -2339,22 +2339,4 @@ static struct pci_driver driver = {
 #endif /* CONFIG_PM */
 };
+module_pci_driver(echo_driver);
-/* initialization of the module */
-static int __init alsa_card_echo_init(void)
-{
-        return pci_register_driver(&driver);
-}
-/* clean up the module */
-static void __exit alsa_card_echo_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_echo_init)
-module_exit(alsa_card_echo_exit)
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 790c65d980c8..7fdbbe4d9965 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -263,7 +263,7 @@ static int snd_emu10k1_resume(struct pci_dev *pci)
 }
 #endif
-static struct pci_driver driver = {
+static struct pci_driver emu10k1_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_emu10k1_ids,
        .probe = snd_card_emu10k1_probe,
@@ -274,15 +274,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_emu10k1_init(void)
+module_pci_driver(emu10k1_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_emu10k1_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_emu10k1_init)
-module_exit(alsa_card_emu10k1_exit)
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 47a651cb6e84..5c8978b2c4d9 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -1612,24 +1612,11 @@ static DEFINE_PCI_DEVICE_TABLE(snd_emu10k1x_ids) = {
 MODULE_DEVICE_TABLE(pci, snd_emu10k1x_ids);
 // pci_driver definition
-static struct pci_driver driver = {
+static struct pci_driver emu10k1x_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_emu10k1x_ids,
        .probe = snd_emu10k1x_probe,
        .remove = __devexit_p(snd_emu10k1x_remove),
 };
-// initialization of the module
+module_pci_driver(emu10k1x_driver);
-static int __init alsa_card_emu10k1x_init(void)
-{
-        return pci_register_driver(&driver);
-}
-// clean up the module
-static void __exit alsa_card_emu10k1x_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_emu10k1x_init)
-module_exit(alsa_card_emu10k1x_exit)
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index 47a245e84190..3821c81d1c99 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -2488,7 +2488,7 @@ static void __devexit snd_audiopci_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver ens137x_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_audiopci_ids,
        .probe = snd_audiopci_probe,
@@ -2499,15 +2499,4 @@ static struct pci_driver driver = {
 #endif
 };
        
-static int __init alsa_card_ens137x_init(void)
+module_pci_driver(ens137x_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_ens137x_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ens137x_init)
-module_exit(alsa_card_ens137x_exit)
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 53eb76b41108..82c8d8c5c52a 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -1882,7 +1882,7 @@ static void __devexit snd_es1938_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver es1938_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_es1938_ids,
        .probe = snd_es1938_probe,
@@ -1893,15 +1893,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_es1938_init(void)
+module_pci_driver(es1938_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_es1938_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_es1938_init)
-module_exit(alsa_card_es1938_exit)
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index a8faae1c85e4..67f47d891959 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -2898,7 +2898,7 @@ static void __devexit snd_es1968_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver es1968_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_es1968_ids,
        .probe = snd_es1968_probe,
@@ -2909,15 +2909,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_es1968_init(void)
+module_pci_driver(es1968_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_es1968_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_es1968_init)
-module_exit(alsa_card_es1968_exit)
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index a416ea8af3e9..f69662322750 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -1416,7 +1416,7 @@ static int snd_fm801_resume(struct pci_dev *pci)
 }
 #endif
-static struct pci_driver driver = {
+static struct pci_driver fm801_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_fm801_ids,
        .probe = snd_card_fm801_probe,
@@ -1427,15 +1427,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_fm801_init(void)
+module_pci_driver(fm801_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_fm801_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_fm801_init)
-module_exit(alsa_card_fm801_exit)
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index 7ee46aba6ea7..4ab8102f87ea 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -2566,6 +2566,8 @@ static struct snd_pci_quirk probe_mask_list[] __devinitdata = {
        /* forced codec slots */
        SND_PCI_QUIRK(0x1043, 0x1262, "ASUS W5Fm", 0x103),
        SND_PCI_QUIRK(0x1046, 0x1262, "ASUS W5F", 0x103),
+        /* WinFast VP200 H (Teradici) user reported broken communication */
+        SND_PCI_QUIRK(0x3a21, 0x040d, "WinFast VP200 H", 0x101),
        {}
 };
@@ -3154,7 +3156,7 @@ static DEFINE_PCI_DEVICE_TABLE(azx_ids) = {
 MODULE_DEVICE_TABLE(pci, azx_ids);
 /* pci_driver definition */
-static struct pci_driver driver = {
+static struct pci_driver azx_driver = {
        .name = KBUILD_MODNAME,
        .id_table = azx_ids,
        .probe = azx_probe,
@@ -3165,15 +3167,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_azx_init(void)
+module_pci_driver(azx_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_azx_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_azx_init)
-module_exit(alsa_card_azx_exit)
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index 132a86e09d07..5be2e120a14e 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -2803,22 +2803,11 @@ static void __devexit snd_ice1712_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver ice1712_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_ice1712_ids,
        .probe = snd_ice1712_probe,
        .remove = __devexit_p(snd_ice1712_remove),
 };
-static int __init alsa_card_ice1712_init(void)
+module_pci_driver(ice1712_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_ice1712_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ice1712_init)
-module_exit(alsa_card_ice1712_exit)
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index 812d10e43ae0..a01a00d1cf4d 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -2873,7 +2873,7 @@ static int snd_vt1724_resume(struct pci_dev *pci)
 }
 #endif
-static struct pci_driver driver = {
+static struct pci_driver vt1724_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_vt1724_ids,
        .probe = snd_vt1724_probe,
@@ -2884,15 +2884,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_ice1724_init(void)
+module_pci_driver(vt1724_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_ice1724_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ice1724_init)
-module_exit(alsa_card_ice1724_exit)
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index e0a4263baa20..f4e2dd4da8cf 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -3338,7 +3338,7 @@ static void __devexit snd_intel8x0_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver intel8x0_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_intel8x0_ids,
        .probe = snd_intel8x0_probe,
@@ -3349,16 +3349,4 @@ static struct pci_driver driver = {
 #endif
 };
+module_pci_driver(intel8x0_driver);
-static int __init alsa_card_intel8x0_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_intel8x0_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_intel8x0_init)
-module_exit(alsa_card_intel8x0_exit)
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index d689913a61be..fc27a6a69e77 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -1324,7 +1324,7 @@ static void __devexit snd_intel8x0m_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver intel8x0m_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_intel8x0m_ids,
        .probe = snd_intel8x0m_probe,
@@ -1335,16 +1335,4 @@ static struct pci_driver driver = {
 #endif
 };
+module_pci_driver(intel8x0m_driver);
-static int __init alsa_card_intel8x0m_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_intel8x0m_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_intel8x0m_init)
-module_exit(alsa_card_intel8x0m_exit)
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index 8fea45ab5882..e69ce5f9c31e 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -2476,22 +2476,11 @@ static void __devexit snd_korg1212_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver korg1212_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_korg1212_ids,
        .probe = snd_korg1212_probe,
        .remove = __devexit_p(snd_korg1212_remove),
 };
-static int __init alsa_card_korg1212_init(void)
+module_pci_driver(korg1212_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_korg1212_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_korg1212_init)
-module_exit(alsa_card_korg1212_exit)
diff --git a/sound/pci/lola/lola.c b/sound/pci/lola/lola.c
index 375982736858..ac15166bee68 100644
--- a/sound/pci/lola/lola.c
+++ b/sound/pci/lola/lola.c
@@ -770,22 +770,11 @@ static DEFINE_PCI_DEVICE_TABLE(lola_ids) = {
 MODULE_DEVICE_TABLE(pci, lola_ids);
 /* pci_driver definition */
-static struct pci_driver driver = {
+static struct pci_driver lola_driver = {
        .name = KBUILD_MODNAME,
        .id_table = lola_ids,
        .probe = lola_probe,
        .remove = __devexit_p(lola_remove),
 };
-static int __init alsa_card_lola_init(void)
+module_pci_driver(lola_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_lola_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_lola_init)
-module_exit(alsa_card_lola_exit)
diff --git a/sound/pci/lx6464es/lx6464es.c b/sound/pci/lx6464es/lx6464es.c
index d94c0c292bd0..d1ab43706735 100644
--- a/sound/pci/lx6464es/lx6464es.c
+++ b/sound/pci/lx6464es/lx6464es.c
@@ -1141,24 +1141,11 @@ static void __devexit snd_lx6464es_remove(struct pci_dev *pci)
 }
-static struct pci_driver driver = {
+static struct pci_driver lx6464es_driver = {
        .name =     KBUILD_MODNAME,
        .id_table = snd_lx6464es_ids,
        .probe =    snd_lx6464es_probe,
        .remove = __devexit_p(snd_lx6464es_remove),
 };
+module_pci_driver(lx6464es_driver);
-/* module initialization */
-static int __init mod_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit mod_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(mod_init);
-module_exit(mod_exit);
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 78229b0dad2b..deef21399586 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -2837,7 +2837,7 @@ static void __devexit snd_m3_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver m3_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_m3_ids,
        .probe = snd_m3_probe,
@@ -2848,15 +2848,4 @@ static struct pci_driver driver = {
 #endif
 };
        
-static int __init alsa_card_m3_init(void)
+module_pci_driver(m3_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_m3_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_m3_init)
-module_exit(alsa_card_m3_exit)
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 487837c01c9f..0762610c99c0 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -1380,22 +1380,11 @@ static void __devexit snd_mixart_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver mixart_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_mixart_ids,
        .probe = snd_mixart_probe,
        .remove = __devexit_p(snd_mixart_remove),
 };
-static int __init alsa_card_mixart_init(void)
+module_pci_driver(mixart_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_mixart_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_mixart_init)
-module_exit(alsa_card_mixart_exit)
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index ade2c64bd606..8159b05ee94d 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -1742,7 +1742,7 @@ static void __devexit snd_nm256_remove(struct pci_dev *pci)
 }
-static struct pci_driver driver = {
+static struct pci_driver nm256_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_nm256_ids,
        .probe = snd_nm256_probe,
@@ -1753,16 +1753,4 @@ static struct pci_driver driver = {
 #endif
 };
+module_pci_driver(nm256_driver);
-static int __init alsa_card_nm256_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_nm256_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_nm256_init)
-module_exit(alsa_card_nm256_exit)
diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c
index eab663eef117..610275bfbaeb 100644
--- a/sound/pci/oxygen/oxygen.c
+++ b/sound/pci/oxygen/oxygen.c
@@ -94,6 +94,7 @@ enum {
        MODEL_2CH_OUTPUT,
        MODEL_HG2PCI,
        MODEL_XONAR_DG,
+        MODEL_XONAR_DGX,
 };
 static DEFINE_PCI_DEVICE_TABLE(oxygen_ids) = {
@@ -109,6 +110,8 @@ static DEFINE_PCI_DEVICE_TABLE(oxygen_ids) = {
        { OXYGEN_PCI_SUBID(0x1a58, 0x0910), .driver_data = MODEL_CMEDIA_REF },
        /* Asus Xonar DG */
        { OXYGEN_PCI_SUBID(0x1043, 0x8467), .driver_data = MODEL_XONAR_DG },
+        /* Asus Xonar DGX */
+        { OXYGEN_PCI_SUBID(0x1043, 0x8521), .driver_data = MODEL_XONAR_DGX },
        /* PCI 2.0 HD Audio */
        { OXYGEN_PCI_SUBID(0x13f6, 0x8782), .driver_data = MODEL_2CH_OUTPUT },
        /* Kuroutoshikou CMI8787-HG2PCI */
@@ -827,6 +830,11 @@ static int __devinit get_oxygen_model(struct oxygen *chip,
                break;
        case MODEL_XONAR_DG:
                chip->model = model_xonar_dg;
+                chip->model.shortname = "Xonar DG";
+                break;
+        case MODEL_XONAR_DGX:
+                chip->model = model_xonar_dg;
+                chip->model.shortname = "Xonar DGX";
                break;
        }
        if (id->driver_data == MODEL_MERIDIAN ||
@@ -870,15 +878,4 @@ static struct pci_driver oxygen_driver = {
 #endif
 };
-static int __init alsa_card_oxygen_init(void)
+module_pci_driver(oxygen_driver);
-{
-        return pci_register_driver(&oxygen_driver);
-}
-static void __exit alsa_card_oxygen_exit(void)
-{
-        pci_unregister_driver(&oxygen_driver);
-}
-module_init(alsa_card_oxygen_init)
-module_exit(alsa_card_oxygen_exit)
diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c
index 3fdee4950174..19962c6d38c3 100644
--- a/sound/pci/oxygen/virtuoso.c
+++ b/sound/pci/oxygen/virtuoso.c
@@ -100,15 +100,4 @@ static struct pci_driver xonar_driver = {
        .shutdown = oxygen_pci_shutdown,
 };
-static int __init alsa_card_xonar_init(void)
+module_pci_driver(xonar_driver);
-{
-        return pci_register_driver(&xonar_driver);
-}
-static void __exit alsa_card_xonar_exit(void)
-{
-        pci_unregister_driver(&xonar_driver);
-}
-module_init(alsa_card_xonar_init)
-module_exit(alsa_card_xonar_exit)
diff --git a/sound/pci/oxygen/xonar_dg.c b/sound/pci/oxygen/xonar_dg.c
index 793bdf03d7e0..77acd790ea47 100644
--- a/sound/pci/oxygen/xonar_dg.c
+++ b/sound/pci/oxygen/xonar_dg.c
@@ -1,5 +1,5 @@
 /*
- * card driver for the Xonar DG
+ * card driver for the Xonar DG/DGX
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 *
@@ -17,8 +17,8 @@
 */
 /*
- * Xonar DG
+ * Xonar DG/DGX
- * --------
+ * ------------
 *
 * CMI8788:
 *
@@ -581,7 +581,6 @@ static void dump_cs4245_registers(struct oxygen *chip,
 }
 struct oxygen_model model_xonar_dg = {
-        .shortname = "Xonar DG",
        .longname = "C-Media Oxygen HD Audio",
        .chip = "CMI8786",
        .init = dg_init,
diff --git a/sound/pci/pcxhr/pcxhr.c b/sound/pci/pcxhr/pcxhr.c
index fd1809ab73b4..0435f45e9513 100644
--- a/sound/pci/pcxhr/pcxhr.c
+++ b/sound/pci/pcxhr/pcxhr.c
@@ -1607,22 +1607,11 @@ static void __devexit pcxhr_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver pcxhr_driver = {
        .name = KBUILD_MODNAME,
        .id_table = pcxhr_ids,
        .probe = pcxhr_probe,
        .remove = __devexit_p(pcxhr_remove),
 };
-static int __init pcxhr_module_init(void)
+module_pci_driver(pcxhr_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit pcxhr_module_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(pcxhr_module_init)
-module_exit(pcxhr_module_exit)
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index 0481d94aac9b..cbeb3f77350c 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -1837,8 +1837,7 @@ static int snd_riptide_free(struct snd_riptide *chip)
        }
        if (chip->irq >= 0)
                free_irq(chip->irq, chip);
-        if (chip->fw_entry)
+        release_firmware(chip->fw_entry);
-                release_firmware(chip->fw_entry);
        release_and_free_resource(chip->res_port);
        kfree(chip);
        return 0;
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index b4819d5e41db..46b3629dda22 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -1984,22 +1984,11 @@ static void __devexit snd_rme32_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver rme32_driver = {
        .name =         KBUILD_MODNAME,
        .id_table =     snd_rme32_ids,
        .probe =        snd_rme32_probe,
        .remove =       __devexit_p(snd_rme32_remove),
 };
-static int __init alsa_card_rme32_init(void)
+module_pci_driver(rme32_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_rme32_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_rme32_init)
-module_exit(alsa_card_rme32_exit)
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index ba894158e76c..9b98dc406988 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -2395,22 +2395,11 @@ static void __devexit snd_rme96_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver rme96_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_rme96_ids,
        .probe = snd_rme96_probe,
        .remove = __devexit_p(snd_rme96_remove),
 };
-static int __init alsa_card_rme96_init(void)
+module_pci_driver(rme96_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_rme96_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_rme96_init)
-module_exit(alsa_card_rme96_exit)
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index 0b2aea2ce172..0d6930c4f4b7 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -5636,22 +5636,11 @@ static void __devexit snd_hdsp_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver hdsp_driver = {
        .name =     KBUILD_MODNAME,
        .id_table = snd_hdsp_ids,
        .probe =    snd_hdsp_probe,
        .remove = __devexit_p(snd_hdsp_remove),
 };
-static int __init alsa_card_hdsp_init(void)
+module_pci_driver(hdsp_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_hdsp_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_hdsp_init)
-module_exit(alsa_card_hdsp_exit)
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index bc030a2088da..0a5027b94714 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -6918,23 +6918,11 @@ static void __devexit snd_hdspm_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver hdspm_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_hdspm_ids,
        .probe = snd_hdspm_probe,
        .remove = __devexit_p(snd_hdspm_remove),
 };
+module_pci_driver(hdspm_driver);
-static int __init alsa_card_hdspm_init(void)
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_hdspm_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_hdspm_init)
-module_exit(alsa_card_hdspm_exit)
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index b737d1619cc7..a15fc100ab0c 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -2631,22 +2631,11 @@ static void __devexit snd_rme9652_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver rme9652_driver = {
        .name     = KBUILD_MODNAME,
        .id_table = snd_rme9652_ids,
        .probe    = snd_rme9652_probe,
        .remove   = __devexit_p(snd_rme9652_remove),
 };
-static int __init alsa_card_hammerfall_init(void)
+module_pci_driver(rme9652_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_hammerfall_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_hammerfall_init)
-module_exit(alsa_card_hammerfall_exit)
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index ff500a87f769..1552642765d6 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -1488,15 +1488,4 @@ static struct pci_driver sis7019_driver = {
 #endif
 };
-static int __init sis7019_init(void)
+module_pci_driver(sis7019_driver);
-{
-        return pci_register_driver(&sis7019_driver);
-}
-static void __exit sis7019_exit(void)
-{
-        pci_unregister_driver(&sis7019_driver);
-}
-module_init(sis7019_init);
-module_exit(sis7019_exit);
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 54cc802050f7..baa9946bedf0 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -1530,22 +1530,11 @@ static void __devexit snd_sonic_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver sonicvibes_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_sonic_ids,
        .probe = snd_sonic_probe,
        .remove = __devexit_p(snd_sonic_remove),
 };
-static int __init alsa_card_sonicvibes_init(void)
+module_pci_driver(sonicvibes_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_sonicvibes_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_sonicvibes_init)
-module_exit(alsa_card_sonicvibes_exit)
diff --git a/sound/pci/trident/trident.c b/sound/pci/trident/trident.c
index 5f1def7f45e5..611983ec7321 100644
--- a/sound/pci/trident/trident.c
+++ b/sound/pci/trident/trident.c
@@ -172,7 +172,7 @@ static void __devexit snd_trident_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver trident_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_trident_ids,
        .probe = snd_trident_probe,
@@ -183,15 +183,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_trident_init(void)
+module_pci_driver(trident_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_trident_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_trident_init)
-module_exit(alsa_card_trident_exit)
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index 75630408c6db..b5afab48943e 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -2619,7 +2619,7 @@ static void __devexit snd_via82xx_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver via82xx_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_via82xx_ids,
        .probe = snd_via82xx_probe,
@@ -2630,15 +2630,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_via82xx_init(void)
+module_pci_driver(via82xx_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_via82xx_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_via82xx_init)
-module_exit(alsa_card_via82xx_exit)
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index 5efcbcac506a..59fd47ed0a31 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -1223,7 +1223,7 @@ static void __devexit snd_via82xx_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver via82xx_modem_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_via82xx_modem_ids,
        .probe = snd_via82xx_probe,
@@ -1234,15 +1234,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_via82xx_init(void)
+module_pci_driver(via82xx_modem_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_via82xx_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_via82xx_init)
-module_exit(alsa_card_via82xx_exit)
diff --git a/sound/pci/vx222/vx222.c b/sound/pci/vx222/vx222.c
index 6a534bfe1274..1ea1f656a5dc 100644
--- a/sound/pci/vx222/vx222.c
+++ b/sound/pci/vx222/vx222.c
@@ -289,7 +289,7 @@ static int snd_vx222_resume(struct pci_dev *pci)
 }
 #endif
-static struct pci_driver driver = {
+static struct pci_driver vx222_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_vx222_ids,
        .probe = snd_vx222_probe,
@@ -300,15 +300,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_vx222_init(void)
+module_pci_driver(vx222_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_vx222_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_vx222_init)
-module_exit(alsa_card_vx222_exit)
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index 94ab728f5ca8..9a1d01d653a7 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -350,7 +350,7 @@ static void __devexit snd_card_ymfpci_remove(struct pci_dev *pci)
        pci_set_drvdata(pci, NULL);
 }
-static struct pci_driver driver = {
+static struct pci_driver ymfpci_driver = {
        .name = KBUILD_MODNAME,
        .id_table = snd_ymfpci_ids,
        .probe = snd_card_ymfpci_probe,
@@ -361,15 +361,4 @@ static struct pci_driver driver = {
 #endif
 };
-static int __init alsa_card_ymfpci_init(void)
+module_pci_driver(ymfpci_driver);
-{
-        return pci_register_driver(&driver);
-}
-static void __exit alsa_card_ymfpci_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ymfpci_init)
-module_exit(alsa_card_ymfpci_exit)
diff --git a/sound/sh/sh_dac_audio.c b/sound/sh/sh_dac_audio.c
index b11f82b5718f..f8b01c77b298 100644
--- a/sound/sh/sh_dac_audio.c
+++ b/sound/sh/sh_dac_audio.c
@@ -433,7 +433,7 @@ probe_error:
 /*
 * "driver" definition
 */
-static struct platform_driver driver = {
+static struct platform_driver sh_dac_driver = {
        .probe  = snd_sh_dac_probe,
        .remove = snd_sh_dac_remove,
        .driver = {
@@ -441,4 +441,4 @@ static struct platform_driver driver = {
        },
 };
-module_platform_driver(driver);
+module_platform_driver(sh_dac_driver);
diff --git a/sound/sound_core.c b/sound/sound_core.c
index c6e81fb928e9..fb9255cca214 100644
--- a/sound/sound_core.c
+++ b/sound/sound_core.c
@@ -361,7 +361,7 @@ int register_sound_special_device(const struct file_operations *fops, int unit,
                                  struct device *dev)
 {
        const int chain = unit % SOUND_STEP;
-        int max_unit = 128 + chain;
+        int max_unit = 256;
        const char *name;
        char _name[16];
diff --git a/sound/usb/card.c b/sound/usb/card.c
index 4a7be7b98331..d5b5c3388e28 100644
--- a/sound/usb/card.c
+++ b/sound/usb/card.c
@@ -131,8 +131,9 @@ static void snd_usb_stream_disconnect(struct list_head *head)
                subs = &as->substream[idx];
                if (!subs->num_formats)
                        continue;
-                snd_usb_release_substream_urbs(subs, 1);
                subs->interface = -1;
+                subs->data_endpoint = NULL;
+                subs->sync_endpoint = NULL;
        }
 }
@@ -276,6 +277,7 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
 static int snd_usb_audio_free(struct snd_usb_audio *chip)
 {
+        mutex_destroy(&chip->mutex);
        kfree(chip);
        return 0;
 }
@@ -336,6 +338,7 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
                return -ENOMEM;
        }
+        mutex_init(&chip->mutex);
        mutex_init(&chip->shutdown_mutex);
        chip->index = idx;
        chip->dev = dev;
@@ -348,6 +351,7 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx,
        chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
                              le16_to_cpu(dev->descriptor.idProduct));
        INIT_LIST_HEAD(&chip->pcm_list);
+        INIT_LIST_HEAD(&chip->ep_list);
        INIT_LIST_HEAD(&chip->midi_list);
        INIT_LIST_HEAD(&chip->mixer_list);
@@ -565,6 +569,10 @@ static void snd_usb_audio_disconnect(struct usb_device *dev,
                list_for_each(p, &chip->pcm_list) {
                        snd_usb_stream_disconnect(p);
                }
+                /* release the endpoint resources */
+                list_for_each(p, &chip->ep_list) {
+                        snd_usb_endpoint_free(p);
+                }
                /* release the midi resources */
                list_for_each(p, &chip->midi_list) {
                        snd_usbmidi_disconnect(p);
diff --git a/sound/usb/card.h b/sound/usb/card.h
index da5fa1ac4eda..0d37238b8457 100644
--- a/sound/usb/card.h
+++ b/sound/usb/card.h
@@ -30,20 +30,71 @@ struct audioformat {
 };
 struct snd_usb_substream;
+struct snd_usb_endpoint;
 struct snd_urb_ctx {
        struct urb *urb;
        unsigned int buffer_size;       /* size of data buffer, if data URB */
        struct snd_usb_substream *subs;
+        struct snd_usb_endpoint *ep;
        int index;      /* index for urb array */
        int packets;    /* number of packets per urb */
+        int packet_size[MAX_PACKS_HS]; /* size of packets for next submission */
+        struct list_head ready_list;
 };
-struct snd_urb_ops {
+struct snd_usb_endpoint {
-        int (*prepare)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
+        struct snd_usb_audio *chip;
-        int (*retire)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
-        int (*prepare_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
+        int use_count;
-        int (*retire_sync)(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *u);
+        int ep_num;             /* the referenced endpoint number */
+        int type;               /* SND_USB_ENDPOINT_TYPE_* */
+        unsigned long flags;
+        void (*prepare_data_urb) (struct snd_usb_substream *subs,
+                                  struct urb *urb);
+        void (*retire_data_urb) (struct snd_usb_substream *subs,
+                                 struct urb *urb);
+        struct snd_usb_substream *data_subs;
+        struct snd_usb_endpoint *sync_master;
+        struct snd_usb_endpoint *sync_slave;
+        struct snd_urb_ctx urb[MAX_URBS];
+        struct snd_usb_packet_info {
+                uint32_t packet_size[MAX_PACKS_HS];
+                int packets;
+        } next_packet[MAX_URBS];
+        int next_packet_read_pos, next_packet_write_pos;
+        struct list_head ready_playback_urbs;
+        unsigned int nurbs;             /* # urbs */
+        unsigned long active_mask;      /* bitmask of active urbs */
+        unsigned long unlink_mask;      /* bitmask of unlinked urbs */
+        char *syncbuf;                  /* sync buffer for all sync URBs */
+        dma_addr_t sync_dma;            /* DMA address of syncbuf */
+        unsigned int pipe;              /* the data i/o pipe */
+        unsigned int freqn;             /* nominal sampling rate in fs/fps in Q16.16 format */
+        unsigned int freqm;             /* momentary sampling rate in fs/fps in Q16.16 format */
+        int        freqshift;           /* how much to shift the feedback value to get Q16.16 */
+        unsigned int freqmax;           /* maximum sampling rate, used for buffer management */
+        unsigned int phase;             /* phase accumulator */
+        unsigned int maxpacksize;       /* max packet size in bytes */
+        unsigned int maxframesize;      /* max packet size in frames */
+        unsigned int curpacksize;       /* current packet size in bytes (for capture) */
+        unsigned int curframesize;      /* current packet size in frames (for capture) */
+        unsigned int syncmaxsize;       /* sync endpoint packet size */
+        unsigned int fill_max:1;        /* fill max packet size always */
+        unsigned int datainterval;      /* log_2 of data packet interval */
+        unsigned int syncinterval;      /* P for adaptive mode, 0 otherwise */
+        unsigned char silence_value;
+        unsigned int stride;
+        int iface, alt_idx;
+        spinlock_t lock;
+        struct list_head list;
 };
 struct snd_usb_substream {
@@ -57,21 +108,6 @@ struct snd_usb_substream {
        unsigned int cur_rate;          /* current rate (for hw_params callback) */
        unsigned int period_bytes;      /* current period bytes (for hw_params callback) */
        unsigned int altset_idx;     /* USB data format: index of alternate setting */
-        unsigned int datapipe;   /* the data i/o pipe */
-        unsigned int syncpipe;   /* 1 - async out or adaptive in */
-        unsigned int datainterval;      /* log_2 of data packet interval */
-        unsigned int syncinterval;  /* P for adaptive mode, 0 otherwise */
-        unsigned int freqn;      /* nominal sampling rate in fs/fps in Q16.16 format */
-        unsigned int freqm;      /* momentary sampling rate in fs/fps in Q16.16 format */
-        int          freqshift;  /* how much to shift the feedback value to get Q16.16 */
-        unsigned int freqmax;    /* maximum sampling rate, used for buffer management */
-        unsigned int phase;      /* phase accumulator */
-        unsigned int maxpacksize;       /* max packet size in bytes */
-        unsigned int maxframesize;      /* max packet size in frames */
-        unsigned int curpacksize;       /* current packet size in bytes (for capture) */
-        unsigned int curframesize;      /* current packet size in frames (for capture) */
-        unsigned int syncmaxsize;       /* sync endpoint packet size */
-        unsigned int fill_max: 1;       /* fill max packet size always */
        unsigned int txfr_quirk:1;      /* allow sub-frame alignment */
        unsigned int fmt_type;          /* USB audio format type (1-3) */
@@ -82,11 +118,10 @@ struct snd_usb_substream {
        unsigned long active_mask;      /* bitmask of active urbs */
        unsigned long unlink_mask;      /* bitmask of unlinked urbs */
-        unsigned int nurbs;                     /* # urbs */
+        /* data and sync endpoints for this stream */
-        struct snd_urb_ctx dataurb[MAX_URBS];   /* data urb table */
+        struct snd_usb_endpoint *data_endpoint;
-        struct snd_urb_ctx syncurb[SYNC_URBS];  /* sync urb table */
+        struct snd_usb_endpoint *sync_endpoint;
-        char *syncbuf;                          /* sync buffer for all sync URBs */
+        unsigned long flags;
-        dma_addr_t sync_dma;                    /* DMA address of syncbuf */
        u64 formats;                    /* format bitmasks (all or'ed) */
        unsigned int num_formats;               /* number of supported audio formats (list) */
@@ -94,7 +129,6 @@ struct snd_usb_substream {
        struct snd_pcm_hw_constraint_list rate_list;    /* limited rates */
        spinlock_t lock;
-        struct snd_urb_ops ops;         /* callbacks (must be filled at init) */
        int last_frame_number;          /* stored frame number */
        int last_delay;                 /* stored delay */
 };
diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 08dcce53720b..e6906901debb 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -20,9 +20,11 @@
 #include <linux/ratelimit.h>
 #include <linux/usb.h>
 #include <linux/usb/audio.h>
+#include <linux/slab.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
+#include <sound/pcm_params.h>
 #include "usbaudio.h"
 #include "helper.h"
@@ -30,6 +32,36 @@
 #include "endpoint.h"
 #include "pcm.h"
+#define EP_FLAG_ACTIVATED       0
+#define EP_FLAG_RUNNING         1
+/*
+ * snd_usb_endpoint is a model that abstracts everything related to an
+ * USB endpoint and its streaming.
+ *
+ * There are functions to activate and deactivate the streaming URBs and
+ * optional callbacks to let the pcm logic handle the actual content of the
+ * packets for playback and record. Thus, the bus streaming and the audio
+ * handlers are fully decoupled.
+ *
+ * There are two different types of endpoints in audio applications.
+ *
+ * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
+ * inbound and outbound traffic.
+ *
+ * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
+ * expect the payload to carry Q10.14 / Q16.16 formatted sync information
+ * (3 or 4 bytes).
+ *
+ * Each endpoint has to be configured prior to being used by calling
+ * snd_usb_endpoint_set_params().
+ *
+ * The model incorporates a reference counting, so that multiple users
+ * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
+ * only the first user will effectively start the URBs, and only the last
+ * one to stop it will tear the URBs down again.
+ */
 /*
 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
 * this will overflow at approx 524 kHz
@@ -49,71 +81,415 @@ static inline unsigned get_usb_high_speed_rate(unsigned int rate)
 }
 /*
- * unlink active urbs.
+ * release a urb data
 */
-static int deactivate_urbs(struct snd_usb_substream *subs, int force, int can_sleep)
+static void release_urb_ctx(struct snd_urb_ctx *u)
 {
-        struct snd_usb_audio *chip = subs->stream->chip;
+        if (u->buffer_size)
-        unsigned int i;
+                usb_free_coherent(u->ep->chip->dev, u->buffer_size,
-        int async;
+                                  u->urb->transfer_buffer,
+                                  u->urb->transfer_dma);
+        usb_free_urb(u->urb);
+        u->urb = NULL;
+}
+static const char *usb_error_string(int err)
+{
+        switch (err) {
+        case -ENODEV:
+                return "no device";
+        case -ENOENT:
+                return "endpoint not enabled";
+        case -EPIPE:
+                return "endpoint stalled";
+        case -ENOSPC:
+                return "not enough bandwidth";
+        case -ESHUTDOWN:
+                return "device disabled";
+        case -EHOSTUNREACH:
+                return "device suspended";
+        case -EINVAL:
+        case -EAGAIN:
+        case -EFBIG:
+        case -EMSGSIZE:
+                return "internal error";
+        default:
+                return "unknown error";
+        }
+}
+/**
+ * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
+ *
+ * @ep: The snd_usb_endpoint
+ *
+ * Determine whether an endpoint is driven by an implicit feedback
+ * data endpoint source.
+ */
+int snd_usb_endpoint_implict_feedback_sink(struct snd_usb_endpoint *ep)
+{
+        return  ep->sync_master &&
+                ep->sync_master->type == SND_USB_ENDPOINT_TYPE_DATA &&
+                ep->type == SND_USB_ENDPOINT_TYPE_DATA &&
+                usb_pipeout(ep->pipe);
+}
-        subs->running = 0;
+/*
+ * For streaming based on information derived from sync endpoints,
+ * prepare_outbound_urb_sizes() will call next_packet_size() to
+ * determine the number of samples to be sent in the next packet.
+ *
+ * For implicit feedback, next_packet_size() is unused.
+ */
+static int next_packet_size(struct snd_usb_endpoint *ep)
+{
+        unsigned long flags;
+        int ret;
-        if (!force && subs->stream->chip->shutdown) /* to be sure... */
+        if (ep->fill_max)
-                return -EBADFD;
+                return ep->maxframesize;
-        async = !can_sleep && chip->async_unlink;
+        spin_lock_irqsave(&ep->lock, flags);
+        ep->phase = (ep->phase & 0xffff)
+                + (ep->freqm << ep->datainterval);
+        ret = min(ep->phase >> 16, ep->maxframesize);
+        spin_unlock_irqrestore(&ep->lock, flags);
-        if (!async && in_interrupt())
+        return ret;
-                return 0;
+}
-        for (i = 0; i < subs->nurbs; i++) {
+static void retire_outbound_urb(struct snd_usb_endpoint *ep,
-                if (test_bit(i, &subs->active_mask)) {
+                                struct snd_urb_ctx *urb_ctx)
-                        if (!test_and_set_bit(i, &subs->unlink_mask)) {
+{
-                                struct urb *u = subs->dataurb[i].urb;
+        if (ep->retire_data_urb)
-                                if (async)
+                ep->retire_data_urb(ep->data_subs, urb_ctx->urb);
-                                        usb_unlink_urb(u);
+}
-                                else
-                                        usb_kill_urb(u);
+static void retire_inbound_urb(struct snd_usb_endpoint *ep,
+                               struct snd_urb_ctx *urb_ctx)
+{
+        struct urb *urb = urb_ctx->urb;
+        if (ep->sync_slave)
+                snd_usb_handle_sync_urb(ep->sync_slave, ep, urb);
+        if (ep->retire_data_urb)
+                ep->retire_data_urb(ep->data_subs, urb);
+}
+static void prepare_outbound_urb_sizes(struct snd_usb_endpoint *ep,
+                                       struct snd_urb_ctx *ctx)
+{
+        int i;
+        for (i = 0; i < ctx->packets; ++i)
+                ctx->packet_size[i] = next_packet_size(ep);
+}
+/*
+ * Prepare a PLAYBACK urb for submission to the bus.
+ */
+static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
+                                 struct snd_urb_ctx *ctx)
+{
+        int i;
+        struct urb *urb = ctx->urb;
+        unsigned char *cp = urb->transfer_buffer;
+        urb->dev = ep->chip->dev; /* we need to set this at each time */
+        switch (ep->type) {
+        case SND_USB_ENDPOINT_TYPE_DATA:
+                if (ep->prepare_data_urb) {
+                        ep->prepare_data_urb(ep->data_subs, urb);
+                } else {
+                        /* no data provider, so send silence */
+                        unsigned int offs = 0;
+                        for (i = 0; i < ctx->packets; ++i) {
+                                int counts = ctx->packet_size[i];
+                                urb->iso_frame_desc[i].offset = offs * ep->stride;
+                                urb->iso_frame_desc[i].length = counts * ep->stride;
+                                offs += counts;
                        }
+                        urb->number_of_packets = ctx->packets;
+                        urb->transfer_buffer_length = offs * ep->stride;
+                        memset(urb->transfer_buffer, ep->silence_value,
+                               offs * ep->stride);
                }
+                break;
+        case SND_USB_ENDPOINT_TYPE_SYNC:
+                if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
+                        /*
+                         * fill the length and offset of each urb descriptor.
+                         * the fixed 12.13 frequency is passed as 16.16 through the pipe.
+                         */
+                        urb->iso_frame_desc[0].length = 4;
+                        urb->iso_frame_desc[0].offset = 0;
+                        cp[0] = ep->freqn;
+                        cp[1] = ep->freqn >> 8;
+                        cp[2] = ep->freqn >> 16;
+                        cp[3] = ep->freqn >> 24;
+                } else {
+                        /*
+                         * fill the length and offset of each urb descriptor.
+                         * the fixed 10.14 frequency is passed through the pipe.
+                         */
+                        urb->iso_frame_desc[0].length = 3;
+                        urb->iso_frame_desc[0].offset = 0;
+                        cp[0] = ep->freqn >> 2;
+                        cp[1] = ep->freqn >> 10;
+                        cp[2] = ep->freqn >> 18;
+                }
+                break;
        }
-        if (subs->syncpipe) {
+}
-                for (i = 0; i < SYNC_URBS; i++) {
-                        if (test_bit(i+16, &subs->active_mask)) {
+/*
-                                if (!test_and_set_bit(i+16, &subs->unlink_mask)) {
+ * Prepare a CAPTURE or SYNC urb for submission to the bus.
-                                        struct urb *u = subs->syncurb[i].urb;
+ */
-                                        if (async)
+static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
-                                                usb_unlink_urb(u);
+                                       struct snd_urb_ctx *urb_ctx)
-                                        else
+{
-                                                usb_kill_urb(u);
+        int i, offs;
-                                }
+        struct urb *urb = urb_ctx->urb;
-                        }
+        urb->dev = ep->chip->dev; /* we need to set this at each time */
+        switch (ep->type) {
+        case SND_USB_ENDPOINT_TYPE_DATA:
+                offs = 0;
+                for (i = 0; i < urb_ctx->packets; i++) {
+                        urb->iso_frame_desc[i].offset = offs;
+                        urb->iso_frame_desc[i].length = ep->curpacksize;
+                        offs += ep->curpacksize;
                }
+                urb->transfer_buffer_length = offs;
+                urb->number_of_packets = urb_ctx->packets;
+                break;
+        case SND_USB_ENDPOINT_TYPE_SYNC:
+                urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
+                urb->iso_frame_desc[0].offset = 0;
+                break;
        }
-        return 0;
 }
+/*
+ * Send output urbs that have been prepared previously. URBs are dequeued
+ * from ep->ready_playback_urbs and in case there there aren't any available
+ * or there are no packets that have been prepared, this function does
+ * nothing.
+ *
+ * The reason why the functionality of sending and preparing URBs is separated
+ * is that host controllers don't guarantee the order in which they return
+ * inbound and outbound packets to their submitters.
+ *
+ * This function is only used for implicit feedback endpoints. For endpoints
+ * driven by dedicated sync endpoints, URBs are immediately re-submitted
+ * from their completion handler.
+ */
+static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
+{
+        while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {
+                unsigned long flags;
+                struct snd_usb_packet_info *uninitialized_var(packet);
+                struct snd_urb_ctx *ctx = NULL;
+                struct urb *urb;
+                int err, i;
+                spin_lock_irqsave(&ep->lock, flags);
+                if (ep->next_packet_read_pos != ep->next_packet_write_pos) {
+                        packet = ep->next_packet + ep->next_packet_read_pos;
+                        ep->next_packet_read_pos++;
+                        ep->next_packet_read_pos %= MAX_URBS;
+                        /* take URB out of FIFO */
+                        if (!list_empty(&ep->ready_playback_urbs))
+                                ctx = list_first_entry(&ep->ready_playback_urbs,
+                                               struct snd_urb_ctx, ready_list);
+                }
+                spin_unlock_irqrestore(&ep->lock, flags);
+                if (ctx == NULL)
+                        return;
+                list_del_init(&ctx->ready_list);
+                urb = ctx->urb;
+                /* copy over the length information */
+                for (i = 0; i < packet->packets; i++)
+                        ctx->packet_size[i] = packet->packet_size[i];
+                /* call the data handler to fill in playback data */
+                prepare_outbound_urb(ep, ctx);
+                err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
+                if (err < 0)
+                        snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n",
+                                   ctx->index, err, ctx->urb);
+                else
+                        set_bit(ctx->index, &ep->active_mask);
+        }
+}
 /*
- * release a urb data
+ * complete callback for urbs
 */
-static void release_urb_ctx(struct snd_urb_ctx *u)
+static void snd_complete_urb(struct urb *urb)
+{
+        struct snd_urb_ctx *ctx = urb->context;
+        struct snd_usb_endpoint *ep = ctx->ep;
+        int err;
+        if (unlikely(urb->status == -ENOENT ||          /* unlinked */
+                     urb->status == -ENODEV ||          /* device removed */
+                     urb->status == -ECONNRESET ||      /* unlinked */
+                     urb->status == -ESHUTDOWN ||       /* device disabled */
+                     ep->chip->shutdown))               /* device disconnected */
+                goto exit_clear;
+        if (usb_pipeout(ep->pipe)) {
+                retire_outbound_urb(ep, ctx);
+                /* can be stopped during retire callback */
+                if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
+                        goto exit_clear;
+                if (snd_usb_endpoint_implict_feedback_sink(ep)) {
+                        unsigned long flags;
+                        spin_lock_irqsave(&ep->lock, flags);
+                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
+                        spin_unlock_irqrestore(&ep->lock, flags);
+                        queue_pending_output_urbs(ep);
+                        goto exit_clear;
+                }
+                prepare_outbound_urb_sizes(ep, ctx);
+                prepare_outbound_urb(ep, ctx);
+        } else {
+                retire_inbound_urb(ep, ctx);
+                /* can be stopped during retire callback */
+                if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
+                        goto exit_clear;
+                prepare_inbound_urb(ep, ctx);
+        }
+        err = usb_submit_urb(urb, GFP_ATOMIC);
+        if (err == 0)
+                return;
+        snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err);
+        //snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
+exit_clear:
+        clear_bit(ctx->index, &ep->active_mask);
+}
+/**
+ * snd_usb_add_endpoint: Add an endpoint to an USB audio chip
+ *
+ * @chip: The chip
+ * @alts: The USB host interface
+ * @ep_num: The number of the endpoint to use
+ * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE
+ * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
+ *
+ * If the requested endpoint has not been added to the given chip before,
+ * a new instance is created. Otherwise, a pointer to the previoulsy
+ * created instance is returned. In case of any error, NULL is returned.
+ *
+ * New endpoints will be added to chip->ep_list and must be freed by
+ * calling snd_usb_endpoint_free().
+ */
+struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
+                                              struct usb_host_interface *alts,
+                                              int ep_num, int direction, int type)
 {
-        if (u->urb) {
+        struct list_head *p;
-                if (u->buffer_size)
+        struct snd_usb_endpoint *ep;
-                        usb_free_coherent(u->subs->dev, u->buffer_size,
+        int ret, is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK;
-                                        u->urb->transfer_buffer,
-                                        u->urb->transfer_dma);
+        mutex_lock(&chip->mutex);
-                usb_free_urb(u->urb);
-                u->urb = NULL;
+        list_for_each(p, &chip->ep_list) {
+                ep = list_entry(p, struct snd_usb_endpoint, list);
+                if (ep->ep_num == ep_num &&
+                    ep->iface == alts->desc.bInterfaceNumber &&
+                    ep->alt_idx == alts->desc.bAlternateSetting) {
+                        snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n",
+                                        ep_num, ep->iface, ep->alt_idx, ep);
+                        goto __exit_unlock;
+                }
+        }
+        snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n",
+                    is_playback ? "playback" : "capture",
+                    type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
+                    ep_num);
+        /* select the alt setting once so the endpoints become valid */
+        ret = usb_set_interface(chip->dev, alts->desc.bInterfaceNumber,
+                                alts->desc.bAlternateSetting);
+        if (ret < 0) {
+                snd_printk(KERN_ERR "%s(): usb_set_interface() failed, ret = %d\n",
+                                        __func__, ret);
+                ep = NULL;
+                goto __exit_unlock;
        }
+        ep = kzalloc(sizeof(*ep), GFP_KERNEL);
+        if (!ep)
+                goto __exit_unlock;
+        ep->chip = chip;
+        spin_lock_init(&ep->lock);
+        ep->type = type;
+        ep->ep_num = ep_num;
+        ep->iface = alts->desc.bInterfaceNumber;
+        ep->alt_idx = alts->desc.bAlternateSetting;
+        INIT_LIST_HEAD(&ep->ready_playback_urbs);
+        ep_num &= USB_ENDPOINT_NUMBER_MASK;
+        if (is_playback)
+                ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
+        else
+                ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
+        if (type == SND_USB_ENDPOINT_TYPE_SYNC) {
+                if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
+                    get_endpoint(alts, 1)->bRefresh >= 1 &&
+                    get_endpoint(alts, 1)->bRefresh <= 9)
+                        ep->syncinterval = get_endpoint(alts, 1)->bRefresh;
+                else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
+                        ep->syncinterval = 1;
+                else if (get_endpoint(alts, 1)->bInterval >= 1 &&
+                         get_endpoint(alts, 1)->bInterval <= 16)
+                        ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
+                else
+                        ep->syncinterval = 3;
+                ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
+        }
+        list_add_tail(&ep->list, &chip->ep_list);
+__exit_unlock:
+        mutex_unlock(&chip->mutex);
+        return ep;
 }
 /*
 *  wait until all urbs are processed.
 */
-static int wait_clear_urbs(struct snd_usb_substream *subs)
+static int wait_clear_urbs(struct snd_usb_endpoint *ep)
 {
        unsigned long end_time = jiffies + msecs_to_jiffies(1000);
        unsigned int i;
@@ -121,153 +497,148 @@ static int wait_clear_urbs(struct snd_usb_substream *subs)
        do {
                alive = 0;
-                for (i = 0; i < subs->nurbs; i++) {
+                for (i = 0; i < ep->nurbs; i++)
-                        if (test_bit(i, &subs->active_mask))
+                        if (test_bit(i, &ep->active_mask))
                                alive++;
-                }
-                if (subs->syncpipe) {
+                if (!alive)
-                        for (i = 0; i < SYNC_URBS; i++) {
-                                if (test_bit(i + 16, &subs->active_mask))
-                                        alive++;
-                        }
-                }
-                if (! alive)
                        break;
                schedule_timeout_uninterruptible(1);
        } while (time_before(jiffies, end_time));
        if (alive)
-                snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
+                snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n",
+                                        alive, ep->ep_num);
        return 0;
 }
 /*
- * release a substream
+ * unlink active urbs.
 */
-void snd_usb_release_substream_urbs(struct snd_usb_substream *subs, int force)
+static int deactivate_urbs(struct snd_usb_endpoint *ep, int force, int can_sleep)
 {
-        int i;
+        unsigned int i;
+        int async;
-        /* stop urbs (to be sure) */
+        if (!force && ep->chip->shutdown) /* to be sure... */
-        deactivate_urbs(subs, force, 1);
+                return -EBADFD;
-        wait_clear_urbs(subs);
-        for (i = 0; i < MAX_URBS; i++)
-                release_urb_ctx(&subs->dataurb[i]);
-        for (i = 0; i < SYNC_URBS; i++)
-                release_urb_ctx(&subs->syncurb[i]);
-        usb_free_coherent(subs->dev, SYNC_URBS * 4,
-                        subs->syncbuf, subs->sync_dma);
-        subs->syncbuf = NULL;
-        subs->nurbs = 0;
-}
-/*
+        async = !can_sleep && ep->chip->async_unlink;
- * complete callback from data urb
- */
+        clear_bit(EP_FLAG_RUNNING, &ep->flags);
-static void snd_complete_urb(struct urb *urb)
-{
+        INIT_LIST_HEAD(&ep->ready_playback_urbs);
-        struct snd_urb_ctx *ctx = urb->context;
+        ep->next_packet_read_pos = 0;
-        struct snd_usb_substream *subs = ctx->subs;
+        ep->next_packet_write_pos = 0;
-        struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
-        int err = 0;
+        if (!async && in_interrupt())
+                return 0;
-        if ((subs->running && subs->ops.retire(subs, substream->runtime, urb)) ||
-            !subs->running || /* can be stopped during retire callback */
+        for (i = 0; i < ep->nurbs; i++) {
-            (err = subs->ops.prepare(subs, substream->runtime, urb)) < 0 ||
+                if (test_bit(i, &ep->active_mask)) {
-            (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
+                        if (!test_and_set_bit(i, &ep->unlink_mask)) {
-                clear_bit(ctx->index, &subs->active_mask);
+                                struct urb *u = ep->urb[i].urb;
-                if (err < 0) {
+                                if (async)
-                        snd_printd(KERN_ERR "cannot submit urb (err = %d)\n", err);
+                                        usb_unlink_urb(u);
-                        snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
+                                else
+                                        usb_kill_urb(u);
+                        }
                }
        }
-}
+        return 0;
+}
 /*
- * complete callback from sync urb
+ * release an endpoint's urbs
 */
-static void snd_complete_sync_urb(struct urb *urb)
+static void release_urbs(struct snd_usb_endpoint *ep, int force)
 {
-        struct snd_urb_ctx *ctx = urb->context;
+        int i;
-        struct snd_usb_substream *subs = ctx->subs;
-        struct snd_pcm_substream *substream = ctx->subs->pcm_substream;
-        int err = 0;
-        if ((subs->running && subs->ops.retire_sync(subs, substream->runtime, urb)) ||
-            !subs->running || /* can be stopped during retire callback */
-            (err = subs->ops.prepare_sync(subs, substream->runtime, urb)) < 0 ||
-            (err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
-                clear_bit(ctx->index + 16, &subs->active_mask);
-                if (err < 0) {
-                        snd_printd(KERN_ERR "cannot submit sync urb (err = %d)\n", err);
-                        snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
-                }
-        }
-}
+        /* route incoming urbs to nirvana */
+        ep->retire_data_urb = NULL;
+        ep->prepare_data_urb = NULL;
+        /* stop urbs */
+        deactivate_urbs(ep, force, 1);
+        wait_clear_urbs(ep);
+        for (i = 0; i < ep->nurbs; i++)
+                release_urb_ctx(&ep->urb[i]);
+        if (ep->syncbuf)
+                usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
+                                  ep->syncbuf, ep->sync_dma);
+        ep->syncbuf = NULL;
+        ep->nurbs = 0;
+}
 /*
- * initialize a substream for plaback/capture
+ * configure a data endpoint
 */
-int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
+static int data_ep_set_params(struct snd_usb_endpoint *ep,
-                                unsigned int period_bytes,
+                              struct snd_pcm_hw_params *hw_params,
-                                unsigned int rate,
+                              struct audioformat *fmt,
-                                unsigned int frame_bits)
+                              struct snd_usb_endpoint *sync_ep)
 {
-        unsigned int maxsize, i;
+        unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms;
-        int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
+        int period_bytes = params_period_bytes(hw_params);
-        unsigned int urb_packs, total_packs, packs_per_ms;
+        int format = params_format(hw_params);
-        struct snd_usb_audio *chip = subs->stream->chip;
+        int is_playback = usb_pipeout(ep->pipe);
+        int frame_bits = snd_pcm_format_physical_width(params_format(hw_params)) *
+                                                        params_channels(hw_params);
+        ep->datainterval = fmt->datainterval;
+        ep->stride = frame_bits >> 3;
+        ep->silence_value = format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0;
-        /* calculate the frequency in 16.16 format */
-        if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
-                subs->freqn = get_usb_full_speed_rate(rate);
-        else
-                subs->freqn = get_usb_high_speed_rate(rate);
-        subs->freqm = subs->freqn;
-        subs->freqshift = INT_MIN;
        /* calculate max. frequency */
-        if (subs->maxpacksize) {
+        if (ep->maxpacksize) {
                /* whatever fits into a max. size packet */
-                maxsize = subs->maxpacksize;
+                maxsize = ep->maxpacksize;
-                subs->freqmax = (maxsize / (frame_bits >> 3))
+                ep->freqmax = (maxsize / (frame_bits >> 3))
-                                << (16 - subs->datainterval);
+                                << (16 - ep->datainterval);
        } else {
                /* no max. packet size: just take 25% higher than nominal */
-                subs->freqmax = subs->freqn + (subs->freqn >> 2);
+                ep->freqmax = ep->freqn + (ep->freqn >> 2);
-                maxsize = ((subs->freqmax + 0xffff) * (frame_bits >> 3))
+                maxsize = ((ep->freqmax + 0xffff) * (frame_bits >> 3))
-                                >> (16 - subs->datainterval);
+                                >> (16 - ep->datainterval);
        }
-        subs->phase = 0;
-        if (subs->fill_max)
+        if (ep->fill_max)
-                subs->curpacksize = subs->maxpacksize;
+                ep->curpacksize = ep->maxpacksize;
        else
-                subs->curpacksize = maxsize;
+                ep->curpacksize = maxsize;
-        if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL)
+        if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL)
-                packs_per_ms = 8 >> subs->datainterval;
+                packs_per_ms = 8 >> ep->datainterval;
        else
                packs_per_ms = 1;
-        if (is_playback) {
+        if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
-                urb_packs = max(chip->nrpacks, 1);
+                urb_packs = max(ep->chip->nrpacks, 1);
-                urb_packs = min(urb_packs, (unsigned int)MAX_PACKS);
+                urb_packs = min(urb_packs, (unsigned int) MAX_PACKS);
-        } else
+        } else {
                urb_packs = 1;
+        }
        urb_packs *= packs_per_ms;
-        if (subs->syncpipe)
-                urb_packs = min(urb_packs, 1U << subs->syncinterval);
+        if (sync_ep && !snd_usb_endpoint_implict_feedback_sink(ep))
+                urb_packs = min(urb_packs, 1U << sync_ep->syncinterval);
        /* decide how many packets to be used */
-        if (is_playback) {
+        if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
                unsigned int minsize, maxpacks;
                /* determine how small a packet can be */
-                minsize = (subs->freqn >> (16 - subs->datainterval))
+                minsize = (ep->freqn >> (16 - ep->datainterval))
                          * (frame_bits >> 3);
                /* with sync from device, assume it can be 12% lower */
-                if (subs->syncpipe)
+                if (sync_ep)
                        minsize -= minsize >> 3;
                minsize = max(minsize, 1u);
                total_packs = (period_bytes + minsize - 1) / minsize;
@@ -284,284 +655,472 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
                        urb_packs >>= 1;
                total_packs = MAX_URBS * urb_packs;
        }
-        subs->nurbs = (total_packs + urb_packs - 1) / urb_packs;
-        if (subs->nurbs > MAX_URBS) {
+        ep->nurbs = (total_packs + urb_packs - 1) / urb_packs;
+        if (ep->nurbs > MAX_URBS) {
                /* too much... */
-                subs->nurbs = MAX_URBS;
+                ep->nurbs = MAX_URBS;
                total_packs = MAX_URBS * urb_packs;
-        } else if (subs->nurbs < 2) {
+        } else if (ep->nurbs < 2) {
                /* too little - we need at least two packets
                 * to ensure contiguous playback/capture
                 */
-                subs->nurbs = 2;
+                ep->nurbs = 2;
        }
        /* allocate and initialize data urbs */
-        for (i = 0; i < subs->nurbs; i++) {
+        for (i = 0; i < ep->nurbs; i++) {
-                struct snd_urb_ctx *u = &subs->dataurb[i];
+                struct snd_urb_ctx *u = &ep->urb[i];
                u->index = i;
-                u->subs = subs;
+                u->ep = ep;
-                u->packets = (i + 1) * total_packs / subs->nurbs
+                u->packets = (i + 1) * total_packs / ep->nurbs
-                        - i * total_packs / subs->nurbs;
+                        - i * total_packs / ep->nurbs;
                u->buffer_size = maxsize * u->packets;
-                if (subs->fmt_type == UAC_FORMAT_TYPE_II)
+                if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
                        u->packets++; /* for transfer delimiter */
                u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
                if (!u->urb)
                        goto out_of_memory;
                u->urb->transfer_buffer =
-                        usb_alloc_coherent(subs->dev, u->buffer_size,
+                        usb_alloc_coherent(ep->chip->dev, u->buffer_size,
                                           GFP_KERNEL, &u->urb->transfer_dma);
                if (!u->urb->transfer_buffer)
                        goto out_of_memory;
-                u->urb->pipe = subs->datapipe;
+                u->urb->pipe = ep->pipe;
                u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
-                u->urb->interval = 1 << subs->datainterval;
+                u->urb->interval = 1 << ep->datainterval;
                u->urb->context = u;
                u->urb->complete = snd_complete_urb;
+                INIT_LIST_HEAD(&u->ready_list);
        }
-        if (subs->syncpipe) {
-                /* allocate and initialize sync urbs */
-                subs->syncbuf = usb_alloc_coherent(subs->dev, SYNC_URBS * 4,
-                                                 GFP_KERNEL, &subs->sync_dma);
-                if (!subs->syncbuf)
-                        goto out_of_memory;
-                for (i = 0; i < SYNC_URBS; i++) {
-                        struct snd_urb_ctx *u = &subs->syncurb[i];
-                        u->index = i;
-                        u->subs = subs;
-                        u->packets = 1;
-                        u->urb = usb_alloc_urb(1, GFP_KERNEL);
-                        if (!u->urb)
-                                goto out_of_memory;
-                        u->urb->transfer_buffer = subs->syncbuf + i * 4;
-                        u->urb->transfer_dma = subs->sync_dma + i * 4;
-                        u->urb->transfer_buffer_length = 4;
-                        u->urb->pipe = subs->syncpipe;
-                        u->urb->transfer_flags = URB_ISO_ASAP |
-                                                 URB_NO_TRANSFER_DMA_MAP;
-                        u->urb->number_of_packets = 1;
-                        u->urb->interval = 1 << subs->syncinterval;
-                        u->urb->context = u;
-                        u->urb->complete = snd_complete_sync_urb;
-                }
-        }
        return 0;
 out_of_memory:
-        snd_usb_release_substream_urbs(subs, 0);
+        release_urbs(ep, 0);
        return -ENOMEM;
 }
 /*
- * prepare urb for full speed capture sync pipe
+ * configure a sync endpoint
- *
- * fill the length and offset of each urb descriptor.
- * the fixed 10.14 frequency is passed through the pipe.
 */
-static int prepare_capture_sync_urb(struct snd_usb_substream *subs,
+static int sync_ep_set_params(struct snd_usb_endpoint *ep,
-                                    struct snd_pcm_runtime *runtime,
+                              struct snd_pcm_hw_params *hw_params,
-                                    struct urb *urb)
+                              struct audioformat *fmt)
 {
-        unsigned char *cp = urb->transfer_buffer;
+        int i;
-        struct snd_urb_ctx *ctx = urb->context;
+        ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
+                                         GFP_KERNEL, &ep->sync_dma);
+        if (!ep->syncbuf)
+                return -ENOMEM;
+        for (i = 0; i < SYNC_URBS; i++) {
+                struct snd_urb_ctx *u = &ep->urb[i];
+                u->index = i;
+                u->ep = ep;
+                u->packets = 1;
+                u->urb = usb_alloc_urb(1, GFP_KERNEL);
+                if (!u->urb)
+                        goto out_of_memory;
+                u->urb->transfer_buffer = ep->syncbuf + i * 4;
+                u->urb->transfer_dma = ep->sync_dma + i * 4;
+                u->urb->transfer_buffer_length = 4;
+                u->urb->pipe = ep->pipe;
+                u->urb->transfer_flags = URB_ISO_ASAP |
+                                         URB_NO_TRANSFER_DMA_MAP;
+                u->urb->number_of_packets = 1;
+                u->urb->interval = 1 << ep->syncinterval;
+                u->urb->context = u;
+                u->urb->complete = snd_complete_urb;
+        }
+        ep->nurbs = SYNC_URBS;
-        urb->dev = ctx->subs->dev; /* we need to set this at each time */
-        urb->iso_frame_desc[0].length = 3;
-        urb->iso_frame_desc[0].offset = 0;
-        cp[0] = subs->freqn >> 2;
-        cp[1] = subs->freqn >> 10;
-        cp[2] = subs->freqn >> 18;
        return 0;
+out_of_memory:
+        release_urbs(ep, 0);
+        return -ENOMEM;
 }
-/*
+/**
- * prepare urb for high speed capture sync pipe
+ * snd_usb_endpoint_set_params: configure an snd_usb_endpoint
+ *
+ * @ep: the snd_usb_endpoint to configure
+ * @hw_params: the hardware parameters
+ * @fmt: the USB audio format information
+ * @sync_ep: the sync endpoint to use, if any
 *
- * fill the length and offset of each urb descriptor.
+ * Determine the number of URBs to be used on this endpoint.
- * the fixed 12.13 frequency is passed as 16.16 through the pipe.
+ * An endpoint must be configured before it can be started.
+ * An endpoint that is already running can not be reconfigured.
 */
-static int prepare_capture_sync_urb_hs(struct snd_usb_substream *subs,
+int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
-                                       struct snd_pcm_runtime *runtime,
+                                struct snd_pcm_hw_params *hw_params,
-                                       struct urb *urb)
+                                struct audioformat *fmt,
+                                struct snd_usb_endpoint *sync_ep)
 {
-        unsigned char *cp = urb->transfer_buffer;
+        int err;
-        struct snd_urb_ctx *ctx = urb->context;
-        urb->dev = ctx->subs->dev; /* we need to set this at each time */
+        if (ep->use_count != 0) {
-        urb->iso_frame_desc[0].length = 4;
+                snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",
-        urb->iso_frame_desc[0].offset = 0;
+                           ep->ep_num);
-        cp[0] = subs->freqn;
+                return -EBUSY;
-        cp[1] = subs->freqn >> 8;
+        }
-        cp[2] = subs->freqn >> 16;
-        cp[3] = subs->freqn >> 24;
+        /* release old buffers, if any */
-        return 0;
+        release_urbs(ep, 0);
+        ep->datainterval = fmt->datainterval;
+        ep->maxpacksize = fmt->maxpacksize;
+        ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
+        if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL)
+                ep->freqn = get_usb_full_speed_rate(params_rate(hw_params));
+        else
+                ep->freqn = get_usb_high_speed_rate(params_rate(hw_params));
+        /* calculate the frequency in 16.16 format */
+        ep->freqm = ep->freqn;
+        ep->freqshift = INT_MIN;
+        ep->phase = 0;
+        switch (ep->type) {
+        case  SND_USB_ENDPOINT_TYPE_DATA:
+                err = data_ep_set_params(ep, hw_params, fmt, sync_ep);
+                break;
+        case  SND_USB_ENDPOINT_TYPE_SYNC:
+                err = sync_ep_set_params(ep, hw_params, fmt);
+                break;
+        default:
+                err = -EINVAL;
+        }
+        snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
+                   ep->ep_num, ep->type, ep->nurbs, err);
+        return err;
 }
-/*
+/**
- * process after capture sync complete
+ * snd_usb_endpoint_start: start an snd_usb_endpoint
- * - nothing to do
+ *
+ * @ep: the endpoint to start
+ *
+ * A call to this function will increment the use count of the endpoint.
+ * In case it is not already running, the URBs for this endpoint will be
+ * submitted. Otherwise, this function does nothing.
+ *
+ * Must be balanced to calls of snd_usb_endpoint_stop().
+ *
+ * Returns an error if the URB submission failed, 0 in all other cases.
 */
-static int retire_capture_sync_urb(struct snd_usb_substream *subs,
+int snd_usb_endpoint_start(struct snd_usb_endpoint *ep)
-                                   struct snd_pcm_runtime *runtime,
-                                   struct urb *urb)
 {
+        int err;
+        unsigned int i;
+        if (ep->chip->shutdown)
+                return -EBADFD;
+        /* already running? */
+        if (++ep->use_count != 1)
+                return 0;
+        if (snd_BUG_ON(!test_bit(EP_FLAG_ACTIVATED, &ep->flags)))
+                return -EINVAL;
+        /* just to be sure */
+        deactivate_urbs(ep, 0, 1);
+        wait_clear_urbs(ep);
+        ep->active_mask = 0;
+        ep->unlink_mask = 0;
+        ep->phase = 0;
+        /*
+         * If this endpoint has a data endpoint as implicit feedback source,
+         * don't start the urbs here. Instead, mark them all as available,
+         * wait for the record urbs to return and queue the playback urbs
+         * from that context.
+         */
+        set_bit(EP_FLAG_RUNNING, &ep->flags);
+        if (snd_usb_endpoint_implict_feedback_sink(ep)) {
+                for (i = 0; i < ep->nurbs; i++) {
+                        struct snd_urb_ctx *ctx = ep->urb + i;
+                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
+                }
+                return 0;
+        }
+        for (i = 0; i < ep->nurbs; i++) {
+                struct urb *urb = ep->urb[i].urb;
+                if (snd_BUG_ON(!urb))
+                        goto __error;
+                if (usb_pipeout(ep->pipe)) {
+                        prepare_outbound_urb_sizes(ep, urb->context);
+                        prepare_outbound_urb(ep, urb->context);
+                } else {
+                        prepare_inbound_urb(ep, urb->context);
+                }
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err < 0) {
+                        snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",
+                                   i, err, usb_error_string(err));
+                        goto __error;
+                }
+                set_bit(i, &ep->active_mask);
+        }
        return 0;
+__error:
+        clear_bit(EP_FLAG_RUNNING, &ep->flags);
+        ep->use_count--;
+        deactivate_urbs(ep, 0, 0);
+        return -EPIPE;
 }
-/*
+/**
- * prepare urb for capture data pipe
+ * snd_usb_endpoint_stop: stop an snd_usb_endpoint
+ *
+ * @ep: the endpoint to stop (may be NULL)
 *
- * fill the offset and length of each descriptor.
+ * A call to this function will decrement the use count of the endpoint.
+ * In case the last user has requested the endpoint stop, the URBs will
+ * actually be deactivated.
 *
- * we use a temporary buffer to write the captured data.
+ * Must be balanced to calls of snd_usb_endpoint_start().
- * since the length of written data is determined by host, we cannot
- * write onto the pcm buffer directly...  the data is thus copied
- * later at complete callback to the global buffer.
 */
-static int prepare_capture_urb(struct snd_usb_substream *subs,
+void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep,
-                               struct snd_pcm_runtime *runtime,
+                           int force, int can_sleep, int wait)
-                               struct urb *urb)
 {
-        int i, offs;
+        if (!ep)
-        struct snd_urb_ctx *ctx = urb->context;
+                return;
-        offs = 0;
+        if (snd_BUG_ON(ep->use_count == 0))
-        urb->dev = ctx->subs->dev; /* we need to set this at each time */
+                return;
-        for (i = 0; i < ctx->packets; i++) {
-                urb->iso_frame_desc[i].offset = offs;
+        if (snd_BUG_ON(!test_bit(EP_FLAG_ACTIVATED, &ep->flags)))
-                urb->iso_frame_desc[i].length = subs->curpacksize;
+                return;
-                offs += subs->curpacksize;
+        if (--ep->use_count == 0) {
+                deactivate_urbs(ep, force, can_sleep);
+                ep->data_subs = NULL;
+                ep->sync_slave = NULL;
+                ep->retire_data_urb = NULL;
+                ep->prepare_data_urb = NULL;
+                if (wait)
+                        wait_clear_urbs(ep);
        }
-        urb->transfer_buffer_length = offs;
-        urb->number_of_packets = ctx->packets;
-        return 0;
 }
-/*
+/**
- * process after capture complete
+ * snd_usb_endpoint_activate: activate an snd_usb_endpoint
+ *
+ * @ep: the endpoint to activate
+ *
+ * If the endpoint is not currently in use, this functions will select the
+ * correct alternate interface setting for the interface of this endpoint.
 *
- * copy the data from each desctiptor to the pcm buffer, and
+ * In case of any active users, this functions does nothing.
- * update the current position.
+ *
+ * Returns an error if usb_set_interface() failed, 0 in all other
+ * cases.
 */
-static int retire_capture_urb(struct snd_usb_substream *subs,
+int snd_usb_endpoint_activate(struct snd_usb_endpoint *ep)
-                              struct snd_pcm_runtime *runtime,
-                              struct urb *urb)
 {
-        unsigned long flags;
+        if (ep->use_count != 0)
-        unsigned char *cp;
+                return 0;
-        int i;
-        unsigned int stride, frames, bytes, oldptr;
-        int period_elapsed = 0;
-        stride = runtime->frame_bits >> 3;
+        if (!ep->chip->shutdown &&
+            !test_and_set_bit(EP_FLAG_ACTIVATED, &ep->flags)) {
+                int ret;
-        for (i = 0; i < urb->number_of_packets; i++) {
+                ret = usb_set_interface(ep->chip->dev, ep->iface, ep->alt_idx);
-                cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+                if (ret < 0) {
-                if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
+                        snd_printk(KERN_ERR "%s() usb_set_interface() failed, ret = %d\n",
-                        snd_printdd("frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
+                                                __func__, ret);
-                        // continue;
+                        clear_bit(EP_FLAG_ACTIVATED, &ep->flags);
-                }
+                        return ret;
-                bytes = urb->iso_frame_desc[i].actual_length;
-                frames = bytes / stride;
-                if (!subs->txfr_quirk)
-                        bytes = frames * stride;
-                if (bytes % (runtime->sample_bits >> 3) != 0) {
-#ifdef CONFIG_SND_DEBUG_VERBOSE
-                        int oldbytes = bytes;
-#endif
-                        bytes = frames * stride;
-                        snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
-                                                        oldbytes, bytes);
-                }
-                /* update the current pointer */
-                spin_lock_irqsave(&subs->lock, flags);
-                oldptr = subs->hwptr_done;
-                subs->hwptr_done += bytes;
-                if (subs->hwptr_done >= runtime->buffer_size * stride)
-                        subs->hwptr_done -= runtime->buffer_size * stride;
-                frames = (bytes + (oldptr % stride)) / stride;
-                subs->transfer_done += frames;
-                if (subs->transfer_done >= runtime->period_size) {
-                        subs->transfer_done -= runtime->period_size;
-                        period_elapsed = 1;
-                }
-                spin_unlock_irqrestore(&subs->lock, flags);
-                /* copy a data chunk */
-                if (oldptr + bytes > runtime->buffer_size * stride) {
-                        unsigned int bytes1 =
-                                        runtime->buffer_size * stride - oldptr;
-                        memcpy(runtime->dma_area + oldptr, cp, bytes1);
-                        memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
-                } else {
-                        memcpy(runtime->dma_area + oldptr, cp, bytes);
                }
+                return 0;
        }
-        if (period_elapsed)
-                snd_pcm_period_elapsed(subs->pcm_substream);
+        return -EBUSY;
-        return 0;
 }
-/*
+/**
- * Process after capture complete when paused.  Nothing to do.
+ * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint
+ *
+ * @ep: the endpoint to deactivate
+ *
+ * If the endpoint is not currently in use, this functions will select the
+ * alternate interface setting 0 for the interface of this endpoint.
+ *
+ * In case of any active users, this functions does nothing.
+ *
+ * Returns an error if usb_set_interface() failed, 0 in all other
+ * cases.
 */
-static int retire_paused_capture_urb(struct snd_usb_substream *subs,
+int snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
-                                     struct snd_pcm_runtime *runtime,
-                                     struct urb *urb)
 {
-        return 0;
+        if (!ep)
-}
+                return -EINVAL;
+        if (ep->use_count != 0)
+                return 0;
-/*
+        if (!ep->chip->shutdown &&
- * prepare urb for playback sync pipe
+            test_and_clear_bit(EP_FLAG_ACTIVATED, &ep->flags)) {
+                int ret;
+                ret = usb_set_interface(ep->chip->dev, ep->iface, 0);
+                if (ret < 0) {
+                        snd_printk(KERN_ERR "%s(): usb_set_interface() failed, ret = %d\n",
+                                                __func__, ret);
+                        return ret;
+                }
+                return 0;
+        }
+        return -EBUSY;
+}
+/**
+ * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
+ *
+ * @ep: the list header of the endpoint to free
 *
- * set up the offset and length to receive the current frequency.
+ * This function does not care for the endpoint's use count but will tear
+ * down all the streaming URBs immediately and free all resources.
 */
-static int prepare_playback_sync_urb(struct snd_usb_substream *subs,
+void snd_usb_endpoint_free(struct list_head *head)
-                                     struct snd_pcm_runtime *runtime,
-                                     struct urb *urb)
 {
-        struct snd_urb_ctx *ctx = urb->context;
+        struct snd_usb_endpoint *ep;
-        urb->dev = ctx->subs->dev; /* we need to set this at each time */
+        ep = list_entry(head, struct snd_usb_endpoint, list);
-        urb->iso_frame_desc[0].length = min(4u, ctx->subs->syncmaxsize);
+        release_urbs(ep, 1);
-        urb->iso_frame_desc[0].offset = 0;
+        kfree(ep);
-        return 0;
 }
-/*
+/**
- * process after playback sync complete
+ * snd_usb_handle_sync_urb: parse an USB sync packet
- *
+ *
- * Full speed devices report feedback values in 10.14 format as samples per
+ * @ep: the endpoint to handle the packet
- * frame, high speed devices in 16.16 format as samples per microframe.
+ * @sender: the sending endpoint
- * Because the Audio Class 1 spec was written before USB 2.0, many high speed
+ * @urb: the received packet
- * devices use a wrong interpretation, some others use an entirely different
+ *
- * format.  Therefore, we cannot predict what format any particular device uses
+ * This function is called from the context of an endpoint that received
- * and must detect it automatically.
+ * the packet and is used to let another endpoint object handle the payload.
 */
-static int retire_playback_sync_urb(struct snd_usb_substream *subs,
+void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
-                                    struct snd_pcm_runtime *runtime,
+                             struct snd_usb_endpoint *sender,
-                                    struct urb *urb)
+                             const struct urb *urb)
 {
-        unsigned int f;
        int shift;
+        unsigned int f;
        unsigned long flags;
+        snd_BUG_ON(ep == sender);
+        /*
+         * In case the endpoint is operating in implicit feedback mode, prepare
+         * a new outbound URB that has the same layout as the received packet
+         * and add it to the list of pending urbs. queue_pending_output_urbs()
+         * will take care of them later.
+         */
+        if (snd_usb_endpoint_implict_feedback_sink(ep) &&
+            ep->use_count != 0) {
+                /* implicit feedback case */
+                int i, bytes = 0;
+                struct snd_urb_ctx *in_ctx;
+                struct snd_usb_packet_info *out_packet;
+                in_ctx = urb->context;
+                /* Count overall packet size */
+                for (i = 0; i < in_ctx->packets; i++)
+                        if (urb->iso_frame_desc[i].status == 0)
+                                bytes += urb->iso_frame_desc[i].actual_length;
+                /*
+                 * skip empty packets. At least M-Audio's Fast Track Ultra stops
+                 * streaming once it received a 0-byte OUT URB
+                 */
+                if (bytes == 0)
+                        return;
+                spin_lock_irqsave(&ep->lock, flags);
+                out_packet = ep->next_packet + ep->next_packet_write_pos;
+                /*
+                 * Iterate through the inbound packet and prepare the lengths
+                 * for the output packet. The OUT packet we are about to send
+                 * will have the same amount of payload bytes than the IN
+                 * packet we just received.
+                 */
+                out_packet->packets = in_ctx->packets;
+                for (i = 0; i < in_ctx->packets; i++) {
+                        if (urb->iso_frame_desc[i].status == 0)
+                                out_packet->packet_size[i] =
+                                        urb->iso_frame_desc[i].actual_length / ep->stride;
+                        else
+                                out_packet->packet_size[i] = 0;
+                }
+                ep->next_packet_write_pos++;
+                ep->next_packet_write_pos %= MAX_URBS;
+                spin_unlock_irqrestore(&ep->lock, flags);
+                queue_pending_output_urbs(ep);
+                return;
+        }
+        /*
+         * process after playback sync complete
+         *
+         * Full speed devices report feedback values in 10.14 format as samples
+         * per frame, high speed devices in 16.16 format as samples per
+         * microframe.
+         *
+         * Because the Audio Class 1 spec was written before USB 2.0, many high
+         * speed devices use a wrong interpretation, some others use an
+         * entirely different format.
+         *
+         * Therefore, we cannot predict what format any particular device uses
+         * and must detect it automatically.
+         */
        if (urb->iso_frame_desc[0].status != 0 ||
            urb->iso_frame_desc[0].actual_length < 3)
-                return 0;
+                return;
        f = le32_to_cpup(urb->transfer_buffer);
        if (urb->iso_frame_desc[0].actual_length == 3)
                f &= 0x00ffffff;
        else
                f &= 0x0fffffff;
        if (f == 0)
-                return 0;
+                return;
-        if (unlikely(subs->freqshift == INT_MIN)) {
+        if (unlikely(ep->freqshift == INT_MIN)) {
                /*
                 * The first time we see a feedback value, determine its format
                 * by shifting it left or right until it matches the nominal
@@ -569,398 +1128,34 @@ static int retire_playback_sync_urb(struct snd_usb_substream *subs,
                 * differ from the nominal value more than +50% or -25%.
                 */
                shift = 0;
-                while (f < subs->freqn - subs->freqn / 4) {
+                while (f < ep->freqn - ep->freqn / 4) {
                        f <<= 1;
                        shift++;
                }
-                while (f > subs->freqn + subs->freqn / 2) {
+                while (f > ep->freqn + ep->freqn / 2) {
                        f >>= 1;
                        shift--;
                }
-                subs->freqshift = shift;
+                ep->freqshift = shift;
-        }
+        } else if (ep->freqshift >= 0)
-        else if (subs->freqshift >= 0)
+                f <<= ep->freqshift;
-                f <<= subs->freqshift;
        else
-                f >>= -subs->freqshift;
+                f >>= -ep->freqshift;
-        if (likely(f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax)) {
+        if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
                /*
                 * If the frequency looks valid, set it.
                 * This value is referred to in prepare_playback_urb().
                 */
-                spin_lock_irqsave(&subs->lock, flags);
+                spin_lock_irqsave(&ep->lock, flags);
-                subs->freqm = f;
+                ep->freqm = f;
-                spin_unlock_irqrestore(&subs->lock, flags);
+                spin_unlock_irqrestore(&ep->lock, flags);
        } else {
                /*
                 * Out of range; maybe the shift value is wrong.
                 * Reset it so that we autodetect again the next time.
                 */
-                subs->freqshift = INT_MIN;
+                ep->freqshift = INT_MIN;
-        }
-        return 0;
-}
-/* determine the number of frames in the next packet */
-static int snd_usb_audio_next_packet_size(struct snd_usb_substream *subs)
-{
-        if (subs->fill_max)
-                return subs->maxframesize;
-        else {
-                subs->phase = (subs->phase & 0xffff)
-                        + (subs->freqm << subs->datainterval);
-                return min(subs->phase >> 16, subs->maxframesize);
        }
 }
-/*
- * Prepare urb for streaming before playback starts or when paused.
- *
- * We don't have any data, so we send silence.
- */
-static int prepare_nodata_playback_urb(struct snd_usb_substream *subs,
-                                       struct snd_pcm_runtime *runtime,
-                                       struct urb *urb)
-{
-        unsigned int i, offs, counts;
-        struct snd_urb_ctx *ctx = urb->context;
-        int stride = runtime->frame_bits >> 3;
-        offs = 0;
-        urb->dev = ctx->subs->dev;
-        for (i = 0; i < ctx->packets; ++i) {
-                counts = snd_usb_audio_next_packet_size(subs);
-                urb->iso_frame_desc[i].offset = offs * stride;
-                urb->iso_frame_desc[i].length = counts * stride;
-                offs += counts;
-        }
-        urb->number_of_packets = ctx->packets;
-        urb->transfer_buffer_length = offs * stride;
-        memset(urb->transfer_buffer,
-               runtime->format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0,
-               offs * stride);
-        return 0;
-}
-/*
- * prepare urb for playback data pipe
- *
- * Since a URB can handle only a single linear buffer, we must use double
- * buffering when the data to be transferred overflows the buffer boundary.
- * To avoid inconsistencies when updating hwptr_done, we use double buffering
- * for all URBs.
- */
-static int prepare_playback_urb(struct snd_usb_substream *subs,
-                                struct snd_pcm_runtime *runtime,
-                                struct urb *urb)
-{
-        int i, stride;
-        unsigned int counts, frames, bytes;
-        unsigned long flags;
-        int period_elapsed = 0;
-        struct snd_urb_ctx *ctx = urb->context;
-        stride = runtime->frame_bits >> 3;
-        frames = 0;
-        urb->dev = ctx->subs->dev; /* we need to set this at each time */
-        urb->number_of_packets = 0;
-        spin_lock_irqsave(&subs->lock, flags);
-        for (i = 0; i < ctx->packets; i++) {
-                counts = snd_usb_audio_next_packet_size(subs);
-                /* set up descriptor */
-                urb->iso_frame_desc[i].offset = frames * stride;
-                urb->iso_frame_desc[i].length = counts * stride;
-                frames += counts;
-                urb->number_of_packets++;
-                subs->transfer_done += counts;
-                if (subs->transfer_done >= runtime->period_size) {
-                        subs->transfer_done -= runtime->period_size;
-                        period_elapsed = 1;
-                        if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
-                                if (subs->transfer_done > 0) {
-                                        /* FIXME: fill-max mode is not
-                                         * supported yet */
-                                        frames -= subs->transfer_done;
-                                        counts -= subs->transfer_done;
-                                        urb->iso_frame_desc[i].length =
-                                                counts * stride;
-                                        subs->transfer_done = 0;
-                                }
-                                i++;
-                                if (i < ctx->packets) {
-                                        /* add a transfer delimiter */
-                                        urb->iso_frame_desc[i].offset =
-                                                frames * stride;
-                                        urb->iso_frame_desc[i].length = 0;
-                                        urb->number_of_packets++;
-                                }
-                                break;
-                        }
-                }
-                if (period_elapsed) /* finish at the period boundary */
-                        break;
-        }
-        bytes = frames * stride;
-        if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
-                /* err, the transferred area goes over buffer boundary. */
-                unsigned int bytes1 =
-                        runtime->buffer_size * stride - subs->hwptr_done;
-                memcpy(urb->transfer_buffer,
-                       runtime->dma_area + subs->hwptr_done, bytes1);
-                memcpy(urb->transfer_buffer + bytes1,
-                       runtime->dma_area, bytes - bytes1);
-        } else {
-                memcpy(urb->transfer_buffer,
-                       runtime->dma_area + subs->hwptr_done, bytes);
-        }
-        subs->hwptr_done += bytes;
-        if (subs->hwptr_done >= runtime->buffer_size * stride)
-                subs->hwptr_done -= runtime->buffer_size * stride;
-        /* update delay with exact number of samples queued */
-        runtime->delay = subs->last_delay;
-        runtime->delay += frames;
-        subs->last_delay = runtime->delay;
-        /* realign last_frame_number */
-        subs->last_frame_number = usb_get_current_frame_number(subs->dev);
-        subs->last_frame_number &= 0xFF; /* keep 8 LSBs */
-        spin_unlock_irqrestore(&subs->lock, flags);
-        urb->transfer_buffer_length = bytes;
-        if (period_elapsed)
-                snd_pcm_period_elapsed(subs->pcm_substream);
-        return 0;
-}
-/*
- * process after playback data complete
- * - decrease the delay count again
- */
-static int retire_playback_urb(struct snd_usb_substream *subs,
-                               struct snd_pcm_runtime *runtime,
-                               struct urb *urb)
-{
-        unsigned long flags;
-        int stride = runtime->frame_bits >> 3;
-        int processed = urb->transfer_buffer_length / stride;
-        int est_delay;
-        spin_lock_irqsave(&subs->lock, flags);
-        est_delay = snd_usb_pcm_delay(subs, runtime->rate);
-        /* update delay with exact number of samples played */
-        if (processed > subs->last_delay)
-                subs->last_delay = 0;
-        else
-                subs->last_delay -= processed;
-        runtime->delay = subs->last_delay;
-        /*
-         * Report when delay estimate is off by more than 2ms.
-         * The error should be lower than 2ms since the estimate relies
-         * on two reads of a counter updated every ms.
-         */
-        if (abs(est_delay - subs->last_delay) * 1000 > runtime->rate * 2)
-                snd_printk(KERN_DEBUG "delay: estimated %d, actual %d\n",
-                        est_delay, subs->last_delay);
-        spin_unlock_irqrestore(&subs->lock, flags);
-        return 0;
-}
-static const char *usb_error_string(int err)
-{
-        switch (err) {
-        case -ENODEV:
-                return "no device";
-        case -ENOENT:
-                return "endpoint not enabled";
-        case -EPIPE:
-                return "endpoint stalled";
-        case -ENOSPC:
-                return "not enough bandwidth";
-        case -ESHUTDOWN:
-                return "device disabled";
-        case -EHOSTUNREACH:
-                return "device suspended";
-        case -EINVAL:
-        case -EAGAIN:
-        case -EFBIG:
-        case -EMSGSIZE:
-                return "internal error";
-        default:
-                return "unknown error";
-        }
-}
-/*
- * set up and start data/sync urbs
- */
-static int start_urbs(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime)
-{
-        unsigned int i;
-        int err;
-        if (subs->stream->chip->shutdown)
-                return -EBADFD;
-        for (i = 0; i < subs->nurbs; i++) {
-                if (snd_BUG_ON(!subs->dataurb[i].urb))
-                        return -EINVAL;
-                if (subs->ops.prepare(subs, runtime, subs->dataurb[i].urb) < 0) {
-                        snd_printk(KERN_ERR "cannot prepare datapipe for urb %d\n", i);
-                        goto __error;
-                }
-        }
-        if (subs->syncpipe) {
-                for (i = 0; i < SYNC_URBS; i++) {
-                        if (snd_BUG_ON(!subs->syncurb[i].urb))
-                                return -EINVAL;
-                        if (subs->ops.prepare_sync(subs, runtime, subs->syncurb[i].urb) < 0) {
-                                snd_printk(KERN_ERR "cannot prepare syncpipe for urb %d\n", i);
-                                goto __error;
-                        }
-                }
-        }
-        subs->active_mask = 0;
-        subs->unlink_mask = 0;
-        subs->running = 1;
-        for (i = 0; i < subs->nurbs; i++) {
-                err = usb_submit_urb(subs->dataurb[i].urb, GFP_ATOMIC);
-                if (err < 0) {
-                        snd_printk(KERN_ERR "cannot submit datapipe "
-                                   "for urb %d, error %d: %s\n",
-                                   i, err, usb_error_string(err));
-                        goto __error;
-                }
-                set_bit(i, &subs->active_mask);
-        }
-        if (subs->syncpipe) {
-                for (i = 0; i < SYNC_URBS; i++) {
-                        err = usb_submit_urb(subs->syncurb[i].urb, GFP_ATOMIC);
-                        if (err < 0) {
-                                snd_printk(KERN_ERR "cannot submit syncpipe "
-                                           "for urb %d, error %d: %s\n",
-                                           i, err, usb_error_string(err));
-                                goto __error;
-                        }
-                        set_bit(i + 16, &subs->active_mask);
-                }
-        }
-        return 0;
- __error:
-        // snd_pcm_stop(subs->pcm_substream, SNDRV_PCM_STATE_XRUN);
-        deactivate_urbs(subs, 0, 0);
-        return -EPIPE;
-}
-/*
- */
-static struct snd_urb_ops audio_urb_ops[2] = {
-        {
-                .prepare =      prepare_nodata_playback_urb,
-                .retire =       retire_playback_urb,
-                .prepare_sync = prepare_playback_sync_urb,
-                .retire_sync =  retire_playback_sync_urb,
-        },
-        {
-                .prepare =      prepare_capture_urb,
-                .retire =       retire_capture_urb,
-                .prepare_sync = prepare_capture_sync_urb,
-                .retire_sync =  retire_capture_sync_urb,
-        },
-};
-/*
- * initialize the substream instance.
- */
-void snd_usb_init_substream(struct snd_usb_stream *as,
-                            int stream, struct audioformat *fp)
-{
-        struct snd_usb_substream *subs = &as->substream[stream];
-        INIT_LIST_HEAD(&subs->fmt_list);
-        spin_lock_init(&subs->lock);
-        subs->stream = as;
-        subs->direction = stream;
-        subs->dev = as->chip->dev;
-        subs->txfr_quirk = as->chip->txfr_quirk;
-        subs->ops = audio_urb_ops[stream];
-        if (snd_usb_get_speed(subs->dev) >= USB_SPEED_HIGH)
-                subs->ops.prepare_sync = prepare_capture_sync_urb_hs;
-        snd_usb_set_pcm_ops(as->pcm, stream);
-        list_add_tail(&fp->list, &subs->fmt_list);
-        subs->formats |= fp->formats;
-        subs->endpoint = fp->endpoint;
-        subs->num_formats++;
-        subs->fmt_type = fp->fmt_type;
-}
-int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-        struct snd_usb_substream *subs = substream->runtime->private_data;
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                subs->ops.prepare = prepare_playback_urb;
-                return 0;
-        case SNDRV_PCM_TRIGGER_STOP:
-                return deactivate_urbs(subs, 0, 0);
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                subs->ops.prepare = prepare_nodata_playback_urb;
-                return 0;
-        }
-        return -EINVAL;
-}
-int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-        struct snd_usb_substream *subs = substream->runtime->private_data;
-        switch (cmd) {
-        case SNDRV_PCM_TRIGGER_START:
-                subs->ops.retire = retire_capture_urb;
-                return start_urbs(subs, substream->runtime);
-        case SNDRV_PCM_TRIGGER_STOP:
-                return deactivate_urbs(subs, 0, 0);
-        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-                subs->ops.retire = retire_paused_capture_urb;
-                return 0;
-        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-                subs->ops.retire = retire_capture_urb;
-                return 0;
-        }
-        return -EINVAL;
-}
-int snd_usb_substream_prepare(struct snd_usb_substream *subs,
-                              struct snd_pcm_runtime *runtime)
-{
-        /* clear urbs (to be sure) */
-        deactivate_urbs(subs, 0, 1);
-        wait_clear_urbs(subs);
-        /* for playback, submit the URBs now; otherwise, the first hwptr_done
-         * updates for all URBs would happen at the same time when starting */
-        if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
-                subs->ops.prepare = prepare_nodata_playback_urb;
-                return start_urbs(subs, runtime);
-        }
-        return 0;
-}
diff --git a/sound/usb/endpoint.h b/sound/usb/endpoint.h
index 88eb63a636eb..ee2723fb174f 100644
--- a/sound/usb/endpoint.h
+++ b/sound/usb/endpoint.h
@@ -1,21 +1,29 @@
 #ifndef __USBAUDIO_ENDPOINT_H
 #define __USBAUDIO_ENDPOINT_H
-void snd_usb_init_substream(struct snd_usb_stream *as,
+#define SND_USB_ENDPOINT_TYPE_DATA     0
-                            int stream,
+#define SND_USB_ENDPOINT_TYPE_SYNC     1
-                            struct audioformat *fp);
-int snd_usb_init_substream_urbs(struct snd_usb_substream *subs,
+struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
-                                unsigned int period_bytes,
+                                              struct usb_host_interface *alts,
-                                unsigned int rate,
+                                              int ep_num, int direction, int type);
-                                unsigned int frame_bits);
-void snd_usb_release_substream_urbs(struct snd_usb_substream *subs, int force);
+int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
+                                struct snd_pcm_hw_params *hw_params,
+                                struct audioformat *fmt,
+                                struct snd_usb_endpoint *sync_ep);
-int snd_usb_substream_prepare(struct snd_usb_substream *subs,
+int  snd_usb_endpoint_start(struct snd_usb_endpoint *ep);
-                              struct snd_pcm_runtime *runtime);
+void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep,
+                           int force, int can_sleep, int wait);
+int  snd_usb_endpoint_activate(struct snd_usb_endpoint *ep);
+int  snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep);
+void snd_usb_endpoint_free(struct list_head *head);
-int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream, int cmd);
+int snd_usb_endpoint_implict_feedback_sink(struct snd_usb_endpoint *ep);
-int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd);
+void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
+                             struct snd_usb_endpoint *sender,
+                             const struct urb *urb);
 #endif /* __USBAUDIO_ENDPOINT_H */
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index ab23869c01bb..4f40ba823163 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -486,7 +486,7 @@ static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
 /*
 * TLV callback for mixer volume controls
 */
-static int mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
+int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
                         unsigned int size, unsigned int __user *_tlv)
 {
        struct usb_mixer_elem_info *cval = kcontrol->private_data;
@@ -770,6 +770,26 @@ static void volume_control_quirks(struct usb_mixer_elem_info *cval,
                                  struct snd_kcontrol *kctl)
 {
        switch (cval->mixer->chip->usb_id) {
+        case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
+        case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
+                if (strcmp(kctl->id.name, "Effect Duration") == 0) {
+                        snd_printk(KERN_INFO
+                                "usb-audio: set quirk for FTU Effect Duration\n");
+                        cval->min = 0x0000;
+                        cval->max = 0x7f00;
+                        cval->res = 0x0100;
+                        break;
+                }
+                if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
+                    strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
+                        snd_printk(KERN_INFO
+                                "usb-audio: set quirks for FTU Effect Feedback/Volume\n");
+                        cval->min = 0x00;
+                        cval->max = 0x7f;
+                        break;
+                }
+                break;
        case USB_ID(0x0471, 0x0101):
        case USB_ID(0x0471, 0x0104):
        case USB_ID(0x0471, 0x0105):
@@ -1121,9 +1141,6 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                len = snd_usb_copy_string_desc(state, nameid,
                                kctl->id.name, sizeof(kctl->id.name));
-        /* get min/max values */
-        get_min_max_with_quirks(cval, 0, kctl);
        switch (control) {
        case UAC_FU_MUTE:
        case UAC_FU_VOLUME:
@@ -1155,17 +1172,7 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                }
                append_ctl_name(kctl, control == UAC_FU_MUTE ?
                                " Switch" : " Volume");
-                if (control == UAC_FU_VOLUME) {
-                        check_mapped_dB(map, cval);
-                        if (cval->dBmin < cval->dBmax || !cval->initialized) {
-                                kctl->tlv.c = mixer_vol_tlv;
-                                kctl->vd[0].access |= 
-                                        SNDRV_CTL_ELEM_ACCESS_TLV_READ |
-                                        SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
-                        }
-                }
                break;
        default:
                if (! len)
                        strlcpy(kctl->id.name, audio_feature_info[control-1].name,
@@ -1173,6 +1180,19 @@ static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
                break;
        }
+        /* get min/max values */
+        get_min_max_with_quirks(cval, 0, kctl);
+        if (control == UAC_FU_VOLUME) {
+                check_mapped_dB(map, cval);
+                if (cval->dBmin < cval->dBmax || !cval->initialized) {
+                        kctl->tlv.c = snd_usb_mixer_vol_tlv;
+                        kctl->vd[0].access |=
+                                SNDRV_CTL_ELEM_ACCESS_TLV_READ |
+                                SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
+                }
+        }
        range = (cval->max - cval->min) / cval->res;
        /* Are there devices with volume range more than 255? I use a bit more
         * to be sure. 384 is a resolution magic number found on Logitech
@@ -1388,7 +1408,7 @@ static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *r
        for (pin = 0; pin < input_pins; pin++) {
                err = parse_audio_unit(state, desc->baSourceID[pin]);
                if (err < 0)
-                        return err;
+                        continue;
                err = check_input_term(state, desc->baSourceID[pin], &iterm);
                if (err < 0)
                        return err;
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index 81b2d8a32fb0..a7f3d45a8acf 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -68,4 +68,7 @@ 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);
+int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
+                          unsigned int size, unsigned int __user *_tlv);
 #endif /* __USBMIXER_H */
diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c
index f1324c423835..41daaa24c25f 100644
--- a/sound/usb/mixer_maps.c
+++ b/sound/usb/mixer_maps.c
@@ -288,6 +288,15 @@ static struct usbmix_name_map scratch_live_map[] = {
        { 0 } /* terminator */
 };
+static struct usbmix_name_map ebox44_map[] = {
+        { 4, NULL }, /* FU */
+        { 6, NULL }, /* MU */
+        { 7, NULL }, /* FU */
+        { 10, NULL }, /* FU */
+        { 11, NULL }, /* MU */
+        { 0 }
+};
 /* "Gamesurround Muse Pocket LT" looks same like "Sound Blaster MP3+"
 *  most importand difference is SU[8], it should be set to "Capture Source"
 *  to make alsamixer and PA working properly.
@@ -371,6 +380,10 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = {
                .map = scratch_live_map,
                .ignore_ctl_error = 1,
        },
+        {
+                .id = USB_ID(0x200c, 0x1018),
+                .map = ebox44_map,
+        },
        { 0 } /* terminator */
 };
diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
index ab125ee0b0f0..41f4b6911920 100644
--- a/sound/usb/mixer_quirks.c
+++ b/sound/usb/mixer_quirks.c
@@ -42,6 +42,77 @@
 extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
+/* private_free callback */
+static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
+{
+        kfree(kctl->private_data);
+        kctl->private_data = NULL;
+}
+/* This function allows for the creation of standard UAC controls.
+ * See the quirks for M-Audio FTUs or Ebox-44.
+ * If you don't want to set a TLV callback pass NULL.
+ *
+ * Since there doesn't seem to be a devices that needs a multichannel
+ * version, we keep it mono for simplicity.
+ */
+static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
+                                unsigned int unitid,
+                                unsigned int control,
+                                unsigned int cmask,
+                                int val_type,
+                                const char *name,
+                                snd_kcontrol_tlv_rw_t *tlv_callback)
+{
+        int err;
+        struct usb_mixer_elem_info *cval;
+        struct snd_kcontrol *kctl;
+        cval = kzalloc(sizeof(*cval), GFP_KERNEL);
+        if (!cval)
+                return -ENOMEM;
+        cval->id = unitid;
+        cval->mixer = mixer;
+        cval->val_type = val_type;
+        cval->channels = 1;
+        cval->control = control;
+        cval->cmask = cmask;
+        /* get_min_max() is called only for integer volumes later,
+         * so provide a short-cut for booleans */
+        cval->min = 0;
+        cval->max = 1;
+        cval->res = 0;
+        cval->dBmin = 0;
+        cval->dBmax = 0;
+        /* Create control */
+        kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
+        if (!kctl) {
+                kfree(cval);
+                return -ENOMEM;
+        }
+        /* Set name */
+        snprintf(kctl->id.name, sizeof(kctl->id.name), name);
+        kctl->private_free = usb_mixer_elem_free;
+        /* set TLV */
+        if (tlv_callback) {
+                kctl->tlv.c = tlv_callback;
+                kctl->vd[0].access |=
+                        SNDRV_CTL_ELEM_ACCESS_TLV_READ |
+                        SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
+        }
+        /* Add control to mixer */
+        err = snd_usb_mixer_add_control(mixer, kctl);
+        if (err < 0)
+                return err;
+        return 0;
+}
 /*
 * Sound Blaster remote control configuration
 *
@@ -495,60 +566,218 @@ static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
 }
 /* M-Audio FastTrack Ultra quirks */
+/* FTU Effect switch */
+struct snd_ftu_eff_switch_priv_val {
+        struct usb_mixer_interface *mixer;
+        int cached_value;
+        int is_cached;
+};
-/* private_free callback */
+static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
-static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
+                                        struct snd_ctl_elem_info *uinfo)
 {
-        kfree(kctl->private_data);
+        static const char *texts[8] = {"Room 1",
-        kctl->private_data = NULL;
+                                       "Room 2",
+                                       "Room 3",
+                                       "Hall 1",
+                                       "Hall 2",
+                                       "Plate",
+                                       "Delay",
+                                       "Echo"
+        };
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 8;
+        if (uinfo->value.enumerated.item > 7)
+                uinfo->value.enumerated.item = 7;
+        strcpy(uinfo->value.enumerated.name,
+                texts[uinfo->value.enumerated.item]);
+        return 0;
 }
-static int snd_maudio_ftu_create_ctl(struct usb_mixer_interface *mixer,
+static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
-                                     int in, int out, const char *name)
+                                        struct snd_ctl_elem_value *ucontrol)
 {
-        struct usb_mixer_elem_info *cval;
+        struct snd_usb_audio *chip;
+        struct usb_mixer_interface *mixer;
+        struct snd_ftu_eff_switch_priv_val *pval;
+        int err;
+        unsigned char value[2];
+        const int id = 6;
+        const int validx = 1;
+        const int val_len = 2;
+        value[0] = 0x00;
+        value[1] = 0x00;
+        pval = (struct snd_ftu_eff_switch_priv_val *)
+                kctl->private_value;
+        if (pval->is_cached) {
+                ucontrol->value.enumerated.item[0] = pval->cached_value;
+                return 0;
+        }
+        mixer = (struct usb_mixer_interface *) pval->mixer;
+        if (snd_BUG_ON(!mixer))
+                return -EINVAL;
+        chip = (struct snd_usb_audio *) mixer->chip;
+        if (snd_BUG_ON(!chip))
+                return -EINVAL;
+        err = snd_usb_ctl_msg(chip->dev,
+                        usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
+                        USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
+                        validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
+                        value, val_len);
+        if (err < 0)
+                return err;
+        ucontrol->value.enumerated.item[0] = value[0];
+        pval->cached_value = value[0];
+        pval->is_cached = 1;
+        return 0;
+}
+static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_value *ucontrol)
+{
+        struct snd_usb_audio *chip;
+        struct snd_ftu_eff_switch_priv_val *pval;
+        struct usb_mixer_interface *mixer;
+        int changed, cur_val, err, new_val;
+        unsigned char value[2];
+        const int id = 6;
+        const int validx = 1;
+        const int val_len = 2;
+        changed = 0;
+        pval = (struct snd_ftu_eff_switch_priv_val *)
+                kctl->private_value;
+        cur_val = pval->cached_value;
+        new_val = ucontrol->value.enumerated.item[0];
+        mixer = (struct usb_mixer_interface *) pval->mixer;
+        if (snd_BUG_ON(!mixer))
+                return -EINVAL;
+        chip = (struct snd_usb_audio *) mixer->chip;
+        if (snd_BUG_ON(!chip))
+                return -EINVAL;
+        if (!pval->is_cached) {
+                /* Read current value */
+                err = snd_usb_ctl_msg(chip->dev,
+                                usb_rcvctrlpipe(chip->dev, 0), UAC_GET_CUR,
+                                USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
+                                validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
+                                value, val_len);
+                if (err < 0)
+                        return err;
+                cur_val = value[0];
+                pval->cached_value = cur_val;
+                pval->is_cached = 1;
+        }
+        /* update value if needed */
+        if (cur_val != new_val) {
+                value[0] = new_val;
+                value[1] = 0;
+                err = snd_usb_ctl_msg(chip->dev,
+                                usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
+                                USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
+                                validx << 8, snd_usb_ctrl_intf(chip) | (id << 8),
+                                value, val_len);
+                if (err < 0)
+                        return err;
+                pval->cached_value = new_val;
+                pval->is_cached = 1;
+                changed = 1;
+        }
+        return changed;
+}
+static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer)
+{
+        static struct snd_kcontrol_new template = {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Effect Program Switch",
+                .index = 0,
+                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+                .info = snd_ftu_eff_switch_info,
+                .get = snd_ftu_eff_switch_get,
+                .put = snd_ftu_eff_switch_put
+        };
+        int err;
        struct snd_kcontrol *kctl;
+        struct snd_ftu_eff_switch_priv_val *pval;
-        cval = kzalloc(sizeof(*cval), GFP_KERNEL);
+        pval = kzalloc(sizeof(*pval), GFP_KERNEL);
-        if (!cval)
+        if (!pval)
                return -ENOMEM;
-        cval->id = 5;
+        pval->cached_value = 0;
-        cval->mixer = mixer;
+        pval->is_cached = 0;
-        cval->val_type = USB_MIXER_S16;
+        pval->mixer = mixer;
-        cval->channels = 1;
-        cval->control = out + 1;
-        cval->cmask = 1 << in;
-        kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
+        template.private_value = (unsigned long) pval;
+        kctl = snd_ctl_new1(&template, mixer->chip);
        if (!kctl) {
-                kfree(cval);
+                kfree(pval);
                return -ENOMEM;
        }
-        snprintf(kctl->id.name, sizeof(kctl->id.name), name);
+        err = snd_ctl_add(mixer->chip->card, kctl);
-        kctl->private_free = usb_mixer_elem_free;
+        if (err < 0)
-        return snd_usb_mixer_add_control(mixer, kctl);
+                return err;
+        return 0;
 }
-static int snd_maudio_ftu_create_mixer(struct usb_mixer_interface *mixer)
+/* Create volume controls for FTU devices*/
+static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
 {
        char name[64];
+        unsigned int control, cmask;
        int in, out, err;
+        const unsigned int id = 5;
+        const int val_type = USB_MIXER_S16;
        for (out = 0; out < 8; out++) {
+                control = out + 1;
                for (in = 0; in < 8; in++) {
+                        cmask = 1 << in;
                        snprintf(name, sizeof(name),
-                                 "AIn%d - Out%d Capture Volume", in  + 1, out + 1);
+                                "AIn%d - Out%d Capture Volume",
-                        err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
+                                in  + 1, out + 1);
+                        err = snd_create_std_mono_ctl(mixer, id, control,
+                                                        cmask, val_type, name,
+                                                        &snd_usb_mixer_vol_tlv);
                        if (err < 0)
                                return err;
                }
                for (in = 8; in < 16; in++) {
+                        cmask = 1 << in;
                        snprintf(name, sizeof(name),
-                                 "DIn%d - Out%d Playback Volume", in - 7, out + 1);
+                                "DIn%d - Out%d Playback Volume",
-                        err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
+                                in - 7, out + 1);
+                        err = snd_create_std_mono_ctl(mixer, id, control,
+                                                        cmask, val_type, name,
+                                                        &snd_usb_mixer_vol_tlv);
                        if (err < 0)
                                return err;
                }
@@ -557,6 +786,191 @@ static int snd_maudio_ftu_create_mixer(struct usb_mixer_interface *mixer)
        return 0;
 }
+/* This control needs a volume quirk, see mixer.c */
+static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
+{
+        static const char name[] = "Effect Volume";
+        const unsigned int id = 6;
+        const int val_type = USB_MIXER_U8;
+        const unsigned int control = 2;
+        const unsigned int cmask = 0;
+        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
+                                        name, snd_usb_mixer_vol_tlv);
+}
+/* This control needs a volume quirk, see mixer.c */
+static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
+{
+        static const char name[] = "Effect Duration";
+        const unsigned int id = 6;
+        const int val_type = USB_MIXER_S16;
+        const unsigned int control = 3;
+        const unsigned int cmask = 0;
+        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
+                                        name, snd_usb_mixer_vol_tlv);
+}
+/* This control needs a volume quirk, see mixer.c */
+static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
+{
+        static const char name[] = "Effect Feedback Volume";
+        const unsigned int id = 6;
+        const int val_type = USB_MIXER_U8;
+        const unsigned int control = 4;
+        const unsigned int cmask = 0;
+        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
+                                        name, NULL);
+}
+static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
+{
+        unsigned int cmask;
+        int err, ch;
+        char name[48];
+        const unsigned int id = 7;
+        const int val_type = USB_MIXER_S16;
+        const unsigned int control = 7;
+        for (ch = 0; ch < 4; ++ch) {
+                cmask = 1 << ch;
+                snprintf(name, sizeof(name),
+                        "Effect Return %d Volume", ch + 1);
+                err = snd_create_std_mono_ctl(mixer, id, control,
+                                                cmask, val_type, name,
+                                                snd_usb_mixer_vol_tlv);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
+{
+        unsigned int  cmask;
+        int err, ch;
+        char name[48];
+        const unsigned int id = 5;
+        const int val_type = USB_MIXER_S16;
+        const unsigned int control = 9;
+        for (ch = 0; ch < 8; ++ch) {
+                cmask = 1 << ch;
+                snprintf(name, sizeof(name),
+                        "Effect Send AIn%d Volume", ch + 1);
+                err = snd_create_std_mono_ctl(mixer, id, control, cmask,
+                                                val_type, name,
+                                                snd_usb_mixer_vol_tlv);
+                if (err < 0)
+                        return err;
+        }
+        for (ch = 8; ch < 16; ++ch) {
+                cmask = 1 << ch;
+                snprintf(name, sizeof(name),
+                        "Effect Send DIn%d Volume", ch - 7);
+                err = snd_create_std_mono_ctl(mixer, id, control, cmask,
+                                                val_type, name,
+                                                snd_usb_mixer_vol_tlv);
+                if (err < 0)
+                        return err;
+        }
+        return 0;
+}
+static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
+{
+        int err;
+        err = snd_ftu_create_volume_ctls(mixer);
+        if (err < 0)
+                return err;
+        err = snd_ftu_create_effect_switch(mixer);
+        if (err < 0)
+                return err;
+        err = snd_ftu_create_effect_volume_ctl(mixer);
+        if (err < 0)
+                return err;
+        err = snd_ftu_create_effect_duration_ctl(mixer);
+        if (err < 0)
+                return err;
+        err = snd_ftu_create_effect_feedback_ctl(mixer);
+        if (err < 0)
+                return err;
+        err = snd_ftu_create_effect_return_ctls(mixer);
+        if (err < 0)
+                return err;
+        err = snd_ftu_create_effect_send_ctls(mixer);
+        if (err < 0)
+                return err;
+        return 0;
+}
+/*
+ * Create mixer for Electrix Ebox-44
+ *
+ * The mixer units from this device are corrupt, and even where they
+ * are valid they presents mono controls as L and R channels of
+ * stereo. So we create a good mixer in code.
+ */
+static int snd_ebox44_create_mixer(struct usb_mixer_interface *mixer)
+{
+        int err;
+        err = snd_create_std_mono_ctl(mixer, 4, 1, 0x0, USB_MIXER_INV_BOOLEAN,
+                                "Headphone Playback Switch", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 4, 2, 0x1, USB_MIXER_S16,
+                                "Headphone A Mix Playback Volume", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 4, 2, 0x2, USB_MIXER_S16,
+                                "Headphone B Mix Playback Volume", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 7, 1, 0x0, USB_MIXER_INV_BOOLEAN,
+                                "Output Playback Switch", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 7, 2, 0x1, USB_MIXER_S16,
+                                "Output A Playback Volume", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 7, 2, 0x2, USB_MIXER_S16,
+                                "Output B Playback Volume", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 10, 1, 0x0, USB_MIXER_INV_BOOLEAN,
+                                "Input Capture Switch", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 10, 2, 0x1, USB_MIXER_S16,
+                                "Input A Capture Volume", NULL);
+        if (err < 0)
+                return err;
+        err = snd_create_std_mono_ctl(mixer, 10, 2, 0x2, USB_MIXER_S16,
+                                "Input B Capture Volume", NULL);
+        if (err < 0)
+                return err;
+        return 0;
+}
 void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
                               unsigned char samplerate_id)
 {
@@ -600,7 +1014,7 @@ int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
        case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
        case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
-                err = snd_maudio_ftu_create_mixer(mixer);
+                err = snd_ftu_create_mixer(mixer);
                break;
        case USB_ID(0x0b05, 0x1739):
@@ -619,6 +1033,10 @@ int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
                                snd_nativeinstruments_ta10_mixers,
                                ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
                break;
+        case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
+                err = snd_ebox44_create_mixer(mixer);
+                break;
        }
        return err;
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 0eed6115c2d4..24839d932648 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -16,6 +16,7 @@
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/ratelimit.h>
 #include <linux/usb.h>
 #include <linux/usb/audio.h>
 #include <linux/usb/audio-v2.h>
@@ -34,6 +35,9 @@
 #include "clock.h"
 #include "power.h"
+#define SUBSTREAM_FLAG_DATA_EP_STARTED  0
+#define SUBSTREAM_FLAG_SYNC_EP_STARTED  1
 /* return the estimated delay based on USB frame counters */
 snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs,
                                    unsigned int rate)
@@ -208,6 +212,84 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
        }
 }
+static int start_endpoints(struct snd_usb_substream *subs)
+{
+        int err;
+        if (!subs->data_endpoint)
+                return -EINVAL;
+        if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
+                struct snd_usb_endpoint *ep = subs->data_endpoint;
+                snd_printdd(KERN_DEBUG "Starting data EP @%p\n", ep);
+                ep->data_subs = subs;
+                err = snd_usb_endpoint_start(ep);
+                if (err < 0) {
+                        clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags);
+                        return err;
+                }
+        }
+        if (subs->sync_endpoint &&
+            !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) {
+                struct snd_usb_endpoint *ep = subs->sync_endpoint;
+                snd_printdd(KERN_DEBUG "Starting sync EP @%p\n", ep);
+                ep->sync_slave = subs->data_endpoint;
+                err = snd_usb_endpoint_start(ep);
+                if (err < 0) {
+                        clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
+                        return err;
+                }
+        }
+        return 0;
+}
+static void stop_endpoints(struct snd_usb_substream *subs,
+                           int force, int can_sleep, int wait)
+{
+        if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags))
+                snd_usb_endpoint_stop(subs->sync_endpoint,
+                                      force, can_sleep, wait);
+        if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags))
+                snd_usb_endpoint_stop(subs->data_endpoint,
+                                      force, can_sleep, wait);
+}
+static int activate_endpoints(struct snd_usb_substream *subs)
+{
+        if (subs->sync_endpoint) {
+                int ret;
+                ret = snd_usb_endpoint_activate(subs->sync_endpoint);
+                if (ret < 0)
+                        return ret;
+        }
+        return snd_usb_endpoint_activate(subs->data_endpoint);
+}
+static int deactivate_endpoints(struct snd_usb_substream *subs)
+{
+        int reta, retb;
+        reta = snd_usb_endpoint_deactivate(subs->sync_endpoint);
+        retb = snd_usb_endpoint_deactivate(subs->data_endpoint);
+        if (reta < 0)
+                return reta;
+        if (retb < 0)
+                return retb;
+        return 0;
+}
 /*
 * find a matching format and set up the interface
 */
@@ -219,7 +301,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
        struct usb_interface *iface;
        unsigned int ep, attr;
        int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
-        int err;
+        int err, implicit_fb = 0;
        iface = usb_ifnum_to_if(dev, fmt->iface);
        if (WARN_ON(!iface))
@@ -232,40 +314,11 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
        if (fmt == subs->cur_audiofmt)
                return 0;
-        /* close the old interface */
+        subs->data_endpoint = snd_usb_add_endpoint(subs->stream->chip,
-        if (subs->interface >= 0 && subs->interface != fmt->iface) {
+                                                   alts, fmt->endpoint, subs->direction,
-                if (usb_set_interface(subs->dev, subs->interface, 0) < 0) {
+                                                   SND_USB_ENDPOINT_TYPE_DATA);
-                        snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed\n",
+        if (!subs->data_endpoint)
-                                dev->devnum, fmt->iface, fmt->altsetting);
+                return -EINVAL;
-                        return -EIO;
-                }
-                subs->interface = -1;
-                subs->altset_idx = 0;
-        }
-        /* set interface */
-        if (subs->interface != fmt->iface || subs->altset_idx != fmt->altset_idx) {
-                if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) {
-                        snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n",
-                                   dev->devnum, fmt->iface, fmt->altsetting);
-                        return -EIO;
-                }
-                snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting);
-                subs->interface = fmt->iface;
-                subs->altset_idx = fmt->altset_idx;
-        }
-        /* create a data pipe */
-        ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK;
-        if (is_playback)
-                subs->datapipe = usb_sndisocpipe(dev, ep);
-        else
-                subs->datapipe = usb_rcvisocpipe(dev, ep);
-        subs->datainterval = fmt->datainterval;
-        subs->syncpipe = subs->syncinterval = 0;
-        subs->maxpacksize = fmt->maxpacksize;
-        subs->syncmaxsize = 0;
-        subs->fill_max = 0;
        /* we need a sync pipe in async OUT or adaptive IN mode */
        /* check the number of EP, since some devices have broken
@@ -273,8 +326,25 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
         * assume it as adaptive-out or sync-in.
         */
        attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
+        switch (subs->stream->chip->usb_id) {
+        case USB_ID(0x0763, 0x2080): /* M-Audio FastTrack Ultra */
+        case USB_ID(0x0763, 0x2081):
+                if (is_playback) {
+                        implicit_fb = 1;
+                        ep = 0x81;
+                        iface = usb_ifnum_to_if(dev, 2);
+                        if (!iface || iface->num_altsetting == 0)
+                                return -EINVAL;
+                        alts = &iface->altsetting[1];
+                        goto add_sync_ep;
+                }
+        }
        if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
-             (! is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
+             (!is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
            altsd->bNumEndpoints >= 2) {
                /* check sync-pipe endpoint */
                /* ... and check descriptor size before accessing bSynchAddress
@@ -282,7 +352,8 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
                   the audio fields in the endpoint descriptors */
                if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 ||
                    (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
-                     get_endpoint(alts, 1)->bSynchAddress != 0)) {
+                     get_endpoint(alts, 1)->bSynchAddress != 0 &&
+                     !implicit_fb)) {
                        snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
                                   dev->devnum, fmt->iface, fmt->altsetting);
                        return -EINVAL;
@@ -290,33 +361,27 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
                ep = get_endpoint(alts, 1)->bEndpointAddress;
                if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
                    (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
-                     (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
+                     (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)) ||
+                     ( is_playback && !implicit_fb))) {
                        snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n",
                                   dev->devnum, fmt->iface, fmt->altsetting);
                        return -EINVAL;
                }
-                ep &= USB_ENDPOINT_NUMBER_MASK;
-                if (is_playback)
+                implicit_fb = (get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_USAGE_MASK)
-                        subs->syncpipe = usb_rcvisocpipe(dev, ep);
+                                == USB_ENDPOINT_USAGE_IMPLICIT_FB;
-                else
-                        subs->syncpipe = usb_sndisocpipe(dev, ep);
+add_sync_ep:
-                if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
+                subs->sync_endpoint = snd_usb_add_endpoint(subs->stream->chip,
-                    get_endpoint(alts, 1)->bRefresh >= 1 &&
+                                                           alts, ep, !subs->direction,
-                    get_endpoint(alts, 1)->bRefresh <= 9)
+                                                           implicit_fb ?
-                        subs->syncinterval = get_endpoint(alts, 1)->bRefresh;
+                                                                SND_USB_ENDPOINT_TYPE_DATA :
-                else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL)
+                                                                SND_USB_ENDPOINT_TYPE_SYNC);
-                        subs->syncinterval = 1;
+                if (!subs->sync_endpoint)
-                else if (get_endpoint(alts, 1)->bInterval >= 1 &&
+                        return -EINVAL;
-                         get_endpoint(alts, 1)->bInterval <= 16)
-                        subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
+                subs->data_endpoint->sync_master = subs->sync_endpoint;
-                else
+        }
-                        subs->syncinterval = 3;
-                subs->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
-        }
-        /* always fill max packet size */
-        if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX)
-                subs->fill_max = 1;
        if ((err = snd_usb_init_pitch(subs->stream->chip, subs->interface, alts, fmt)) < 0)
                return err;
@@ -390,15 +455,30 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
        if (changed) {
                mutex_lock(&subs->stream->chip->shutdown_mutex);
                /* format changed */
-                snd_usb_release_substream_urbs(subs, 0);
+                stop_endpoints(subs, 0, 0, 0);
-                /* influenced: period_bytes, channels, rate, format, */
+                deactivate_endpoints(subs);
-                ret = snd_usb_init_substream_urbs(subs, params_period_bytes(hw_params),
-                                                  params_rate(hw_params),
+                ret = activate_endpoints(subs);
-                                                  snd_pcm_format_physical_width(params_format(hw_params)) *
+                if (ret < 0)
-                                                        params_channels(hw_params));
+                        goto unlock;
+                ret = snd_usb_endpoint_set_params(subs->data_endpoint, hw_params, fmt,
+                                                  subs->sync_endpoint);
+                if (ret < 0)
+                        goto unlock;
+                if (subs->sync_endpoint)
+                        ret = snd_usb_endpoint_set_params(subs->sync_endpoint,
+                                                          hw_params, fmt, NULL);
+unlock:
                mutex_unlock(&subs->stream->chip->shutdown_mutex);
        }
+        if (ret == 0) {
+                subs->interface = fmt->iface;
+                subs->altset_idx = fmt->altset_idx;
+        }
        return ret;
 }
@@ -415,7 +495,7 @@ static int snd_usb_hw_free(struct snd_pcm_substream *substream)
        subs->cur_rate = 0;
        subs->period_bytes = 0;
        mutex_lock(&subs->stream->chip->shutdown_mutex);
-        snd_usb_release_substream_urbs(subs, 0);
+        stop_endpoints(subs, 0, 1, 1);
        mutex_unlock(&subs->stream->chip->shutdown_mutex);
        return snd_pcm_lib_free_vmalloc_buffer(substream);
 }
@@ -435,19 +515,28 @@ static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
                return -ENXIO;
        }
+        if (snd_BUG_ON(!subs->data_endpoint))
+                return -EIO;
        /* some unit conversions in runtime */
-        subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize);
+        subs->data_endpoint->maxframesize =
-        subs->curframesize = bytes_to_frames(runtime, subs->curpacksize);
+                bytes_to_frames(runtime, subs->data_endpoint->maxpacksize);
+        subs->data_endpoint->curframesize =
+                bytes_to_frames(runtime, subs->data_endpoint->curpacksize);
        /* reset the pointer */
        subs->hwptr_done = 0;
        subs->transfer_done = 0;
-        subs->phase = 0;
        subs->last_delay = 0;
        subs->last_frame_number = 0;
        runtime->delay = 0;
-        return snd_usb_substream_prepare(subs, runtime);
+        /* for playback, submit the URBs now; otherwise, the first hwptr_done
+         * updates for all URBs would happen at the same time when starting */
+        if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK)
+                return start_endpoints(subs);
+        return 0;
 }
 static struct snd_pcm_hardware snd_usb_hardware =
@@ -842,16 +931,171 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction)
 static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
 {
+        int ret;
        struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
        struct snd_usb_substream *subs = &as->substream[direction];
-        if (!as->chip->shutdown && subs->interface >= 0) {
+        stop_endpoints(subs, 0, 0, 0);
-                usb_set_interface(subs->dev, subs->interface, 0);
+        ret = deactivate_endpoints(subs);
-                subs->interface = -1;
-        }
        subs->pcm_substream = NULL;
        snd_usb_autosuspend(subs->stream->chip);
-        return 0;
+        return ret;
+}
+/* Since a URB can handle only a single linear buffer, we must use double
+ * buffering when the data to be transferred overflows the buffer boundary.
+ * To avoid inconsistencies when updating hwptr_done, we use double buffering
+ * for all URBs.
+ */
+static void retire_capture_urb(struct snd_usb_substream *subs,
+                               struct urb *urb)
+{
+        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
+        unsigned int stride, frames, bytes, oldptr;
+        int i, period_elapsed = 0;
+        unsigned long flags;
+        unsigned char *cp;
+        stride = runtime->frame_bits >> 3;
+        for (i = 0; i < urb->number_of_packets; i++) {
+                cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset;
+                if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
+                        snd_printdd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
+                        // continue;
+                }
+                bytes = urb->iso_frame_desc[i].actual_length;
+                frames = bytes / stride;
+                if (!subs->txfr_quirk)
+                        bytes = frames * stride;
+                if (bytes % (runtime->sample_bits >> 3) != 0) {
+#ifdef CONFIG_SND_DEBUG_VERBOSE
+                        int oldbytes = bytes;
+#endif
+                        bytes = frames * stride;
+                        snd_printdd(KERN_ERR "Corrected urb data len. %d->%d\n",
+                                                        oldbytes, bytes);
+                }
+                /* update the current pointer */
+                spin_lock_irqsave(&subs->lock, flags);
+                oldptr = subs->hwptr_done;
+                subs->hwptr_done += bytes;
+                if (subs->hwptr_done >= runtime->buffer_size * stride)
+                        subs->hwptr_done -= runtime->buffer_size * stride;
+                frames = (bytes + (oldptr % stride)) / stride;
+                subs->transfer_done += frames;
+                if (subs->transfer_done >= runtime->period_size) {
+                        subs->transfer_done -= runtime->period_size;
+                        period_elapsed = 1;
+                }
+                spin_unlock_irqrestore(&subs->lock, flags);
+                /* copy a data chunk */
+                if (oldptr + bytes > runtime->buffer_size * stride) {
+                        unsigned int bytes1 =
+                                        runtime->buffer_size * stride - oldptr;
+                        memcpy(runtime->dma_area + oldptr, cp, bytes1);
+                        memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
+                } else {
+                        memcpy(runtime->dma_area + oldptr, cp, bytes);
+                }
+        }
+        if (period_elapsed)
+                snd_pcm_period_elapsed(subs->pcm_substream);
+}
+static void prepare_playback_urb(struct snd_usb_substream *subs,
+                                 struct urb *urb)
+{
+        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
+        struct snd_urb_ctx *ctx = urb->context;
+        unsigned int counts, frames, bytes;
+        int i, stride, period_elapsed = 0;
+        unsigned long flags;
+        stride = runtime->frame_bits >> 3;
+        frames = 0;
+        urb->number_of_packets = 0;
+        spin_lock_irqsave(&subs->lock, flags);
+        for (i = 0; i < ctx->packets; i++) {
+                counts = ctx->packet_size[i];
+                /* set up descriptor */
+                urb->iso_frame_desc[i].offset = frames * stride;
+                urb->iso_frame_desc[i].length = counts * stride;
+                frames += counts;
+                urb->number_of_packets++;
+                subs->transfer_done += counts;
+                if (subs->transfer_done >= runtime->period_size) {
+                        subs->transfer_done -= runtime->period_size;
+                        period_elapsed = 1;
+                        if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
+                                if (subs->transfer_done > 0) {
+                                        /* FIXME: fill-max mode is not
+                                         * supported yet */
+                                        frames -= subs->transfer_done;
+                                        counts -= subs->transfer_done;
+                                        urb->iso_frame_desc[i].length =
+                                                counts * stride;
+                                        subs->transfer_done = 0;
+                                }
+                                i++;
+                                if (i < ctx->packets) {
+                                        /* add a transfer delimiter */
+                                        urb->iso_frame_desc[i].offset =
+                                                frames * stride;
+                                        urb->iso_frame_desc[i].length = 0;
+                                        urb->number_of_packets++;
+                                }
+                                break;
+                        }
+                }
+                if (period_elapsed &&
+                    !snd_usb_endpoint_implict_feedback_sink(subs->data_endpoint)) /* finish at the period boundary */
+                        break;
+        }
+        bytes = frames * stride;
+        if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
+                /* err, the transferred area goes over buffer boundary. */
+                unsigned int bytes1 =
+                        runtime->buffer_size * stride - subs->hwptr_done;
+                memcpy(urb->transfer_buffer,
+                       runtime->dma_area + subs->hwptr_done, bytes1);
+                memcpy(urb->transfer_buffer + bytes1,
+                       runtime->dma_area, bytes - bytes1);
+        } else {
+                memcpy(urb->transfer_buffer,
+                       runtime->dma_area + subs->hwptr_done, bytes);
+        }
+        subs->hwptr_done += bytes;
+        if (subs->hwptr_done >= runtime->buffer_size * stride)
+                subs->hwptr_done -= runtime->buffer_size * stride;
+        runtime->delay += frames;
+        spin_unlock_irqrestore(&subs->lock, flags);
+        urb->transfer_buffer_length = bytes;
+        if (period_elapsed)
+                snd_pcm_period_elapsed(subs->pcm_substream);
+}
+/*
+ * process after playback data complete
+ * - decrease the delay count again
+ */
+static void retire_playback_urb(struct snd_usb_substream *subs,
+                               struct urb *urb)
+{
+        unsigned long flags;
+        struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
+        int stride = runtime->frame_bits >> 3;
+        int processed = urb->transfer_buffer_length / stride;
+        spin_lock_irqsave(&subs->lock, flags);
+        if (processed > runtime->delay)
+                runtime->delay = 0;
+        else
+                runtime->delay -= processed;
+        spin_unlock_irqrestore(&subs->lock, flags);
 }
 static int snd_usb_playback_open(struct snd_pcm_substream *substream)
@@ -874,6 +1118,63 @@ static int snd_usb_capture_close(struct snd_pcm_substream *substream)
        return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE);
 }
+static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream,
+                                              int cmd)
+{
+        struct snd_usb_substream *subs = substream->runtime->private_data;
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                subs->data_endpoint->prepare_data_urb = prepare_playback_urb;
+                subs->data_endpoint->retire_data_urb = retire_playback_urb;
+                subs->running = 1;
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                stop_endpoints(subs, 0, 0, 0);
+                subs->running = 0;
+                return 0;
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                subs->data_endpoint->prepare_data_urb = NULL;
+                subs->data_endpoint->retire_data_urb = NULL;
+                subs->running = 0;
+                return 0;
+        }
+        return -EINVAL;
+}
+int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        int err;
+        struct snd_usb_substream *subs = substream->runtime->private_data;
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                err = start_endpoints(subs);
+                if (err < 0)
+                        return err;
+                subs->data_endpoint->retire_data_urb = retire_capture_urb;
+                subs->running = 1;
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                stop_endpoints(subs, 0, 0, 0);
+                subs->running = 0;
+                return 0;
+        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+                subs->data_endpoint->retire_data_urb = NULL;
+                subs->running = 0;
+                return 0;
+        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+                subs->data_endpoint->retire_data_urb = retire_capture_urb;
+                subs->running = 1;
+                return 0;
+        }
+        return -EINVAL;
+}
 static struct snd_pcm_ops snd_usb_playback_ops = {
        .open =         snd_usb_playback_open,
        .close =        snd_usb_playback_close,
diff --git a/sound/usb/proc.c b/sound/usb/proc.c
index 961c9a250686..ebc1a5b5b3f1 100644
--- a/sound/usb/proc.c
+++ b/sound/usb/proc.c
@@ -25,6 +25,7 @@
 #include "usbaudio.h"
 #include "helper.h"
 #include "card.h"
+#include "endpoint.h"
 #include "proc.h"
 /* convert our full speed USB rate into sampling rate in Hz */
@@ -115,28 +116,33 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
        }
 }
+static void proc_dump_ep_status(struct snd_usb_substream *subs,
+                                struct snd_usb_endpoint *ep,
+                                struct snd_info_buffer *buffer)
+{
+        if (!ep)
+                return;
+        snd_iprintf(buffer, "    Packet Size = %d\n", ep->curpacksize);
+        snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
+                    snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
+                    ? get_full_speed_hz(ep->freqm)
+                    : get_high_speed_hz(ep->freqm),
+                    ep->freqm >> 16, ep->freqm & 0xffff);
+        if (ep->freqshift != INT_MIN) {
+                int res = 16 - ep->freqshift;
+                snd_iprintf(buffer, "    Feedback Format = %d.%d\n",
+                            (ep->syncmaxsize > 3 ? 32 : 24) - res, res);
+        }
+}
 static void proc_dump_substream_status(struct snd_usb_substream *subs, struct snd_info_buffer *buffer)
 {
        if (subs->running) {
-                unsigned int i;
                snd_iprintf(buffer, "  Status: Running\n");
                snd_iprintf(buffer, "    Interface = %d\n", subs->interface);
                snd_iprintf(buffer, "    Altset = %d\n", subs->altset_idx);
-                snd_iprintf(buffer, "    URBs = %d [ ", subs->nurbs);
+                proc_dump_ep_status(subs, subs->data_endpoint, buffer);
-                for (i = 0; i < subs->nurbs; i++)
+                proc_dump_ep_status(subs, subs->sync_endpoint, buffer);
-                        snd_iprintf(buffer, "%d ", subs->dataurb[i].packets);
-                snd_iprintf(buffer, "]\n");
-                snd_iprintf(buffer, "    Packet Size = %d\n", subs->curpacksize);
-                snd_iprintf(buffer, "    Momentary freq = %u Hz (%#x.%04x)\n",
-                            snd_usb_get_speed(subs->dev) == USB_SPEED_FULL
-                            ? get_full_speed_hz(subs->freqm)
-                            : get_high_speed_hz(subs->freqm),
-                            subs->freqm >> 16, subs->freqm & 0xffff);
-                if (subs->freqshift != INT_MIN)
-                        snd_iprintf(buffer, "    Feedback Format = %d.%d\n",
-                                    (subs->syncmaxsize > 3 ? 32 : 24)
-                                                - (16 - subs->freqshift),
-                                    16 - subs->freqshift);
        } else {
                snd_iprintf(buffer, "  Status: Stop\n");
        }
diff --git a/sound/usb/stream.c b/sound/usb/stream.c
index 5ff8010b2d6f..6b7d7a2b7baa 100644
--- a/sound/usb/stream.c
+++ b/sound/usb/stream.c
@@ -73,6 +73,31 @@ static void snd_usb_audio_pcm_free(struct snd_pcm *pcm)
        }
 }
+/*
+ * initialize the substream instance.
+ */
+static void snd_usb_init_substream(struct snd_usb_stream *as,
+                                   int stream,
+                                   struct audioformat *fp)
+{
+        struct snd_usb_substream *subs = &as->substream[stream];
+        INIT_LIST_HEAD(&subs->fmt_list);
+        spin_lock_init(&subs->lock);
+        subs->stream = as;
+        subs->direction = stream;
+        subs->dev = as->chip->dev;
+        subs->txfr_quirk = as->chip->txfr_quirk;
+        snd_usb_set_pcm_ops(as->pcm, stream);
+        list_add_tail(&fp->list, &subs->fmt_list);
+        subs->formats |= fp->formats;
+        subs->num_formats++;
+        subs->fmt_type = fp->fmt_type;
+}
 /*
 * add this endpoint to the chip instance.
@@ -94,9 +119,9 @@ int snd_usb_add_audio_stream(struct snd_usb_audio *chip,
                if (as->fmt_type != fp->fmt_type)
                        continue;
                subs = &as->substream[stream];
-                if (!subs->endpoint)
+                if (!subs->data_endpoint)
                        continue;
-                if (subs->endpoint == fp->endpoint) {
+                if (subs->data_endpoint->ep_num == fp->endpoint) {
                        list_add_tail(&fp->list, &subs->fmt_list);
                        subs->num_formats++;
                        subs->formats |= fp->formats;
@@ -109,7 +134,7 @@ int snd_usb_add_audio_stream(struct snd_usb_audio *chip,
                if (as->fmt_type != fp->fmt_type)
                        continue;
                subs = &as->substream[stream];
-                if (subs->endpoint)
+                if (subs->data_endpoint)
                        continue;
                err = snd_pcm_new_stream(as->pcm, stream, 1);
                if (err < 0)
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index 3e2b03577936..b8233ebe250f 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -36,6 +36,7 @@ struct snd_usb_audio {
        struct snd_card *card;
        struct usb_interface *pm_intf;
        u32 usb_id;
+        struct mutex mutex;
        struct mutex shutdown_mutex;
        unsigned int shutdown:1;
        unsigned int probing:1;
@@ -46,6 +47,7 @@ struct snd_usb_audio {
        int num_suspended_intf;
        struct list_head pcm_list;      /* list of pcm streams */
+        struct list_head ep_list;       /* list of audio-related endpoints */
        int pcm_devs;
        struct list_head midi_list;     /* list of midi interfaces */
author	Takashi Iwai <tiwai@suse.de>	2012-05-21 06:51:35 -0400
committer	Takashi Iwai <tiwai@suse.de>	2012-05-21 06:51:35 -0400
commit	382e6a859e6622de0aa62c01976ae8ebd90e986d (patch)
tree	2501c554c231c5d0fcda7ff2e6e055bf23134d6f /sound
parent	6de15b2a9330aeb5df9b66545f67c6c6ad2c045a (diff)
parent	97f8d3b6503082416898f893a442a78f8819c42a (diff)