Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

21 files changed, 2903 insertions, 765 deletions

diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig
index 73525c048e7f..c570ae3e6d55 100644
--- a/sound/usb/Kconfig
+++ b/sound/usb/Kconfig
@@ -21,6 +21,18 @@ config SND_USB_AUDIO
           To compile this driver as a module, choose M here: the module
           will be called snd-usb-audio.
 
+config SND_USB_UA101
+        tristate "Edirol UA-101/UA-1000 driver (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        select SND_PCM
+        select SND_RAWMIDI
+        help
+          Say Y here to include support for the Edirol UA-101 and UA-1000
+          audio/MIDI interfaces.
+
+          To compile this driver as a module, choose M here: the module
+          will be called snd-ua101.
+
 config SND_USB_USX2Y
         tristate "Tascam US-122, US-224 and US-428 USB driver"
         depends on X86 || PPC || ALPHA
diff --git a/sound/usb/Makefile b/sound/usb/Makefile
index abb288bfe35d..5bf64aef9558 100644
--- a/sound/usb/Makefile
+++ b/sound/usb/Makefile
@@ -4,9 +4,11 @@
 
 snd-usb-audio-objs := usbaudio.o usbmixer.o
 snd-usb-lib-objs := usbmidi.o
+snd-ua101-objs := ua101.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_USB_AUDIO) += snd-usb-audio.o snd-usb-lib.o
+obj-$(CONFIG_SND_USB_UA101) += snd-ua101.o snd-usb-lib.o
 obj-$(CONFIG_SND_USB_USX2Y) += snd-usb-lib.o
 obj-$(CONFIG_SND_USB_US122L) += snd-usb-lib.o
 
diff --git a/sound/usb/caiaq/audio.c b/sound/usb/caiaq/audio.c
index 86b2c3b92df5..4328cad6c3a2 100644
--- a/sound/usb/caiaq/audio.c
+++ b/sound/usb/caiaq/audio.c
@@ -17,6 +17,7 @@
 */
 
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/usb.h>
 #include <sound/core.h>
diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c
index a3f02dd97440..afc5aeb68005 100644
--- a/sound/usb/caiaq/device.c
+++ b/sound/usb/caiaq/device.c
@@ -23,6 +23,7 @@
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/gfp.h>
 #include <linux/usb.h>
 #include <sound/initval.h>
 #include <sound/core.h>
diff --git a/sound/usb/caiaq/midi.c b/sound/usb/caiaq/midi.c
index 538e8c00d31a..2f218c77fff2 100644
--- a/sound/usb/caiaq/midi.c
+++ b/sound/usb/caiaq/midi.c
@@ -17,6 +17,7 @@
 */
 
 #include <linux/usb.h>
+#include <linux/gfp.h>
 #include <sound/rawmidi.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
diff --git a/sound/usb/caiaq/midi.h b/sound/usb/caiaq/midi.h
index 9d16db027fc3..380f984babc9 100644
--- a/sound/usb/caiaq/midi.h
+++ b/sound/usb/caiaq/midi.h
@@ -3,6 +3,6 @@
 
 int snd_usb_caiaq_midi_init(struct snd_usb_caiaqdev *dev);
 void snd_usb_caiaq_midi_handle_input(struct snd_usb_caiaqdev *dev, int port, const char *buf, int len);
-void snd_usb_caiaq_midi_output_done(struct urb* urb);
+void snd_usb_caiaq_midi_output_done(struct urb *urb);
 
 #endif /* CAIAQ_MIDI_H */
