Merge remote branch 'alsa/devel' into topic/misc
[linux-2.6.git] / sound / usb / usbaudio.c
index 7ad8089..20b656e 100644 (file)
@@ -46,6 +46,9 @@
 #include <linux/usb.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>
@@ -596,7 +599,7 @@ static int prepare_playback_urb(struct snd_usb_substream *subs,
                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 */
@@ -1104,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)
@@ -1180,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;
@@ -1192,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;
@@ -1229,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;
@@ -1252,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 */
@@ -1384,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
@@ -1426,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)
@@ -1884,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;
@@ -1959,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;
        }
@@ -2118,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 */
 };
 
@@ -2157,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);
@@ -2420,29 +2423,68 @@ 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]) {
+               printk(" XXXXX SAMPLE BYTES %d\n", sample_bytes);
+               switch (sample_bytes) {
                case 1:
                        pcm_format = SNDRV_PCM_FORMAT_S8;
                        break;
@@ -2463,12 +2505,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
@@ -2476,13 +2518,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:
@@ -2496,7 +2538,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
@@ -2504,13 +2546,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;
        }
@@ -2561,14 +2603,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...
@@ -2586,34 +2701,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:
@@ -2622,26 +2760,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",
@@ -2659,7 +2817,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;
@@ -2688,10 +2846,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;
 
@@ -2710,10 +2868,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)
@@ -2734,30 +2893,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;
                }
@@ -2770,6 +2964,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;
@@ -2778,7 +2973,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);
@@ -2798,6 +2993,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);
@@ -2810,12 +3007,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
@@ -2824,16 +3021,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;
@@ -2875,6 +3072,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
  */
@@ -2882,67 +3138,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) {
-                       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, 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;
@@ -3033,7 +3303,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,
@@ -3554,7 +3824,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;