diff --git a/sound/usb/ua101.c b/sound/usb/ua101.c
new file mode 100644
index 000000000000..3d458d3b9962
--- /dev/null
+++ b/sound/usb/ua101.c
@@ -0,0 +1,1387 @@
+/*
+ * Edirol UA-101/UA-1000 driver
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ * This driver is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2.
+ *
+ * This driver is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this driver.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/audio.h>
+#include <sound/core.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include "usbaudio.h"
+
+MODULE_DESCRIPTION("Edirol UA-101/1000 driver");
+MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
+MODULE_LICENSE("GPL v2");
+MODULE_SUPPORTED_DEVICE("{{Edirol,UA-101},{Edirol,UA-1000}}");
+
+/*
+ * Should not be lower than the minimum scheduling delay of the host
+ * controller.  Some Intel controllers need more than one frame; as long as
+ * that driver doesn't tell us about this, use 1.5 frames just to be sure.
+ */
+#define MIN_QUEUE_LENGTH        12
+/* Somewhat random. */
+#define MAX_QUEUE_LENGTH        30
+/*
+ * This magic value optimizes memory usage efficiency for the UA-101's packet
+ * sizes at all sample rates, taking into account the stupid cache pool sizes
+ * that usb_buffer_alloc() uses.
+ */
+#define DEFAULT_QUEUE_LENGTH    21
+
+#define MAX_PACKET_SIZE         672 /* hardware specific */
+#define MAX_MEMORY_BUFFERS      DIV_ROUND_UP(MAX_QUEUE_LENGTH, \
+                                             PAGE_SIZE / MAX_PACKET_SIZE)
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+static unsigned int queue_length = 21;
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "card index");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "enable card");
+module_param(queue_length, uint, 0644);
+MODULE_PARM_DESC(queue_length, "USB queue length in microframes, "
+                 __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH));
+
+enum {
+        INTF_PLAYBACK,
+        INTF_CAPTURE,
+        INTF_MIDI,
+
+        INTF_COUNT
+};
+
+/* bits in struct ua101::states */
+enum {
+        USB_CAPTURE_RUNNING,
+        USB_PLAYBACK_RUNNING,
+        ALSA_CAPTURE_OPEN,
+        ALSA_PLAYBACK_OPEN,
+        ALSA_CAPTURE_RUNNING,
+        ALSA_PLAYBACK_RUNNING,
+        CAPTURE_URB_COMPLETED,
+        PLAYBACK_URB_COMPLETED,
+        DISCONNECTED,
+};
+
+struct ua101 {
+        struct usb_device *dev;
+        struct snd_card *card;
+        struct usb_interface *intf[INTF_COUNT];
+        int card_index;
+        struct snd_pcm *pcm;
+        struct list_head midi_list;
+        u64 format_bit;
+        unsigned int rate;
+        unsigned int packets_per_second;
+        spinlock_t lock;
+        struct mutex mutex;
+        unsigned long states;
+
+        /* FIFO to synchronize playback rate to capture rate */
+        unsigned int rate_feedback_start;
+        unsigned int rate_feedback_count;
+        u8 rate_feedback[MAX_QUEUE_LENGTH];
+
+        struct list_head ready_playback_urbs;
+        struct tasklet_struct playback_tasklet;
+        wait_queue_head_t alsa_capture_wait;
+        wait_queue_head_t rate_feedback_wait;
+        wait_queue_head_t alsa_playback_wait;
+        struct ua101_stream {
+                struct snd_pcm_substream *substream;
+                unsigned int usb_pipe;
+                unsigned int channels;
+                unsigned int frame_bytes;
+                unsigned int max_packet_bytes;
+                unsigned int period_pos;
+                unsigned int buffer_pos;
+                unsigned int queue_length;
+                struct ua101_urb {
+                        struct urb urb;
+                        struct usb_iso_packet_descriptor iso_frame_desc[1];
+                        struct list_head ready_list;
+                } *urbs[MAX_QUEUE_LENGTH];
+                struct {
+                        unsigned int size;
+                        void *addr;
+                        dma_addr_t dma;
+                } buffers[MAX_MEMORY_BUFFERS];
+        } capture, playback;
+};
+
+static DEFINE_MUTEX(devices_mutex);
+static unsigned int devices_used;
+static struct usb_driver ua101_driver;
+
+static void abort_alsa_playback(struct ua101 *ua);
+static void abort_alsa_capture(struct ua101 *ua);
+
+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";
+        }
+}
+
+static void abort_usb_capture(struct ua101 *ua)
+{
+        if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) {
+                wake_up(&ua->alsa_capture_wait);
+                wake_up(&ua->rate_feedback_wait);
+        }
+}
+
+static void abort_usb_playback(struct ua101 *ua)
+{
+        if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                wake_up(&ua->alsa_playback_wait);
+}
+
+static void playback_urb_complete(struct urb *usb_urb)
+{
+        struct ua101_urb *urb = (struct ua101_urb *)usb_urb;
+        struct ua101 *ua = urb->urb.context;
+        unsigned long flags;
+
+        if (unlikely(urb->urb.status == -ENOENT ||      /* unlinked */
+                     urb->urb.status == -ENODEV ||      /* device removed */
+                     urb->urb.status == -ECONNRESET ||  /* unlinked */
+                     urb->urb.status == -ESHUTDOWN)) {  /* device disabled */
+                abort_usb_playback(ua);
+                abort_alsa_playback(ua);
+                return;
+        }
+
+        if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) {
+                /* append URB to FIFO */
+                spin_lock_irqsave(&ua->lock, flags);
+                list_add_tail(&urb->ready_list, &ua->ready_playback_urbs);
+                if (ua->rate_feedback_count > 0)
+                        tasklet_schedule(&ua->playback_tasklet);
+                ua->playback.substream->runtime->delay -=
+                                urb->urb.iso_frame_desc[0].length /
+                                                ua->playback.frame_bytes;
+                spin_unlock_irqrestore(&ua->lock, flags);
+        }
+}
+
+static void first_playback_urb_complete(struct urb *urb)
+{
+        struct ua101 *ua = urb->context;
+
+        urb->complete = playback_urb_complete;
+        playback_urb_complete(urb);
+
+        set_bit(PLAYBACK_URB_COMPLETED, &ua->states);
+        wake_up(&ua->alsa_playback_wait);
+}
+
+/* copy data from the ALSA ring buffer into the URB buffer */
+static bool copy_playback_data(struct ua101_stream *stream, struct urb *urb,
+                               unsigned int frames)
+{
+        struct snd_pcm_runtime *runtime;
+        unsigned int frame_bytes, frames1;
+        const u8 *source;
+
+        runtime = stream->substream->runtime;
+        frame_bytes = stream->frame_bytes;
+        source = runtime->dma_area + stream->buffer_pos * frame_bytes;
+        if (stream->buffer_pos + frames <= runtime->buffer_size) {
+                memcpy(urb->transfer_buffer, source, frames * frame_bytes);
+        } else {
+                /* wrap around at end of ring buffer */
+                frames1 = runtime->buffer_size - stream->buffer_pos;
+                memcpy(urb->transfer_buffer, source, frames1 * frame_bytes);
+                memcpy(urb->transfer_buffer + frames1 * frame_bytes,
+                       runtime->dma_area, (frames - frames1) * frame_bytes);
+        }
+
+        stream->buffer_pos += frames;
+        if (stream->buffer_pos >= runtime->buffer_size)
+                stream->buffer_pos -= runtime->buffer_size;
+        stream->period_pos += frames;
+        if (stream->period_pos >= runtime->period_size) {
+                stream->period_pos -= runtime->period_size;
+                return true;
+        }
+        return false;
+}
+
+static inline void add_with_wraparound(struct ua101 *ua,
+                                       unsigned int *value, unsigned int add)
+{
+        *value += add;
+        if (*value >= ua->playback.queue_length)
+                *value -= ua->playback.queue_length;
+}
+
+static void playback_tasklet(unsigned long data)
+{
+        struct ua101 *ua = (void *)data;
+        unsigned long flags;
+        unsigned int frames;
+        struct ua101_urb *urb;
+        bool do_period_elapsed = false;
+        int err;
+
+        if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states)))
+                return;
+
+        /*
+         * Synchronizing the playback rate to the capture rate is done by using
+         * the same sequence of packet sizes for both streams.
+         * Submitting a playback URB therefore requires both a ready URB and
+         * the size of the corresponding capture packet, i.e., both playback
+         * and capture URBs must have been completed.  Since the USB core does
+         * not guarantee that playback and capture complete callbacks are
+         * called alternately, we use two FIFOs for packet sizes and read URBs;
+         * submitting playback URBs is possible as long as both FIFOs are
+         * nonempty.
+         */
+        spin_lock_irqsave(&ua->lock, flags);
+        while (ua->rate_feedback_count > 0 &&
+               !list_empty(&ua->ready_playback_urbs)) {
+                /* take packet size out of FIFO */
+                frames = ua->rate_feedback[ua->rate_feedback_start];
+                add_with_wraparound(ua, &ua->rate_feedback_start, 1);
+                ua->rate_feedback_count--;
+
+                /* take URB out of FIFO */
+                urb = list_first_entry(&ua->ready_playback_urbs,
+                                       struct ua101_urb, ready_list);
+                list_del(&urb->ready_list);
+
+                /* fill packet with data or silence */
+                urb->urb.iso_frame_desc[0].length =
+                        frames * ua->playback.frame_bytes;
+                if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
+                        do_period_elapsed |= copy_playback_data(&ua->playback,
+                                                                &urb->urb,
+                                                                frames);
+                else
+                        memset(urb->urb.transfer_buffer, 0,
+                               urb->urb.iso_frame_desc[0].length);
+
+                /* and off you go ... */
+                err = usb_submit_urb(&urb->urb, GFP_ATOMIC);
+                if (unlikely(err < 0)) {
+                        spin_unlock_irqrestore(&ua->lock, flags);
+                        abort_usb_playback(ua);
+                        abort_alsa_playback(ua);
+                        dev_err(&ua->dev->dev, "USB request error %d: %s\n",
+                                err, usb_error_string(err));
+                        return;
+                }
+                ua->playback.substream->runtime->delay += frames;
+        }
+        spin_unlock_irqrestore(&ua->lock, flags);
+        if (do_period_elapsed)
+                snd_pcm_period_elapsed(ua->playback.substream);
+}
+
+/* copy data from the URB buffer into the ALSA ring buffer */
+static bool copy_capture_data(struct ua101_stream *stream, struct urb *urb,
+                              unsigned int frames)
+{
+        struct snd_pcm_runtime *runtime;
+        unsigned int frame_bytes, frames1;
+        u8 *dest;
+
+        runtime = stream->substream->runtime;
+        frame_bytes = stream->frame_bytes;
+        dest = runtime->dma_area + stream->buffer_pos * frame_bytes;
+        if (stream->buffer_pos + frames <= runtime->buffer_size) {
+                memcpy(dest, urb->transfer_buffer, frames * frame_bytes);
+        } else {
+                /* wrap around at end of ring buffer */
+                frames1 = runtime->buffer_size - stream->buffer_pos;
+                memcpy(dest, urb->transfer_buffer, frames1 * frame_bytes);
+                memcpy(runtime->dma_area,
+                       urb->transfer_buffer + frames1 * frame_bytes,
+                       (frames - frames1) * frame_bytes);
+        }
+
+        stream->buffer_pos += frames;
+        if (stream->buffer_pos >= runtime->buffer_size)
+                stream->buffer_pos -= runtime->buffer_size;
+        stream->period_pos += frames;
+        if (stream->period_pos >= runtime->period_size) {
+                stream->period_pos -= runtime->period_size;
+                return true;
+        }
+        return false;
+}
+
+static void capture_urb_complete(struct urb *urb)
+{
+        struct ua101 *ua = urb->context;
+        struct ua101_stream *stream = &ua->capture;
+        unsigned long flags;
+        unsigned int frames, write_ptr;
+        bool do_period_elapsed;
+        int err;
+
+        if (unlikely(urb->status == -ENOENT ||          /* unlinked */
+                     urb->status == -ENODEV ||          /* device removed */
+                     urb->status == -ECONNRESET ||      /* unlinked */
+                     urb->status == -ESHUTDOWN))        /* device disabled */
+                goto stream_stopped;
+
+        if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0)
+                frames = urb->iso_frame_desc[0].actual_length /
+                        stream->frame_bytes;
+        else
+                frames = 0;
+
+        spin_lock_irqsave(&ua->lock, flags);
+
+        if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
+                do_period_elapsed = copy_capture_data(stream, urb, frames);
+        else
+                do_period_elapsed = false;
+
+        if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (unlikely(err < 0)) {
+                        spin_unlock_irqrestore(&ua->lock, flags);
+                        dev_err(&ua->dev->dev, "USB request error %d: %s\n",
+                                err, usb_error_string(err));
+                        goto stream_stopped;
+                }
+
+                /* append packet size to FIFO */
+                write_ptr = ua->rate_feedback_start;
+                add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count);
+                ua->rate_feedback[write_ptr] = frames;
+                if (ua->rate_feedback_count < ua->playback.queue_length) {
+                        ua->rate_feedback_count++;
+                        if (ua->rate_feedback_count ==
+                                                ua->playback.queue_length)
+                                wake_up(&ua->rate_feedback_wait);
+                } else {
+                        /*
+                         * Ring buffer overflow; this happens when the playback
+                         * stream is not running.  Throw away the oldest entry,
+                         * so that the playback stream, when it starts, sees
+                         * the most recent packet sizes.
+                         */
+                        add_with_wraparound(ua, &ua->rate_feedback_start, 1);
+                }
+                if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) &&
+                    !list_empty(&ua->ready_playback_urbs))
+                        tasklet_schedule(&ua->playback_tasklet);
+        }
+
+        spin_unlock_irqrestore(&ua->lock, flags);
+
+        if (do_period_elapsed)
+                snd_pcm_period_elapsed(stream->substream);
+
+        return;
+
+stream_stopped:
+        abort_usb_playback(ua);
+        abort_usb_capture(ua);
+        abort_alsa_playback(ua);
+        abort_alsa_capture(ua);
+}
+
+static void first_capture_urb_complete(struct urb *urb)
+{
+        struct ua101 *ua = urb->context;
+
+        urb->complete = capture_urb_complete;
+        capture_urb_complete(urb);
+
+        set_bit(CAPTURE_URB_COMPLETED, &ua->states);
+        wake_up(&ua->alsa_capture_wait);
+}
+
+static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < stream->queue_length; ++i) {
+                int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL);
+                if (err < 0) {
+                        dev_err(&ua->dev->dev, "USB request error %d: %s\n",
+                                err, usb_error_string(err));
+                        return err;
+                }
+        }
+        return 0;
+}
+
+static void kill_stream_urbs(struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < stream->queue_length; ++i)
+                usb_kill_urb(&stream->urbs[i]->urb);
+}
+
+static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index)
+{
+        struct usb_host_interface *alts;
+
+        alts = ua->intf[intf_index]->cur_altsetting;
+        if (alts->desc.bAlternateSetting != 1) {
+                int err = usb_set_interface(ua->dev,
+                                            alts->desc.bInterfaceNumber, 1);
+                if (err < 0) {
+                        dev_err(&ua->dev->dev,
+                                "cannot initialize interface; error %d: %s\n",
+                                err, usb_error_string(err));
+                        return err;
+                }
+        }
+        return 0;
+}
+
+static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index)
+{
+        struct usb_host_interface *alts;
+
+        alts = ua->intf[intf_index]->cur_altsetting;
+        if (alts->desc.bAlternateSetting != 0) {
+                int err = usb_set_interface(ua->dev,
+                                            alts->desc.bInterfaceNumber, 0);
+                if (err < 0 && !test_bit(DISCONNECTED, &ua->states))
+                        dev_warn(&ua->dev->dev,
+                                 "interface reset failed; error %d: %s\n",
+                                 err, usb_error_string(err));
+        }
+}
+
+static void stop_usb_capture(struct ua101 *ua)
+{
+        clear_bit(USB_CAPTURE_RUNNING, &ua->states);
+
+        kill_stream_urbs(&ua->capture);
+
+        disable_iso_interface(ua, INTF_CAPTURE);
+}
+
+static int start_usb_capture(struct ua101 *ua)
+{
+        int err;
+
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+
+        if (test_bit(USB_CAPTURE_RUNNING, &ua->states))
+                return 0;
+
+        kill_stream_urbs(&ua->capture);
+
+        err = enable_iso_interface(ua, INTF_CAPTURE);
+        if (err < 0)
+                return err;
+
+        clear_bit(CAPTURE_URB_COMPLETED, &ua->states);
+        ua->capture.urbs[0]->urb.complete = first_capture_urb_complete;
+        ua->rate_feedback_start = 0;
+        ua->rate_feedback_count = 0;
+
+        set_bit(USB_CAPTURE_RUNNING, &ua->states);
+        err = submit_stream_urbs(ua, &ua->capture);
+        if (err < 0)
+                stop_usb_capture(ua);
+        return err;
+}
+
+static void stop_usb_playback(struct ua101 *ua)
+{
+        clear_bit(USB_PLAYBACK_RUNNING, &ua->states);
+
+        kill_stream_urbs(&ua->playback);
+
+        tasklet_kill(&ua->playback_tasklet);
+
+        disable_iso_interface(ua, INTF_PLAYBACK);
+}
+
+static int start_usb_playback(struct ua101 *ua)
+{
+        unsigned int i, frames;
+        struct urb *urb;
+        int err = 0;
+
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+
+        if (test_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                return 0;
+
+        kill_stream_urbs(&ua->playback);
+        tasklet_kill(&ua->playback_tasklet);
+
+        err = enable_iso_interface(ua, INTF_PLAYBACK);
+        if (err < 0)
+                return err;
+
+        clear_bit(PLAYBACK_URB_COMPLETED, &ua->states);
+        ua->playback.urbs[0]->urb.complete =
+                first_playback_urb_complete;
+        spin_lock_irq(&ua->lock);
+        INIT_LIST_HEAD(&ua->ready_playback_urbs);
+        spin_unlock_irq(&ua->lock);
+
+        /*
+         * We submit the initial URBs all at once, so we have to wait for the
+         * packet size FIFO to be full.
+         */
+        wait_event(ua->rate_feedback_wait,
+                   ua->rate_feedback_count >= ua->playback.queue_length ||
+                   !test_bit(USB_CAPTURE_RUNNING, &ua->states) ||
+                   test_bit(DISCONNECTED, &ua->states));
+        if (test_bit(DISCONNECTED, &ua->states)) {
+                stop_usb_playback(ua);
+                return -ENODEV;
+        }
+        if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) {
+                stop_usb_playback(ua);
+                return -EIO;
+        }
+
+        for (i = 0; i < ua->playback.queue_length; ++i) {
+                /* all initial URBs contain silence */
+                spin_lock_irq(&ua->lock);
+                frames = ua->rate_feedback[ua->rate_feedback_start];
+                add_with_wraparound(ua, &ua->rate_feedback_start, 1);
+                ua->rate_feedback_count--;
+                spin_unlock_irq(&ua->lock);
+                urb = &ua->playback.urbs[i]->urb;
+                urb->iso_frame_desc[0].length =
+                        frames * ua->playback.frame_bytes;
+                memset(urb->transfer_buffer, 0,
+                       urb->iso_frame_desc[0].length);
+        }
+
+        set_bit(USB_PLAYBACK_RUNNING, &ua->states);
+        err = submit_stream_urbs(ua, &ua->playback);
+        if (err < 0)
+                stop_usb_playback(ua);
+        return err;
+}
+
+static void abort_alsa_capture(struct ua101 *ua)
+{
+        if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states))
+                snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN);
+}
+
+static void abort_alsa_playback(struct ua101 *ua)
+{
+        if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states))
+                snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN);
+}
+
+static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream,
+                         unsigned int channels)
+{
+        int err;
+
+        substream->runtime->hw.info =
+                SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_BATCH |
+                SNDRV_PCM_INFO_INTERLEAVED |
+                SNDRV_PCM_INFO_BLOCK_TRANSFER |
+                SNDRV_PCM_INFO_FIFO_IN_FRAMES;
+        substream->runtime->hw.formats = ua->format_bit;
+        substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate);
+        substream->runtime->hw.rate_min = ua->rate;
+        substream->runtime->hw.rate_max = ua->rate;
+        substream->runtime->hw.channels_min = channels;
+        substream->runtime->hw.channels_max = channels;
+        substream->runtime->hw.buffer_bytes_max = 45000 * 1024;
+        substream->runtime->hw.period_bytes_min = 1;
+        substream->runtime->hw.period_bytes_max = UINT_MAX;
+        substream->runtime->hw.periods_min = 2;
+        substream->runtime->hw.periods_max = UINT_MAX;
+        err = snd_pcm_hw_constraint_minmax(substream->runtime,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+                                           1500000 / ua->packets_per_second,
+                                           8192000);
+        if (err < 0)
+                return err;
+        err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24);
+        return err;
+}
+
+static int capture_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        ua->capture.substream = substream;
+        err = set_stream_hw(ua, substream, ua->capture.channels);
+        if (err < 0)
+                return err;
+        substream->runtime->hw.fifo_size =
+                DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second);
+        substream->runtime->delay = substream->runtime->hw.fifo_size;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err >= 0)
+                set_bit(ALSA_CAPTURE_OPEN, &ua->states);
+        mutex_unlock(&ua->mutex);
+        return err;
+}
+
+static int playback_pcm_open(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        ua->playback.substream = substream;
+        err = set_stream_hw(ua, substream, ua->playback.channels);
+        if (err < 0)
+                return err;
+        substream->runtime->hw.fifo_size =
+                DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length,
+                                  ua->packets_per_second);
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err < 0)
+                goto error;
+        err = start_usb_playback(ua);
+        if (err < 0) {
+                if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
+                        stop_usb_capture(ua);
+                goto error;
+        }
+        set_bit(ALSA_PLAYBACK_OPEN, &ua->states);
+error:
+        mutex_unlock(&ua->mutex);
+        return err;
+}
+
+static int capture_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+
+        mutex_lock(&ua->mutex);
+        clear_bit(ALSA_CAPTURE_OPEN, &ua->states);
+        if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states))
+                stop_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        return 0;
+}
+
+static int playback_pcm_close(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+
+        mutex_lock(&ua->mutex);
+        stop_usb_playback(ua);
+        clear_bit(ALSA_PLAYBACK_OPEN, &ua->states);
+        if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states))
+                stop_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        return 0;
+}
+
+static int capture_pcm_hw_params(struct snd_pcm_substream *substream,
+                                 struct snd_pcm_hw_params *hw_params)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        return snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                                params_buffer_bytes(hw_params));
+}
+
+static int playback_pcm_hw_params(struct snd_pcm_substream *substream,
+                                  struct snd_pcm_hw_params *hw_params)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err >= 0)
+                err = start_usb_playback(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        return snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                                params_buffer_bytes(hw_params));
+}
+
+static int ua101_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+        return snd_pcm_lib_free_vmalloc_buffer(substream);
+}
+
+static int capture_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        /*
+         * The EHCI driver schedules the first packet of an iso stream at 10 ms
+         * in the future, i.e., no data is actually captured for that long.
+         * Take the wait here so that the stream is known to be actually
+         * running when the start trigger has been called.
+         */
+        wait_event(ua->alsa_capture_wait,
+                   test_bit(CAPTURE_URB_COMPLETED, &ua->states) ||
+                   !test_bit(USB_CAPTURE_RUNNING, &ua->states));
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+        if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
+                return -EIO;
+
+        ua->capture.period_pos = 0;
+        ua->capture.buffer_pos = 0;
+        return 0;
+}
+
+static int playback_pcm_prepare(struct snd_pcm_substream *substream)
+{
+        struct ua101 *ua = substream->private_data;
+        int err;
+
+        mutex_lock(&ua->mutex);
+        err = start_usb_capture(ua);
+        if (err >= 0)
+                err = start_usb_playback(ua);
+        mutex_unlock(&ua->mutex);
+        if (err < 0)
+                return err;
+
+        /* see the comment in capture_pcm_prepare() */
+        wait_event(ua->alsa_playback_wait,
+                   test_bit(PLAYBACK_URB_COMPLETED, &ua->states) ||
+                   !test_bit(USB_PLAYBACK_RUNNING, &ua->states));
+        if (test_bit(DISCONNECTED, &ua->states))
+                return -ENODEV;
+        if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                return -EIO;
+
+        substream->runtime->delay = 0;
+        ua->playback.period_pos = 0;
+        ua->playback.buffer_pos = 0;
+        return 0;
+}
+
+static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct ua101 *ua = substream->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                if (!test_bit(USB_CAPTURE_RUNNING, &ua->states))
+                        return -EIO;
+                set_bit(ALSA_CAPTURE_RUNNING, &ua->states);
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                clear_bit(ALSA_CAPTURE_RUNNING, &ua->states);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+        struct ua101 *ua = substream->private_data;
+
+        switch (cmd) {
+        case SNDRV_PCM_TRIGGER_START:
+                if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states))
+                        return -EIO;
+                set_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
+                return 0;
+        case SNDRV_PCM_TRIGGER_STOP:
+                clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states);
+                return 0;
+        default:
+                return -EINVAL;
+        }
+}
+
+static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua,
+                                                  struct ua101_stream *stream)
+{
+        unsigned long flags;
+        unsigned int pos;
+
+        spin_lock_irqsave(&ua->lock, flags);
+        pos = stream->buffer_pos;
+        spin_unlock_irqrestore(&ua->lock, flags);
+        return pos;
+}
+
+static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs)
+{
+        struct ua101 *ua = subs->private_data;
+
+        return ua101_pcm_pointer(ua, &ua->capture);
+}
+
+static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs)
+{
+        struct ua101 *ua = subs->private_data;
+
+        return ua101_pcm_pointer(ua, &ua->playback);
+}
+
+static struct snd_pcm_ops capture_pcm_ops = {
+        .open = capture_pcm_open,
+        .close = capture_pcm_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = capture_pcm_hw_params,
+        .hw_free = ua101_pcm_hw_free,
+        .prepare = capture_pcm_prepare,
+        .trigger = capture_pcm_trigger,
+        .pointer = capture_pcm_pointer,
+        .page = snd_pcm_lib_get_vmalloc_page,
+        .mmap = snd_pcm_lib_mmap_vmalloc,
+};
+
+static struct snd_pcm_ops playback_pcm_ops = {
+        .open = playback_pcm_open,
+        .close = playback_pcm_close,
+        .ioctl = snd_pcm_lib_ioctl,
+        .hw_params = playback_pcm_hw_params,
+        .hw_free = ua101_pcm_hw_free,
+        .prepare = playback_pcm_prepare,
+        .trigger = playback_pcm_trigger,
+        .pointer = playback_pcm_pointer,
+        .page = snd_pcm_lib_get_vmalloc_page,
+        .mmap = snd_pcm_lib_mmap_vmalloc,
+};
+
+static const struct uac_format_type_i_discrete_descriptor *
+find_format_descriptor(struct usb_interface *interface)
+{
+        struct usb_host_interface *alt;
+        u8 *extra;
+        int extralen;
+
+        if (interface->num_altsetting != 2) {
+                dev_err(&interface->dev, "invalid num_altsetting\n");
+                return NULL;
+        }
+
+        alt = &interface->altsetting[0];
+        if (alt->desc.bNumEndpoints != 0) {
+                dev_err(&interface->dev, "invalid bNumEndpoints\n");
+                return NULL;
+        }
+
+        alt = &interface->altsetting[1];
+        if (alt->desc.bNumEndpoints != 1) {
+                dev_err(&interface->dev, "invalid bNumEndpoints\n");
+                return NULL;
+        }
+
+        extra = alt->extra;
+        extralen = alt->extralen;
+        while (extralen >= sizeof(struct usb_descriptor_header)) {
+                struct uac_format_type_i_discrete_descriptor *desc;
+
+                desc = (struct uac_format_type_i_discrete_descriptor *)extra;
+                if (desc->bLength > extralen) {
+                        dev_err(&interface->dev, "descriptor overflow\n");
+                        return NULL;
+                }
+                if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) &&
+                    desc->bDescriptorType == USB_DT_CS_INTERFACE &&
+                    desc->bDescriptorSubtype == UAC_FORMAT_TYPE) {
+                        if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM ||
+                            desc->bSamFreqType != 1) {
+                                dev_err(&interface->dev,
+                                        "invalid format type\n");
+                                return NULL;
+                        }
+                        return desc;
+                }
+                extralen -= desc->bLength;
+                extra += desc->bLength;
+        }
+        dev_err(&interface->dev, "sample format descriptor not found\n");
+        return NULL;
+}
+
+static int detect_usb_format(struct ua101 *ua)
+{
+        const struct uac_format_type_i_discrete_descriptor *fmt_capture;
+        const struct uac_format_type_i_discrete_descriptor *fmt_playback;
+        const struct usb_endpoint_descriptor *epd;
+        unsigned int rate2;
+
+        fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]);
+        fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]);
+        if (!fmt_capture || !fmt_playback)
+                return -ENXIO;
+
+        switch (fmt_capture->bSubframeSize) {
+        case 3:
+                ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE;
+                break;
+        case 4:
+                ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE;
+                break;
+        default:
+                dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n");
+                return -ENXIO;
+        }
+        if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) {
+                dev_err(&ua->dev->dev,
+                        "playback/capture sample widths do not match\n");
+                return -ENXIO;
+        }
+
+        if (fmt_capture->bBitResolution != 24 ||
+            fmt_playback->bBitResolution != 24) {
+                dev_err(&ua->dev->dev, "sample width is not 24 bits\n");
+                return -ENXIO;
+        }
+
+        ua->rate = combine_triple(fmt_capture->tSamFreq[0]);
+        rate2 = combine_triple(fmt_playback->tSamFreq[0]);
+        if (ua->rate != rate2) {
+                dev_err(&ua->dev->dev,
+                        "playback/capture rates do not match: %u/%u\n",
+                        rate2, ua->rate);
+                return -ENXIO;
+        }
+
+        switch (ua->dev->speed) {
+        case USB_SPEED_FULL:
+                ua->packets_per_second = 1000;
+                break;
+        case USB_SPEED_HIGH:
+                ua->packets_per_second = 8000;
+                break;
+        default:
+                dev_err(&ua->dev->dev, "unknown device speed\n");
+                return -ENXIO;
+        }
+
+        ua->capture.channels = fmt_capture->bNrChannels;
+        ua->playback.channels = fmt_playback->bNrChannels;
+        ua->capture.frame_bytes =
+                fmt_capture->bSubframeSize * ua->capture.channels;
+        ua->playback.frame_bytes =
+                fmt_playback->bSubframeSize * ua->playback.channels;
+
+        epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc;
+        if (!usb_endpoint_is_isoc_in(epd)) {
+                dev_err(&ua->dev->dev, "invalid capture endpoint\n");
+                return -ENXIO;
+        }
+        ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd));
+        ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
+
+        epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc;
+        if (!usb_endpoint_is_isoc_out(epd)) {
+                dev_err(&ua->dev->dev, "invalid playback endpoint\n");
+                return -ENXIO;
+        }
+        ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd));
+        ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize);
+        return 0;
+}
+
+static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
+{
+        unsigned int remaining_packets, packets, packets_per_page, i;
+        size_t size;
+
+        stream->queue_length = queue_length;
+        stream->queue_length = max(stream->queue_length,
+                                   (unsigned int)MIN_QUEUE_LENGTH);
+        stream->queue_length = min(stream->queue_length,
+                                   (unsigned int)MAX_QUEUE_LENGTH);
+
+        /*
+         * The cache pool sizes used by usb_buffer_alloc() (128, 512, 2048) are
+         * quite bad when used with the packet sizes of this device (e.g. 280,
+         * 520, 624).  Therefore, we allocate and subdivide entire pages, using
+         * a smaller buffer only for the last chunk.
+         */
+        remaining_packets = stream->queue_length;
+        packets_per_page = PAGE_SIZE / stream->max_packet_bytes;
+        for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) {
+                packets = min(remaining_packets, packets_per_page);
+                size = packets * stream->max_packet_bytes;
+                stream->buffers[i].addr =
+                        usb_buffer_alloc(ua->dev, size, GFP_KERNEL,
+                                         &stream->buffers[i].dma);
+                if (!stream->buffers[i].addr)
+                        return -ENOMEM;
+                stream->buffers[i].size = size;
+                remaining_packets -= packets;
+                if (!remaining_packets)
+                        break;
+        }
+        if (remaining_packets) {
+                dev_err(&ua->dev->dev, "too many packets\n");
+                return -ENXIO;
+        }
+        return 0;
+}
+
+static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i)
+                usb_buffer_free(ua->dev,
+                                stream->buffers[i].size,
+                                stream->buffers[i].addr,
+                                stream->buffers[i].dma);
+}
+
+static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream,
+                             void (*urb_complete)(struct urb *))
+{
+        unsigned max_packet_size = stream->max_packet_bytes;
+        struct ua101_urb *urb;
+        unsigned int b, u = 0;
+
+        for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) {
+                unsigned int size = stream->buffers[b].size;
+                u8 *addr = stream->buffers[b].addr;
+                dma_addr_t dma = stream->buffers[b].dma;
+
+                while (size >= max_packet_size) {
+                        if (u >= stream->queue_length)
+                                goto bufsize_error;
+                        urb = kmalloc(sizeof(*urb), GFP_KERNEL);
+                        if (!urb)
+                                return -ENOMEM;
+                        usb_init_urb(&urb->urb);
+                        urb->urb.dev = ua->dev;
+                        urb->urb.pipe = stream->usb_pipe;
+                        urb->urb.transfer_flags = URB_ISO_ASAP |
+                                        URB_NO_TRANSFER_DMA_MAP;
+                        urb->urb.transfer_buffer = addr;
+                        urb->urb.transfer_dma = dma;
+                        urb->urb.transfer_buffer_length = max_packet_size;
+                        urb->urb.number_of_packets = 1;
+                        urb->urb.interval = 1;
+                        urb->urb.context = ua;
+                        urb->urb.complete = urb_complete;
+                        urb->urb.iso_frame_desc[0].offset = 0;
+                        urb->urb.iso_frame_desc[0].length = max_packet_size;
+                        stream->urbs[u++] = urb;
+                        size -= max_packet_size;
+                        addr += max_packet_size;
+                        dma += max_packet_size;
+                }
+        }
+        if (u == stream->queue_length)
+                return 0;
+bufsize_error:
+        dev_err(&ua->dev->dev, "internal buffer size error\n");
+        return -ENXIO;
+}
+
+static void free_stream_urbs(struct ua101_stream *stream)
+{
+        unsigned int i;
+
+        for (i = 0; i < stream->queue_length; ++i)
+                kfree(stream->urbs[i]);
+}
+
+static void free_usb_related_resources(struct ua101 *ua,
+                                       struct usb_interface *interface)
+{
+        unsigned int i;
+
+        free_stream_urbs(&ua->capture);
+        free_stream_urbs(&ua->playback);
+        free_stream_buffers(ua, &ua->capture);
+        free_stream_buffers(ua, &ua->playback);
+
+        for (i = 0; i < ARRAY_SIZE(ua->intf); ++i)
+                if (ua->intf[i]) {
+                        usb_set_intfdata(ua->intf[i], NULL);
+                        if (ua->intf[i] != interface)
+                                usb_driver_release_interface(&ua101_driver,
+                                                             ua->intf[i]);
+                }
+}
+
+static void ua101_card_free(struct snd_card *card)
+{
+        struct ua101 *ua = card->private_data;
+
+        mutex_destroy(&ua->mutex);
+}
+
+static int ua101_probe(struct usb_interface *interface,
+                       const struct usb_device_id *usb_id)
+{
+        static const struct snd_usb_midi_endpoint_info midi_ep = {
+                .out_cables = 0x0001,
+                .in_cables = 0x0001
+        };
+        static const struct snd_usb_audio_quirk midi_quirk = {
+                .type = QUIRK_MIDI_FIXED_ENDPOINT,
+                .data = &midi_ep
+        };
+        static const int intf_numbers[2][3] = {
+                {       /* UA-101 */
+                        [INTF_PLAYBACK] = 0,
+                        [INTF_CAPTURE] = 1,
+                        [INTF_MIDI] = 2,
+                },
+                {       /* UA-1000 */
+                        [INTF_CAPTURE] = 1,
+                        [INTF_PLAYBACK] = 2,
+                        [INTF_MIDI] = 3,
+                },
+        };
+        struct snd_card *card;
+        struct ua101 *ua;
+        unsigned int card_index, i;
+        int is_ua1000;
+        const char *name;
+        char usb_path[32];
+        int err;
+
+        is_ua1000 = usb_id->idProduct == 0x0044;
+
+        if (interface->altsetting->desc.bInterfaceNumber !=
+            intf_numbers[is_ua1000][0])
+                return -ENODEV;
+
+        mutex_lock(&devices_mutex);
+
+        for (card_index = 0; card_index < SNDRV_CARDS; ++card_index)
+                if (enable[card_index] && !(devices_used & (1 << card_index)))
+                        break;
+        if (card_index >= SNDRV_CARDS) {
+                mutex_unlock(&devices_mutex);
+                return -ENOENT;
+        }
+        err = snd_card_create(index[card_index], id[card_index], THIS_MODULE,
+                              sizeof(*ua), &card);
+        if (err < 0) {
+                mutex_unlock(&devices_mutex);
+                return err;
+        }
+        card->private_free = ua101_card_free;
+        ua = card->private_data;
+        ua->dev = interface_to_usbdev(interface);
+        ua->card = card;
+        ua->card_index = card_index;
+        INIT_LIST_HEAD(&ua->midi_list);
+        spin_lock_init(&ua->lock);
+        mutex_init(&ua->mutex);
+        INIT_LIST_HEAD(&ua->ready_playback_urbs);
+        tasklet_init(&ua->playback_tasklet,
+                     playback_tasklet, (unsigned long)ua);
+        init_waitqueue_head(&ua->alsa_capture_wait);
+        init_waitqueue_head(&ua->rate_feedback_wait);
+        init_waitqueue_head(&ua->alsa_playback_wait);
+
+        ua->intf[0] = interface;
+        for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) {
+                ua->intf[i] = usb_ifnum_to_if(ua->dev,
+                                              intf_numbers[is_ua1000][i]);
+                if (!ua->intf[i]) {
+                        dev_err(&ua->dev->dev, "interface %u not found\n",
+                                intf_numbers[is_ua1000][i]);
+                        err = -ENXIO;
+                        goto probe_error;
+                }
+                err = usb_driver_claim_interface(&ua101_driver,
+                                                 ua->intf[i], ua);
+                if (err < 0) {
+                        ua->intf[i] = NULL;
+                        err = -EBUSY;
+                        goto probe_error;
+                }
+        }
+
+        snd_card_set_dev(card, &interface->dev);
+
+        err = detect_usb_format(ua);
+        if (err < 0)
+                goto probe_error;
+
+        name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101";
+        strcpy(card->driver, "UA-101");
+        strcpy(card->shortname, name);
+        usb_make_path(ua->dev, usb_path, sizeof(usb_path));
+        snprintf(ua->card->longname, sizeof(ua->card->longname),
+                 "EDIROL %s (serial %s), %u Hz at %s, %s speed", name,
+                 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path,
+                 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full");
+
+        err = alloc_stream_buffers(ua, &ua->capture);
+        if (err < 0)
+                goto probe_error;
+        err = alloc_stream_buffers(ua, &ua->playback);
+        if (err < 0)
+                goto probe_error;
+
+        err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete);
+        if (err < 0)
+                goto probe_error;
+        err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete);
+        if (err < 0)
+                goto probe_error;
+
+        err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm);
+        if (err < 0)
+                goto probe_error;
+        ua->pcm->private_data = ua;
+        strcpy(ua->pcm->name, name);
+        snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops);
+        snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops);
+
+        err = snd_usbmidi_create(card, ua->intf[INTF_MIDI],
+                                 &ua->midi_list, &midi_quirk);
+        if (err < 0)
+                goto probe_error;
+
+        err = snd_card_register(card);
+        if (err < 0)
+                goto probe_error;
+
+        usb_set_intfdata(interface, ua);
+        devices_used |= 1 << card_index;
+
+        mutex_unlock(&devices_mutex);
+        return 0;
+
+probe_error:
+        free_usb_related_resources(ua, interface);
+        snd_card_free(card);
+        mutex_unlock(&devices_mutex);
+        return err;
+}
+
+static void ua101_disconnect(struct usb_interface *interface)
+{
+        struct ua101 *ua = usb_get_intfdata(interface);
+        struct list_head *midi;
+
+        if (!ua)
+                return;
+
+        mutex_lock(&devices_mutex);
+
+        set_bit(DISCONNECTED, &ua->states);
+        wake_up(&ua->rate_feedback_wait);
+
+        /* make sure that userspace cannot create new requests */
+        snd_card_disconnect(ua->card);
+
+        /* make sure that there are no pending USB requests */
+        __list_for_each(midi, &ua->midi_list)
+                snd_usbmidi_disconnect(midi);
+        abort_alsa_playback(ua);
+        abort_alsa_capture(ua);
+        mutex_lock(&ua->mutex);
+        stop_usb_playback(ua);
+        stop_usb_capture(ua);
+        mutex_unlock(&ua->mutex);
+
+        free_usb_related_resources(ua, interface);
+
+        devices_used &= ~(1 << ua->card_index);
+
+        snd_card_free_when_closed(ua->card);
+
+        mutex_unlock(&devices_mutex);
+}
+
+static struct usb_device_id ua101_ids[] = {
+        { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */
+        { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */
+        { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */
+        { }
+};
+MODULE_DEVICE_TABLE(usb, ua101_ids);
+
+static struct usb_driver ua101_driver = {
+        .name = "snd-ua101",
+        .id_table = ua101_ids,
+        .probe = ua101_probe,
+        .disconnect = ua101_disconnect,
+#if 0
+        .suspend = ua101_suspend,
+        .resume = ua101_resume,
+#endif
+};
+
+static int __init alsa_card_ua101_init(void)
+{
+        return usb_register(&ua101_driver);
+}
+
+static void __exit alsa_card_ua101_exit(void)
+{
+        usb_deregister(&ua101_driver);
+        mutex_destroy(&devices_mutex);
+}
+
+module_init(alsa_card_ua101_init);
+module_exit(alsa_card_ua101_exit);
diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 8db0374e10d5..11b0826b8fe6 100644
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -44,9 +44,11 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/usb.h>
-#include <linux/vmalloc.h>
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
+#include <linux/usb/audio.h>
+#include <linux/usb/ch9.h>
+
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/pcm.h>
@@ -170,11 +172,12 @@ struct snd_usb_substream {
         unsigned int curpacksize;       /* current packet size in bytes (for capture) */
         unsigned int curframesize;      /* current packet size in frames (for capture) */
         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) */
 
         unsigned int running: 1;        /* running status */
 
-        unsigned int hwptr_done;                        /* processed frame position in the buffer */
+        unsigned int hwptr_done;        /* processed byte position in the buffer */
         unsigned int transfer_done;             /* processed frames since last period update */
         unsigned long active_mask;      /* bitmask of active urbs */
         unsigned long unlink_mask;      /* bitmask of unlinked urbs */
@@ -343,7 +346,7 @@ static int retire_capture_urb(struct snd_usb_substream *subs,
         unsigned long flags;
         unsigned char *cp;
         int i;
-        unsigned int stride, len, oldptr;
+        unsigned int stride, frames, bytes, oldptr;
         int period_elapsed = 0;
 
         stride = runtime->frame_bits >> 3;
@@ -354,29 +357,39 @@ static int retire_capture_urb(struct snd_usb_substream *subs,
                         snd_printd(KERN_ERR "frame %d active: %d\n", i, urb->iso_frame_desc[i].status);
                         // continue;
                 }
-                len = urb->iso_frame_desc[i].actual_length / stride;
-                if (! len)
-                        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 += len;
-                if (subs->hwptr_done >= runtime->buffer_size)
-                        subs->hwptr_done -= runtime->buffer_size;
-                subs->transfer_done += len;
+                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 + len > runtime->buffer_size) {
-                        unsigned int cnt = runtime->buffer_size - oldptr;
-                        unsigned int blen = cnt * stride;
-                        memcpy(runtime->dma_area + oldptr * stride, cp, blen);
-                        memcpy(runtime->dma_area, cp + blen, len * stride - blen);
+                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 * stride, cp, len * stride);
+                        memcpy(runtime->dma_area + oldptr, cp, bytes);
                 }
         }
         if (period_elapsed)
@@ -563,34 +576,34 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                                 struct snd_pcm_runtime *runtime,
                                 struct urb *urb)
 {
-        int i, stride, offs;
-        unsigned int counts;
+        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;
 
-        offs = 0;
+        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 = offs * stride;
+                urb->iso_frame_desc[i].offset = frames * stride;
                 urb->iso_frame_desc[i].length = counts * stride;
-                offs += counts;
+                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 == USB_FORMAT_TYPE_II) {
+                        if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
                                 if (subs->transfer_done > 0) {
                                         /* FIXME: fill-max mode is not
                                          * supported yet */
-                                        offs -= subs->transfer_done;
+                                        frames -= subs->transfer_done;
                                         counts -= subs->transfer_done;
                                         urb->iso_frame_desc[i].length =
                                                 counts * stride;
@@ -600,7 +613,7 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                                 if (i < ctx->packets) {
                                         /* add a transfer delimiter */
                                         urb->iso_frame_desc[i].offset =
-                                                offs * stride;
+                                                frames * stride;
                                         urb->iso_frame_desc[i].length = 0;
                                         urb->number_of_packets++;
                                 }
@@ -610,26 +623,25 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                 if (period_elapsed) /* finish at the period boundary */
                         break;
         }
-        if (subs->hwptr_done + offs > runtime->buffer_size) {
+        bytes = frames * stride;
+        if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
                 /* err, the transferred area goes over buffer boundary. */
-                unsigned int len = runtime->buffer_size - subs->hwptr_done;
+                unsigned int bytes1 =
+                        runtime->buffer_size * stride - subs->hwptr_done;
                 memcpy(urb->transfer_buffer,
-                       runtime->dma_area + subs->hwptr_done * stride,
-                       len * stride);
-                memcpy(urb->transfer_buffer + len * stride,
-                       runtime->dma_area,
-                       (offs - len) * stride);
+                       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 * stride,
-                       offs * stride);
+                       runtime->dma_area + subs->hwptr_done, bytes);
         }
-        subs->hwptr_done += offs;
-        if (subs->hwptr_done >= runtime->buffer_size)
-                subs->hwptr_done -= runtime->buffer_size;
-        runtime->delay += offs;
+        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 = offs * stride;
+        urb->transfer_buffer_length = bytes;
         if (period_elapsed)
                 snd_pcm_period_elapsed(subs->pcm_substream);
         return 0;
@@ -735,41 +747,6 @@ static void snd_complete_sync_urb(struct urb *urb)
 }
 
 
-/* get the physical page pointer at the given offset */
-static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
-                                             unsigned long offset)
-{
-        void *pageptr = subs->runtime->dma_area + offset;
-        return vmalloc_to_page(pageptr);
-}
-
-/* allocate virtual buffer; may be called more than once */
-static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs, size_t size)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-        if (runtime->dma_area) {
-                if (runtime->dma_bytes >= size)
-                        return 0; /* already large enough */
-                vfree(runtime->dma_area);
-        }
-        runtime->dma_area = vmalloc(size);
-        if (!runtime->dma_area)
-                return -ENOMEM;
-        runtime->dma_bytes = size;
-        return 0;
-}
-
-/* free virtual buffer; may be called more than once */
-static int snd_pcm_free_vmalloc_buffer(struct snd_pcm_substream *subs)
-{
-        struct snd_pcm_runtime *runtime = subs->runtime;
-
-        vfree(runtime->dma_area);
-        runtime->dma_area = NULL;
-        return 0;
-}
-
-
 /*
  * unlink active urbs.
  */
@@ -937,18 +914,18 @@ static int wait_clear_urbs(struct snd_usb_substream *subs)
 
 
 /*
- * return the current pcm pointer.  just return the hwptr_done value.
+ * return the current pcm pointer.  just based on the hwptr_done value.
  */
 static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
 {
         struct snd_usb_substream *subs;
-        snd_pcm_uframes_t hwptr_done;
+        unsigned int hwptr_done;
         
         subs = (struct snd_usb_substream *)substream->runtime->private_data;
         spin_lock(&subs->lock);
         hwptr_done = subs->hwptr_done;
         spin_unlock(&subs->lock);
-        return hwptr_done;
+        return hwptr_done / (substream->runtime->frame_bits >> 3);
 }
 
 
@@ -1130,7 +1107,7 @@ static int init_substream_urbs(struct snd_usb_substream *subs, unsigned int peri
                 u->packets = (i + 1) * total_packs / subs->nurbs
                         - i * total_packs / subs->nurbs;
                 u->buffer_size = maxsize * u->packets;
-                if (subs->fmt_type == USB_FORMAT_TYPE_II)
+                if (subs->fmt_type == UAC_FORMAT_TYPE_II)
                         u->packets++; /* for transfer delimiter */
                 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
                 if (!u->urb)
@@ -1206,7 +1183,7 @@ static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned
                         if (i >= fp->nr_rates)
                                 continue;
                 }
-                attr = fp->ep_attr & EP_ATTR_MASK;
+                attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
                 if (! found) {
                         found = fp;
                         cur_attr = attr;
@@ -1218,14 +1195,14 @@ static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned
                  * M-audio audiophile USB.
                  */
                 if (attr != cur_attr) {
-                        if ((attr == EP_ATTR_ASYNC &&
+                        if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
-                            (attr == EP_ATTR_ADAPTIVE &&
+                            (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
                              subs->direction == SNDRV_PCM_STREAM_CAPTURE))
                                 continue;
-                        if ((cur_attr == EP_ATTR_ASYNC &&
+                        if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
                              subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
-                            (cur_attr == EP_ATTR_ADAPTIVE &&
+                            (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
                              subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
                                 found = fp;
                                 cur_attr = attr;
@@ -1255,11 +1232,11 @@ static int init_usb_pitch(struct usb_device *dev, int iface,
 
         ep = get_endpoint(alts, 0)->bEndpointAddress;
         /* if endpoint has pitch control, enable it */
-        if (fmt->attributes & EP_CS_ATTR_PITCH_CONTROL) {
+        if (fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL) {
                 data[0] = 1;
-                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
+                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                                           PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
+                                           UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep, data, 1, 1000)) < 0) {
                         snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n",
                                    dev->devnum, iface, ep);
                         return err;
@@ -1278,21 +1255,21 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface,
 
         ep = get_endpoint(alts, 0)->bEndpointAddress;
         /* if endpoint has sampling rate control, set it */
-        if (fmt->attributes & EP_CS_ATTR_SAMPLE_RATE) {
+        if (fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE) {
                 int crate;
                 data[0] = rate;
                 data[1] = rate >> 8;
                 data[2] = rate >> 16;
-                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
+                if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                                           SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
+                                           UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000)) < 0) {
                         snd_printk(KERN_ERR "%d:%d:%d: cannot set freq %d to ep %#x\n",
                                    dev->devnum, iface, fmt->altsetting, rate, ep);
                         return err;
                 }
-                if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), GET_CUR,
+                if ((err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
                                            USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_IN,
-                                           SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000)) < 0) {
+                                           UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000)) < 0) {
                         snd_printk(KERN_WARNING "%d:%d:%d: cannot get freq at ep %#x\n",
                                    dev->devnum, iface, fmt->altsetting, ep);
                         return 0; /* some devices don't support reading */
@@ -1307,6 +1284,47 @@ static int init_usb_sample_rate(struct usb_device *dev, int iface,
 }
 
 /*
+ * For E-Mu 0404USB/0202USB/TrackerPre sample rate should be set for device,
+ * not for interface.
+ */
+static void set_format_emu_quirk(struct snd_usb_substream *subs,
+                                 struct audioformat *fmt)
+{
+        unsigned char emu_samplerate_id = 0;
+
+        /* When capture is active
+         * sample rate shouldn't be changed
+         * by playback substream
+         */
+        if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
+                        return;
+        }
+
+        switch (fmt->rate_min) {
+        case 48000:
+                emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
+                break;
+        case 88200:
+                emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
+                break;
+        case 96000:
+                emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
+                break;
+        case 176400:
+                emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
+                break;
+        case 192000:
+                emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
+                break;
+        default:
+                emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
+                break;
+        }
+        snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
+}
+
+/*
  * find a matching format and set up the interface
  */
 static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
@@ -1369,9 +1387,9 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
          * descriptors which fool us.  if it has only one EP,
          * assume it as adaptive-out or sync-in.
          */
-        attr = fmt->ep_attr & EP_ATTR_MASK;
-        if (((is_playback && attr == EP_ATTR_ASYNC) ||
-             (! is_playback && attr == EP_ATTR_ADAPTIVE)) &&
+        attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
+        if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) ||
+             (! is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) &&
             altsd->bNumEndpoints >= 2) {
                 /* check sync-pipe endpoint */
                 /* ... and check descriptor size before accessing bSynchAddress
@@ -1411,7 +1429,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
         }
 
         /* always fill max packet size */
-        if (fmt->attributes & EP_CS_ATTR_FILL_MAX)
+        if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX)
                 subs->fill_max = 1;
 
         if ((err = init_usb_pitch(dev, subs->interface, alts, fmt)) < 0)
@@ -1419,6 +1437,14 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
 
         subs->cur_audiofmt = fmt;
 
+        switch (subs->stream->chip->usb_id) {
+        case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
+        case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
+        case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
+                set_format_emu_quirk(subs, fmt);
+                break;
+        }
+
 #if 0
         printk(KERN_DEBUG
                "setting done: format = %d, rate = %d..%d, channels = %d\n",
@@ -1449,8 +1475,8 @@ static int snd_usb_hw_params(struct snd_pcm_substream *substream,
         unsigned int channels, rate, format;
         int ret, changed;
 
-        ret = snd_pcm_alloc_vmalloc_buffer(substream,
-                                           params_buffer_bytes(hw_params));
+        ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
+                                               params_buffer_bytes(hw_params));
         if (ret < 0)
                 return ret;
 
@@ -1507,7 +1533,7 @@ static int snd_usb_hw_free(struct snd_pcm_substream *substream)
         subs->period_bytes = 0;
         if (!subs->stream->chip->shutdown)
                 release_substream_urbs(subs, 0);
-        return snd_pcm_free_vmalloc_buffer(substream);
+        return snd_pcm_lib_free_vmalloc_buffer(substream);
 }
 
 /*
@@ -1861,7 +1887,7 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre
                         runtime->hw.channels_min = fp->channels;
                 if (runtime->hw.channels_max < fp->channels)
                         runtime->hw.channels_max = fp->channels;
-                if (fp->fmt_type == USB_FORMAT_TYPE_II && fp->frame_size > 0) {
+                if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
                         /* FIXME: there might be more than one audio formats... */
                         runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
                                 fp->frame_size;
@@ -1936,7 +1962,7 @@ static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction)
         struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
         struct snd_usb_substream *subs = &as->substream[direction];
 
-        if (subs->interface >= 0) {
+        if (!as->chip->shutdown && subs->interface >= 0) {
                 usb_set_interface(subs->dev, subs->interface, 0);
                 subs->interface = -1;
         }
@@ -1973,7 +1999,8 @@ static struct snd_pcm_ops snd_usb_playback_ops = {
         .prepare =      snd_usb_pcm_prepare,
         .trigger =      snd_usb_pcm_playback_trigger,
         .pointer =      snd_usb_pcm_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 static struct snd_pcm_ops snd_usb_capture_ops = {
@@ -1985,7 +2012,8 @@ static struct snd_pcm_ops snd_usb_capture_ops = {
         .prepare =      snd_usb_pcm_prepare,
         .trigger =      snd_usb_pcm_capture_trigger,
         .pointer =      snd_usb_pcm_pointer,
-        .page =         snd_pcm_get_vmalloc_page,
+        .page =         snd_pcm_lib_get_vmalloc_page,
+        .mmap =         snd_pcm_lib_mmap_vmalloc,
 };
 
 
@@ -2093,7 +2121,7 @@ static struct usb_device_id usb_audio_ids [] = {
 #include "usbquirks.h"
     { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
       .bInterfaceClass = USB_CLASS_AUDIO,
-      .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL },
+      .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL },
     { }                                         /* Terminating entry */
 };
 
@@ -2132,7 +2160,7 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s
                 snd_iprintf(buffer, "    Endpoint: %d %s (%s)\n",
                             fp->endpoint & USB_ENDPOINT_NUMBER_MASK,
                             fp->endpoint & USB_DIR_IN ? "IN" : "OUT",
-                            sync_types[(fp->ep_attr & EP_ATTR_MASK) >> 2]);
+                            sync_types[(fp->ep_attr & USB_ENDPOINT_SYNCTYPE) >> 2]);
                 if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) {
                         snd_iprintf(buffer, "    Rates: %d - %d (continuous)\n",
                                     fp->rate_min, fp->rate_max);
@@ -2227,6 +2255,7 @@ static void init_substream(struct snd_usb_stream *as, int stream, struct audiofo
         subs->stream = as;
         subs->direction = stream;
         subs->dev = as->chip->dev;
+        subs->txfr_quirk = as->chip->txfr_quirk;
         if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) {
                 subs->ops = audio_urb_ops[stream];
         } else {
@@ -2394,29 +2423,67 @@ static int is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *
  * @format: the format tag (wFormatTag)
  * @fmt: the format type descriptor
  */
-static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audioformat *fp,
-                                     int format, unsigned char *fmt)
+static int parse_audio_format_i_type(struct snd_usb_audio *chip,
+                                     struct audioformat *fp,
+                                     int format, void *_fmt,
+                                     int protocol)
 {
-        int pcm_format;
+        int pcm_format, i;
         int sample_width, sample_bytes;
 
+        switch (protocol) {
+        case UAC_VERSION_1: {
+                struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
+                sample_width = fmt->bBitResolution;
+                sample_bytes = fmt->bSubframeSize;
+                break;
+        }
+
+        case UAC_VERSION_2: {
+                struct uac_format_type_i_ext_descriptor *fmt = _fmt;
+                sample_width = fmt->bBitResolution;
+                sample_bytes = fmt->bSubslotSize;
+
+                /*
+                 * FIXME
+                 * USB audio class v2 devices specify a bitmap of possible
+                 * audio formats rather than one fix value. For now, we just
+                 * pick one of them and report that as the only possible
+                 * value for this setting.
+                 * The bit allocation map is in fact compatible to the
+                 * wFormatTag of the v1 AS streaming descriptors, which is why
+                 * we can simply map the matrix.
+                 */
+
+                for (i = 0; i < 5; i++)
+                        if (format & (1UL << i)) {
+                                format = i + 1;
+                                break;
+                        }
+
+                break;
+        }
+
+        default:
+                return -EINVAL;
+        }
+
         /* FIXME: correct endianess and sign? */
         pcm_format = -1;
-        sample_width = fmt[6];
-        sample_bytes = fmt[5];
+
         switch (format) {
-        case 0: /* some devices don't define this correctly... */
+        case UAC_FORMAT_TYPE_I_UNDEFINED: /* some devices don't define this correctly... */
                 snd_printdd(KERN_INFO "%d:%u:%d : format type 0 is detected, processed as PCM\n",
                             chip->dev->devnum, fp->iface, fp->altsetting);
                 /* fall-through */
-        case USB_AUDIO_FORMAT_PCM:
+        case UAC_FORMAT_TYPE_I_PCM:
                 if (sample_width > sample_bytes * 8) {
                         snd_printk(KERN_INFO "%d:%u:%d : sample bitwidth %d in over sample bytes %d\n",
                                    chip->dev->devnum, fp->iface, fp->altsetting,
                                    sample_width, sample_bytes);
                 }
                 /* check the format byte size */
-                switch (fmt[5]) {
+                switch (sample_bytes) {
                 case 1:
                         pcm_format = SNDRV_PCM_FORMAT_S8;
                         break;
@@ -2437,12 +2504,12 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
                         break;
                 default:
                         snd_printk(KERN_INFO "%d:%u:%d : unsupported sample bitwidth %d in %d bytes\n",
-                                   chip->dev->devnum, fp->iface,
-                                   fp->altsetting, sample_width, sample_bytes);
+                                   chip->dev->devnum, fp->iface, fp->altsetting,
+                                   sample_width, sample_bytes);
                         break;
                 }
                 break;
-        case USB_AUDIO_FORMAT_PCM8:
+        case UAC_FORMAT_TYPE_I_PCM8:
                 pcm_format = SNDRV_PCM_FORMAT_U8;
 
                 /* Dallas DS4201 workaround: it advertises U8 format, but really
@@ -2450,13 +2517,13 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
                 if (chip->usb_id == USB_ID(0x04fa, 0x4201))
                         pcm_format = SNDRV_PCM_FORMAT_S8;
                 break;
-        case USB_AUDIO_FORMAT_IEEE_FLOAT:
+        case UAC_FORMAT_TYPE_I_IEEE_FLOAT:
                 pcm_format = SNDRV_PCM_FORMAT_FLOAT_LE;
                 break;
-        case USB_AUDIO_FORMAT_ALAW:
+        case UAC_FORMAT_TYPE_I_ALAW:
                 pcm_format = SNDRV_PCM_FORMAT_A_LAW;
                 break;
-        case USB_AUDIO_FORMAT_MU_LAW:
+        case UAC_FORMAT_TYPE_I_MULAW:
                 pcm_format = SNDRV_PCM_FORMAT_MU_LAW;
                 break;
         default:
@@ -2470,7 +2537,7 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
 
 /*
  * parse the format descriptor and stores the possible sample rates
- * on the audioformat table.
+ * on the audioformat table (audio class v1).
  *
  * @dev: usb device
  * @fp: audioformat record
@@ -2478,13 +2545,13 @@ static int parse_audio_format_i_type(struct snd_usb_audio *chip, struct audiofor
  * @offset: the start offset of descriptor pointing the rate type
  *          (7 for type I and II, 8 for type II)
  */
-static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioformat *fp,
-                                    unsigned char *fmt, int offset)
+static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp,
+                                       unsigned char *fmt, int offset)
 {
         int nr_rates = fmt[offset];
 
         if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) {
-                snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
+                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
                                    chip->dev->devnum, fp->iface, fp->altsetting);
                 return -1;
         }
@@ -2513,6 +2580,9 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
                              chip->usb_id == USB_ID(0x0d8c, 0x0102)) &&
                             fp->altsetting == 5 && fp->maxpacksize == 392)
                                 rate = 96000;
+                        /* Creative VF0470 Live Cam reports 16 kHz instead of 8kHz */
+                        if (rate == 16000 && chip->usb_id == USB_ID(0x041e, 0x4068))
+                                rate = 8000;
                         fp->rate_table[fp->nr_rates] = rate;
                         if (!fp->rate_min || rate < fp->rate_min)
                                 fp->rate_min = rate;
@@ -2535,14 +2605,87 @@ static int parse_audio_format_rates(struct snd_usb_audio *chip, struct audioform
 }
 
 /*
+ * parse the format descriptor and stores the possible sample rates
+ * on the audioformat table (audio class v2).
+ */
+static int parse_audio_format_rates_v2(struct snd_usb_audio *chip,
+                                       struct audioformat *fp,
+                                       struct usb_host_interface *iface)
+{
+        struct usb_device *dev = chip->dev;
+        unsigned char tmp[2], *data;
+        int i, nr_rates, data_size, ret = 0;
+
+        /* get the number of sample rates first by only fetching 2 bytes */
+        ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
+                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                               0x0100, chip->clock_id << 8, tmp, sizeof(tmp), 1000);
+
+        if (ret < 0) {
+                snd_printk(KERN_ERR "unable to retrieve number of sample rates\n");
+                goto err;
+        }
+
+        nr_rates = (tmp[1] << 8) | tmp[0];
+        data_size = 2 + 12 * nr_rates;
+        data = kzalloc(data_size, GFP_KERNEL);
+        if (!data) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        /* now get the full information */
+        ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE,
+                               USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
+                               0x0100, chip->clock_id << 8, data, data_size, 1000);
+
+        if (ret < 0) {
+                snd_printk(KERN_ERR "unable to retrieve sample rate range\n");
+                ret = -EINVAL;
+                goto err_free;
+        }
+
+        fp->rate_table = kmalloc(sizeof(int) * nr_rates, GFP_KERNEL);
+        if (!fp->rate_table) {
+                ret = -ENOMEM;
+                goto err_free;
+        }
+
+        fp->nr_rates = 0;
+        fp->rate_min = fp->rate_max = 0;
+
+        for (i = 0; i < nr_rates; i++) {
+                int rate = combine_quad(&data[2 + 12 * i]);
+
+                fp->rate_table[fp->nr_rates] = rate;
+                if (!fp->rate_min || rate < fp->rate_min)
+                        fp->rate_min = rate;
+                if (!fp->rate_max || rate > fp->rate_max)
+                        fp->rate_max = rate;
+                fp->rates |= snd_pcm_rate_to_rate_bit(rate);
+                fp->nr_rates++;
+        }
+
+err_free:
+        kfree(data);
+err:
+        return ret;
+}
+
+/*
  * parse the format type I and III descriptors
  */
-static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *fp,
-                                int format, unsigned char *fmt)
+static int parse_audio_format_i(struct snd_usb_audio *chip,
+                                struct audioformat *fp,
+                                int format, void *_fmt,
+                                struct usb_host_interface *iface)
 {
-        int pcm_format;
+        struct usb_interface_descriptor *altsd = get_iface_desc(iface);
+        struct uac_format_type_i_discrete_descriptor *fmt = _fmt;
+        int protocol = altsd->bInterfaceProtocol;
+        int pcm_format, ret;
 
-        if (fmt[3] == USB_FORMAT_TYPE_III) {
+        if (fmt->bFormatType == UAC_FORMAT_TYPE_III) {
                 /* FIXME: the format type is really IECxxx
                  *        but we give normal PCM format to get the existing
                  *        apps working...
@@ -2560,34 +2703,57 @@ static int parse_audio_format_i(struct snd_usb_audio *chip, struct audioformat *
                         pcm_format = SNDRV_PCM_FORMAT_S16_LE;
                 }
         } else {
-                pcm_format = parse_audio_format_i_type(chip, fp, format, fmt);
+                pcm_format = parse_audio_format_i_type(chip, fp, format, fmt, protocol);
                 if (pcm_format < 0)
                         return -1;
         }
+
         fp->format = pcm_format;
-        fp->channels = fmt[4];
+
+        /* gather possible sample rates */
+        /* audio class v1 reports possible sample rates as part of the
+         * proprietary class specific descriptor.
+         * audio class v2 uses class specific EP0 range requests for that.
+         */
+        switch (protocol) {
+        case UAC_VERSION_1:
+                fp->channels = fmt->bNrChannels;
+                ret = parse_audio_format_rates_v1(chip, fp, _fmt, 7);
+                break;
+        case UAC_VERSION_2:
+                /* fp->channels is already set in this case */
+                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                break;
+        }
+
         if (fp->channels < 1) {
                 snd_printk(KERN_ERR "%d:%u:%d : invalid channels %d\n",
                            chip->dev->devnum, fp->iface, fp->altsetting, fp->channels);
                 return -1;
         }
-        return parse_audio_format_rates(chip, fp, fmt, 7);
+
+        return ret;
 }
 
 /*
- * prase the format type II descriptor
+ * parse the format type II descriptor
  */
-static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat *fp,
-                                 int format, unsigned char *fmt)
+static int parse_audio_format_ii(struct snd_usb_audio *chip,
+                                 struct audioformat *fp,
+                                 int format, void *_fmt,
+                                 struct usb_host_interface *iface)
 {
-        int brate, framesize;
+        int brate, framesize, ret;
+        struct usb_interface_descriptor *altsd = get_iface_desc(iface);
+        int protocol = altsd->bInterfaceProtocol;
+
         switch (format) {
-        case USB_AUDIO_FORMAT_AC3:
+        case UAC_FORMAT_TYPE_II_AC3:
                 /* FIXME: there is no AC3 format defined yet */
                 // fp->format = SNDRV_PCM_FORMAT_AC3;
                 fp->format = SNDRV_PCM_FORMAT_U8; /* temporarily hack to receive byte streams */
                 break;
-        case USB_AUDIO_FORMAT_MPEG:
+        case UAC_FORMAT_TYPE_II_MPEG:
                 fp->format = SNDRV_PCM_FORMAT_MPEG;
                 break;
         default:
@@ -2596,26 +2762,46 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, struct audioformat
                 fp->format = SNDRV_PCM_FORMAT_MPEG;
                 break;
         }
+
         fp->channels = 1;
-        brate = combine_word(&fmt[4]);  /* fmt[4,5] : wMaxBitRate (in kbps) */
-        framesize = combine_word(&fmt[6]); /* fmt[6,7]: wSamplesPerFrame */
-        snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
-        fp->frame_size = framesize;
-        return parse_audio_format_rates(chip, fp, fmt, 8); /* fmt[8..] sample rates */
+
+        switch (protocol) {
+        case UAC_VERSION_1: {
+                struct uac_format_type_ii_discrete_descriptor *fmt = _fmt;
+                brate = le16_to_cpu(fmt->wMaxBitRate);
+                framesize = le16_to_cpu(fmt->wSamplesPerFrame);
+                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
+                fp->frame_size = framesize;
+                ret = parse_audio_format_rates_v1(chip, fp, _fmt, 8); /* fmt[8..] sample rates */
+                break;
+        }
+        case UAC_VERSION_2: {
+                struct uac_format_type_ii_ext_descriptor *fmt = _fmt;
+                brate = le16_to_cpu(fmt->wMaxBitRate);
+                framesize = le16_to_cpu(fmt->wSamplesPerFrame);
+                snd_printd(KERN_INFO "found format II with max.bitrate = %d, frame size=%d\n", brate, framesize);
+                fp->frame_size = framesize;
+                ret = parse_audio_format_rates_v2(chip, fp, iface);
+                break;
+        }
+        }
+
+        return ret;
 }
 
 static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp,
-                              int format, unsigned char *fmt, int stream)
+                              int format, unsigned char *fmt, int stream,
+                              struct usb_host_interface *iface)
 {
         int err;
 
         switch (fmt[3]) {
-        case USB_FORMAT_TYPE_I:
-        case USB_FORMAT_TYPE_III:
-                err = parse_audio_format_i(chip, fp, format, fmt);
+        case UAC_FORMAT_TYPE_I:
+        case UAC_FORMAT_TYPE_III:
+                err = parse_audio_format_i(chip, fp, format, fmt, iface);
                 break;
-        case USB_FORMAT_TYPE_II:
-                err = parse_audio_format_ii(chip, fp, format, fmt);
+        case UAC_FORMAT_TYPE_II:
+                err = parse_audio_format_ii(chip, fp, format, fmt, iface);
                 break;
         default:
                 snd_printd(KERN_INFO "%d:%u:%d : format type %d is not supported yet\n",
@@ -2633,7 +2819,7 @@ static int parse_audio_format(struct snd_usb_audio *chip, struct audioformat *fp
         if (chip->usb_id == USB_ID(0x041e, 0x3000) ||
             chip->usb_id == USB_ID(0x041e, 0x3020) ||
             chip->usb_id == USB_ID(0x041e, 0x3061)) {
-                if (fmt[3] == USB_FORMAT_TYPE_I &&
+                if (fmt[3] == UAC_FORMAT_TYPE_I &&
                     fp->rates != SNDRV_PCM_RATE_48000 &&
                     fp->rates != SNDRV_PCM_RATE_96000)
                         return -1;
@@ -2662,10 +2848,10 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
         struct usb_host_interface *alts;
         struct usb_interface_descriptor *altsd;
         int i, altno, err, stream;
-        int format;
+        int format = 0, num_channels = 0;
         struct audioformat *fp = NULL;
         unsigned char *fmt, *csep;
-        int num;
+        int num, protocol;
 
         dev = chip->dev;
 
@@ -2684,10 +2870,11 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
         for (i = 0; i < num; i++) {
                 alts = &iface->altsetting[i];
                 altsd = get_iface_desc(alts);
+                protocol = altsd->bInterfaceProtocol;
                 /* skip invalid one */
                 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
                      altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
-                    (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING &&
+                    (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING &&
                      altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) ||
                     altsd->bNumEndpoints < 1 ||
                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0)
@@ -2708,30 +2895,65 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         continue;
 
                 /* get audio formats */
-                fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, AS_GENERAL);
-                if (!fmt) {
-                        snd_printk(KERN_ERR "%d:%u:%d : AS_GENERAL descriptor not found\n",
-                                   dev->devnum, iface_no, altno);
-                        continue;
+                switch (protocol) {
+                case UAC_VERSION_1: {
+                        struct uac_as_header_descriptor_v1 *as =
+                                snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
+
+                        if (!as) {
+                                snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        if (as->bLength < sizeof(*as)) {
+                                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        format = le16_to_cpu(as->wFormatTag); /* remember the format value */
+                        break;
                 }
 
-                if (fmt[0] < 7) {
-                        snd_printk(KERN_ERR "%d:%u:%d : invalid AS_GENERAL desc\n",
-                                   dev->devnum, iface_no, altno);
-                        continue;
+                case UAC_VERSION_2: {
+                        struct uac_as_header_descriptor_v2 *as =
+                                snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL);
+
+                        if (!as) {
+                                snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        if (as->bLength < sizeof(*as)) {
+                                snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n",
+                                           dev->devnum, iface_no, altno);
+                                continue;
+                        }
+
+                        num_channels = as->bNrChannels;
+                        format = le32_to_cpu(as->bmFormats);
+
+                        break;
                 }
 
-                format = (fmt[6] << 8) | fmt[5]; /* remember the format value */
+                default:
+                        snd_printk(KERN_ERR "%d:%u:%d : unknown interface protocol %04x\n",
+                                   dev->devnum, iface_no, altno, protocol);
+                        continue;
+                }
 
                 /* get format type */
-                fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, FORMAT_TYPE);
+                fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE);
                 if (!fmt) {
-                        snd_printk(KERN_ERR "%d:%u:%d : no FORMAT_TYPE desc\n",
+                        snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n",
                                    dev->devnum, iface_no, altno);
                         continue;
                 }
-                if (fmt[0] < 8) {
-                        snd_printk(KERN_ERR "%d:%u:%d : invalid FORMAT_TYPE desc\n",
+                if (((protocol == UAC_VERSION_1) && (fmt[0] < 8)) ||
+                    ((protocol == UAC_VERSION_2) && (fmt[0] != 6))) {
+                        snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n",
                                    dev->devnum, iface_no, altno);
                         continue;
                 }
@@ -2744,6 +2966,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 if (fmt[4] == 1 && fmt[5] == 2 && altno == 2 && num == 3 &&
                     fp && fp->altsetting == 1 && fp->channels == 1 &&
                     fp->format == SNDRV_PCM_FORMAT_S16_LE &&
+                    protocol == UAC_VERSION_1 &&
                     le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) ==
                                                         fp->maxpacksize * 2)
                         continue;
@@ -2752,7 +2975,7 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 /* Creamware Noah has this descriptor after the 2nd endpoint */
                 if (!csep && altsd->bNumEndpoints >= 2)
                         csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT);
-                if (!csep || csep[0] < 7 || csep[2] != EP_GENERAL) {
+                if (!csep || csep[0] < 7 || csep[2] != UAC_EP_GENERAL) {
                         snd_printk(KERN_WARNING "%d:%u:%d : no or invalid"
                                    " class specific endpoint descriptor\n",
                                    dev->devnum, iface_no, altno);
@@ -2772,6 +2995,8 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
                 fp->datainterval = parse_datainterval(chip, alts);
                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
+                /* num_channels is only set for v2 interfaces */
+                fp->channels = num_channels;
                 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH)
                         fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1)
                                         * (fp->maxpacksize & 0x7ff);
@@ -2784,12 +3009,12 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                         /* Optoplay sets the sample rate attribute although
                          * it seems not supporting it in fact.
                          */
-                        fp->attributes &= ~EP_CS_ATTR_SAMPLE_RATE;
+                        fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
                         break;
                 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
                 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
                         /* doesn't set the sample rate attribute, but supports it */
-                        fp->attributes |= EP_CS_ATTR_SAMPLE_RATE;
+                        fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
                         break;
                 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
                 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
@@ -2798,16 +3023,16 @@ static int parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no)
                  * plantronics headset and Griffin iMic have set adaptive-in
                  * although it's really not...
                  */
-                        fp->ep_attr &= ~EP_ATTR_MASK;
+                        fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
                         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
-                                fp->ep_attr |= EP_ATTR_ADAPTIVE;
+                                fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
                         else
-                                fp->ep_attr |= EP_ATTR_SYNC;
+                                fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
                         break;
                 }
 
                 /* ok, let's parse further... */
-                if (parse_audio_format(chip, fp, format, fmt, stream) < 0) {
+                if (parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) {
                         kfree(fp->rate_table);
                         kfree(fp);
                         continue;
@@ -2849,6 +3074,65 @@ static void snd_usb_stream_disconnect(struct list_head *head)
         }
 }
 
+static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface)
+{
+        struct usb_device *dev = chip->dev;
+        struct usb_host_interface *alts;
+        struct usb_interface_descriptor *altsd;
+        struct usb_interface *iface = usb_ifnum_to_if(dev, interface);
+
+        if (!iface) {
+                snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
+                           dev->devnum, ctrlif, interface);
+                return -EINVAL;
+        }
+
+        if (usb_interface_claimed(iface)) {
+                snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
+                                                dev->devnum, ctrlif, interface);
+                return -EINVAL;
+        }
+
+        alts = &iface->altsetting[0];
+        altsd = get_iface_desc(alts);
+        if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
+             altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
+            altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
+                int err = snd_usbmidi_create(chip->card, iface,
+                                             &chip->midi_list, NULL);
+                if (err < 0) {
+                        snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
+                                                dev->devnum, ctrlif, interface);
+                        return -EINVAL;
+                }
+                usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
+
+                return 0;
+        }
+
+        if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
+             altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
+            altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
+                snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
+                                        dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
+                /* skip non-supported classes */
+                return -EINVAL;
+        }
+
+        if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
+                snd_printk(KERN_ERR "low speed audio streaming not supported\n");
+                return -EINVAL;
+        }
+
+        if (! parse_audio_endpoints(chip, interface)) {
+                usb_set_interface(dev, interface, 0); /* reset the current interface */
+                usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 /*
  * parse audio control descriptor and create pcm/midi streams
  */
@@ -2856,65 +3140,81 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
 {
         struct usb_device *dev = chip->dev;
         struct usb_host_interface *host_iface;
-        struct usb_interface *iface;
-        unsigned char *p1;
-        int i, j;
+        struct usb_interface_descriptor *altsd;
+        void *control_header;
+        int i, protocol;
 
         /* find audiocontrol interface */
         host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
-        if (!(p1 = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen, NULL, HEADER))) {
-                snd_printk(KERN_ERR "cannot find HEADER\n");
-                return -EINVAL;
-        }
-        if (! p1[7] || p1[0] < 8 + p1[7]) {
-                snd_printk(KERN_ERR "invalid HEADER\n");
+        control_header = snd_usb_find_csint_desc(host_iface->extra,
+                                                 host_iface->extralen,
+                                                 NULL, UAC_HEADER);
+        altsd = get_iface_desc(host_iface);
+        protocol = altsd->bInterfaceProtocol;
+
+        if (!control_header) {
+                snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
                 return -EINVAL;
         }
 
-        /*
-         * parse all USB audio streaming interfaces
-         */
-        for (i = 0; i < p1[7]; i++) {
-                struct usb_host_interface *alts;
-                struct usb_interface_descriptor *altsd;
-                j = p1[8 + i];
-                iface = usb_ifnum_to_if(dev, j);
-                if (!iface) {
-                        snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
-                                   dev->devnum, ctrlif, j);
-                        continue;
-                }
-                if (usb_interface_claimed(iface)) {
-                        snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", dev->devnum, ctrlif, j);
-                        continue;
+        switch (protocol) {
+        case UAC_VERSION_1: {
+                struct uac_ac_header_descriptor_v1 *h1 = control_header;
+
+                if (!h1->bInCollection) {
+                        snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
+                        return -EINVAL;
                 }
-                alts = &iface->altsetting[0];
-                altsd = get_iface_desc(alts);
-                if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
-                     altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
-                    altsd->bInterfaceSubClass == USB_SUBCLASS_MIDI_STREAMING) {
-                        if (snd_usb_create_midi_interface(chip, iface, NULL) < 0) {
-                                snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", dev->devnum, ctrlif, j);
-                                continue;
-                        }
-                        usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
-                        continue;
+
+                if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
+                        snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
+                        return -EINVAL;
                 }
-                if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
-                     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
-                    altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIO_STREAMING) {
-                        snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", dev->devnum, ctrlif, j, altsd->bInterfaceClass);
-                        /* skip non-supported classes */
-                        continue;
+
+                for (i = 0; i < h1->bInCollection; i++)
+                        snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]);
+
+                break;
+        }
+
+        case UAC_VERSION_2: {
+                struct uac_clock_source_descriptor *cs;
+                struct usb_interface_assoc_descriptor *assoc =
+                        usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
+
+                if (!assoc) {
+                        snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
+                        return -EINVAL;
                 }
-                if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
-                        snd_printk(KERN_ERR "low speed audio streaming not supported\n");
-                        continue;
+
+                /* FIXME: for now, we expect there is at least one clock source
+                 * descriptor and we always take the first one.
+                 * We should properly support devices with multiple clock sources,
+                 * clock selectors and sample rate conversion units. */
+
+                cs = snd_usb_find_csint_desc(host_iface->extra, host_iface->extralen,
+                                                NULL, UAC_CLOCK_SOURCE);
+
+                if (!cs) {
+                        snd_printk(KERN_ERR "CLOCK_SOURCE descriptor not found\n");
+                        return -EINVAL;
                 }
-                if (! parse_audio_endpoints(chip, j)) {
-                        usb_set_interface(dev, j, 0); /* reset the current interface */
-                        usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
+
+                chip->clock_id = cs->bClockID;
+
+                for (i = 0; i < assoc->bInterfaceCount; i++) {
+                        int intf = assoc->bFirstInterface + i;
+
+                        if (intf != ctrlif)
+                                snd_usb_create_stream(chip, ctrlif, intf);
                 }
+
+                break;
+        }
+
+        default:
+                snd_printk(KERN_ERR "unknown protocol version 0x%02x\n", protocol);
+                return -EINVAL;
         }
 
         return 0;
@@ -3005,7 +3305,7 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
         static const struct audioformat ua_format = {
                 .format = SNDRV_PCM_FORMAT_S24_3LE,
                 .channels = 2,
-                .fmt_type = USB_FORMAT_TYPE_I,
+                .fmt_type = UAC_FORMAT_TYPE_I,
                 .altsetting = 1,
                 .altset_idx = 1,
                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
@@ -3038,12 +3338,11 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
                         .data = &uaxx_ep
                 };
-                if (chip->usb_id == USB_ID(0x0582, 0x002b))
-                        return snd_usb_create_midi_interface(chip, iface,
-                                                             &ua700_quirk);
-                else
-                        return snd_usb_create_midi_interface(chip, iface,
-                                                             &uaxx_quirk);
+                const struct snd_usb_audio_quirk *quirk =
+                        chip->usb_id == USB_ID(0x0582, 0x002b)
+                        ? &ua700_quirk : &uaxx_quirk;
+                return snd_usbmidi_create(chip->card, iface,
+                                          &chip->midi_list, quirk);
         }
 
         if (altsd->bNumEndpoints != 1)
@@ -3089,111 +3388,6 @@ static int create_uaxx_quirk(struct snd_usb_audio *chip,
         return 0;
 }
 
-/*
- * Create a stream for an Edirol UA-1000 interface.
- */
-static int create_ua1000_quirk(struct snd_usb_audio *chip,
-                               struct usb_interface *iface,
-                               const struct snd_usb_audio_quirk *quirk)
-{
-        static const struct audioformat ua1000_format = {
-                .format = SNDRV_PCM_FORMAT_S32_LE,
-                .fmt_type = USB_FORMAT_TYPE_I,
-                .altsetting = 1,
-                .altset_idx = 1,
-                .attributes = 0,
-                .rates = SNDRV_PCM_RATE_CONTINUOUS,
-        };
-        struct usb_host_interface *alts;
-        struct usb_interface_descriptor *altsd;
-        struct audioformat *fp;
-        int stream, err;
-
-        if (iface->num_altsetting != 2)
-                return -ENXIO;
-        alts = &iface->altsetting[1];
-        altsd = get_iface_desc(alts);
-        if (alts->extralen != 11 || alts->extra[1] != USB_DT_CS_INTERFACE ||
-            altsd->bNumEndpoints != 1)
-                return -ENXIO;
-
-        fp = kmemdup(&ua1000_format, sizeof(*fp), GFP_KERNEL);
-        if (!fp)
-                return -ENOMEM;
-
-        fp->channels = alts->extra[4];
-        fp->iface = altsd->bInterfaceNumber;
-        fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
-        fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
-        fp->datainterval = parse_datainterval(chip, alts);
-        fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
-        fp->rate_max = fp->rate_min = combine_triple(&alts->extra[8]);
-
-        stream = (fp->endpoint & USB_DIR_IN)
-                ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
-        err = add_audio_endpoint(chip, stream, fp);
-        if (err < 0) {
-                kfree(fp);
-                return err;
-        }
-        /* FIXME: playback must be synchronized to capture */
-        usb_set_interface(chip->dev, fp->iface, 0);
-        return 0;
-}
-
-/*
- * Create a stream for an Edirol UA-101 interface.
- * Copy, paste and modify from Edirol UA-1000
- */
-static int create_ua101_quirk(struct snd_usb_audio *chip,
-                               struct usb_interface *iface,
-                               const struct snd_usb_audio_quirk *quirk)
-{
-        static const struct audioformat ua101_format = {
-                .format = SNDRV_PCM_FORMAT_S32_LE,
-                .fmt_type = USB_FORMAT_TYPE_I,
-                .altsetting = 1,
-                .altset_idx = 1,
-                .attributes = 0,
-                .rates = SNDRV_PCM_RATE_CONTINUOUS,
-        };
-        struct usb_host_interface *alts;
-        struct usb_interface_descriptor *altsd;
-        struct audioformat *fp;
-        int stream, err;
-
-        if (iface->num_altsetting != 2)
-                return -ENXIO;
-        alts = &iface->altsetting[1];
-        altsd = get_iface_desc(alts);
-        if (alts->extralen != 18 || alts->extra[1] != USB_DT_CS_INTERFACE ||
-            altsd->bNumEndpoints != 1)
-                return -ENXIO;
-
-        fp = kmemdup(&ua101_format, sizeof(*fp), GFP_KERNEL);
-        if (!fp)
-                return -ENOMEM;
-
-        fp->channels = alts->extra[11];
-        fp->iface = altsd->bInterfaceNumber;
-        fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
-        fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
-        fp->datainterval = parse_datainterval(chip, alts);
-        fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
-        fp->rate_max = fp->rate_min = combine_triple(&alts->extra[15]);
-
-        stream = (fp->endpoint & USB_DIR_IN)
-                ? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
-        err = add_audio_endpoint(chip, stream, fp);
-        if (err < 0) {
-                kfree(fp);
-                return err;
-        }
-        /* FIXME: playback must be synchronized to capture */
-        usb_set_interface(chip->dev, fp->iface, 0);
-        return 0;
-}
-
 static int snd_usb_create_quirk(struct snd_usb_audio *chip,
                                 struct usb_interface *iface,
                                 const struct snd_usb_audio_quirk *quirk);
@@ -3231,6 +3425,18 @@ static int ignore_interface_quirk(struct snd_usb_audio *chip,
         return 0;
 }
 
+/*
+ * Allow alignment on audio sub-slot (channel samples) rather than
+ * on audio slots (audio frames)
+ */
+static int create_align_transfer_quirk(struct snd_usb_audio *chip,
+                                  struct usb_interface *iface,
+                                  const struct snd_usb_audio_quirk *quirk)
+{
+        chip->txfr_quirk = 1;
+        return 1;       /* Continue with creating streams and mixer */
+}
+
 
 /*
  * boot quirks
@@ -3326,6 +3532,32 @@ static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
 }
 
 /*
+ * This call will put the synth in "USB send" mode, i.e it will send MIDI
+ * messages through USB (this is disabled at startup). The synth will
+ * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
+ * sign on its LCD. Values here are chosen based on sniffing USB traffic
+ * under Windows.
+ */
+static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
+{
+        int err, actual_length;
+
+        /* "midi send" enable */
+        static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
+
+        void *buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
+                        ARRAY_SIZE(seq), &actual_length, 1000);
+        kfree(buf);
+        if (err < 0)
+                return err;
+
+        return 0;
+}
+
+/*
  * Setup quirks
  */
 #define AUDIOPHILE_SET                  0x01 /* if set, parse device_setup */
@@ -3370,6 +3602,13 @@ static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
         return 0; /* keep this altsetting */
 }
 
+static int create_any_midi_quirk(struct snd_usb_audio *chip,
+                                 struct usb_interface *intf,
+                                 const struct snd_usb_audio_quirk *quirk)
+{
+        return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
+}
+
 /*
  * audio-interface quirks
  *
@@ -3387,19 +3626,18 @@ static int snd_usb_create_quirk(struct snd_usb_audio *chip,
         static const quirk_func_t quirk_funcs[] = {
                 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
                 [QUIRK_COMPOSITE] = create_composite_quirk,
-                [QUIRK_MIDI_STANDARD_INTERFACE] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_FIXED_ENDPOINT] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_YAMAHA] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_MIDIMAN] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_NOVATION] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_FASTLANE] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_EMAGIC] = snd_usb_create_midi_interface,
-                [QUIRK_MIDI_CME] = snd_usb_create_midi_interface,
+                [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
+                [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
+                [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
+                [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
+                [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
+                [QUIRK_MIDI_FASTLANE] = create_any_midi_quirk,
+                [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
+                [QUIRK_MIDI_CME] = create_any_midi_quirk,
                 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
-                [QUIRK_AUDIO_EDIROL_UA1000] = create_ua1000_quirk,
-                [QUIRK_AUDIO_EDIROL_UA101] = create_ua101_quirk,
-                [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk
+                [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
+                [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk
         };
 
         if (quirk->type < QUIRK_TYPE_COUNT) {
@@ -3588,7 +3826,6 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
         ifnum = get_iface_desc(alts)->bInterfaceNumber;
         id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
                     le16_to_cpu(dev->descriptor.idProduct));
-
         if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
                 goto __err_val;
 
@@ -3616,6 +3853,12 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                         goto __err_val;
         }
 
+        /* Access Music VirusTI Desktop */
+        if (id == USB_ID(0x133e, 0x0815)) {
+                if (snd_usb_accessmusic_boot_quirk(dev) < 0)
+                        goto __err_val;
+        }
+
         /*
          * found a config.  now register to ALSA
          */
@@ -3653,6 +3896,7 @@ static void *snd_usb_audio_probe(struct usb_device *dev,
                 }
         }
 
+        chip->txfr_quirk = 0;
         err = 1; /* continue */
         if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
                 /* need some special handlings */
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index e9a3a9dca15c..42c299cbf63a 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -21,93 +21,6 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
 
-
-/*
- */
-
-#define USB_SUBCLASS_AUDIO_CONTROL      0x01
-#define USB_SUBCLASS_AUDIO_STREAMING    0x02
-#define USB_SUBCLASS_MIDI_STREAMING     0x03
-#define USB_SUBCLASS_VENDOR_SPEC        0xff
-
-#define HEADER                          0x01
-#define INPUT_TERMINAL                  0x02
-#define OUTPUT_TERMINAL                 0x03
-#define MIXER_UNIT                      0x04
-#define SELECTOR_UNIT                   0x05
-#define FEATURE_UNIT                    0x06
-#define PROCESSING_UNIT                 0x07
-#define EXTENSION_UNIT                  0x08
-
-#define AS_GENERAL                      0x01
-#define FORMAT_TYPE                     0x02
-#define FORMAT_SPECIFIC                 0x03
-
-#define EP_GENERAL                      0x01
-
-#define MS_GENERAL                      0x01
-#define MIDI_IN_JACK                    0x02
-#define MIDI_OUT_JACK                   0x03
-
-/* endpoint attributes */
-#define EP_ATTR_MASK                    0x0c
-#define EP_ATTR_ASYNC                   0x04
-#define EP_ATTR_ADAPTIVE                0x08
-#define EP_ATTR_SYNC                    0x0c
-
-/* cs endpoint attributes */
-#define EP_CS_ATTR_SAMPLE_RATE          0x01
-#define EP_CS_ATTR_PITCH_CONTROL        0x02
-#define EP_CS_ATTR_FILL_MAX             0x80
-
-/* Audio Class specific Request Codes */
-
-#define SET_CUR    0x01
-#define GET_CUR    0x81
-#define SET_MIN    0x02
-#define GET_MIN    0x82
-#define SET_MAX    0x03
-#define GET_MAX    0x83
-#define SET_RES    0x04
-#define GET_RES    0x84
-#define SET_MEM    0x05
-#define GET_MEM    0x85
-#define GET_STAT   0xff
-
-/* Terminal Control Selectors */
-
-#define COPY_PROTECT_CONTROL       0x01
-
-/* Endpoint Control Selectors */
-
-#define SAMPLING_FREQ_CONTROL      0x01
-#define PITCH_CONTROL              0x02
-
-/* Format Types */
-#define USB_FORMAT_TYPE_I       0x01
-#define USB_FORMAT_TYPE_II      0x02
-#define USB_FORMAT_TYPE_III     0x03
-
-/* type I */
-#define USB_AUDIO_FORMAT_PCM    0x01
-#define USB_AUDIO_FORMAT_PCM8   0x02
-#define USB_AUDIO_FORMAT_IEEE_FLOAT     0x03
-#define USB_AUDIO_FORMAT_ALAW   0x04
-#define USB_AUDIO_FORMAT_MU_LAW 0x05
-
-/* type II */
-#define USB_AUDIO_FORMAT_MPEG   0x1001
-#define USB_AUDIO_FORMAT_AC3    0x1002
-
-/* type III */
-#define USB_AUDIO_FORMAT_IEC1937_AC3    0x2001
-#define USB_AUDIO_FORMAT_IEC1937_MPEG1_LAYER1   0x2002
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_NOEXT    0x2003
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_EXT      0x2004
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_LAYER1_LS        0x2005
-#define USB_AUDIO_FORMAT_IEC1937_MPEG2_LAYER23_LS       0x2006
-
-
 /* maximum number of endpoints per interface */
 #define MIDI_MAX_ENDPOINTS 2
 
@@ -125,14 +38,17 @@ struct snd_usb_audio {
         struct snd_card *card;
         u32 usb_id;
         int shutdown;
+        unsigned int txfr_quirk:1; /* Subframe boundaries on transfers */
         int num_interfaces;
         int num_suspended_intf;
 
+        /* for audio class v2 */
+        int clock_id;
+
         struct list_head pcm_list;      /* list of pcm streams */
         int pcm_devs;
 
         struct list_head midi_list;     /* list of midi interfaces */
-        int next_midi_device;
 
         struct list_head mixer_list;    /* list of mixer interfaces */
 };
@@ -159,9 +75,8 @@ enum quirk_type {
         QUIRK_MIDI_US122L,
         QUIRK_AUDIO_STANDARD_INTERFACE,
         QUIRK_AUDIO_FIXED_ENDPOINT,
-        QUIRK_AUDIO_EDIROL_UA1000,
-        QUIRK_AUDIO_EDIROL_UA101,
         QUIRK_AUDIO_EDIROL_UAXX,
+        QUIRK_AUDIO_ALIGN_TRANSFER,
 
         QUIRK_TYPE_COUNT
 };
@@ -196,7 +111,7 @@ struct snd_usb_midi_endpoint_info {
 
 /* for QUIRK_AUDIO/MIDI_STANDARD_INTERFACE, data is NULL */
 
-/* for QUIRK_AUDIO_EDIROL_UA700_UA25/UA1000, data is NULL */
+/* for QUIRK_AUDIO_EDIROL_UAXX, data is NULL */
 
 /* for QUIRK_IGNORE_INTERFACE, data is NULL */
 
@@ -210,6 +125,16 @@ struct snd_usb_midi_endpoint_info {
 /*
  */
 
+/*E-mu USB samplerate control quirk*/
+enum {
+        EMU_QUIRK_SR_44100HZ = 0,
+        EMU_QUIRK_SR_48000HZ,
+        EMU_QUIRK_SR_88200HZ,
+        EMU_QUIRK_SR_96000HZ,
+        EMU_QUIRK_SR_176400HZ,
+        EMU_QUIRK_SR_192000HZ
+};
+
 #define combine_word(s)    ((*(s)) | ((unsigned int)(s)[1] << 8))
 #define combine_triple(s)  (combine_word(s) | ((unsigned int)(s)[2] << 16))
 #define combine_quad(s)    (combine_triple(s) | ((unsigned int)(s)[3] << 24))
@@ -227,12 +152,17 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                          int ignore_error);
 void snd_usb_mixer_disconnect(struct list_head *p);
 
-int snd_usb_create_midi_interface(struct snd_usb_audio *chip, struct usb_interface *iface,
-                                  const struct snd_usb_audio_quirk *quirk);
+int snd_usbmidi_create(struct snd_card *card,
+                       struct usb_interface *iface,
+                       struct list_head *midi_list,
+                       const struct snd_usb_audio_quirk *quirk);
 void snd_usbmidi_input_stop(struct list_head* p);
 void snd_usbmidi_input_start(struct list_head* p);
 void snd_usbmidi_disconnect(struct list_head *p);
 
+void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
+                        unsigned char samplerate_id);
+
 /*
  * retrieve usb_interface descriptor from the host interface
  * (conditional for compatibility with the older API)
diff --git a/sound/usb/usbmidi.c b/sound/usb/usbmidi.c
index 0eff19ceb7e1..9e28b20cb2ce 100644
--- a/sound/usb/usbmidi.c
+++ b/sound/usb/usbmidi.c
@@ -1,7 +1,7 @@
 /*
  * usbmidi.c - ALSA USB MIDI driver
  *
- * Copyright (c) 2002-2007 Clemens Ladisch
+ * Copyright (c) 2002-2009 Clemens Ladisch
  * All rights reserved.
  *
  * Based on the OSS usb-midi driver by NAGANO Daisuke,
@@ -46,7 +46,10 @@
 #include <linux/timer.h>
 #include <linux/usb.h>
 #include <linux/wait.h>
+#include <linux/usb/audio.h>
+
 #include <sound/core.h>
+#include <sound/control.h>
 #include <sound/rawmidi.h>
 #include <sound/asequencer.h>
 #include "usbaudio.h"
@@ -101,7 +104,8 @@ struct usb_protocol_ops {
 };
 
 struct snd_usb_midi {
-        struct snd_usb_audio *chip;
+        struct usb_device *dev;
+        struct snd_card *card;
         struct usb_interface *iface;
         const struct snd_usb_audio_quirk *quirk;
         struct snd_rawmidi *rmidi;
@@ -109,13 +113,19 @@ struct snd_usb_midi {
         struct list_head list;
         struct timer_list error_timer;
         spinlock_t disc_lock;
+        struct mutex mutex;
+        u32 usb_id;
+        int next_midi_device;
 
         struct snd_usb_midi_endpoint {
                 struct snd_usb_midi_out_endpoint *out;
                 struct snd_usb_midi_in_endpoint *in;
         } endpoints[MIDI_MAX_ENDPOINTS];
         unsigned long input_triggered;
+        unsigned int opened;
         unsigned char disconnected;
+
+        struct snd_kcontrol *roland_load_ctl;
 };
 
 struct snd_usb_midi_out_endpoint {
@@ -255,7 +265,7 @@ static void snd_usbmidi_in_urb_complete(struct urb* urb)
                 }
         }
 
-        urb->dev = ep->umidi->chip->dev;
+        urb->dev = ep->umidi->dev;
         snd_usbmidi_submit_urb(urb, GFP_ATOMIC);
 }
 
@@ -296,7 +306,7 @@ static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep)
         unsigned long flags;
 
         spin_lock_irqsave(&ep->buffer_lock, flags);
-        if (ep->umidi->chip->shutdown) {
+        if (ep->umidi->disconnected) {
                 spin_unlock_irqrestore(&ep->buffer_lock, flags);
                 return;
         }
@@ -312,7 +322,7 @@ static void snd_usbmidi_do_output(struct snd_usb_midi_out_endpoint* ep)
 
                         dump_urb("sending", urb->transfer_buffer,
                                  urb->transfer_buffer_length);
-                        urb->dev = ep->umidi->chip->dev;
+                        urb->dev = ep->umidi->dev;
                         if (snd_usbmidi_submit_urb(urb, GFP_ATOMIC) < 0)
                                 break;
                         ep->active_urbs |= 1 << urb_index;
@@ -349,7 +359,7 @@ static void snd_usbmidi_error_timer(unsigned long data)
                 if (in && in->error_resubmit) {
                         in->error_resubmit = 0;
                         for (j = 0; j < INPUT_URBS; ++j) {
-                                in->urbs[j]->dev = umidi->chip->dev;
+                                in->urbs[j]->dev = umidi->dev;
                                 snd_usbmidi_submit_urb(in->urbs[j], GFP_ATOMIC);
                         }
                 }
@@ -369,7 +379,7 @@ static int send_bulk_static_data(struct snd_usb_midi_out_endpoint* ep,
                 return -ENOMEM;
         dump_urb("sending", buf, len);
         if (ep->urbs[0].urb)
-                err = usb_bulk_msg(ep->umidi->chip->dev, ep->urbs[0].urb->pipe,
+                err = usb_bulk_msg(ep->umidi->dev, ep->urbs[0].urb->pipe,
                                    buf, len, NULL, 250);
         kfree(buf);
         return err;
@@ -724,8 +734,7 @@ static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep,
 
         if (!ep->ports[0].active)
                 return;
-        count = snd_usb_get_speed(ep->umidi->chip->dev) == USB_SPEED_HIGH
-                ? 1 : 2;
+        count = snd_usb_get_speed(ep->umidi->dev) == USB_SPEED_HIGH ? 1 : 2;
         count = snd_rawmidi_transmit(ep->ports[0].substream,
                                      urb->transfer_buffer,
                                      count);
@@ -879,6 +888,50 @@ static struct usb_protocol_ops snd_usbmidi_emagic_ops = {
 };
 
 
+static void update_roland_altsetting(struct snd_usb_midi* umidi)
+{
+        struct usb_interface *intf;
+        struct usb_host_interface *hostif;
+        struct usb_interface_descriptor *intfd;
+        int is_light_load;
+
+        intf = umidi->iface;
+        is_light_load = intf->cur_altsetting != intf->altsetting;
+        if (umidi->roland_load_ctl->private_value == is_light_load)
+                return;
+        hostif = &intf->altsetting[umidi->roland_load_ctl->private_value];
+        intfd = get_iface_desc(hostif);
+        snd_usbmidi_input_stop(&umidi->list);
+        usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
+                          intfd->bAlternateSetting);
+        snd_usbmidi_input_start(&umidi->list);
+}
+
+static void substream_open(struct snd_rawmidi_substream *substream, int open)
+{
+        struct snd_usb_midi* umidi = substream->rmidi->private_data;
+        struct snd_kcontrol *ctl;
+
+        mutex_lock(&umidi->mutex);
+        if (open) {
+                if (umidi->opened++ == 0 && umidi->roland_load_ctl) {
+                        ctl = umidi->roland_load_ctl;
+                        ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                        snd_ctl_notify(umidi->card,
+                                       SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
+                        update_roland_altsetting(umidi);
+                }
+        } else {
+                if (--umidi->opened == 0 && umidi->roland_load_ctl) {
+                        ctl = umidi->roland_load_ctl;
+                        ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+                        snd_ctl_notify(umidi->card,
+                                       SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
+                }
+        }
+        mutex_unlock(&umidi->mutex);
+}
+
 static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream)
 {
         struct snd_usb_midi* umidi = substream->rmidi->private_data;
@@ -898,11 +951,13 @@ static int snd_usbmidi_output_open(struct snd_rawmidi_substream *substream)
         }
         substream->runtime->private_data = port;
         port->state = STATE_UNKNOWN;
+        substream_open(substream, 1);
         return 0;
 }
 
 static int snd_usbmidi_output_close(struct snd_rawmidi_substream *substream)
 {
+        substream_open(substream, 0);
         return 0;
 }
 
@@ -912,7 +967,7 @@ static void snd_usbmidi_output_trigger(struct snd_rawmidi_substream *substream,
 
         port->active = up;
         if (up) {
-                if (port->ep->umidi->chip->shutdown) {
+                if (port->ep->umidi->disconnected) {
                         /* gobble up remaining bytes to prevent wait in
                          * snd_rawmidi_drain_output */
                         while (!snd_rawmidi_transmit_empty(substream))
@@ -931,6 +986,8 @@ static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
         DEFINE_WAIT(wait);
         long timeout = msecs_to_jiffies(50);
 
+        if (ep->umidi->disconnected)
+                return;
         /*
          * The substream buffer is empty, but some data might still be in the
          * currently active URBs, so we have to wait for those to complete.
@@ -954,11 +1011,13 @@ static void snd_usbmidi_output_drain(struct snd_rawmidi_substream *substream)
 
 static int snd_usbmidi_input_open(struct snd_rawmidi_substream *substream)
 {
+        substream_open(substream, 1);
         return 0;
 }
 
 static int snd_usbmidi_input_close(struct snd_rawmidi_substream *substream)
 {
+        substream_open(substream, 0);
         return 0;
 }
 
@@ -988,7 +1047,7 @@ static struct snd_rawmidi_ops snd_usbmidi_input_ops = {
 static void free_urb_and_buffer(struct snd_usb_midi *umidi, struct urb *urb,
                                 unsigned int buffer_length)
 {
-        usb_buffer_free(umidi->chip->dev, buffer_length,
+        usb_buffer_free(umidi->dev, buffer_length,
                         urb->transfer_buffer, urb->transfer_dma);
         usb_free_urb(urb);
 }
@@ -1035,24 +1094,24 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
                 }
         }
         if (ep_info->in_interval)
-                pipe = usb_rcvintpipe(umidi->chip->dev, ep_info->in_ep);
+                pipe = usb_rcvintpipe(umidi->dev, ep_info->in_ep);
         else
-                pipe = usb_rcvbulkpipe(umidi->chip->dev, ep_info->in_ep);
-        length = usb_maxpacket(umidi->chip->dev, pipe, 0);
+                pipe = usb_rcvbulkpipe(umidi->dev, ep_info->in_ep);
+        length = usb_maxpacket(umidi->dev, pipe, 0);
         for (i = 0; i < INPUT_URBS; ++i) {
-                buffer = usb_buffer_alloc(umidi->chip->dev, length, GFP_KERNEL,
+                buffer = usb_buffer_alloc(umidi->dev, length, GFP_KERNEL,
                                           &ep->urbs[i]->transfer_dma);
                 if (!buffer) {
                         snd_usbmidi_in_endpoint_delete(ep);
                         return -ENOMEM;
                 }
                 if (ep_info->in_interval)
-                        usb_fill_int_urb(ep->urbs[i], umidi->chip->dev,
+                        usb_fill_int_urb(ep->urbs[i], umidi->dev,
                                          pipe, buffer, length,
                                          snd_usbmidi_in_urb_complete,
                                          ep, ep_info->in_interval);
                 else
-                        usb_fill_bulk_urb(ep->urbs[i], umidi->chip->dev,
+                        usb_fill_bulk_urb(ep->urbs[i], umidi->dev,
                                           pipe, buffer, length,
                                           snd_usbmidi_in_urb_complete, ep);
                 ep->urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
@@ -1062,27 +1121,25 @@ static int snd_usbmidi_in_endpoint_create(struct snd_usb_midi* umidi,
         return 0;
 }
 
-static unsigned int snd_usbmidi_count_bits(unsigned int x)
-{
-        unsigned int bits;
-
-        for (bits = 0; x; ++bits)
-                x &= x - 1;
-        return bits;
-}
-
 /*
  * Frees an output endpoint.
  * May be called when ep hasn't been initialized completely.
  */
-static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint* ep)
+static void snd_usbmidi_out_endpoint_clear(struct snd_usb_midi_out_endpoint *ep)
 {
         unsigned int i;
 
         for (i = 0; i < OUTPUT_URBS; ++i)
-                if (ep->urbs[i].urb)
+                if (ep->urbs[i].urb) {
                         free_urb_and_buffer(ep->umidi, ep->urbs[i].urb,
                                             ep->max_transfer);
+                        ep->urbs[i].urb = NULL;
+                }
+}
+
+static void snd_usbmidi_out_endpoint_delete(struct snd_usb_midi_out_endpoint *ep)
+{
+        snd_usbmidi_out_endpoint_clear(ep);
         kfree(ep);
 }
 
@@ -1113,15 +1170,27 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                 ep->urbs[i].ep = ep;
         }
         if (ep_info->out_interval)
-                pipe = usb_sndintpipe(umidi->chip->dev, ep_info->out_ep);
+                pipe = usb_sndintpipe(umidi->dev, ep_info->out_ep);
         else
-                pipe = usb_sndbulkpipe(umidi->chip->dev, ep_info->out_ep);
-        if (umidi->chip->usb_id == USB_ID(0x0a92, 0x1020)) /* ESI M4U */
+                pipe = usb_sndbulkpipe(umidi->dev, ep_info->out_ep);
+        switch (umidi->usb_id) {
+        default:
+                ep->max_transfer = usb_maxpacket(umidi->dev, pipe, 1);
+                break;
+                /*
+                 * Various chips declare a packet size larger than 4 bytes, but
+                 * do not actually work with larger packets:
+                 */
+        case USB_ID(0x0a92, 0x1020): /* ESI M4U */
+        case USB_ID(0x1430, 0x474b): /* RedOctane GH MIDI INTERFACE */
+        case USB_ID(0x15ca, 0x0101): /* Textech USB Midi Cable */
+        case USB_ID(0x15ca, 0x1806): /* Textech USB Midi Cable */
+        case USB_ID(0x1a86, 0x752d): /* QinHeng CH345 "USB2.0-MIDI" */
                 ep->max_transfer = 4;
-        else
-                ep->max_transfer = usb_maxpacket(umidi->chip->dev, pipe, 1);
+                break;
+        }
         for (i = 0; i < OUTPUT_URBS; ++i) {
-                buffer = usb_buffer_alloc(umidi->chip->dev,
+                buffer = usb_buffer_alloc(umidi->dev,
                                           ep->max_transfer, GFP_KERNEL,
                                           &ep->urbs[i].urb->transfer_dma);
                 if (!buffer) {
@@ -1129,12 +1198,12 @@ static int snd_usbmidi_out_endpoint_create(struct snd_usb_midi* umidi,
                         return -ENOMEM;
                 }
                 if (ep_info->out_interval)
-                        usb_fill_int_urb(ep->urbs[i].urb, umidi->chip->dev,
+                        usb_fill_int_urb(ep->urbs[i].urb, umidi->dev,
                                          pipe, buffer, ep->max_transfer,
                                          snd_usbmidi_out_urb_complete,
                                          &ep->urbs[i], ep_info->out_interval);
                 else
-                        usb_fill_bulk_urb(ep->urbs[i].urb, umidi->chip->dev,
+                        usb_fill_bulk_urb(ep->urbs[i].urb, umidi->dev,
                                           pipe, buffer, ep->max_transfer,
                                           snd_usbmidi_out_urb_complete,
                                           &ep->urbs[i]);
@@ -1172,6 +1241,7 @@ static void snd_usbmidi_free(struct snd_usb_midi* umidi)
                 if (ep->in)
                         snd_usbmidi_in_endpoint_delete(ep->in);
         }
+        mutex_destroy(&umidi->mutex);
         kfree(umidi);
 }
 
@@ -1201,15 +1271,18 @@ void snd_usbmidi_disconnect(struct list_head* p)
                                 usb_kill_urb(ep->out->urbs[j].urb);
                         if (umidi->usb_protocol_ops->finish_out_endpoint)
                                 umidi->usb_protocol_ops->finish_out_endpoint(ep->out);
+                        ep->out->active_urbs = 0;
+                        if (ep->out->drain_urbs) {
+                                ep->out->drain_urbs = 0;
+                                wake_up(&ep->out->drain_wait);
+                        }
                 }
                 if (ep->in)
                         for (j = 0; j < INPUT_URBS; ++j)
                                 usb_kill_urb(ep->in->urbs[j]);
                 /* free endpoints here; later call can result in Oops */
-                if (ep->out) {
-                        snd_usbmidi_out_endpoint_delete(ep->out);
-                        ep->out = NULL;
-                }
+                if (ep->out)
+                        snd_usbmidi_out_endpoint_clear(ep->out);
                 if (ep->in) {
                         snd_usbmidi_in_endpoint_delete(ep->in);
                         ep->in = NULL;
@@ -1360,6 +1433,12 @@ static struct port_info {
         EXTERNAL_PORT(0x086a, 0x0001, 8, "%s Broadcast"),
         EXTERNAL_PORT(0x086a, 0x0002, 8, "%s Broadcast"),
         EXTERNAL_PORT(0x086a, 0x0003, 4, "%s Broadcast"),
+        /* Access Music Virus TI */
+        EXTERNAL_PORT(0x133e, 0x0815, 0, "%s MIDI"),
+        PORT_INFO(0x133e, 0x0815, 1, "%s Synth", 0,
+                SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
+                SNDRV_SEQ_PORT_TYPE_HARDWARE |
+                SNDRV_SEQ_PORT_TYPE_SYNTHESIZER),
 };
 
 static struct port_info *find_port_info(struct snd_usb_midi* umidi, int number)
@@ -1367,7 +1446,7 @@ static struct port_info *find_port_info(struct snd_usb_midi* umidi, int number)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(snd_usbmidi_port_info); ++i) {
-                if (snd_usbmidi_port_info[i].id == umidi->chip->usb_id &&
+                if (snd_usbmidi_port_info[i].id == umidi->usb_id &&
                     snd_usbmidi_port_info[i].port == number)
                         return &snd_usbmidi_port_info[i];
         }
@@ -1405,7 +1484,7 @@ static void snd_usbmidi_init_substream(struct snd_usb_midi* umidi,
         port_info = find_port_info(umidi, number);
         name_format = port_info ? port_info->name : "%s MIDI %d";
         snprintf(substream->name, sizeof(substream->name),
-                 name_format, umidi->chip->card->shortname, number + 1);
+                 name_format, umidi->card->shortname, number + 1);
 
         *rsubstream = substream;
 }
@@ -1475,7 +1554,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
         if (hostif->extralen >= 7 &&
             ms_header->bLength >= 7 &&
             ms_header->bDescriptorType == USB_DT_CS_INTERFACE &&
-            ms_header->bDescriptorSubtype == HEADER)
+            ms_header->bDescriptorSubtype == UAC_HEADER)
                 snd_printdd(KERN_INFO "MIDIStreaming version %02x.%02x\n",
                             ms_header->bcdMSC[1], ms_header->bcdMSC[0]);
         else
@@ -1491,7 +1570,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                 if (hostep->extralen < 4 ||
                     ms_ep->bLength < 4 ||
                     ms_ep->bDescriptorType != USB_DT_CS_ENDPOINT ||
-                    ms_ep->bDescriptorSubtype != MS_GENERAL)
+                    ms_ep->bDescriptorSubtype != UAC_MS_GENERAL)
                         continue;
                 if (usb_endpoint_dir_out(ep)) {
                         if (endpoints[epidx].out_ep) {
@@ -1503,7 +1582,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                         endpoints[epidx].out_ep = usb_endpoint_num(ep);
                         if (usb_endpoint_xfer_int(ep))
                                 endpoints[epidx].out_interval = ep->bInterval;
-                        else if (snd_usb_get_speed(umidi->chip->dev) == USB_SPEED_LOW)
+                        else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
                                 /*
                                  * Low speed bulk transfers don't exist, so
                                  * force interrupt transfers for devices like
@@ -1523,7 +1602,7 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
                         endpoints[epidx].in_ep = usb_endpoint_num(ep);
                         if (usb_endpoint_xfer_int(ep))
                                 endpoints[epidx].in_interval = ep->bInterval;
-                        else if (snd_usb_get_speed(umidi->chip->dev) == USB_SPEED_LOW)
+                        else if (snd_usb_get_speed(umidi->dev) == USB_SPEED_LOW)
                                 endpoints[epidx].in_interval = 1;
                         endpoints[epidx].in_cables = (1 << ms_ep->bNumEmbMIDIJack) - 1;
                         snd_printdd(KERN_INFO "EP %02X: %d jack(s)\n",
@@ -1533,6 +1612,52 @@ static int snd_usbmidi_get_ms_info(struct snd_usb_midi* umidi,
         return 0;
 }
 
+static int roland_load_info(struct snd_kcontrol *kcontrol,
+                            struct snd_ctl_elem_info *info)
+{
+        static const char *const names[] = { "High Load", "Light Load" };
+
+        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        info->count = 1;
+        info->value.enumerated.items = 2;
+        if (info->value.enumerated.item > 1)
+                info->value.enumerated.item = 1;
+        strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
+        return 0;
+}
+
+static int roland_load_get(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *value)
+{
+        value->value.enumerated.item[0] = kcontrol->private_value;
+        return 0;
+}
+
+static int roland_load_put(struct snd_kcontrol *kcontrol,
+                           struct snd_ctl_elem_value *value)
+{
+        struct snd_usb_midi* umidi = kcontrol->private_data;
+        int changed;
+
+        if (value->value.enumerated.item[0] > 1)
+                return -EINVAL;
+        mutex_lock(&umidi->mutex);
+        changed = value->value.enumerated.item[0] != kcontrol->private_value;
+        if (changed)
+                kcontrol->private_value = value->value.enumerated.item[0];
+        mutex_unlock(&umidi->mutex);
+        return changed;
+}
+
+static struct snd_kcontrol_new roland_load_ctl = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "MIDI Input Mode",
+        .info = roland_load_info,
+        .get = roland_load_get,
+        .put = roland_load_put,
+        .private_value = 1,
+};
+
 /*
  * On Roland devices, use the second alternate setting to be able to use
  * the interrupt input endpoint.
@@ -1556,8 +1681,12 @@ static void snd_usbmidi_switch_roland_altsetting(struct snd_usb_midi* umidi)
 
         snd_printdd(KERN_INFO "switching to altsetting %d with int ep\n",
                     intfd->bAlternateSetting);
-        usb_set_interface(umidi->chip->dev, intfd->bInterfaceNumber,
+        usb_set_interface(umidi->dev, intfd->bInterfaceNumber,
                           intfd->bAlternateSetting);
+
+        umidi->roland_load_ctl = snd_ctl_new1(&roland_load_ctl, umidi);
+        if (snd_ctl_add(umidi->card, umidi->roland_load_ctl) < 0)
+                umidi->roland_load_ctl = NULL;
 }
 
 /*
@@ -1573,7 +1702,7 @@ static int snd_usbmidi_detect_endpoints(struct snd_usb_midi* umidi,
         struct usb_endpoint_descriptor* epd;
         int i, out_eps = 0, in_eps = 0;
 
-        if (USB_ID_VENDOR(umidi->chip->usb_id) == 0x0582)
+        if (USB_ID_VENDOR(umidi->usb_id) == 0x0582)
                 snd_usbmidi_switch_roland_altsetting(umidi);
 
         if (endpoint[0].out_ep || endpoint[0].in_ep)
@@ -1653,9 +1782,9 @@ static int snd_usbmidi_detect_yamaha(struct snd_usb_midi* umidi,
              cs_desc < hostif->extra + hostif->extralen && cs_desc[0] >= 2;
              cs_desc += cs_desc[0]) {
                 if (cs_desc[1] == USB_DT_CS_INTERFACE) {
-                        if (cs_desc[2] == MIDI_IN_JACK)
+                        if (cs_desc[2] == UAC_MIDI_IN_JACK)
                                 endpoint->in_cables = (endpoint->in_cables << 1) | 1;
-                        else if (cs_desc[2] == MIDI_OUT_JACK)
+                        else if (cs_desc[2] == UAC_MIDI_OUT_JACK)
                                 endpoint->out_cables = (endpoint->out_cables << 1) | 1;
                 }
         }
@@ -1760,12 +1889,12 @@ static int snd_usbmidi_create_rawmidi(struct snd_usb_midi* umidi,
         struct snd_rawmidi *rmidi;
         int err;
 
-        err = snd_rawmidi_new(umidi->chip->card, "USB MIDI",
-                              umidi->chip->next_midi_device++,
+        err = snd_rawmidi_new(umidi->card, "USB MIDI",
+                              umidi->next_midi_device++,
                               out_ports, in_ports, &rmidi);
         if (err < 0)
                 return err;
-        strcpy(rmidi->name, umidi->chip->card->shortname);
+        strcpy(rmidi->name, umidi->card->shortname);
         rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
                             SNDRV_RAWMIDI_INFO_INPUT |
                             SNDRV_RAWMIDI_INFO_DUPLEX;
@@ -1804,7 +1933,7 @@ static void snd_usbmidi_input_start_ep(struct snd_usb_midi_in_endpoint* ep)
                 return;
         for (i = 0; i < INPUT_URBS; ++i) {
                 struct urb* urb = ep->urbs[i];
-                urb->dev = ep->umidi->chip->dev;
+                urb->dev = ep->umidi->dev;
                 snd_usbmidi_submit_urb(urb, GFP_KERNEL);
         }
 }
@@ -1825,9 +1954,10 @@ void snd_usbmidi_input_start(struct list_head* p)
 /*
  * Creates and registers everything needed for a MIDI streaming interface.
  */
-int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
-                                  struct usb_interface* iface,
-                                  const struct snd_usb_audio_quirk* quirk)
+int snd_usbmidi_create(struct snd_card *card,
+                       struct usb_interface* iface,
+                       struct list_head *midi_list,
+                       const struct snd_usb_audio_quirk* quirk)
 {
         struct snd_usb_midi* umidi;
         struct snd_usb_midi_endpoint_info endpoints[MIDI_MAX_ENDPOINTS];
@@ -1837,12 +1967,16 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
         umidi = kzalloc(sizeof(*umidi), GFP_KERNEL);
         if (!umidi)
                 return -ENOMEM;
-        umidi->chip = chip;
+        umidi->dev = interface_to_usbdev(iface);
+        umidi->card = card;
         umidi->iface = iface;
         umidi->quirk = quirk;
         umidi->usb_protocol_ops = &snd_usbmidi_standard_ops;
         init_timer(&umidi->error_timer);
         spin_lock_init(&umidi->disc_lock);
+        mutex_init(&umidi->mutex);
+        umidi->usb_id = USB_ID(le16_to_cpu(umidi->dev->descriptor.idVendor),
+                               le16_to_cpu(umidi->dev->descriptor.idProduct));
         umidi->error_timer.function = snd_usbmidi_error_timer;
         umidi->error_timer.data = (unsigned long)umidi;
 
@@ -1851,7 +1985,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
         switch (quirk ? quirk->type : QUIRK_MIDI_STANDARD_INTERFACE) {
         case QUIRK_MIDI_STANDARD_INTERFACE:
                 err = snd_usbmidi_get_ms_info(umidi, endpoints);
-                if (chip->usb_id == USB_ID(0x0763, 0x0150)) /* M-Audio Uno */
+                if (umidi->usb_id == USB_ID(0x0763, 0x0150)) /* M-Audio Uno */
                         umidi->usb_protocol_ops =
                                 &snd_usbmidi_maudio_broken_running_status_ops;
                 break;
@@ -1887,7 +2021,7 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
                  * interface 0, so we have to make sure that the USB core looks
                  * again at interface 0 by calling usb_set_interface() on it.
                  */
-                usb_set_interface(umidi->chip->dev, 0, 0);
+                usb_set_interface(umidi->dev, 0, 0);
                 err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints);
                 break;
         case QUIRK_MIDI_EMAGIC:
@@ -1914,8 +2048,8 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
         out_ports = 0;
         in_ports = 0;
         for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i) {
-                out_ports += snd_usbmidi_count_bits(endpoints[i].out_cables);
-                in_ports += snd_usbmidi_count_bits(endpoints[i].in_cables);
+                out_ports += hweight16(endpoints[i].out_cables);
+                in_ports += hweight16(endpoints[i].in_cables);
         }
         err = snd_usbmidi_create_rawmidi(umidi, out_ports, in_ports);
         if (err < 0) {
@@ -1933,14 +2067,14 @@ int snd_usb_create_midi_interface(struct snd_usb_audio* chip,
                 return err;
         }
 
-        list_add(&umidi->list, &umidi->chip->midi_list);
+        list_add_tail(&umidi->list, midi_list);
 
         for (i = 0; i < MIDI_MAX_ENDPOINTS; ++i)
                 snd_usbmidi_input_start_ep(umidi->endpoints[i].in);
         return 0;
 }
 
-EXPORT_SYMBOL(snd_usb_create_midi_interface);
+EXPORT_SYMBOL(snd_usbmidi_create);
 EXPORT_SYMBOL(snd_usbmidi_input_stop);
 EXPORT_SYMBOL(snd_usbmidi_input_start);
 EXPORT_SYMBOL(snd_usbmidi_disconnect);
diff --git a/sound/usb/usbmixer.c b/sound/usb/usbmixer.c
index c998220b99c6..8e8f871b74ca 100644
--- a/sound/usb/usbmixer.c
+++ b/sound/usb/usbmixer.c
@@ -32,6 +32,8 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/usb.h>
+#include <linux/usb/audio.h>
+
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/hwdep.h>
@@ -69,13 +71,16 @@ static const struct rc_config {
         { USB_ID(0x041e, 0x3048), 2, 2, 6, 6,  2,  0x6e91 }, /* Toshiba SB0500 */
 };
 
+#define MAX_ID_ELEMS    256
+
 struct usb_mixer_interface {
         struct snd_usb_audio *chip;
         unsigned int ctrlif;
         struct list_head list;
         unsigned int ignore_ctl_error;
         struct urb *urb;
-        struct usb_mixer_elem_info **id_elems; /* array[256], indexed by unit id */
+        /* array[MAX_ID_ELEMS], indexed by unit id */
+        struct usb_mixer_elem_info **id_elems;
 
         /* Sound Blaster remote control stuff */
         const struct rc_config *rc_cfg;
@@ -105,7 +110,7 @@ struct mixer_build {
         struct usb_mixer_interface *mixer;
         unsigned char *buffer;
         unsigned int buflen;
-        DECLARE_BITMAP(unitbitmap, 256);
+        DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
         struct usb_audio_term oterm;
         const struct usbmix_name_map *map;
         const struct usbmix_selector_map *selector_map;
@@ -123,6 +128,7 @@ struct usb_mixer_elem_info {
         int channels;
         int val_type;
         int min, max, res;
+        int dBmin, dBmax;
         int cached;
         int cache_val[MAX_CHANNELS];
         u8 initialized;
@@ -186,6 +192,21 @@ enum {
         USB_PROC_DCR_RELEASE = 6,
 };
 
+/*E-mu 0202(0404) eXtension Unit(XU) control*/
+enum {
+        USB_XU_CLOCK_RATE               = 0xe301,
+        USB_XU_CLOCK_SOURCE             = 0xe302,
+        USB_XU_DIGITAL_IO_STATUS        = 0xe303,
+        USB_XU_DEVICE_OPTIONS           = 0xe304,
+        USB_XU_DIRECT_MONITORING        = 0xe305,
+        USB_XU_METERING                 = 0xe306
+};
+enum {
+        USB_XU_CLOCK_SOURCE_SELECTOR = 0x02,    /* clock source*/
+        USB_XU_CLOCK_RATE_SELECTOR = 0x03,      /* clock rate */
+        USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01,  /* the spdif format */
+        USB_XU_SOFT_LIMIT_SELECTOR = 0x03       /* soft limiter */
+};
 
 /*
  * manual mapping of mixer names
@@ -194,42 +215,50 @@ enum {
  */
 #include "usbmixer_maps.c"
 
-/* get the mapped name if the unit matches */
-static int check_mapped_name(struct mixer_build *state, int unitid, int control, char *buf, int buflen)
+static const struct usbmix_name_map *
+find_map(struct mixer_build *state, int unitid, int control)
 {
-        const struct usbmix_name_map *p;
+        const struct usbmix_name_map *p = state->map;
 
-        if (! state->map)
-                return 0;
+        if (!p)
+                return NULL;
 
         for (p = state->map; p->id; p++) {
-                if (p->id == unitid && p->name &&
-                    (! control || ! p->control || control == p->control)) {
-                        buflen--;
-                        return strlcpy(buf, p->name, buflen);
-                }
+                if (p->id == unitid &&
+                    (!control || !p->control || control == p->control))
+                        return p;
         }
-        return 0;
+        return NULL;
 }
 
-/* check whether the control should be ignored */
-static int check_ignored_ctl(struct mixer_build *state, int unitid, int control)
+/* get the mapped name if the unit matches */
+static int
+check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen)
 {
-        const struct usbmix_name_map *p;
+        if (!p || !p->name)
+                return 0;
+
+        buflen--;
+        return strlcpy(buf, p->name, buflen);
+}
 
-        if (! state->map)
+/* check whether the control should be ignored */
+static inline int
+check_ignored_ctl(const struct usbmix_name_map *p)
+{
+        if (!p || p->name || p->dB)
                 return 0;
-        for (p = state->map; p->id; p++) {
-                if (p->id == unitid && ! p->name &&
-                    (! control || ! p->control || control == p->control)) {
-                        /*
-                        printk(KERN_DEBUG "ignored control %d:%d\n",
-                               unitid, control);
-                        */
-                        return 1;
-                }
+        return 1;
+}
+
+/* dB mapping */
+static inline void check_mapped_dB(const struct usbmix_name_map *p,
+                                   struct usb_mixer_elem_info *cval)
+{
+        if (p && p->dB) {
+                cval->dBmin = p->dB->min;
+                cval->dBmax = p->dB->max;
         }
-        return 0;
 }
 
 /* get the mapped selector source name */
@@ -257,7 +286,7 @@ static void *find_audio_control_unit(struct mixer_build *state, unsigned char un
         p = NULL;
         while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
                                       USB_DT_CS_INTERFACE)) != NULL) {
-                if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
+                if (p[0] >= 4 && p[2] >= UAC_INPUT_TERMINAL && p[2] <= UAC_EXTENSION_UNIT_V1 && p[3] == unit)
                         return p;
         }
         return NULL;
@@ -378,14 +407,14 @@ static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali
 
 static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
 {
-        return get_ctl_value(cval, GET_CUR, validx, value);
+        return get_ctl_value(cval, UAC_GET_CUR, validx, value);
 }
 
 /* channel = 0: master, 1 = first channel */
 static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
                                   int channel, int *value)
 {
-        return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value);
+        return get_ctl_value(cval, UAC_GET_CUR, (cval->control << 8) | channel, value);
 }
 
 static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
@@ -439,14 +468,14 @@ static int set_ctl_value(struct usb_mixer_elem_info *cval, int request, int vali
 
 static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
 {
-        return set_ctl_value(cval, SET_CUR, validx, value);
+        return set_ctl_value(cval, UAC_SET_CUR, validx, value);
 }
 
 static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
                              int index, int value)
 {
         int err;
-        err = set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel,
+        err = set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
                             value);
         if (err < 0)
                 return err;
@@ -466,20 +495,8 @@ static int mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 
         if (size < sizeof(scale))
                 return -ENOMEM;
-        /* USB descriptions contain the dB scale in 1/256 dB unit
-         * while ALSA TLV contains in 1/100 dB unit
-         */
-        scale[2] = (convert_signed_value(cval, cval->min) * 100) / 256;
-        scale[3] = (convert_signed_value(cval, cval->max) * 100) / 256;
-        if (scale[3] <= scale[2]) {
-                /* something is wrong; assume it's either from/to 0dB */
-                if (scale[2] < 0)
-                        scale[3] = 0;
-                else if (scale[2] > 0)
-                        scale[2] = 0;
-                else /* totally crap, return an error */
-                        return -EINVAL;
-        }
+        scale[2] = cval->dBmin;
+        scale[3] = cval->dBmax;
         if (copy_to_user(_tlv, scale, sizeof(scale)))
                 return -EFAULT;
         return 0;
@@ -588,13 +605,13 @@ static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm
                 if (term_only)
                         return 0;
                 switch (iterm->type >> 16) {
-                case SELECTOR_UNIT:
+                case UAC_SELECTOR_UNIT:
                         strcpy(name, "Selector"); return 8;
-                case PROCESSING_UNIT:
+                case UAC_PROCESSING_UNIT_V1:
                         strcpy(name, "Process Unit"); return 12;
-                case EXTENSION_UNIT:
+                case UAC_EXTENSION_UNIT_V1:
                         strcpy(name, "Ext Unit"); return 8;
-                case MIXER_UNIT:
+                case UAC_MIXER_UNIT:
                         strcpy(name, "Mixer"); return 5;
                 default:
                         return sprintf(name, "Unit %d", iterm->id);
@@ -633,22 +650,22 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
         while ((p1 = find_audio_control_unit(state, id)) != NULL) {
                 term->id = id;
                 switch (p1[2]) {
-                case INPUT_TERMINAL:
+                case UAC_INPUT_TERMINAL:
                         term->type = combine_word(p1 + 4);
                         term->channels = p1[7];
                         term->chconfig = combine_word(p1 + 8);
                         term->name = p1[11];
                         return 0;
-                case FEATURE_UNIT:
+                case UAC_FEATURE_UNIT:
                         id = p1[4];
                         break; /* continue to parse */
-                case MIXER_UNIT:
+                case UAC_MIXER_UNIT:
                         term->type = p1[2] << 16; /* virtual type */
                         term->channels = p1[5 + p1[4]];
                         term->chconfig = combine_word(p1 + 6 + p1[4]);
                         term->name = p1[p1[0] - 1];
                         return 0;
-                case SELECTOR_UNIT:
+                case UAC_SELECTOR_UNIT:
                         /* call recursively to retrieve the channel info */
                         if (check_input_term(state, p1[5], term) < 0)
                                 return -ENODEV;
@@ -656,8 +673,8 @@ static int check_input_term(struct mixer_build *state, int id, struct usb_audio_
                         term->id = id;
                         term->name = p1[9 + p1[0] - 1];
                         return 0;
-                case PROCESSING_UNIT:
-                case EXTENSION_UNIT:
+                case UAC_PROCESSING_UNIT_V1:
+                case UAC_EXTENSION_UNIT_V1:
                         if (p1[6] == 1) {
                                 id = p1[7];
                                 break; /* continue to parse */
@@ -720,6 +737,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
         cval->min = default_min;
         cval->max = cval->min + 1;
         cval->res = 1;
+        cval->dBmin = cval->dBmax = 0;
 
         if (cval->val_type == USB_MIXER_BOOLEAN ||
             cval->val_type == USB_MIXER_INV_BOOLEAN) {
@@ -734,23 +752,23 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
                                         break;
                                 }
                 }
-                if (get_ctl_value(cval, GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
-                    get_ctl_value(cval, GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
+                if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
+                    get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
                         snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
                                    cval->id, cval->mixer->ctrlif, cval->control, cval->id);
                         return -EINVAL;
                 }
-                if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
+                if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
                         cval->res = 1;
                 } else {
                         int last_valid_res = cval->res;
 
                         while (cval->res > 1) {
-                                if (set_ctl_value(cval, SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
+                                if (set_ctl_value(cval, UAC_SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
                                         break;
                                 cval->res /= 2;
                         }
-                        if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
+                        if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
                                 cval->res = last_valid_res;
                 }
                 if (cval->res == 0)
@@ -787,6 +805,24 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min)
 
                 cval->initialized = 1;
         }
+
+        /* USB descriptions contain the dB scale in 1/256 dB unit
+         * while ALSA TLV contains in 1/100 dB unit
+         */
+        cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
+        cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
+        if (cval->dBmin > cval->dBmax) {
+                /* something is wrong; assume it's either from/to 0dB */
+                if (cval->dBmin < 0)
+                        cval->dBmax = 0;
+                else if (cval->dBmin > 0)
+                        cval->dBmin = 0;
+                if (cval->dBmin > cval->dBmax) {
+                        /* totally crap, return an error */
+                        return -EINVAL;
+                }
+        }
+
         return 0;
 }
 
@@ -912,6 +948,7 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
         int nameid = desc[desc[0] - 1];
         struct snd_kcontrol *kctl;
         struct usb_mixer_elem_info *cval;
+        const struct usbmix_name_map *map;
 
         control++; /* change from zero-based to 1-based value */
 
@@ -920,7 +957,8 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                 return;
         }
 
-        if (check_ignored_ctl(state, unitid, control))
+        map = find_map(state, unitid, control);
+        if (check_ignored_ctl(map))
                 return;
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
@@ -954,10 +992,11 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
         }
         kctl->private_free = usb_mixer_elem_free;
 
-        len = check_mapped_name(state, unitid, control, kctl->id.name, sizeof(kctl->id.name));
+        len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
         mapped_name = len != 0;
         if (! len && nameid)
-                len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
+                len = snd_usb_copy_string_desc(state, nameid,
+                                kctl->id.name, sizeof(kctl->id.name));
 
         switch (control) {
         case USB_FEATURE_MUTE:
@@ -995,6 +1034,7 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
                         kctl->vd[0].access |= 
                                 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
                                 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
+                        check_mapped_dB(map, cval);
                 }
                 break;
 
@@ -1048,29 +1088,30 @@ static void build_feature_ctl(struct mixer_build *state, unsigned char *desc,
  *
  * most of controlls are defined here.
  */
-static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsigned char *ftr)
+static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void *_ftr)
 {
         int channels, i, j;
         struct usb_audio_term iterm;
         unsigned int master_bits, first_ch_bits;
         int err, csize;
+        struct uac_feature_unit_descriptor *ftr = _ftr;
 
-        if (ftr[0] < 7 || ! (csize = ftr[5]) || ftr[0] < 7 + csize) {
-                snd_printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
+        if (ftr->bLength < 7 || ! (csize = ftr->bControlSize) || ftr->bLength < 7 + csize) {
+                snd_printk(KERN_ERR "usbaudio: unit %u: invalid UAC_FEATURE_UNIT descriptor\n", unitid);
                 return -EINVAL;
         }
 
         /* parse the source unit */
-        if ((err = parse_audio_unit(state, ftr[4])) < 0)
+        if ((err = parse_audio_unit(state, ftr->bSourceID)) < 0)
                 return err;
 
         /* determine the input source type and name */
-        if (check_input_term(state, ftr[4], &iterm) < 0)
+        if (check_input_term(state, ftr->bSourceID, &iterm) < 0)
                 return -EINVAL;
 
-        channels = (ftr[0] - 7) / csize - 1;
+        channels = (ftr->bLength - 7) / csize - 1;
 
-        master_bits = snd_usb_combine_bytes(ftr + 6, csize);
+        master_bits = snd_usb_combine_bytes(ftr->controls, csize);
         /* master configuration quirks */
         switch (state->chip->usb_id) {
         case USB_ID(0x08bb, 0x2702):
@@ -1081,21 +1122,21 @@ static int parse_audio_feature_unit(struct mixer_build *state, int unitid, unsig
                 break;
         }
         if (channels > 0)
-                first_ch_bits = snd_usb_combine_bytes(ftr + 6 + csize, csize);
+                first_ch_bits = snd_usb_combine_bytes(ftr->controls + csize, csize);
         else
                 first_ch_bits = 0;
         /* check all control types */
         for (i = 0; i < 10; i++) {
                 unsigned int ch_bits = 0;
                 for (j = 0; j < channels; j++) {
-                        unsigned int mask = snd_usb_combine_bytes(ftr + 6 + csize * (j+1), csize);
+                        unsigned int mask = snd_usb_combine_bytes(ftr->controls + csize * (j+1), csize);
                         if (mask & (1 << i))
                                 ch_bits |= (1 << j);
                 }
                 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
-                        build_feature_ctl(state, ftr, ch_bits, i, &iterm, unitid);
+                        build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid);
                 if (master_bits & (1 << i))
-                        build_feature_ctl(state, ftr, 0, i, &iterm, unitid);
+                        build_feature_ctl(state, _ftr, 0, i, &iterm, unitid);
         }
 
         return 0;
@@ -1122,8 +1163,10 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
         unsigned int num_outs = desc[5 + input_pins];
         unsigned int i, len;
         struct snd_kcontrol *kctl;
+        const struct usbmix_name_map *map;
 
-        if (check_ignored_ctl(state, unitid, 0))
+        map = find_map(state, unitid, 0);
+        if (check_ignored_ctl(map))
                 return;
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
@@ -1152,7 +1195,7 @@ static void build_mixer_unit_ctl(struct mixer_build *state, unsigned char *desc,
         }
         kctl->private_free = usb_mixer_elem_free;
 
-        len = check_mapped_name(state, unitid, 0, kctl->id.name, sizeof(kctl->id.name));
+        len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
         if (! len)
                 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
         if (! len)
@@ -1330,7 +1373,32 @@ static struct procunit_info procunits[] = {
         { USB_PROC_DCR, "DCR", dcr_proc_info },
         { 0 },
 };
-
+/*
+ * predefined data for extension units
+ */
+static struct procunit_value_info clock_rate_xu_info[] = {
+       { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 },
+       { 0 }
+};
+static struct procunit_value_info clock_source_xu_info[] = {
+        { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN },
+        { 0 }
+};
+static struct procunit_value_info spdif_format_xu_info[] = {
+        { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN },
+        { 0 }
+};
+static struct procunit_value_info soft_limit_xu_info[] = {
+        { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN },
+        { 0 }
+};
+static struct procunit_info extunits[] = {
+        { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info },
+        { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info },
+        { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info },
+        { USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info },
+        { 0 }
+};
 /*
  * build a processing/extension unit
  */
@@ -1342,6 +1410,7 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
         int i, err, nameid, type, len;
         struct procunit_info *info;
         struct procunit_value_info *valinfo;
+        const struct usbmix_name_map *map;
         static struct procunit_value_info default_value_info[] = {
                 { 0x01, "Switch", USB_MIXER_BOOLEAN },
                 { 0 }
@@ -1371,7 +1440,8 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                 /* FIXME: bitmap might be longer than 8bit */
                 if (! (dsc[12 + num_ins] & (1 << (valinfo->control - 1))))
                         continue;
-                if (check_ignored_ctl(state, unitid, valinfo->control))
+                map = find_map(state, unitid, valinfo->control);
+                if (check_ignored_ctl(map))
                         continue;
                 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
                 if (! cval) {
@@ -1391,8 +1461,18 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                         cval->max = dsc[15];
                         cval->res = 1;
                         cval->initialized = 1;
-                } else
-                        get_min_max(cval, valinfo->min_value);
+                } else {
+                        if (type == USB_XU_CLOCK_RATE) {
+                                /* E-Mu USB 0404/0202/TrackerPre
+                                 * samplerate control quirk
+                                 */
+                                cval->min = 0;
+                                cval->max = 5;
+                                cval->res = 1;
+                                cval->initialized = 1;
+                        } else
+                                get_min_max(cval, valinfo->min_value);
+                }
 
                 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
                 if (! kctl) {
@@ -1402,8 +1482,9 @@ static int build_audio_procunit(struct mixer_build *state, int unitid, unsigned
                 }
                 kctl->private_free = usb_mixer_elem_free;
 
-                if (check_mapped_name(state, unitid, cval->control, kctl->id.name, sizeof(kctl->id.name)))
-                        ;
+                if (check_mapped_name(map, kctl->id.name,
+                                                sizeof(kctl->id.name)))
+                        /* nothing */ ;
                 else if (info->name)
                         strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name));
                 else {
@@ -1433,7 +1514,7 @@ static int parse_audio_processing_unit(struct mixer_build *state, int unitid, un
 
 static int parse_audio_extension_unit(struct mixer_build *state, int unitid, unsigned char *desc)
 {
-        return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit");
+        return build_audio_procunit(state, unitid, desc, extunits, "Extension Unit");
 }
 
 
@@ -1542,6 +1623,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
         int err;
         struct usb_mixer_elem_info *cval;
         struct snd_kcontrol *kctl;
+        const struct usbmix_name_map *map;
         char **namelist;
 
         if (! num_ins || desc[0] < 5 + num_ins) {
@@ -1557,7 +1639,8 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
         if (num_ins == 1) /* only one ? nonsense! */
                 return 0;
 
-        if (check_ignored_ctl(state, unitid, 0))
+        map = find_map(state, unitid, 0);
+        if (check_ignored_ctl(map))
                 return 0;
 
         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
@@ -1612,7 +1695,7 @@ static int parse_audio_selector_unit(struct mixer_build *state, int unitid, unsi
         kctl->private_free = usb_mixer_selector_elem_free;
 
         nameid = desc[desc[0] - 1];
-        len = check_mapped_name(state, unitid, 0, kctl->id.name, sizeof(kctl->id.name));
+        len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
         if (len)
                 ;
         else if (nameid)
@@ -1656,17 +1739,17 @@ static int parse_audio_unit(struct mixer_build *state, int unitid)
         }
 
         switch (p1[2]) {
-        case INPUT_TERMINAL:
+        case UAC_INPUT_TERMINAL:
                 return 0; /* NOP */
-        case MIXER_UNIT:
+        case UAC_MIXER_UNIT:
                 return parse_audio_mixer_unit(state, unitid, p1);
-        case SELECTOR_UNIT:
+        case UAC_SELECTOR_UNIT:
                 return parse_audio_selector_unit(state, unitid, p1);
-        case FEATURE_UNIT:
+        case UAC_FEATURE_UNIT:
                 return parse_audio_feature_unit(state, unitid, p1);
-        case PROCESSING_UNIT:
+        case UAC_PROCESSING_UNIT_V1:
                 return parse_audio_processing_unit(state, unitid, p1);
-        case EXTENSION_UNIT:
+        case UAC_EXTENSION_UNIT_V1:
                 return parse_audio_extension_unit(state, unitid, p1);
         default:
                 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
@@ -1696,11 +1779,11 @@ static int snd_usb_mixer_dev_free(struct snd_device *device)
 /*
  * create mixer controls
  *
- * walk through all OUTPUT_TERMINAL descriptors to search for mixers
+ * walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers
  */
 static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
 {
-        unsigned char *desc;
+        struct uac_output_terminal_descriptor_v1 *desc;
         struct mixer_build state;
         int err;
         const struct usbmix_ctl_map *map;
@@ -1724,14 +1807,14 @@ static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
         }
 
         desc = NULL;
-        while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, OUTPUT_TERMINAL)) != NULL) {
-                if (desc[0] < 9)
+        while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, UAC_OUTPUT_TERMINAL)) != NULL) {
+                if (desc->bLength < 9)
                         continue; /* invalid descriptor? */
-                set_bit(desc[3], state.unitbitmap);  /* mark terminal ID as visited */
-                state.oterm.id = desc[3];
-                state.oterm.type = combine_word(&desc[4]);
-                state.oterm.name = desc[8];
-                err = parse_audio_unit(&state, desc[7]);
+                set_bit(desc->bTerminalID, state.unitbitmap);  /* mark terminal ID as visited */
+                state.oterm.id = desc->bTerminalID;
+                state.oterm.type = le16_to_cpu(desc->wTerminalType);
+                state.oterm.name = desc->iTerminal;
+                err = parse_audio_unit(&state, desc->bSourceID);
                 if (err < 0)
                         return err;
         }
@@ -1748,6 +1831,46 @@ static void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer,
                                info->elem_id);
 }
 
+static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer,
+                                    int unitid,
+                                    struct usb_mixer_elem_info *cval)
+{
+        static char *val_types[] = {"BOOLEAN", "INV_BOOLEAN",
+                                    "S8", "U8", "S16", "U16"};
+        snd_iprintf(buffer, "  Unit: %i\n", unitid);
+        if (cval->elem_id)
+                snd_iprintf(buffer, "    Control: name=\"%s\", index=%i\n",
+                                cval->elem_id->name, cval->elem_id->index);
+        snd_iprintf(buffer, "    Info: id=%i, control=%i, cmask=0x%x, "
+                            "channels=%i, type=\"%s\"\n", cval->id,
+                            cval->control, cval->cmask, cval->channels,
+                            val_types[cval->val_type]);
+        snd_iprintf(buffer, "    Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n",
+                            cval->min, cval->max, cval->dBmin, cval->dBmax);
+}
+
+static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
+                                    struct snd_info_buffer *buffer)
+{
+        struct snd_usb_audio *chip = entry->private_data;
+        struct usb_mixer_interface *mixer;
+        struct usb_mixer_elem_info *cval;
+        int unitid;
+
+        list_for_each_entry(mixer, &chip->mixer_list, list) {
+                snd_iprintf(buffer,
+                        "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
+                                chip->usb_id, mixer->ctrlif,
+                                mixer->ignore_ctl_error);
+                snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
+                for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
+                        for (cval = mixer->id_elems[unitid]; cval;
+                                                cval = cval->next_id_elem)
+                                snd_usb_mixer_dump_cval(buffer, unitid, cval);
+                }
+        }
+}
+
 static void snd_usb_mixer_memory_change(struct usb_mixer_interface *mixer,
                                         int unitid)
 {
@@ -1924,7 +2047,7 @@ static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
         }
         mixer->rc_setup_packet->bRequestType =
                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
-        mixer->rc_setup_packet->bRequest = GET_MEM;
+        mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
         mixer->rc_setup_packet->wValue = cpu_to_le16(0);
         mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
         mixer->rc_setup_packet->wLength = cpu_to_le16(len);
@@ -2047,7 +2170,7 @@ static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
                 snd_iprintf(buffer, "%s: ", jacks[i].name);
                 err = snd_usb_ctl_msg(mixer->chip->dev,
                                       usb_rcvctrlpipe(mixer->chip->dev, 0),
-                                      GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
+                                      UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
                                       USB_RECIP_INTERFACE, 0,
                                       jacks[i].unitid << 8, buf, 3, 100);
                 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
@@ -2109,6 +2232,24 @@ static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
         return 0;
 }
 
+void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
+                               unsigned char samplerate_id)
+{
+        struct usb_mixer_interface *mixer;
+        struct usb_mixer_elem_info *cval;
+        int unitid = 12; /* SamleRate ExtensionUnit ID */
+
+        list_for_each_entry(mixer, &chip->mixer_list, list) {
+                cval = mixer->id_elems[unitid];
+                if (cval) {
+                        set_cur_ctl_value(cval, cval->control << 8,
+                                          samplerate_id);
+                        snd_usb_mixer_notify_id(mixer, unitid);
+                }
+                break;
+        }
+}
+
 int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                          int ignore_error)
 {
@@ -2116,7 +2257,9 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
                 .dev_free = snd_usb_mixer_dev_free
         };
         struct usb_mixer_interface *mixer;
-        int err;
+        struct snd_info_entry *entry;
+        struct usb_host_interface *host_iface;
+        int err, protocol;
 
         strcpy(chip->card->mixername, "USB Mixer");
 
@@ -2126,12 +2269,23 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         mixer->chip = chip;
         mixer->ctrlif = ctrlif;
         mixer->ignore_ctl_error = ignore_error;
-        mixer->id_elems = kcalloc(256, sizeof(*mixer->id_elems), GFP_KERNEL);
+        mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
+                                  GFP_KERNEL);
         if (!mixer->id_elems) {
                 kfree(mixer);
                 return -ENOMEM;
         }
 
+        host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
+        protocol = host_iface->desc.bInterfaceProtocol;
+
+        /* FIXME! */
+        if (protocol != UAC_VERSION_1) {
+                snd_printk(KERN_WARNING "mixer interface protocol 0x%02x not yet supported\n",
+                                        protocol);
+                return 0;
+        }
+
         if ((err = snd_usb_mixer_controls(mixer)) < 0 ||
             (err = snd_usb_mixer_status_create(mixer)) < 0)
                 goto _error;
@@ -2142,8 +2296,6 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
             mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
             mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
-                struct snd_info_entry *entry;
-
                 if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
                         goto _error;
                 if (!snd_card_proc_new(chip->card, "audigy2nx", &entry))
@@ -2161,6 +2313,11 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
         err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
         if (err < 0)
                 goto _error;
+
+        if (list_empty(&chip->mixer_list) &&
+            !snd_card_proc_new(chip->card, "usbmixer", &entry))
+                snd_info_set_text_ops(entry, chip, snd_usb_mixer_proc_read);
+
         list_add(&mixer->list, &chip->mixer_list);
         return 0;
 
diff --git a/sound/usb/usbmixer_maps.c b/sound/usb/usbmixer_maps.c
index 3e5d66cf1f5a..79e903a60862 100644
--- a/sound/usb/usbmixer_maps.c
+++ b/sound/usb/usbmixer_maps.c
@@ -19,11 +19,16 @@
  *
  */
 
+struct usbmix_dB_map {
+        u32 min;
+        u32 max;
+};
 
 struct usbmix_name_map {
         int id;
         const char *name;
         int control;
+        struct usbmix_dB_map *dB;
 };
 
 struct usbmix_selector_map {
@@ -72,7 +77,7 @@ static struct usbmix_name_map extigy_map[] = {
         { 8, "Line Playback" }, /* FU */
         /* 9: IT mic */
         { 10, "Mic Playback" }, /* FU */
-        { 11, "Capture Input Source" }, /* SU */
+        { 11, "Capture Source" }, /* SU */
         { 12, "Capture" }, /* FU */
         /* 13: OT pcm capture */
         /* 14: MU (w/o controls) */
@@ -102,6 +107,9 @@ static struct usbmix_name_map extigy_map[] = {
  * e.g. no Master and fake PCM volume
  *                      Pavel Mihaylov <bin@bash.info>
  */
+static struct usbmix_dB_map mp3plus_dB_1 = {-4781, 0};  /* just guess */
+static struct usbmix_dB_map mp3plus_dB_2 = {-1781, 618}; /* just guess */
+
 static struct usbmix_name_map mp3plus_map[] = {
         /* 1: IT pcm */
         /* 2: IT mic */
@@ -110,16 +118,19 @@ static struct usbmix_name_map mp3plus_map[] = {
         /* 5: OT digital out */
         /* 6: OT speaker */
         /* 7: OT pcm capture */
-        { 8, "Capture Input Source" }, /* FU, default PCM Capture Source */
+        { 8, "Capture Source" }, /* FU, default PCM Capture Source */
                 /* (Mic, Input 1 = Line input, Input 2 = Optical input) */
         { 9, "Master Playback" }, /* FU, default Speaker 1 */
         /* { 10, "Mic Capture", 1 }, */ /* FU, Mic Capture */
-        /* { 10, "Mic Capture", 2 }, */ /* FU, Mic Capture */
+        { 10, /* "Mic Capture", */ NULL, 2, .dB = &mp3plus_dB_2 },
+                /* FU, Mic Capture */
         { 10, "Mic Boost", 7 }, /* FU, default Auto Gain Input */
-        { 11, "Line Capture" }, /* FU, default PCM Capture */
+        { 11, "Line Capture", .dB = &mp3plus_dB_2 },
+                /* FU, default PCM Capture */
         { 12, "Digital In Playback" }, /* FU, default PCM 1 */
-        /* { 13, "Mic Playback" }, */ /* FU, default Mic Playback */
-        { 14, "Line Playback" }, /* FU, default Speaker */
+        { 13, /* "Mic Playback", */ .dB = &mp3plus_dB_1 },
+                /* FU, default Mic Playback */
+        { 14, "Line Playback", .dB = &mp3plus_dB_1 }, /* FU, default Speaker */
         /* 15: MU */
         { 0 } /* terminator */
 };
@@ -277,6 +288,22 @@ static struct usbmix_name_map scratch_live_map[] = {
         { 0 } /* terminator */
 };
 
+/* "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.
+ *  FIXME: or mp3plus_map should use "Capture Source" too,
+ *  so this maps can be merget
+ */
+static struct usbmix_name_map hercules_usb51_map[] = {
+        { 8, "Capture Source" },        /* SU, default "PCM Capture Source" */
+        { 9, "Master Playback" },       /* FU, default "Speaker Playback" */
+        { 10, "Mic Boost", 7 },         /* FU, default "Auto Gain Input" */
+        { 11, "Line Capture" },         /* FU, default "PCM Capture" */
+        { 13, "Mic Bypass Playback" },  /* FU, default "Mic Playback" */
+        { 14, "Line Bypass Playback" }, /* FU, default "Line Playback" */
+        { 0 }                           /* terminator */
+};
+
 /*
  * Control map entries
  */
@@ -316,6 +343,13 @@ static struct usbmix_ctl_map usbmix_ctl_maps[] = {
                 .ignore_ctl_error = 1,
         },
         {
+                /* Hercules Gamesurround Muse Pocket LT
+                 * (USB 5.1 Channel Audio Adapter)
+                 */
+                .id = USB_ID(0x06f8, 0xc000),
+                .map = hercules_usb51_map,
+        },
+        {
                 .id = USB_ID(0x08bb, 0x2702),
                 .map = linex_map,
                 .ignore_ctl_error = 1,
diff --git a/sound/usb/usbquirks.h b/sound/usb/usbquirks.h
index f6f201eb24ce..2b426c1fd0e8 100644
--- a/sound/usb/usbquirks.h
+++ b/sound/usb/usbquirks.h
@@ -91,7 +91,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x0850,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -100,7 +100,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08ae,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -109,7 +109,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08c6,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -118,7 +118,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08f0,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -127,7 +127,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08f5,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
@@ -136,7 +136,7 @@
         .idVendor = 0x046d,
         .idProduct = 0x08f6,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 },
 {
         USB_DEVICE(0x046d, 0x0990),
@@ -301,7 +301,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                                         .iface = 1,
                                         .altsetting = 1,
                                         .altset_idx = 1,
-                                        .attributes = EP_CS_ATTR_FILL_MAX,
+                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX,
                                         .endpoint = 0x81,
                                         .ep_attr = 0x05,
                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
@@ -1016,36 +1016,6 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 {
-        USB_DEVICE(0x0582, 0x0044),
-        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
-                .vendor_name = "Roland",
-                .product_name = "UA-1000",
-                .ifnum = QUIRK_ANY_INTERFACE,
-                .type = QUIRK_COMPOSITE,
-                .data = (const struct snd_usb_audio_quirk[]) {
-                        {
-                                .ifnum = 1,
-                                .type = QUIRK_AUDIO_EDIROL_UA1000
-                        },
-                        {
-                                .ifnum = 2,
-                                .type = QUIRK_AUDIO_EDIROL_UA1000
-                        },
-                        {
-                                .ifnum = 3,
-                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
-                                .data = & (const struct snd_usb_midi_endpoint_info) {
-                                        .out_cables = 0x0003,
-                                        .in_cables  = 0x0003
-                                }
-                        },
-                        {
-                                .ifnum = -1
-                        }
-                }
-        }
-},
-{
         /* has ID 0x0049 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0047),
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
@@ -1266,37 +1236,6 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
-/* Roland UA-101 in High-Speed Mode only */
-{
-        USB_DEVICE(0x0582, 0x007d),
-        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
-                .vendor_name = "Roland",
-                .product_name = "UA-101",
-                .ifnum = QUIRK_ANY_INTERFACE,
-                .type = QUIRK_COMPOSITE,
-                .data = (const struct snd_usb_audio_quirk[]) {
-                        {
-                                .ifnum = 0,
-                                .type = QUIRK_AUDIO_EDIROL_UA101
-                        },
-                        {
-                                .ifnum = 1,
-                                .type = QUIRK_AUDIO_EDIROL_UA101
-                        },
-                        {
-                                .ifnum = 2,
-                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
-                                .data = & (const struct snd_usb_midi_endpoint_info) {
-                                        .out_cables = 0x0001,
-                                        .in_cables  = 0x0001
-                                }
-                        },
-                        {
-                                .ifnum = -1
-                        }
-                }
-        }
-},
 {
         /* has ID 0x0081 when not in "Advanced Driver" mode */
         USB_DEVICE(0x0582, 0x0080),
@@ -1563,6 +1502,29 @@ YAMAHA_DEVICE(0x7010, "UB99"),
                 }
         }
 },
+{
+        /* has ID 0x00ea when not in Advanced Driver mode */
+        USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
+        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
+                /* .vendor_name = "Roland", */
+                /* .product_name = "UA-1G", */
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
 
 /* Guillemot devices */
 {
@@ -2050,6 +2012,33 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 
+/* Access Music devices */
+{
+        /* VirusTI Desktop */
+        USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = &(const struct snd_usb_audio_quirk[]) {
+                        {
+                                .ifnum = 3,
+                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
+                                .data = &(const struct snd_usb_midi_endpoint_info) {
+                                        .out_cables = 0x0003,
+                                        .in_cables  = 0x0003
+                                }
+                        },
+                        {
+                                .ifnum = 4,
+                                .type = QUIRK_IGNORE_INTERFACE
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+        }
+},
+
 /* */
 {
         /* aka. Serato Scratch Live DJ Box */
@@ -2082,6 +2071,165 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         }
 },
 
+/* Hauppauge HVR-950Q and HVR-850 */
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7201),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7202),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7203),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7204),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7205),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7250),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-950Q",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+{
+        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7230),
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
+                       USB_DEVICE_ID_MATCH_INT_CLASS |
+                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
+        .bInterfaceClass = USB_CLASS_AUDIO,
+        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Hauppauge",
+                .product_name = "HVR-850",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
+        }
+},
+
+/* Digidesign Mbox */
+{
+        /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
+        USB_DEVICE(0x0dba, 0x1000),
+        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
+                .vendor_name = "Digidesign",
+                .product_name = "MBox",
+                .ifnum = QUIRK_ANY_INTERFACE,
+                .type = QUIRK_COMPOSITE,
+                .data = (const struct snd_usb_audio_quirk[]){
+                        {
+                                .ifnum = 0,
+                                .type = QUIRK_IGNORE_INTERFACE,
+                        },
+                        {
+                                .ifnum = 1,
+                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
+                                .data = &(const struct audioformat) {
+                                        .format = SNDRV_PCM_FORMAT_S24_3BE,
+                                        .channels = 2,
+                                        .iface = 1,
+                                        .altsetting = 1,
+                                        .altset_idx = 1,
+                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
+                                        .endpoint = 0x02,
+                                        .ep_attr = 0x01,
+                                        .maxpacksize = 0x130,
+                                        .rates = SNDRV_PCM_RATE_44100 |
+                                                 SNDRV_PCM_RATE_48000,
+                                        .rate_min = 44100,
+                                        .rate_max = 48000,
+                                        .nr_rates = 2,
+                                        .rate_table = (unsigned int[]) {
+                                                44100, 48000
+                                        }
+                                }
+                        },
+                        {
+                                .ifnum = -1
+                        }
+                }
+
+        }
+},
+
 {
         /*
          * Some USB MIDI devices don't have an audio control interface,
@@ -2090,7 +2238,7 @@ YAMAHA_DEVICE(0x7010, "UB99"),
         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
         .bInterfaceClass = USB_CLASS_AUDIO,
-        .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
+        .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
                 .ifnum = QUIRK_ANY_INTERFACE,
                 .type = QUIRK_MIDI_STANDARD_INTERFACE
diff --git a/sound/usb/usx2y/us122l.c b/sound/usb/usx2y/us122l.c
index 99f33766cd51..9ca9a13a78da 100644
--- a/sound/usb/usx2y/us122l.c
+++ b/sound/usb/usx2y/us122l.c
@@ -16,6 +16,9 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/audio.h>
 #include <sound/core.h>
 #include <sound/hwdep.h>
 #include <sound/pcm.h>
@@ -59,11 +62,33 @@ static int us122l_create_usbmidi(struct snd_card *card)
                 .type = QUIRK_MIDI_US122L,
                 .data = &quirk_data
         };
-        struct usb_device *dev = US122L(card)->chip.dev;
+        struct usb_device *dev = US122L(card)->dev;
         struct usb_interface *iface = usb_ifnum_to_if(dev, 1);
 
-        return snd_usb_create_midi_interface(&US122L(card)->chip,
-                                             iface, &quirk);
+        return snd_usbmidi_create(card, iface,
+                                  &US122L(card)->midi_list, &quirk);
+}
+
+static int us144_create_usbmidi(struct snd_card *card)
+{
+        static struct snd_usb_midi_endpoint_info quirk_data = {
+                .out_ep = 4,
+                .in_ep = 3,
+                .out_cables =   0x001,
+                .in_cables =    0x001
+        };
+        static struct snd_usb_audio_quirk quirk = {
+                .vendor_name =  "US144",
+                .product_name = NAME_ALLCAPS,
+                .ifnum =        0,
+                .type = QUIRK_MIDI_US122L,
+                .data = &quirk_data
+        };
+        struct usb_device *dev = US122L(card)->dev;
+        struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
+
+        return snd_usbmidi_create(card, iface,
+                                  &US122L(card)->midi_list, &quirk);
 }
 
 /*
@@ -171,7 +196,13 @@ static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
 
         if (!us122l->first)
                 us122l->first = file;
-        iface = usb_ifnum_to_if(us122l->chip.dev, 1);
+
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                iface = usb_ifnum_to_if(us122l->dev, 0);
+                usb_autopm_get_interface(iface);
+        }
+        iface = usb_ifnum_to_if(us122l->dev, 1);
         usb_autopm_get_interface(iface);
         return 0;
 }
@@ -179,8 +210,15 @@ static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
 static int usb_stream_hwdep_release(struct snd_hwdep *hw, struct file *file)
 {
         struct us122l   *us122l = hw->private_data;
-        struct usb_interface *iface = usb_ifnum_to_if(us122l->chip.dev, 1);
+        struct usb_interface *iface;
         snd_printdd(KERN_DEBUG "%p %p\n", hw, file);
+
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                iface = usb_ifnum_to_if(us122l->dev, 0);
+                usb_autopm_put_interface(iface);
+        }
+        iface = usb_ifnum_to_if(us122l->dev, 1);
         usb_autopm_put_interface(iface);
         if (us122l->first == file)
                 us122l->first = NULL;
@@ -264,7 +302,7 @@ static unsigned int usb_stream_hwdep_poll(struct snd_hwdep *hw,
 static void us122l_stop(struct us122l *us122l)
 {
         struct list_head *p;
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_stop(p);
 
         usb_stream_stop(&us122l->sk);
@@ -280,9 +318,9 @@ static int us122l_set_sample_rate(struct usb_device *dev, int rate)
         data[0] = rate;
         data[1] = rate >> 8;
         data[2] = rate >> 16;
-        err = us122l_ctl_msg(dev, usb_sndctrlpipe(dev, 0), SET_CUR,
+        err = us122l_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
                              USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
-                             SAMPLING_FREQ_CONTROL << 8, ep, data, 3, 1000);
+                             UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3, 1000);
         if (err < 0)
                 snd_printk(KERN_ERR "%d: cannot set freq %d to ep 0x%x\n",
                            dev->devnum, rate, ep);
@@ -297,7 +335,7 @@ static bool us122l_start(struct us122l *us122l,
         unsigned use_packsize = 0;
         bool success = false;
 
-        if (us122l->chip.dev->speed == USB_SPEED_HIGH) {
+        if (us122l->dev->speed == USB_SPEED_HIGH) {
                 /* The us-122l's descriptor defaults to iso max_packsize 78,
                    which isn't needed for samplerates <= 48000.
                    Lets save some memory:
@@ -314,11 +352,11 @@ static bool us122l_start(struct us122l *us122l,
                         break;
                 }
         }
-        if (!usb_stream_new(&us122l->sk, us122l->chip.dev, 1, 2,
+        if (!usb_stream_new(&us122l->sk, us122l->dev, 1, 2,
                             rate, use_packsize, period_frames, 6))
                 goto out;
 
-        err = us122l_set_sample_rate(us122l->chip.dev, rate);
+        err = us122l_set_sample_rate(us122l->dev, rate);
         if (err < 0) {
                 us122l_stop(us122l);
                 snd_printk(KERN_ERR "us122l_set_sample_rate error \n");
@@ -330,7 +368,7 @@ static bool us122l_start(struct us122l *us122l,
                 snd_printk(KERN_ERR "us122l_start error %i \n", err);
                 goto out;
         }
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_start(p);
         success = true;
 out:
@@ -357,7 +395,7 @@ static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
                 err = -ENXIO;
                 goto free;
         }
-        high_speed = us122l->chip.dev->speed == USB_SPEED_HIGH;
+        high_speed = us122l->dev->speed == USB_SPEED_HIGH;
         if ((cfg->sample_rate != 44100 && cfg->sample_rate != 48000  &&
              (!high_speed ||
               (cfg->sample_rate != 88200 && cfg->sample_rate != 96000))) ||
@@ -417,7 +455,7 @@ static int usb_stream_hwdep_new(struct snd_card *card)
 {
         int err;
         struct snd_hwdep *hw;
-        struct usb_device *dev = US122L(card)->chip.dev;
+        struct usb_device *dev = US122L(card)->dev;
 
         err = snd_hwdep_new(card, SND_USB_STREAM_ID, 0, &hw);
         if (err < 0)
@@ -443,19 +481,31 @@ static bool us122l_create_card(struct snd_card *card)
         int err;
         struct us122l *us122l = US122L(card);
 
-        err = usb_set_interface(us122l->chip.dev, 1, 1);
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                err = usb_set_interface(us122l->dev, 0, 1);
+                if (err) {
+                        snd_printk(KERN_ERR "usb_set_interface error \n");
+                        return false;
+                }
+        }
+        err = usb_set_interface(us122l->dev, 1, 1);
         if (err) {
                 snd_printk(KERN_ERR "usb_set_interface error \n");
                 return false;
         }
 
-        pt_info_set(us122l->chip.dev, 0x11);
-        pt_info_set(us122l->chip.dev, 0x10);
+        pt_info_set(us122l->dev, 0x11);
+        pt_info_set(us122l->dev, 0x10);
 
         if (!us122l_start(us122l, 44100, 256))
                 return false;
 
-        err = us122l_create_usbmidi(card);
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII)
+                err = us144_create_usbmidi(card);
+        else
+                err = us122l_create_usbmidi(card);
         if (err < 0) {
                 snd_printk(KERN_ERR "us122l_create_usbmidi error %i \n", err);
                 us122l_stop(us122l);
@@ -465,7 +515,7 @@ static bool us122l_create_card(struct snd_card *card)
         if (err < 0) {
 /* release the midi resources */
                 struct list_head *p;
-                list_for_each(p, &us122l->chip.midi_list)
+                list_for_each(p, &us122l->midi_list)
                         snd_usbmidi_disconnect(p);
 
                 us122l_stop(us122l);
@@ -477,7 +527,7 @@ static bool us122l_create_card(struct snd_card *card)
 static void snd_us122l_free(struct snd_card *card)
 {
         struct us122l   *us122l = US122L(card);
-        int             index = us122l->chip.index;
+        int             index = us122l->card_index;
         if (index >= 0  &&  index < SNDRV_CARDS)
                 snd_us122l_card_used[index] = 0;
 }
@@ -497,13 +547,12 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
                               sizeof(struct us122l), &card);
         if (err < 0)
                 return err;
-        snd_us122l_card_used[US122L(card)->chip.index = dev] = 1;
+        snd_us122l_card_used[US122L(card)->card_index = dev] = 1;
         card->private_free = snd_us122l_free;
-        US122L(card)->chip.dev = device;
-        US122L(card)->chip.card = card;
+        US122L(card)->dev = device;
         mutex_init(&US122L(card)->mutex);
         init_waitqueue_head(&US122L(card)->sk.sleep);
-        INIT_LIST_HEAD(&US122L(card)->chip.midi_list);
+        INIT_LIST_HEAD(&US122L(card)->midi_list);
         strcpy(card->driver, "USB "NAME_ALLCAPS"");
         sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
         sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
@@ -511,8 +560,8 @@ static int usx2y_create_card(struct usb_device *device, struct snd_card **cardp)
                 le16_to_cpu(device->descriptor.idVendor),
                 le16_to_cpu(device->descriptor.idProduct),
                 0,
-                US122L(card)->chip.dev->bus->busnum,
-                US122L(card)->chip.dev->devnum
+                US122L(card)->dev->bus->busnum,
+                US122L(card)->dev->devnum
                 );
         *cardp = card;
         return 0;
@@ -542,6 +591,7 @@ static int us122l_usb_probe(struct usb_interface *intf,
                 return err;
         }
 
+        usb_get_intf(usb_ifnum_to_if(device, 0));
         usb_get_dev(device);
         *cardp = card;
         return 0;
@@ -550,9 +600,17 @@ static int us122l_usb_probe(struct usb_interface *intf,
 static int snd_us122l_probe(struct usb_interface *intf,
                             const struct usb_device_id *id)
 {
+        struct usb_device *device = interface_to_usbdev(intf);
         struct snd_card *card;
         int err;
 
+        if ((device->descriptor.idProduct == USB_ID_US144 ||
+             device->descriptor.idProduct == USB_ID_US144MKII)
+                && device->speed == USB_SPEED_HIGH) {
+                snd_printk(KERN_ERR "disable ehci-hcd to run US-144 \n");
+                return -ENODEV;
+        }
+
         snd_printdd(KERN_DEBUG"%p:%i\n",
                     intf, intf->cur_altsetting->desc.bInterfaceNumber);
         if (intf->cur_altsetting->desc.bInterfaceNumber != 1)
@@ -584,15 +642,15 @@ static void snd_us122l_disconnect(struct usb_interface *intf)
         mutex_lock(&us122l->mutex);
         us122l_stop(us122l);
         mutex_unlock(&us122l->mutex);
-        us122l->chip.shutdown = 1;
 
 /* release the midi resources */
-        list_for_each(p, &us122l->chip.midi_list) {
+        list_for_each(p, &us122l->midi_list) {
                 snd_usbmidi_disconnect(p);
         }
 
-        usb_put_intf(intf);
-        usb_put_dev(us122l->chip.dev);
+        usb_put_intf(usb_ifnum_to_if(us122l->dev, 0));
+        usb_put_intf(usb_ifnum_to_if(us122l->dev, 1));
+        usb_put_dev(us122l->dev);
 
         while (atomic_read(&us122l->mmap_count))
                 msleep(500);
@@ -615,7 +673,7 @@ static int snd_us122l_suspend(struct usb_interface *intf, pm_message_t message)
         if (!us122l)
                 return 0;
 
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_stop(p);
 
         mutex_lock(&us122l->mutex);
@@ -642,16 +700,24 @@ static int snd_us122l_resume(struct usb_interface *intf)
 
         mutex_lock(&us122l->mutex);
         /* needed, doesn't restart without: */
-        err = usb_set_interface(us122l->chip.dev, 1, 1);
+        if (us122l->dev->descriptor.idProduct == USB_ID_US144 ||
+            us122l->dev->descriptor.idProduct == USB_ID_US144MKII) {
+                err = usb_set_interface(us122l->dev, 0, 1);
+                if (err) {
+                        snd_printk(KERN_ERR "usb_set_interface error \n");
+                        goto unlock;
+                }
+        }
+        err = usb_set_interface(us122l->dev, 1, 1);
         if (err) {
                 snd_printk(KERN_ERR "usb_set_interface error \n");
                 goto unlock;
         }
 
-        pt_info_set(us122l->chip.dev, 0x11);
-        pt_info_set(us122l->chip.dev, 0x10);
+        pt_info_set(us122l->dev, 0x11);
+        pt_info_set(us122l->dev, 0x10);
 
-        err = us122l_set_sample_rate(us122l->chip.dev,
+        err = us122l_set_sample_rate(us122l->dev,
                                      us122l->sk.s->cfg.sample_rate);
         if (err < 0) {
                 snd_printk(KERN_ERR "us122l_set_sample_rate error \n");
@@ -661,7 +727,7 @@ static int snd_us122l_resume(struct usb_interface *intf)
         if (err)
                 goto unlock;
 
-        list_for_each(p, &us122l->chip.midi_list)
+        list_for_each(p, &us122l->midi_list)
                 snd_usbmidi_input_start(p);
 unlock:
         mutex_unlock(&us122l->mutex);
@@ -675,11 +741,21 @@ static struct usb_device_id snd_us122l_usb_id_table[] = {
                 .idVendor =     0x0644,
                 .idProduct =    USB_ID_US122L
         },
-/*      { */            /* US-144 maybe works when @USB1.1. Untested. */
-/*              .match_flags =  USB_DEVICE_ID_MATCH_DEVICE, */
-/*              .idVendor =     0x0644, */
-/*              .idProduct =    USB_ID_US144 */
-/*      }, */
+        {       /* US-144 only works at USB1.1! Disable module ehci-hcd. */
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     0x0644,
+                .idProduct =    USB_ID_US144
+        },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     0x0644,
+                .idProduct =    USB_ID_US122MKII
+        },
+        {
+                .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
+                .idVendor =     0x0644,
+                .idProduct =    USB_ID_US144MKII
+        },
         { /* terminator */ }
 };
 
diff --git a/sound/usb/usx2y/us122l.h b/sound/usb/usx2y/us122l.h
index 3d10c4b2a0f5..f263b3f96c86 100644
--- a/sound/usb/usx2y/us122l.h
+++ b/sound/usb/usx2y/us122l.h
@@ -3,7 +3,8 @@
 
 
 struct us122l {
-        struct snd_usb_audio    chip;
+        struct usb_device       *dev;
+        int                     card_index;
         int                     stride;
         struct usb_stream_kernel sk;
 
@@ -12,6 +13,7 @@ struct us122l {
         unsigned                second_periods_polled;
         struct file             *master;
         struct file             *slave;
+        struct list_head        midi_list;
 
         atomic_t                mmap_count;
 };
@@ -23,5 +25,7 @@ struct us122l {
 
 #define USB_ID_US122L 0x800E
 #define USB_ID_US144 0x800F
+#define USB_ID_US122MKII 0x8021
+#define USB_ID_US144MKII 0x8020
 
 #endif
diff --git a/sound/usb/usx2y/usX2Yhwdep.c b/sound/usb/usx2y/usX2Yhwdep.c
index 52e04b2f35d3..04aafb43a13c 100644
--- a/sound/usb/usx2y/usX2Yhwdep.c
+++ b/sound/usb/usx2y/usX2Yhwdep.c
@@ -21,6 +21,7 @@
  */
 
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <sound/core.h>
 #include <sound/memalloc.h>
@@ -114,7 +115,7 @@ static int snd_usX2Y_hwdep_dsp_status(struct snd_hwdep *hw,
         struct usX2Ydev *us428 = hw->private_data;
         int id = -1;
 
-        switch (le16_to_cpu(us428->chip.dev->descriptor.idProduct)) {
+        switch (le16_to_cpu(us428->dev->descriptor.idProduct)) {
         case USB_ID_US122:
                 id = USX2Y_TYPE_122;
                 break;
@@ -164,14 +165,14 @@ static int usX2Y_create_usbmidi(struct snd_card *card)
                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
                 .data = &quirk_data_2
         };
-        struct usb_device *dev = usX2Y(card)->chip.dev;
+        struct usb_device *dev = usX2Y(card)->dev;
         struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
         struct snd_usb_audio_quirk *quirk =
                 le16_to_cpu(dev->descriptor.idProduct) == USB_ID_US428 ?
                 &quirk_2 : &quirk_1;
 
         snd_printdd("usX2Y_create_usbmidi \n");
-        return snd_usb_create_midi_interface(&usX2Y(card)->chip, iface, quirk);
+        return snd_usbmidi_create(card, iface, &usX2Y(card)->midi_list, quirk);
 }
 
 static int usX2Y_create_alsa_devices(struct snd_card *card)
@@ -202,7 +203,7 @@ static int snd_usX2Y_hwdep_dsp_load(struct snd_hwdep *hw,
         snd_printdd( "dsp_load %s\n", dsp->name);
 
         if (access_ok(VERIFY_READ, dsp->image, dsp->length)) {
-                struct usb_device* dev = priv->chip.dev;
+                struct usb_device* dev = priv->dev;
                 char *buf;
 
                 buf = memdup_user(dsp->image, dsp->length);
diff --git a/sound/usb/usx2y/usb_stream.c b/sound/usb/usx2y/usb_stream.c
index 12ae0340adc0..c400ade3ff08 100644
--- a/sound/usb/usx2y/usb_stream.c
+++ b/sound/usb/usx2y/usb_stream.c
@@ -17,6 +17,7 @@
  */
 
 #include <linux/usb.h>
+#include <linux/gfp.h>
 
 #include "usb_stream.h"
 
diff --git a/sound/usb/usx2y/usbusx2y.c b/sound/usb/usx2y/usbusx2y.c
index cb4bb8373ca2..cbd37f2c76d0 100644
--- a/sound/usb/usx2y/usbusx2y.c
+++ b/sound/usb/usx2y/usbusx2y.c
@@ -133,6 +133,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/usb.h>
 #include <sound/core.h>
@@ -239,8 +240,8 @@ static void i_usX2Y_In04Int(struct urb *urb)
                                 for (j = 0; j < URBS_AsyncSeq  &&  !err; ++j)
                                         if (0 == usX2Y->AS04.urb[j]->status) {
                                                 struct us428_p4out *p4out = us428ctls->p4out + send;    // FIXME if more than 1 p4out is new, 1 gets lost.
-                                                usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->chip.dev,
-                                                                  usb_sndbulkpipe(usX2Y->chip.dev, 0x04), &p4out->val.vol, 
+                                                usb_fill_bulk_urb(usX2Y->AS04.urb[j], usX2Y->dev,
+                                                                  usb_sndbulkpipe(usX2Y->dev, 0x04), &p4out->val.vol,
                                                                   p4out->type == eLT_Light ? sizeof(struct us428_lights) : 5,
                                                                   i_usX2Y_Out04Int, usX2Y);
                                                 err = usb_submit_urb(usX2Y->AS04.urb[j], GFP_ATOMIC);
@@ -253,7 +254,7 @@ static void i_usX2Y_In04Int(struct urb *urb)
         if (err)
                 snd_printk(KERN_ERR "In04Int() usb_submit_urb err=%i\n", err);
 
-        urb->dev = usX2Y->chip.dev;
+        urb->dev = usX2Y->dev;
         usb_submit_urb(urb, GFP_ATOMIC);
 }
 
@@ -273,8 +274,8 @@ int usX2Y_AsyncSeq04_init(struct usX2Ydev *usX2Y)
                                 err = -ENOMEM;
                                 break;
                         }
-                        usb_fill_bulk_urb(      usX2Y->AS04.urb[i], usX2Y->chip.dev,
-                                                usb_sndbulkpipe(usX2Y->chip.dev, 0x04),
+                        usb_fill_bulk_urb(      usX2Y->AS04.urb[i], usX2Y->dev,
+                                                usb_sndbulkpipe(usX2Y->dev, 0x04),
                                                 usX2Y->AS04.buffer + URB_DataLen_AsyncSeq*i, 0,
                                                 i_usX2Y_Out04Int, usX2Y
                                 );
@@ -293,7 +294,7 @@ int usX2Y_In04_init(struct usX2Ydev *usX2Y)
         }
          
         init_waitqueue_head(&usX2Y->In04WaitQueue);
-        usb_fill_int_urb(usX2Y->In04urb, usX2Y->chip.dev, usb_rcvintpipe(usX2Y->chip.dev, 0x4),
+        usb_fill_int_urb(usX2Y->In04urb, usX2Y->dev, usb_rcvintpipe(usX2Y->dev, 0x4),
                          usX2Y->In04Buf, 21,
                          i_usX2Y_In04Int, usX2Y,
                          10);
@@ -348,13 +349,12 @@ static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
                               sizeof(struct usX2Ydev), &card);
         if (err < 0)
                 return err;
-        snd_usX2Y_card_used[usX2Y(card)->chip.index = dev] = 1;
+        snd_usX2Y_card_used[usX2Y(card)->card_index = dev] = 1;
         card->private_free = snd_usX2Y_card_private_free;
-        usX2Y(card)->chip.dev = device;
-        usX2Y(card)->chip.card = card;
+        usX2Y(card)->dev = device;
         init_waitqueue_head(&usX2Y(card)->prepare_wait_queue);
         mutex_init(&usX2Y(card)->prepare_mutex);
-        INIT_LIST_HEAD(&usX2Y(card)->chip.midi_list);
+        INIT_LIST_HEAD(&usX2Y(card)->midi_list);
         strcpy(card->driver, "USB "NAME_ALLCAPS"");
         sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
         sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
@@ -362,7 +362,7 @@ static int usX2Y_create_card(struct usb_device *device, struct snd_card **cardp)
                 le16_to_cpu(device->descriptor.idVendor),
                 le16_to_cpu(device->descriptor.idProduct),
                 0,//us428(card)->usbmidi.ifnum,
-                usX2Y(card)->chip.dev->bus->busnum, usX2Y(card)->chip.dev->devnum
+                usX2Y(card)->dev->bus->busnum, usX2Y(card)->dev->devnum
                 );
         *cardp = card;
         return 0;
@@ -432,8 +432,8 @@ static void snd_usX2Y_card_private_free(struct snd_card *card)
         usb_free_urb(usX2Y(card)->In04urb);
         if (usX2Y(card)->us428ctls_sharedmem)
                 snd_free_pages(usX2Y(card)->us428ctls_sharedmem, sizeof(*usX2Y(card)->us428ctls_sharedmem));
-        if (usX2Y(card)->chip.index >= 0  &&  usX2Y(card)->chip.index < SNDRV_CARDS)
-                snd_usX2Y_card_used[usX2Y(card)->chip.index] = 0;
+        if (usX2Y(card)->card_index >= 0  &&  usX2Y(card)->card_index < SNDRV_CARDS)
+                snd_usX2Y_card_used[usX2Y(card)->card_index] = 0;
 }
 
 /*
@@ -445,13 +445,12 @@ static void usX2Y_usb_disconnect(struct usb_device *device, void* ptr)
                 struct snd_card *card = ptr;
                 struct usX2Ydev *usX2Y = usX2Y(card);
                 struct list_head *p;
-                usX2Y->chip.shutdown = 1;
                 usX2Y->chip_status = USX2Y_STAT_CHIP_HUP;
                 usX2Y_unlinkSeq(&usX2Y->AS04);
                 usb_kill_urb(usX2Y->In04urb);
                 snd_card_disconnect(card);
                 /* release the midi resources */
-                list_for_each(p, &usX2Y->chip.midi_list) {
+                list_for_each(p, &usX2Y->midi_list) {
                         snd_usbmidi_disconnect(p);
                 }
                 if (usX2Y->us428ctls_sharedmem) 
diff --git a/sound/usb/usx2y/usbusx2y.h b/sound/usb/usx2y/usbusx2y.h
index 456b5fdbc339..1d174cea352b 100644
--- a/sound/usb/usx2y/usbusx2y.h
+++ b/sound/usb/usx2y/usbusx2y.h
@@ -22,7 +22,8 @@ struct snd_usX2Y_urbSeq {
 #include "usx2yhwdeppcm.h"
 
 struct usX2Ydev {
-        struct snd_usb_audio    chip;
+        struct usb_device       *dev;
+        int                     card_index;
         int                     stride;
         struct urb              *In04urb;
         void                    *In04Buf;
@@ -42,6 +43,9 @@ struct usX2Ydev {
         struct snd_usX2Y_substream      *subs[4];
         struct snd_usX2Y_substream      * volatile  prepare_subs;
         wait_queue_head_t       prepare_wait_queue;
+        struct list_head        midi_list;
+        struct list_head        pcm_list;
+        int                     pcm_devs;
 };
 
 
diff --git a/sound/usb/usx2y/usbusx2yaudio.c b/sound/usb/usx2y/usbusx2yaudio.c
index 9efd27f6b52f..5d37d1ccf813 100644
--- a/sound/usb/usx2y/usbusx2yaudio.c
+++ b/sound/usb/usx2y/usbusx2yaudio.c
@@ -32,6 +32,7 @@
 
 
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/usb.h>
 #include <sound/core.h>
 #include <sound/info.h>
@@ -199,7 +200,7 @@ static int usX2Y_urb_submit(struct snd_usX2Y_substream *subs, struct urb *urb, i
                 return -ENODEV;
         urb->start_frame = (frame + NRURBS * nr_of_packs());  // let hcd do rollover sanity checks
         urb->hcpriv = NULL;
-        urb->dev = subs->usX2Y->chip.dev; /* we need to set this at each time */
+        urb->dev = subs->usX2Y->dev; /* we need to set this at each time */
         if ((err = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
                 snd_printk(KERN_ERR "usb_submit_urb() returned %i\n", err);
                 return err;
@@ -300,7 +301,7 @@ static void usX2Y_error_sequence(struct usX2Ydev *usX2Y,
 "Sequence Error!(hcd_frame=%i ep=%i%s;wait=%i,frame=%i).\n"
 "Most propably some urb of usb-frame %i is still missing.\n"
 "Cause could be too long delays in usb-hcd interrupt handling.\n",
-                   usb_get_current_frame_number(usX2Y->chip.dev),
+                   usb_get_current_frame_number(usX2Y->dev),
                    subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                    usX2Y->wait_iso_frame, urb->start_frame, usX2Y->wait_iso_frame);
         usX2Y_clients_stop(usX2Y);
@@ -313,7 +314,7 @@ static void i_usX2Y_urb_complete(struct urb *urb)
 
         if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
                 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
-                            usb_get_current_frame_number(usX2Y->chip.dev),
+                            usb_get_current_frame_number(usX2Y->dev),
                             subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                             urb->status, urb->start_frame);
                 return;
@@ -424,7 +425,7 @@ static int usX2Y_urbs_allocate(struct snd_usX2Y_substream *subs)
         int i;
         unsigned int pipe;
         int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
-        struct usb_device *dev = subs->usX2Y->chip.dev;
+        struct usb_device *dev = subs->usX2Y->dev;
 
         pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
                         usb_rcvisocpipe(dev, subs->endpoint);
@@ -500,7 +501,7 @@ static int usX2Y_urbs_start(struct snd_usX2Y_substream *subs)
                         unsigned long pack;
                         if (0 == i)
                                 atomic_set(&subs->state, state_STARTING3);
-                        urb->dev = usX2Y->chip.dev;
+                        urb->dev = usX2Y->dev;
                         urb->transfer_flags = URB_ISO_ASAP;
                         for (pack = 0; pack < nr_of_packs(); pack++) {
                                 urb->iso_frame_desc[pack].offset = subs->maxpacksize * pack;
@@ -692,7 +693,7 @@ static int usX2Y_rate_set(struct usX2Ydev *usX2Y, int rate)
                         }
                         ((char*)(usbdata + i))[0] = ra[i].c1;
                         ((char*)(usbdata + i))[1] = ra[i].c2;
-                        usb_fill_bulk_urb(us->urb[i], usX2Y->chip.dev, usb_sndbulkpipe(usX2Y->chip.dev, 4),
+                        usb_fill_bulk_urb(us->urb[i], usX2Y->dev, usb_sndbulkpipe(usX2Y->dev, 4),
                                           usbdata + i, 2, i_usX2Y_04Int, usX2Y);
 #ifdef OLD_USB
                         us->urb[i]->transfer_flags = USB_QUEUE_BULK;
@@ -740,17 +741,17 @@ static int usX2Y_format_set(struct usX2Ydev *usX2Y, snd_pcm_format_t format)
                 alternate = 1;
                 usX2Y->stride = 4;
         }
-        list_for_each(p, &usX2Y->chip.midi_list) {
+        list_for_each(p, &usX2Y->midi_list) {
                 snd_usbmidi_input_stop(p);
         }
         usb_kill_urb(usX2Y->In04urb);
-        if ((err = usb_set_interface(usX2Y->chip.dev, 0, alternate))) {
+        if ((err = usb_set_interface(usX2Y->dev, 0, alternate))) {
                 snd_printk(KERN_ERR "usb_set_interface error \n");
                 return err;
         }
-        usX2Y->In04urb->dev = usX2Y->chip.dev;
+        usX2Y->In04urb->dev = usX2Y->dev;
         err = usb_submit_urb(usX2Y->In04urb, GFP_KERNEL);
-        list_for_each(p, &usX2Y->chip.midi_list) {
+        list_for_each(p, &usX2Y->midi_list) {
                 snd_usbmidi_input_start(p);
         }
         usX2Y->format = format;
@@ -955,7 +956,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
         struct snd_pcm *pcm;
         int err, i;
         struct snd_usX2Y_substream **usX2Y_substream =
-                usX2Y(card)->subs + 2 * usX2Y(card)->chip.pcm_devs;
+                usX2Y(card)->subs + 2 * usX2Y(card)->pcm_devs;
 
         for (i = playback_endpoint ? SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
              i <= SNDRV_PCM_STREAM_CAPTURE; ++i) {
@@ -971,7 +972,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
                 usX2Y_substream[SNDRV_PCM_STREAM_PLAYBACK]->endpoint = playback_endpoint;
         usX2Y_substream[SNDRV_PCM_STREAM_CAPTURE]->endpoint = capture_endpoint;
 
-        err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usX2Y(card)->chip.pcm_devs,
+        err = snd_pcm_new(card, NAME_ALLCAPS" Audio", usX2Y(card)->pcm_devs,
                           playback_endpoint ? 1 : 0, 1,
                           &pcm);
         if (err < 0) {
@@ -987,7 +988,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
         pcm->private_free = snd_usX2Y_pcm_private_free;
         pcm->info_flags = 0;
 
-        sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usX2Y(card)->chip.pcm_devs);
+        sprintf(pcm->name, NAME_ALLCAPS" Audio #%d", usX2Y(card)->pcm_devs);
 
         if ((playback_endpoint &&
              0 > (err = snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
@@ -1001,7 +1002,7 @@ static int usX2Y_audio_stream_new(struct snd_card *card, int playback_endpoint,
                 snd_usX2Y_pcm_private_free(pcm);
                 return err;
         }
-        usX2Y(card)->chip.pcm_devs++;
+        usX2Y(card)->pcm_devs++;
 
         return 0;
 }
@@ -1013,14 +1014,14 @@ int usX2Y_audio_create(struct snd_card *card)
 {
         int err = 0;
         
-        INIT_LIST_HEAD(&usX2Y(card)->chip.pcm_list);
+        INIT_LIST_HEAD(&usX2Y(card)->pcm_list);
 
         if (0 > (err = usX2Y_audio_stream_new(card, 0xA, 0x8)))
                 return err;
-        if (le16_to_cpu(usX2Y(card)->chip.dev->descriptor.idProduct) == USB_ID_US428)
+        if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) == USB_ID_US428)
              if (0 > (err = usX2Y_audio_stream_new(card, 0, 0xA)))
                      return err;
-        if (le16_to_cpu(usX2Y(card)->chip.dev->descriptor.idProduct) != USB_ID_US122)
+        if (le16_to_cpu(usX2Y(card)->dev->descriptor.idProduct) != USB_ID_US122)
                 err = usX2Y_rate_set(usX2Y(card), 44100);       // Lets us428 recognize output-volume settings, disturbs us122.
         return err;
 }
diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c
index 4b2304c2e02d..2a528e56afd5 100644
--- a/sound/usb/usx2y/usx2yhwdeppcm.c
+++ b/sound/usb/usx2y/usx2yhwdeppcm.c
@@ -51,6 +51,7 @@
 */
 
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include "usbusx2yaudio.c"
 
 #if defined(USX2Y_NRPACKS_VARIABLE) || (!defined(USX2Y_NRPACKS_VARIABLE) &&  USX2Y_NRPACKS == 1)
@@ -234,7 +235,7 @@ static void i_usX2Y_usbpcm_urb_complete(struct urb *urb)
 
         if (unlikely(atomic_read(&subs->state) < state_PREPARED)) {
                 snd_printdd("hcd_frame=%i ep=%i%s status=%i start_frame=%i\n",
-                            usb_get_current_frame_number(usX2Y->chip.dev),
+                            usb_get_current_frame_number(usX2Y->dev),
                             subs->endpoint, usb_pipein(urb->pipe) ? "in" : "out",
                             urb->status, urb->start_frame);
                 return;
@@ -318,7 +319,7 @@ static int usX2Y_usbpcm_urbs_allocate(struct snd_usX2Y_substream *subs)
         int i;
         unsigned int pipe;
         int is_playback = subs == subs->usX2Y->subs[SNDRV_PCM_STREAM_PLAYBACK];
-        struct usb_device *dev = subs->usX2Y->chip.dev;
+        struct usb_device *dev = subs->usX2Y->dev;
 
         pipe = is_playback ? usb_sndisocpipe(dev, subs->endpoint) :
                         usb_rcvisocpipe(dev, subs->endpoint);
@@ -441,7 +442,7 @@ static int usX2Y_usbpcm_urbs_start(struct snd_usX2Y_substream *subs)
                                         unsigned long pack;
                                         if (0 == u)
                                                 atomic_set(&subs->state, state_STARTING3);
-                                        urb->dev = usX2Y->chip.dev;
+                                        urb->dev = usX2Y->dev;
                                         urb->transfer_flags = URB_ISO_ASAP;
                                         for (pack = 0; pack < nr_of_packs(); pack++) {
                                                 urb->iso_frame_desc[pack].offset = subs->maxpacksize * (pack + u * nr_of_packs());
@@ -741,7 +742,7 @@ int usX2Y_hwdep_pcm_new(struct snd_card *card)
         int err;
         struct snd_hwdep *hw;
         struct snd_pcm *pcm;
-        struct usb_device *dev = usX2Y(card)->chip.dev;
+        struct usb_device *dev = usX2Y(card)->dev;
         if (1 != nr_of_packs())
                 return 0;