sound/usb/quirks.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  */
   4
   5 #include <linux/init.h>
   6 #include <linux/slab.h>
   7 #include <linux/usb.h>
   8 #include <linux/usb/audio.h>
   9 #include <linux/usb/midi.h>
  10 #include <linux/bits.h>
  11
  12 #include <sound/control.h>
  13 #include <sound/core.h>
  14 #include <sound/info.h>
  15 #include <sound/pcm.h>
  16
  17 #include "usbaudio.h"
  18 #include "card.h"
  19 #include "mixer.h"
  20 #include "mixer_quirks.h"
  21 #include "midi.h"
  22 #include "quirks.h"
  23 #include "helper.h"
  24 #include "endpoint.h"
  25 #include "pcm.h"
  26 #include "clock.h"
  27 #include "stream.h"
  28
  29 /*
  30  * handle the quirks for the contained interfaces
  31  */
  32 static int create_composite_quirk(struct snd_usb_audio *chip,
  33                                   struct usb_interface *iface,
  34                                   struct usb_driver *driver,
  35                                   const struct snd_usb_audio_quirk *quirk_comp)
  36 {
  37         int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
  38         const struct snd_usb_audio_quirk *quirk;
  39         int err;
  40
  41         for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
  42                 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
  43                 if (!iface)
  44                         continue;
  45                 if (quirk->ifnum != probed_ifnum &&
  46                     usb_interface_claimed(iface))
  47                         continue;
  48                 err = snd_usb_create_quirk(chip, iface, driver, quirk);
  49                 if (err < 0)
  50                         return err;
  51         }
  52
  53         for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
  54                 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
  55                 if (!iface)
  56                         continue;
  57                 if (quirk->ifnum != probed_ifnum &&
  58                     !usb_interface_claimed(iface)) {
  59                         err = usb_driver_claim_interface(driver, iface,
  60                                                          USB_AUDIO_IFACE_UNUSED);
  61                         if (err < 0)
  62                                 return err;
  63                 }
  64         }
  65
  66         return 0;
  67 }
  68
  69 static int ignore_interface_quirk(struct snd_usb_audio *chip,
  70                                   struct usb_interface *iface,
  71                                   struct usb_driver *driver,
  72                                   const struct snd_usb_audio_quirk *quirk)
  73 {
  74         return 0;
  75 }
  76
  77
  78 /*
  79  * Allow alignment on audio sub-slot (channel samples) rather than
  80  * on audio slots (audio frames)
  81  */
  82 static int create_align_transfer_quirk(struct snd_usb_audio *chip,
  83                                        struct usb_interface *iface,
  84                                        struct usb_driver *driver,
  85                                        const struct snd_usb_audio_quirk *quirk)
  86 {
  87         chip->txfr_quirk = 1;
  88         return 1;       /* Continue with creating streams and mixer */
  89 }
  90
  91 static int create_any_midi_quirk(struct snd_usb_audio *chip,
  92                                  struct usb_interface *intf,
  93                                  struct usb_driver *driver,
  94                                  const struct snd_usb_audio_quirk *quirk)
  95 {
  96         return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
  97 }
  98
  99 /*
 100  * create a stream for an interface with proper descriptors
 101  */
 102 static int create_standard_audio_quirk(struct snd_usb_audio *chip,
 103                                        struct usb_interface *iface,
 104                                        struct usb_driver *driver,
 105                                        const struct snd_usb_audio_quirk *quirk)
 106 {
 107         struct usb_host_interface *alts;
 108         struct usb_interface_descriptor *altsd;
 109         int err;
 110
 111         if (chip->usb_id == USB_ID(0x1686, 0x00dd)) /* Zoom R16/24 */
 112                 chip->tx_length_quirk = 1;
 113
 114         alts = &iface->altsetting[0];
 115         altsd = get_iface_desc(alts);
 116         err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);
 117         if (err < 0) {
 118                 usb_audio_err(chip, "cannot setup if %d: error %d\n",
 119                            altsd->bInterfaceNumber, err);
 120                 return err;
 121         }
 122         /* reset the current interface */
 123         usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
 124         return 0;
 125 }
 126
 127 /* create the audio stream and the corresponding endpoints from the fixed
 128  * audioformat object; this is used for quirks with the fixed EPs
 129  */
 130 static int add_audio_stream_from_fixed_fmt(struct snd_usb_audio *chip,
 131                                            struct audioformat *fp)
 132 {
 133         int stream, err;
 134
 135         stream = (fp->endpoint & USB_DIR_IN) ?
 136                 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
 137
 138         snd_usb_audioformat_set_sync_ep(chip, fp);
 139
 140         err = snd_usb_add_audio_stream(chip, stream, fp);
 141         if (err < 0)
 142                 return err;
 143
 144         err = snd_usb_add_endpoint(chip, fp->endpoint,
 145                                    SND_USB_ENDPOINT_TYPE_DATA);
 146         if (err < 0)
 147                 return err;
 148
 149         if (fp->sync_ep) {
 150                 err = snd_usb_add_endpoint(chip, fp->sync_ep,
 151                                            fp->implicit_fb ?
 152                                            SND_USB_ENDPOINT_TYPE_DATA :
 153                                            SND_USB_ENDPOINT_TYPE_SYNC);
 154                 if (err < 0)
 155                         return err;
 156         }
 157
 158         return 0;
 159 }
 160
 161 /*
 162  * create a stream for an endpoint/altsetting without proper descriptors
 163  */
 164 static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
 165                                      struct usb_interface *iface,
 166                                      struct usb_driver *driver,
 167                                      const struct snd_usb_audio_quirk *quirk)
 168 {
 169         struct audioformat *fp;
 170         struct usb_host_interface *alts;
 171         struct usb_interface_descriptor *altsd;
 172         unsigned *rate_table = NULL;
 173         int err;
 174
 175         fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
 176         if (!fp)
 177                 return -ENOMEM;
 178
 179         INIT_LIST_HEAD(&fp->list);
 180         if (fp->nr_rates > MAX_NR_RATES) {
 181                 kfree(fp);
 182                 return -EINVAL;
 183         }
 184         if (fp->nr_rates > 0) {
 185                 rate_table = kmemdup(fp->rate_table,
 186                                      sizeof(int) * fp->nr_rates, GFP_KERNEL);
 187                 if (!rate_table) {
 188                         kfree(fp);
 189                         return -ENOMEM;
 190                 }
 191                 fp->rate_table = rate_table;
 192         }
 193
 194         if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
 195             fp->altset_idx >= iface->num_altsetting) {
 196                 err = -EINVAL;
 197                 goto error;
 198         }
 199         alts = &iface->altsetting[fp->altset_idx];
 200         altsd = get_iface_desc(alts);
 201         if (altsd->bNumEndpoints <= fp->ep_idx) {
 202                 err = -EINVAL;
 203                 goto error;
 204         }
 205
 206         fp->protocol = altsd->bInterfaceProtocol;
 207
 208         if (fp->datainterval == 0)
 209                 fp->datainterval = snd_usb_parse_datainterval(chip, alts);
 210         if (fp->maxpacksize == 0)
 211                 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, fp->ep_idx)->wMaxPacketSize);
 212         if (!fp->fmt_type)
 213                 fp->fmt_type = UAC_FORMAT_TYPE_I;
 214
 215         err = add_audio_stream_from_fixed_fmt(chip, fp);
 216         if (err < 0)
 217                 goto error;
 218
 219         usb_set_interface(chip->dev, fp->iface, 0);
 220         snd_usb_init_pitch(chip, fp);
 221         snd_usb_init_sample_rate(chip, fp, fp->rate_max);
 222         return 0;
 223
 224  error:
 225         list_del(&fp->list); /* unlink for avoiding double-free */
 226         kfree(fp);
 227         kfree(rate_table);
 228         return err;
 229 }
 230
 231 static int create_auto_pcm_quirk(struct snd_usb_audio *chip,
 232                                  struct usb_interface *iface,
 233                                  struct usb_driver *driver)
 234 {
 235         struct usb_host_interface *alts;
 236         struct usb_interface_descriptor *altsd;
 237         struct usb_endpoint_descriptor *epd;
 238         struct uac1_as_header_descriptor *ashd;
 239         struct uac_format_type_i_discrete_descriptor *fmtd;
 240
 241         /*
 242          * Most Roland/Yamaha audio streaming interfaces have more or less
 243          * standard descriptors, but older devices might lack descriptors, and
 244          * future ones might change, so ensure that we fail silently if the
 245          * interface doesn't look exactly right.
 246          */
 247
 248         /* must have a non-zero altsetting for streaming */
 249         if (iface->num_altsetting < 2)
 250                 return -ENODEV;
 251         alts = &iface->altsetting[1];
 252         altsd = get_iface_desc(alts);
 253
 254         /* must have an isochronous endpoint for streaming */
 255         if (altsd->bNumEndpoints < 1)
 256                 return -ENODEV;
 257         epd = get_endpoint(alts, 0);
 258         if (!usb_endpoint_xfer_isoc(epd))
 259                 return -ENODEV;
 260
 261         /* must have format descriptors */
 262         ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
 263                                        UAC_AS_GENERAL);
 264         fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
 265                                        UAC_FORMAT_TYPE);
 266         if (!ashd || ashd->bLength < 7 ||
 267             !fmtd || fmtd->bLength < 8)
 268                 return -ENODEV;
 269
 270         return create_standard_audio_quirk(chip, iface, driver, NULL);
 271 }
 272
 273 static int create_yamaha_midi_quirk(struct snd_usb_audio *chip,
 274                                     struct usb_interface *iface,
 275                                     struct usb_driver *driver,
 276                                     struct usb_host_interface *alts)
 277 {
 278         static const struct snd_usb_audio_quirk yamaha_midi_quirk = {
 279                 .type = QUIRK_MIDI_YAMAHA
 280         };
 281         struct usb_midi_in_jack_descriptor *injd;
 282         struct usb_midi_out_jack_descriptor *outjd;
 283
 284         /* must have some valid jack descriptors */
 285         injd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 286                                        NULL, USB_MS_MIDI_IN_JACK);
 287         outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
 288                                         NULL, USB_MS_MIDI_OUT_JACK);
 289         if (!injd && !outjd)
 290                 return -ENODEV;
 291         if ((injd && !snd_usb_validate_midi_desc(injd)) ||
 292             (outjd && !snd_usb_validate_midi_desc(outjd)))
 293                 return -ENODEV;
 294         if (injd && (injd->bLength < 5 ||
 295                      (injd->bJackType != USB_MS_EMBEDDED &&
 296                       injd->bJackType != USB_MS_EXTERNAL)))
 297                 return -ENODEV;
 298         if (outjd && (outjd->bLength < 6 ||
 299                       (outjd->bJackType != USB_MS_EMBEDDED &&
 300                        outjd->bJackType != USB_MS_EXTERNAL)))
 301                 return -ENODEV;
 302         return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk);
 303 }
 304
 305 static int create_roland_midi_quirk(struct snd_usb_audio *chip,
 306                                     struct usb_interface *iface,
 307                                     struct usb_driver *driver,
 308                                     struct usb_host_interface *alts)
 309 {
 310         static const struct snd_usb_audio_quirk roland_midi_quirk = {
 311                 .type = QUIRK_MIDI_ROLAND
 312         };
 313         u8 *roland_desc = NULL;
 314
 315         /* might have a vendor-specific descriptor <06 24 F1 02 ...> */
 316         for (;;) {
 317                 roland_desc = snd_usb_find_csint_desc(alts->extra,
 318                                                       alts->extralen,
 319                                                       roland_desc, 0xf1);
 320                 if (!roland_desc)
 321                         return -ENODEV;
 322                 if (roland_desc[0] < 6 || roland_desc[3] != 2)
 323                         continue;
 324                 return create_any_midi_quirk(chip, iface, driver,
 325                                              &roland_midi_quirk);
 326         }
 327 }
 328
 329 static int create_std_midi_quirk(struct snd_usb_audio *chip,
 330                                  struct usb_interface *iface,
 331                                  struct usb_driver *driver,
 332                                  struct usb_host_interface *alts)
 333 {
 334         struct usb_ms_header_descriptor *mshd;
 335         struct usb_ms_endpoint_descriptor *msepd;
 336
 337         /* must have the MIDIStreaming interface header descriptor*/
 338         mshd = (struct usb_ms_header_descriptor *)alts->extra;
 339         if (alts->extralen < 7 ||
 340             mshd->bLength < 7 ||
 341             mshd->bDescriptorType != USB_DT_CS_INTERFACE ||
 342             mshd->bDescriptorSubtype != USB_MS_HEADER)
 343                 return -ENODEV;
 344         /* must have the MIDIStreaming endpoint descriptor*/
 345         msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra;
 346         if (alts->endpoint[0].extralen < 4 ||
 347             msepd->bLength < 4 ||
 348             msepd->bDescriptorType != USB_DT_CS_ENDPOINT ||
 349             msepd->bDescriptorSubtype != UAC_MS_GENERAL ||
 350             msepd->bNumEmbMIDIJack < 1 ||
 351             msepd->bNumEmbMIDIJack > 16)
 352                 return -ENODEV;
 353
 354         return create_any_midi_quirk(chip, iface, driver, NULL);
 355 }
 356
 357 static int create_auto_midi_quirk(struct snd_usb_audio *chip,
 358                                   struct usb_interface *iface,
 359                                   struct usb_driver *driver)
 360 {
 361         struct usb_host_interface *alts;
 362         struct usb_interface_descriptor *altsd;
 363         struct usb_endpoint_descriptor *epd;
 364         int err;
 365
 366         alts = &iface->altsetting[0];
 367         altsd = get_iface_desc(alts);
 368
 369         /* must have at least one bulk/interrupt endpoint for streaming */
 370         if (altsd->bNumEndpoints < 1)
 371                 return -ENODEV;
 372         epd = get_endpoint(alts, 0);
 373         if (!usb_endpoint_xfer_bulk(epd) &&
 374             !usb_endpoint_xfer_int(epd))
 375                 return -ENODEV;
 376
 377         switch (USB_ID_VENDOR(chip->usb_id)) {
 378         case 0x0499: /* Yamaha */
 379                 err = create_yamaha_midi_quirk(chip, iface, driver, alts);
 380                 if (err != -ENODEV)
 381                         return err;
 382                 break;
 383         case 0x0582: /* Roland */
 384                 err = create_roland_midi_quirk(chip, iface, driver, alts);
 385                 if (err != -ENODEV)
 386                         return err;
 387                 break;
 388         }
 389
 390         return create_std_midi_quirk(chip, iface, driver, alts);
 391 }
 392
 393 static int create_autodetect_quirk(struct snd_usb_audio *chip,
 394                                    struct usb_interface *iface,
 395                                    struct usb_driver *driver)
 396 {
 397         int err;
 398
 399         err = create_auto_pcm_quirk(chip, iface, driver);
 400         if (err == -ENODEV)
 401                 err = create_auto_midi_quirk(chip, iface, driver);
 402         return err;
 403 }
 404
 405 static int create_autodetect_quirks(struct snd_usb_audio *chip,
 406                                     struct usb_interface *iface,
 407                                     struct usb_driver *driver,
 408                                     const struct snd_usb_audio_quirk *quirk)
 409 {
 410         int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
 411         int ifcount, ifnum, err;
 412
 413         err = create_autodetect_quirk(chip, iface, driver);
 414         if (err < 0)
 415                 return err;
 416
 417         /*
 418          * ALSA PCM playback/capture devices cannot be registered in two steps,
 419          * so we have to claim the other corresponding interface here.
 420          */
 421         ifcount = chip->dev->actconfig->desc.bNumInterfaces;
 422         for (ifnum = 0; ifnum < ifcount; ifnum++) {
 423                 if (ifnum == probed_ifnum || quirk->ifnum >= 0)
 424                         continue;
 425                 iface = usb_ifnum_to_if(chip->dev, ifnum);
 426                 if (!iface ||
 427                     usb_interface_claimed(iface) ||
 428                     get_iface_desc(iface->altsetting)->bInterfaceClass !=
 429                                                         USB_CLASS_VENDOR_SPEC)
 430                         continue;
 431
 432                 err = create_autodetect_quirk(chip, iface, driver);
 433                 if (err >= 0) {
 434                         err = usb_driver_claim_interface(driver, iface,
 435                                                          USB_AUDIO_IFACE_UNUSED);
 436                         if (err < 0)
 437                                 return err;
 438                 }
 439         }
 440
 441         return 0;
 442 }
 443
 444 /*
 445  * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
 446  * The only way to detect the sample rate is by looking at wMaxPacketSize.
 447  */
 448 static int create_uaxx_quirk(struct snd_usb_audio *chip,
 449                              struct usb_interface *iface,
 450                              struct usb_driver *driver,
 451                              const struct snd_usb_audio_quirk *quirk)
 452 {
 453         static const struct audioformat ua_format = {
 454                 .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 455                 .channels = 2,
 456                 .fmt_type = UAC_FORMAT_TYPE_I,
 457                 .altsetting = 1,
 458                 .altset_idx = 1,
 459                 .rates = SNDRV_PCM_RATE_CONTINUOUS,
 460         };
 461         struct usb_host_interface *alts;
 462         struct usb_interface_descriptor *altsd;
 463         struct audioformat *fp;
 464         int err;
 465
 466         /* both PCM and MIDI interfaces have 2 or more altsettings */
 467         if (iface->num_altsetting < 2)
 468                 return -ENXIO;
 469         alts = &iface->altsetting[1];
 470         altsd = get_iface_desc(alts);
 471
 472         if (altsd->bNumEndpoints == 2) {
 473                 static const struct snd_usb_midi_endpoint_info ua700_ep = {
 474                         .out_cables = 0x0003,
 475                         .in_cables  = 0x0003
 476                 };
 477                 static const struct snd_usb_audio_quirk ua700_quirk = {
 478                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
 479                         .data = &ua700_ep
 480                 };
 481                 static const struct snd_usb_midi_endpoint_info uaxx_ep = {
 482                         .out_cables = 0x0001,
 483                         .in_cables  = 0x0001
 484                 };
 485                 static const struct snd_usb_audio_quirk uaxx_quirk = {
 486                         .type = QUIRK_MIDI_FIXED_ENDPOINT,
 487                         .data = &uaxx_ep
 488                 };
 489                 const struct snd_usb_audio_quirk *quirk =
 490                         chip->usb_id == USB_ID(0x0582, 0x002b)
 491                         ? &ua700_quirk : &uaxx_quirk;
 492                 return __snd_usbmidi_create(chip->card, iface,
 493                                           &chip->midi_list, quirk,
 494                                           chip->usb_id);
 495         }
 496
 497         if (altsd->bNumEndpoints != 1)
 498                 return -ENXIO;
 499
 500         fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL);
 501         if (!fp)
 502                 return -ENOMEM;
 503
 504         fp->iface = altsd->bInterfaceNumber;
 505         fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
 506         fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
 507         fp->datainterval = 0;
 508         fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
 509         INIT_LIST_HEAD(&fp->list);
 510
 511         switch (fp->maxpacksize) {
 512         case 0x120:
 513                 fp->rate_max = fp->rate_min = 44100;
 514                 break;
 515         case 0x138:
 516         case 0x140:
 517                 fp->rate_max = fp->rate_min = 48000;
 518                 break;
 519         case 0x258:
 520         case 0x260:
 521                 fp->rate_max = fp->rate_min = 96000;
 522                 break;
 523         default:
 524                 usb_audio_err(chip, "unknown sample rate\n");
 525                 kfree(fp);
 526                 return -ENXIO;
 527         }
 528
 529         err = add_audio_stream_from_fixed_fmt(chip, fp);
 530         if (err < 0) {
 531                 list_del(&fp->list); /* unlink for avoiding double-free */
 532                 kfree(fp);
 533                 return err;
 534         }
 535         usb_set_interface(chip->dev, fp->iface, 0);
 536         return 0;
 537 }
 538
 539 /*
 540  * Create a standard mixer for the specified interface.
 541  */
 542 static int create_standard_mixer_quirk(struct snd_usb_audio *chip,
 543                                        struct usb_interface *iface,
 544                                        struct usb_driver *driver,
 545                                        const struct snd_usb_audio_quirk *quirk)
 546 {
 547         if (quirk->ifnum < 0)
 548                 return 0;
 549
 550         return snd_usb_create_mixer(chip, quirk->ifnum, 0);
 551 }
 552
 553 static int setup_disable_autosuspend(struct snd_usb_audio *chip,
 554                                        struct usb_interface *iface,
 555                                        struct usb_driver *driver,
 556                                        const struct snd_usb_audio_quirk *quirk)
 557 {
 558         usb_disable_autosuspend(interface_to_usbdev(iface));
 559         return 1;       /* Continue with creating streams and mixer */
 560 }
 561
 562 /*
 563  * audio-interface quirks
 564  *
 565  * returns zero if no standard audio/MIDI parsing is needed.
 566  * returns a positive value if standard audio/midi interfaces are parsed
 567  * after this.
 568  * returns a negative value at error.
 569  */
 570 int snd_usb_create_quirk(struct snd_usb_audio *chip,
 571                          struct usb_interface *iface,
 572                          struct usb_driver *driver,
 573                          const struct snd_usb_audio_quirk *quirk)
 574 {
 575         typedef int (*quirk_func_t)(struct snd_usb_audio *,
 576                                     struct usb_interface *,
 577                                     struct usb_driver *,
 578                                     const struct snd_usb_audio_quirk *);
 579         static const quirk_func_t quirk_funcs[] = {
 580                 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
 581                 [QUIRK_COMPOSITE] = create_composite_quirk,
 582                 [QUIRK_AUTODETECT] = create_autodetect_quirks,
 583                 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
 584                 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
 585                 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
 586                 [QUIRK_MIDI_ROLAND] = create_any_midi_quirk,
 587                 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
 588                 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
 589                 [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk,
 590                 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
 591                 [QUIRK_MIDI_CME] = create_any_midi_quirk,
 592                 [QUIRK_MIDI_AKAI] = create_any_midi_quirk,
 593                 [QUIRK_MIDI_FTDI] = create_any_midi_quirk,
 594                 [QUIRK_MIDI_CH345] = create_any_midi_quirk,
 595                 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
 596                 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
 597                 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
 598                 [QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk,
 599                 [QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
 600                 [QUIRK_SETUP_DISABLE_AUTOSUSPEND] = setup_disable_autosuspend,
 601         };
 602
 603         if (quirk->type < QUIRK_TYPE_COUNT) {
 604                 return quirk_funcs[quirk->type](chip, iface, driver, quirk);
 605         } else {
 606                 usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);
 607                 return -ENXIO;
 608         }
 609 }
 610
 611 /*
 612  * boot quirks
 613  */
 614
 615 #define EXTIGY_FIRMWARE_SIZE_OLD 794
 616 #define EXTIGY_FIRMWARE_SIZE_NEW 483
 617
 618 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
 619 {
 620         struct usb_host_config *config = dev->actconfig;
 621         int err;
 622
 623         if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
 624             le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
 625                 dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");
 626                 /* Send message to force it to reconnect with full interface. */
 627                 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
 628                                       0x10, 0x43, 0x0001, 0x000a, NULL, 0);
 629                 if (err < 0)
 630                         dev_dbg(&dev->dev, "error sending boot message: %d\n", err);
 631                 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
 632                                 &dev->descriptor, sizeof(dev->descriptor));
 633                 config = dev->actconfig;
 634                 if (err < 0)
 635                         dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
 636                 err = usb_reset_configuration(dev);
 637                 if (err < 0)
 638                         dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
 639                 dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",
 640                             le16_to_cpu(get_cfg_desc(config)->wTotalLength));
 641                 return -ENODEV; /* quit this anyway */
 642         }
 643         return 0;
 644 }
 645
 646 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
 647 {
 648         u8 buf = 1;
 649
 650         snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
 651                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 652                         0, 0, &buf, 1);
 653         if (buf == 0) {
 654                 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
 655                                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 656                                 1, 2000, NULL, 0);
 657                 return -ENODEV;
 658         }
 659         return 0;
 660 }
 661
 662 static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
 663 {
 664         int err;
 665
 666         if (dev->actconfig->desc.bConfigurationValue == 1) {
 667                 dev_info(&dev->dev,
 668                            "Fast Track Pro switching to config #2\n");
 669                 /* This function has to be available by the usb core module.
 670                  * if it is not avialable the boot quirk has to be left out
 671                  * and the configuration has to be set by udev or hotplug
 672                  * rules
 673                  */
 674                 err = usb_driver_set_configuration(dev, 2);
 675                 if (err < 0)
 676                         dev_dbg(&dev->dev,
 677                                 "error usb_driver_set_configuration: %d\n",
 678                                 err);
 679                 /* Always return an error, so that we stop creating a device
 680                    that will just be destroyed and recreated with a new
 681                    configuration */
 682                 return -ENODEV;
 683         } else
 684                 dev_info(&dev->dev, "Fast Track Pro config OK\n");
 685
 686         return 0;
 687 }
 688
 689 /*
 690  * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
 691  * documented in the device's data sheet.
 692  */
 693 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
 694 {
 695         u8 buf[4];
 696         buf[0] = 0x20;
 697         buf[1] = value & 0xff;
 698         buf[2] = (value >> 8) & 0xff;
 699         buf[3] = reg;
 700         return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
 701                                USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
 702                                0, 0, &buf, 4);
 703 }
 704
 705 static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
 706 {
 707         /*
 708          * Enable line-out driver mode, set headphone source to front
 709          * channels, enable stereo mic.
 710          */
 711         return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
 712 }
 713
 714 /*
 715  * CM6206 registers from the CM6206 datasheet rev 2.1
 716  */
 717 #define CM6206_REG0_DMA_MASTER BIT(15)
 718 #define CM6206_REG0_SPDIFO_RATE_48K (2 << 12)
 719 #define CM6206_REG0_SPDIFO_RATE_96K (7 << 12)
 720 /* Bit 4 thru 11 is the S/PDIF category code */
 721 #define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4)
 722 #define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3)
 723 #define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2)
 724 #define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1)
 725 #define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0)
 726
 727 #define CM6206_REG1_TEST_SEL_CLK BIT(14)
 728 #define CM6206_REG1_PLLBIN_EN BIT(13)
 729 #define CM6206_REG1_SOFT_MUTE_EN BIT(12)
 730 #define CM6206_REG1_GPIO4_OUT BIT(11)
 731 #define CM6206_REG1_GPIO4_OE BIT(10)
 732 #define CM6206_REG1_GPIO3_OUT BIT(9)
 733 #define CM6206_REG1_GPIO3_OE BIT(8)
 734 #define CM6206_REG1_GPIO2_OUT BIT(7)
 735 #define CM6206_REG1_GPIO2_OE BIT(6)
 736 #define CM6206_REG1_GPIO1_OUT BIT(5)
 737 #define CM6206_REG1_GPIO1_OE BIT(4)
 738 #define CM6206_REG1_SPDIFO_INVALID BIT(3)
 739 #define CM6206_REG1_SPDIF_LOOP_EN BIT(2)
 740 #define CM6206_REG1_SPDIFO_DIS BIT(1)
 741 #define CM6206_REG1_SPDIFI_MIX BIT(0)
 742
 743 #define CM6206_REG2_DRIVER_ON BIT(15)
 744 #define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13)
 745 #define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13)
 746 #define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13)
 747 #define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13)
 748 #define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12)
 749 #define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11)
 750 #define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10)
 751 #define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9)
 752 #define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8)
 753 #define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7)
 754 #define CM6206_REG2_MUTE_SUBWOOFER BIT(6)
 755 #define CM6206_REG2_MUTE_CENTER BIT(5)
 756 #define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3)
 757 #define CM6206_REG2_MUTE_LEFT_FRONT BIT(3)
 758 #define CM6206_REG2_EN_BTL BIT(2)
 759 #define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0)
 760 #define CM6206_REG2_MCUCLKSEL_3_MHZ (1)
 761 #define CM6206_REG2_MCUCLKSEL_6_MHZ (2)
 762 #define CM6206_REG2_MCUCLKSEL_12_MHZ (3)
 763
 764 /* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */
 765 #define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11)
 766 #define CM6206_REG3_VRAP25EN BIT(10)
 767 #define CM6206_REG3_MSEL1 BIT(9)
 768 #define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7)
 769 #define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7)
 770 #define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7)
 771 #define CM6206_REG3_PINSEL BIT(6)
 772 #define CM6206_REG3_FOE BIT(5)
 773 #define CM6206_REG3_ROE BIT(4)
 774 #define CM6206_REG3_CBOE BIT(3)
 775 #define CM6206_REG3_LOSE BIT(2)
 776 #define CM6206_REG3_HPOE BIT(1)
 777 #define CM6206_REG3_SPDIFI_CANREC BIT(0)
 778
 779 #define CM6206_REG5_DA_RSTN BIT(13)
 780 #define CM6206_REG5_AD_RSTN BIT(12)
 781 #define CM6206_REG5_SPDIFO_AD2SPDO BIT(12)
 782 #define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9)
 783 #define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9)
 784 #define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9)
 785 #define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9)
 786 #define CM6206_REG5_CODECM BIT(8)
 787 #define CM6206_REG5_EN_HPF BIT(7)
 788 #define CM6206_REG5_T_SEL_DSDA4 BIT(6)
 789 #define CM6206_REG5_T_SEL_DSDA3 BIT(5)
 790 #define CM6206_REG5_T_SEL_DSDA2 BIT(4)
 791 #define CM6206_REG5_T_SEL_DSDA1 BIT(3)
 792 #define CM6206_REG5_T_SEL_DSDAD_NORMAL 0
 793 #define CM6206_REG5_T_SEL_DSDAD_FRONT 4
 794 #define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5
 795 #define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6
 796 #define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7
 797
 798 static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
 799 {
 800         int err  = 0, reg;
 801         int val[] = {
 802                 /*
 803                  * Values here are chosen based on sniffing USB traffic
 804                  * under Windows.
 805                  *
 806                  * REG0: DAC is master, sample rate 48kHz, no copyright
 807                  */
 808                 CM6206_REG0_SPDIFO_RATE_48K |
 809                 CM6206_REG0_SPDIFO_COPYRIGHT_NA,
 810                 /*
 811                  * REG1: PLL binary search enable, soft mute enable.
 812                  */
 813                 CM6206_REG1_PLLBIN_EN |
 814                 CM6206_REG1_SOFT_MUTE_EN,
 815                 /*
 816                  * REG2: enable output drivers,
 817                  * select front channels to the headphone output,
 818                  * then mute the headphone channels, run the MCU
 819                  * at 1.5 MHz.
 820                  */
 821                 CM6206_REG2_DRIVER_ON |
 822                 CM6206_REG2_HEADP_SEL_FRONT_CHANNELS |
 823                 CM6206_REG2_MUTE_HEADPHONE_RIGHT |
 824                 CM6206_REG2_MUTE_HEADPHONE_LEFT,
 825                 /*
 826                  * REG3: default flyspeed, set 2.5V mic bias
 827                  * enable all line out ports and enable SPDIF
 828                  */
 829                 CM6206_REG3_FLYSPEED_DEFAULT |
 830                 CM6206_REG3_VRAP25EN |
 831                 CM6206_REG3_FOE |
 832                 CM6206_REG3_ROE |
 833                 CM6206_REG3_CBOE |
 834                 CM6206_REG3_LOSE |
 835                 CM6206_REG3_HPOE |
 836                 CM6206_REG3_SPDIFI_CANREC,
 837                 /* REG4 is just a bunch of GPIO lines */
 838                 0x0000,
 839                 /* REG5: de-assert AD/DA reset signals */
 840                 CM6206_REG5_DA_RSTN |
 841                 CM6206_REG5_AD_RSTN };
 842
 843         for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
 844                 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
 845                 if (err < 0)
 846                         return err;
 847         }
 848
 849         return err;
 850 }
 851
 852 /* quirk for Plantronics GameCom 780 with CM6302 chip */
 853 static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev)
 854 {
 855         /* set the initial volume and don't change; other values are either
 856          * too loud or silent due to firmware bug (bko#65251)
 857          */
 858         u8 buf[2] = { 0x74, 0xe3 };
 859         return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
 860                         USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
 861                         UAC_FU_VOLUME << 8, 9 << 8, buf, 2);
 862 }
 863
 864 /*
 865  * Novation Twitch DJ controller
 866  * Focusrite Novation Saffire 6 USB audio card
 867  */
 868 static int snd_usb_novation_boot_quirk(struct usb_device *dev)
 869 {
 870         /* preemptively set up the device because otherwise the
 871          * raw MIDI endpoints are not active */
 872         usb_set_interface(dev, 0, 1);
 873         return 0;
 874 }
 875
 876 /*
 877  * This call will put the synth in "USB send" mode, i.e it will send MIDI
 878  * messages through USB (this is disabled at startup). The synth will
 879  * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
 880  * sign on its LCD. Values here are chosen based on sniffing USB traffic
 881  * under Windows.
 882  */
 883 static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
 884 {
 885         int err, actual_length;
 886         /* "midi send" enable */
 887         static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
 888         void *buf;
 889
 890         if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x05)))
 891                 return -EINVAL;
 892         buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
 893         if (!buf)
 894                 return -ENOMEM;
 895         err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
 896                         ARRAY_SIZE(seq), &actual_length, 1000);
 897         kfree(buf);
 898         if (err < 0)
 899                 return err;
 900
 901         return 0;
 902 }
 903
 904 /*
 905  * Some sound cards from Native Instruments are in fact compliant to the USB
 906  * audio standard of version 2 and other approved USB standards, even though
 907  * they come up as vendor-specific device when first connected.
 908  *
 909  * However, they can be told to come up with a new set of descriptors
 910  * upon their next enumeration, and the interfaces announced by the new
 911  * descriptors will then be handled by the kernel's class drivers. As the
 912  * product ID will also change, no further checks are required.
 913  */
 914
 915 static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev)
 916 {
 917         int ret;
 918
 919         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 920                                   0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 921                                   1, 0, NULL, 0, 1000);
 922
 923         if (ret < 0)
 924                 return ret;
 925
 926         usb_reset_device(dev);
 927
 928         /* return -EAGAIN, so the creation of an audio interface for this
 929          * temporary device is aborted. The device will reconnect with a
 930          * new product ID */
 931         return -EAGAIN;
 932 }
 933
 934 static void mbox2_setup_48_24_magic(struct usb_device *dev)
 935 {
 936         u8 srate[3];
 937         u8 temp[12];
 938
 939         /* Choose 48000Hz permanently */
 940         srate[0] = 0x80;
 941         srate[1] = 0xbb;
 942         srate[2] = 0x00;
 943
 944         /* Send the magic! */
 945         snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 946                 0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003);
 947         snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
 948                 0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003);
 949         snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
 950                 0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003);
 951         snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
 952                 0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003);
 953         return;
 954 }
 955
 956 /* Digidesign Mbox 2 needs to load firmware onboard
 957  * and driver must wait a few seconds for initialisation.
 958  */
 959
 960 #define MBOX2_FIRMWARE_SIZE    646
 961 #define MBOX2_BOOT_LOADING     0x01 /* Hard coded into the device */
 962 #define MBOX2_BOOT_READY       0x02 /* Hard coded into the device */
 963
 964 static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
 965 {
 966         struct usb_host_config *config = dev->actconfig;
 967         int err;
 968         u8 bootresponse[0x12];
 969         int fwsize;
 970         int count;
 971
 972         fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
 973
 974         if (fwsize != MBOX2_FIRMWARE_SIZE) {
 975                 dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);
 976                 return -ENODEV;
 977         }
 978
 979         dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");
 980
 981         count = 0;
 982         bootresponse[0] = MBOX2_BOOT_LOADING;
 983         while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) {
 984                 msleep(500); /* 0.5 second delay */
 985                 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 986                         /* Control magic - load onboard firmware */
 987                         0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);
 988                 if (bootresponse[0] == MBOX2_BOOT_READY)
 989                         break;
 990                 dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");
 991                 count++;
 992         }
 993
 994         if (bootresponse[0] != MBOX2_BOOT_READY) {
 995                 dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
 996                 return -ENODEV;
 997         }
 998
 999         dev_dbg(&dev->dev, "device initialised!\n");
1000
1001         err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
1002                 &dev->descriptor, sizeof(dev->descriptor));
1003         config = dev->actconfig;
1004         if (err < 0)
1005                 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
1006
1007         err = usb_reset_configuration(dev);
1008         if (err < 0)
1009                 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
1010         dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",
1011                 le16_to_cpu(get_cfg_desc(config)->wTotalLength));
1012
1013         mbox2_setup_48_24_magic(dev);
1014
1015         dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");
1016
1017         return 0; /* Successful boot */
1018 }
1019
1020 static int snd_usb_axefx3_boot_quirk(struct usb_device *dev)
1021 {
1022         int err;
1023
1024         dev_dbg(&dev->dev, "Waiting for Axe-Fx III to boot up...\n");
1025
1026         /* If the Axe-Fx III has not fully booted, it will timeout when trying
1027          * to enable the audio streaming interface. A more generous timeout is
1028          * used here to detect when the Axe-Fx III has finished booting as the
1029          * set interface message will be acked once it has
1030          */
1031         err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1032                                 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
1033                                 1, 1, NULL, 0, 120000);
1034         if (err < 0) {
1035                 dev_err(&dev->dev,
1036                         "failed waiting for Axe-Fx III to boot: %d\n", err);
1037                 return err;
1038         }
1039
1040         dev_dbg(&dev->dev, "Axe-Fx III is now ready\n");
1041
1042         err = usb_set_interface(dev, 1, 0);
1043         if (err < 0)
1044                 dev_dbg(&dev->dev,
1045                         "error stopping Axe-Fx III interface: %d\n", err);
1046
1047         return 0;
1048 }
1049
1050
1051 #define MICROBOOK_BUF_SIZE 128
1052
1053 static int snd_usb_motu_microbookii_communicate(struct usb_device *dev, u8 *buf,
1054                                                 int buf_size, int *length)
1055 {
1056         int err, actual_length;
1057
1058         if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x01)))
1059                 return -EINVAL;
1060         err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x01), buf, *length,
1061                                 &actual_length, 1000);
1062         if (err < 0)
1063                 return err;
1064
1065         print_hex_dump(KERN_DEBUG, "MicroBookII snd: ", DUMP_PREFIX_NONE, 16, 1,
1066                        buf, actual_length, false);
1067
1068         memset(buf, 0, buf_size);
1069
1070         if (usb_pipe_type_check(dev, usb_rcvintpipe(dev, 0x82)))
1071                 return -EINVAL;
1072         err = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x82), buf, buf_size,
1073                                 &actual_length, 1000);
1074         if (err < 0)
1075                 return err;
1076
1077         print_hex_dump(KERN_DEBUG, "MicroBookII rcv: ", DUMP_PREFIX_NONE, 16, 1,
1078                        buf, actual_length, false);
1079
1080         *length = actual_length;
1081         return 0;
1082 }
1083
1084 static int snd_usb_motu_microbookii_boot_quirk(struct usb_device *dev)
1085 {
1086         int err, actual_length, poll_attempts = 0;
1087         static const u8 set_samplerate_seq[] = { 0x00, 0x00, 0x00, 0x00,
1088                                                  0x00, 0x00, 0x0b, 0x14,
1089                                                  0x00, 0x00, 0x00, 0x01 };
1090         static const u8 poll_ready_seq[] = { 0x00, 0x04, 0x00, 0x00,
1091                                              0x00, 0x00, 0x0b, 0x18 };
1092         u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, GFP_KERNEL);
1093
1094         if (!buf)
1095                 return -ENOMEM;
1096
1097         dev_info(&dev->dev, "Waiting for MOTU Microbook II to boot up...\n");
1098
1099         /* First we tell the device which sample rate to use. */
1100         memcpy(buf, set_samplerate_seq, sizeof(set_samplerate_seq));
1101         actual_length = sizeof(set_samplerate_seq);
1102         err = snd_usb_motu_microbookii_communicate(dev, buf, MICROBOOK_BUF_SIZE,
1103                                                    &actual_length);
1104
1105         if (err < 0) {
1106                 dev_err(&dev->dev,
1107                         "failed setting the sample rate for Motu MicroBook II: %d\n",
1108                         err);
1109                 goto free_buf;
1110         }
1111
1112         /* Then we poll every 100 ms until the device informs of its readiness. */
1113         while (true) {
1114                 if (++poll_attempts > 100) {
1115                         dev_err(&dev->dev,
1116                                 "failed booting Motu MicroBook II: timeout\n");
1117                         err = -ENODEV;
1118                         goto free_buf;
1119                 }
1120
1121                 memset(buf, 0, MICROBOOK_BUF_SIZE);
1122                 memcpy(buf, poll_ready_seq, sizeof(poll_ready_seq));
1123
1124                 actual_length = sizeof(poll_ready_seq);
1125                 err = snd_usb_motu_microbookii_communicate(
1126                         dev, buf, MICROBOOK_BUF_SIZE, &actual_length);
1127                 if (err < 0) {
1128                         dev_err(&dev->dev,
1129                                 "failed booting Motu MicroBook II: communication error %d\n",
1130                                 err);
1131                         goto free_buf;
1132                 }
1133
1134                 /* the device signals its readiness through a message of the
1135                  * form
1136                  *           XX 06 00 00 00 00 0b 18  00 00 00 01
1137                  * If the device is not yet ready to accept audio data, the
1138                  * last byte of that sequence is 00.
1139                  */
1140                 if (actual_length == 12 && buf[actual_length - 1] == 1)
1141                         break;
1142
1143                 msleep(100);
1144         }
1145
1146         dev_info(&dev->dev, "MOTU MicroBook II ready\n");
1147
1148 free_buf:
1149         kfree(buf);
1150         return err;
1151 }
1152
1153 static int snd_usb_motu_m_series_boot_quirk(struct usb_device *dev)
1154 {
1155         msleep(2000);
1156
1157         return 0;
1158 }
1159
1160 /*
1161  * Setup quirks
1162  */
1163 #define MAUDIO_SET              0x01 /* parse device_setup */
1164 #define MAUDIO_SET_COMPATIBLE   0x80 /* use only "win-compatible" interfaces */
1165 #define MAUDIO_SET_DTS          0x02 /* enable DTS Digital Output */
1166 #define MAUDIO_SET_96K          0x04 /* 48-96kHz rate if set, 8-48kHz otherwise */
1167 #define MAUDIO_SET_24B          0x08 /* 24bits sample if set, 16bits otherwise */
1168 #define MAUDIO_SET_DI           0x10 /* enable Digital Input */
1169 #define MAUDIO_SET_MASK         0x1f /* bit mask for setup value */
1170 #define MAUDIO_SET_24B_48K_DI    0x19 /* 24bits+48kHz+Digital Input */
1171 #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48kHz+No Digital Input */
1172 #define MAUDIO_SET_16B_48K_DI    0x11 /* 16bits+48kHz+Digital Input */
1173 #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48kHz+No Digital Input */
1174
1175 static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,
1176                                       int iface, int altno)
1177 {
1178         /* Reset ALL ifaces to 0 altsetting.
1179          * Call it for every possible altsetting of every interface.
1180          */
1181         usb_set_interface(chip->dev, iface, 0);
1182         if (chip->setup & MAUDIO_SET) {
1183                 if (chip->setup & MAUDIO_SET_COMPATIBLE) {
1184                         if (iface != 1 && iface != 2)
1185                                 return 1; /* skip all interfaces but 1 and 2 */
1186                 } else {
1187                         unsigned int mask;
1188                         if (iface == 1 || iface == 2)
1189                                 return 1; /* skip interfaces 1 and 2 */
1190                         if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1191                                 return 1; /* skip this altsetting */
1192                         mask = chip->setup & MAUDIO_SET_MASK;
1193                         if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1194                                 return 1; /* skip this altsetting */
1195                         if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1196                                 return 1; /* skip this altsetting */
1197                         if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4)
1198                                 return 1; /* skip this altsetting */
1199                 }
1200         }
1201         usb_audio_dbg(chip,
1202                     "using altsetting %d for interface %d config %d\n",
1203                     altno, iface, chip->setup);
1204         return 0; /* keep this altsetting */
1205 }
1206
1207 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
1208                                          int iface,
1209                                          int altno)
1210 {
1211         /* Reset ALL ifaces to 0 altsetting.
1212          * Call it for every possible altsetting of every interface.
1213          */
1214         usb_set_interface(chip->dev, iface, 0);
1215
1216         if (chip->setup & MAUDIO_SET) {
1217                 unsigned int mask;
1218                 if ((chip->setup & MAUDIO_SET_DTS) && altno != 6)
1219                         return 1; /* skip this altsetting */
1220                 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
1221                         return 1; /* skip this altsetting */
1222                 mask = chip->setup & MAUDIO_SET_MASK;
1223                 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
1224                         return 1; /* skip this altsetting */
1225                 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
1226                         return 1; /* skip this altsetting */
1227                 if (mask == MAUDIO_SET_16B_48K_DI && altno != 4)
1228                         return 1; /* skip this altsetting */
1229                 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5)
1230                         return 1; /* skip this altsetting */
1231         }
1232
1233         return 0; /* keep this altsetting */
1234 }
1235
1236 static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,
1237                                            int iface, int altno)
1238 {
1239         /* Reset ALL ifaces to 0 altsetting.
1240          * Call it for every possible altsetting of every interface.
1241          */
1242         usb_set_interface(chip->dev, iface, 0);
1243
1244         /* possible configuration where both inputs and only one output is
1245          *used is not supported by the current setup
1246          */
1247         if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) {
1248                 if (chip->setup & MAUDIO_SET_96K) {
1249                         if (altno != 3 && altno != 6)
1250                                 return 1;
1251                 } else if (chip->setup & MAUDIO_SET_DI) {
1252                         if (iface == 4)
1253                                 return 1; /* no analog input */
1254                         if (altno != 2 && altno != 5)
1255                                 return 1; /* enable only altsets 2 and 5 */
1256                 } else {
1257                         if (iface == 5)
1258                                 return 1; /* disable digialt input */
1259                         if (altno != 2 && altno != 5)
1260                                 return 1; /* enalbe only altsets 2 and 5 */
1261                 }
1262         } else {
1263                 /* keep only 16-Bit mode */
1264                 if (altno != 1)
1265                         return 1;
1266         }
1267
1268         usb_audio_dbg(chip,
1269                     "using altsetting %d for interface %d config %d\n",
1270                     altno, iface, chip->setup);
1271         return 0; /* keep this altsetting */
1272 }
1273
1274 static int s1810c_skip_setting_quirk(struct snd_usb_audio *chip,
1275                                            int iface, int altno)
1276 {
1277         /*
1278          * Altno settings:
1279          *
1280          * Playback (Interface 1):
1281          * 1: 6 Analog + 2 S/PDIF
1282          * 2: 6 Analog + 2 S/PDIF
1283          * 3: 6 Analog
1284          *
1285          * Capture (Interface 2):
1286          * 1: 8 Analog + 2 S/PDIF + 8 ADAT
1287          * 2: 8 Analog + 2 S/PDIF + 4 ADAT
1288          * 3: 8 Analog
1289          */
1290
1291         /*
1292          * I'll leave 2 as the default one and
1293          * use device_setup to switch to the
1294          * other two.
1295          */
1296         if ((chip->setup == 0 || chip->setup > 2) && altno != 2)
1297                 return 1;
1298         else if (chip->setup == 1 && altno != 1)
1299                 return 1;
1300         else if (chip->setup == 2 && altno != 3)
1301                 return 1;
1302
1303         return 0;
1304 }
1305
1306 int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
1307                                   int iface,
1308                                   int altno)
1309 {
1310         /* audiophile usb: skip altsets incompatible with device_setup */
1311         if (chip->usb_id == USB_ID(0x0763, 0x2003))
1312                 return audiophile_skip_setting_quirk(chip, iface, altno);
1313         /* quattro usb: skip altsets incompatible with device_setup */
1314         if (chip->usb_id == USB_ID(0x0763, 0x2001))
1315                 return quattro_skip_setting_quirk(chip, iface, altno);
1316         /* fasttrackpro usb: skip altsets incompatible with device_setup */
1317         if (chip->usb_id == USB_ID(0x0763, 0x2012))
1318                 return fasttrackpro_skip_setting_quirk(chip, iface, altno);
1319         /* presonus studio 1810c: skip altsets incompatible with device_setup */
1320         if (chip->usb_id == USB_ID(0x0194f, 0x010c))
1321                 return s1810c_skip_setting_quirk(chip, iface, altno);
1322
1323
1324         return 0;
1325 }
1326
1327 int snd_usb_apply_boot_quirk(struct usb_device *dev,
1328                              struct usb_interface *intf,
1329                              const struct snd_usb_audio_quirk *quirk,
1330                              unsigned int id)
1331 {
1332         switch (id) {
1333         case USB_ID(0x041e, 0x3000):
1334                 /* SB Extigy needs special boot-up sequence */
1335                 /* if more models come, this will go to the quirk list. */
1336                 return snd_usb_extigy_boot_quirk(dev, intf);
1337
1338         case USB_ID(0x041e, 0x3020):
1339                 /* SB Audigy 2 NX needs its own boot-up magic, too */
1340                 return snd_usb_audigy2nx_boot_quirk(dev);
1341
1342         case USB_ID(0x10f5, 0x0200):
1343                 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
1344                 return snd_usb_cm106_boot_quirk(dev);
1345
1346         case USB_ID(0x0d8c, 0x0102):
1347                 /* C-Media CM6206 / CM106-Like Sound Device */
1348         case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */
1349                 return snd_usb_cm6206_boot_quirk(dev);
1350
1351         case USB_ID(0x0dba, 0x3000):
1352                 /* Digidesign Mbox 2 */
1353                 return snd_usb_mbox2_boot_quirk(dev);
1354
1355         case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */
1356         case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */
1357                 return snd_usb_novation_boot_quirk(dev);
1358
1359         case USB_ID(0x133e, 0x0815):
1360                 /* Access Music VirusTI Desktop */
1361                 return snd_usb_accessmusic_boot_quirk(dev);
1362
1363         case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */
1364         case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */
1365         case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */
1366                 return snd_usb_nativeinstruments_boot_quirk(dev);
1367         case USB_ID(0x0763, 0x2012):  /* M-Audio Fast Track Pro USB */
1368                 return snd_usb_fasttrackpro_boot_quirk(dev);
1369         case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */
1370                 return snd_usb_gamecon780_boot_quirk(dev);
1371         case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */
1372                 return snd_usb_axefx3_boot_quirk(dev);
1373         case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */
1374                 /*
1375                  * For some reason interface 3 with vendor-spec class is
1376                  * detected on MicroBook IIc.
1377                  */
1378                 if (get_iface_desc(intf->altsetting)->bInterfaceClass ==
1379                     USB_CLASS_VENDOR_SPEC &&
1380                     get_iface_desc(intf->altsetting)->bInterfaceNumber < 3)
1381                         return snd_usb_motu_microbookii_boot_quirk(dev);
1382                 break;
1383         }
1384
1385         return 0;
1386 }
1387
1388 int snd_usb_apply_boot_quirk_once(struct usb_device *dev,
1389                                   struct usb_interface *intf,
1390                                   const struct snd_usb_audio_quirk *quirk,
1391                                   unsigned int id)
1392 {
1393         switch (id) {
1394         case USB_ID(0x07fd, 0x0008): /* MOTU M Series */
1395                 return snd_usb_motu_m_series_boot_quirk(dev);
1396         }
1397
1398         return 0;
1399 }
1400
1401 /*
1402  * check if the device uses big-endian samples
1403  */
1404 int snd_usb_is_big_endian_format(struct snd_usb_audio *chip,
1405                                  const struct audioformat *fp)
1406 {
1407         /* it depends on altsetting whether the device is big-endian or not */
1408         switch (chip->usb_id) {
1409         case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
1410                 if (fp->altsetting == 2 || fp->altsetting == 3 ||
1411                         fp->altsetting == 5 || fp->altsetting == 6)
1412                         return 1;
1413                 break;
1414         case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1415                 if (chip->setup == 0x00 ||
1416                         fp->altsetting == 1 || fp->altsetting == 2 ||
1417                         fp->altsetting == 3)
1418                         return 1;
1419                 break;
1420         case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */
1421                 if (fp->altsetting == 2 || fp->altsetting == 3 ||
1422                         fp->altsetting == 5 || fp->altsetting == 6)
1423                         return 1;
1424                 break;
1425         }
1426         return 0;
1427 }
1428
1429 /*
1430  * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,
1431  * not for interface.
1432  */
1433
1434 enum {
1435         EMU_QUIRK_SR_44100HZ = 0,
1436         EMU_QUIRK_SR_48000HZ,
1437         EMU_QUIRK_SR_88200HZ,
1438         EMU_QUIRK_SR_96000HZ,
1439         EMU_QUIRK_SR_176400HZ,
1440         EMU_QUIRK_SR_192000HZ
1441 };
1442
1443 static void set_format_emu_quirk(struct snd_usb_substream *subs,
1444                                  const struct audioformat *fmt)
1445 {
1446         unsigned char emu_samplerate_id = 0;
1447
1448         /* When capture is active
1449          * sample rate shouldn't be changed
1450          * by playback substream
1451          */
1452         if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1453                 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].cur_audiofmt)
1454                         return;
1455         }
1456
1457         switch (fmt->rate_min) {
1458         case 48000:
1459                 emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
1460                 break;
1461         case 88200:
1462                 emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
1463                 break;
1464         case 96000:
1465                 emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
1466                 break;
1467         case 176400:
1468                 emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
1469                 break;
1470         case 192000:
1471                 emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
1472                 break;
1473         default:
1474                 emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
1475                 break;
1476         }
1477         snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
1478         subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0;
1479 }
1480
1481 static int pioneer_djm_set_format_quirk(struct snd_usb_substream *subs,
1482                                         u16 windex)
1483 {
1484         unsigned int cur_rate = subs->data_endpoint->cur_rate;
1485         u8 sr[3];
1486         // Convert to little endian
1487         sr[0] = cur_rate & 0xff;
1488         sr[1] = (cur_rate >> 8) & 0xff;
1489         sr[2] = (cur_rate >> 16) & 0xff;
1490         usb_set_interface(subs->dev, 0, 1);
1491         // we should derive windex from fmt-sync_ep but it's not set
1492         snd_usb_ctl_msg(subs->stream->chip->dev,
1493                 usb_sndctrlpipe(subs->stream->chip->dev, 0),
1494                 0x01, 0x22, 0x0100, windex, &sr, 0x0003);
1495         return 0;
1496 }
1497
1498 void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
1499                               const struct audioformat *fmt)
1500 {
1501         switch (subs->stream->chip->usb_id) {
1502         case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1503         case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1504         case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1505         case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
1506                 set_format_emu_quirk(subs, fmt);
1507                 break;
1508         case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */
1509                 subs->stream_offset_adj = 2;
1510                 break;
1511         case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */
1512                 pioneer_djm_set_format_quirk(subs, 0x0082);
1513                 break;
1514         case USB_ID(0x08e4, 0x017f): /* Pioneer DJM-750 */
1515         case USB_ID(0x08e4, 0x0163): /* Pioneer DJM-850 */
1516                 pioneer_djm_set_format_quirk(subs, 0x0086);
1517                 break;
1518         }
1519 }
1520
1521 bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
1522 {
1523         /* devices which do not support reading the sample rate. */
1524         switch (chip->usb_id) {
1525         case USB_ID(0x041e, 0x4080): /* Creative Live Cam VF0610 */
1526         case USB_ID(0x04d8, 0xfeea): /* Benchmark DAC1 Pre */
1527         case USB_ID(0x0556, 0x0014): /* Phoenix Audio TMX320VC */
1528         case USB_ID(0x05a3, 0x9420): /* ELP HD USB Camera */
1529         case USB_ID(0x05a7, 0x1020): /* Bose Companion 5 */
1530         case USB_ID(0x074d, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */
1531         case USB_ID(0x1395, 0x740a): /* Sennheiser DECT */
1532         case USB_ID(0x1901, 0x0191): /* GE B850V3 CP2114 audio interface */
1533         case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
1534         case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */
1535         case USB_ID(0x413c, 0xa506): /* Dell AE515 sound bar */
1536         case USB_ID(0x046d, 0x084c): /* Logitech ConferenceCam Connect */
1537                 return true;
1538         }
1539
1540         /* devices of these vendors don't support reading rate, either */
1541         switch (USB_ID_VENDOR(chip->usb_id)) {
1542         case 0x045e: /* MS Lifecam */
1543         case 0x047f: /* Plantronics */
1544         case 0x1de7: /* Phoenix Audio */
1545                 return true;
1546         }
1547
1548         return false;
1549 }
1550
1551 /* ITF-USB DSD based DACs need a vendor cmd to switch
1552  * between PCM and native DSD mode
1553  */
1554 static bool is_itf_usb_dsd_dac(unsigned int id)
1555 {
1556         switch (id) {
1557         case USB_ID(0x154e, 0x1002): /* Denon DCD-1500RE */
1558         case USB_ID(0x154e, 0x1003): /* Denon DA-300USB */
1559         case USB_ID(0x154e, 0x3005): /* Marantz HD-DAC1 */
1560         case USB_ID(0x154e, 0x3006): /* Marantz SA-14S1 */
1561         case USB_ID(0x1852, 0x5065): /* Luxman DA-06 */
1562         case USB_ID(0x0644, 0x8043): /* TEAC UD-501/UD-501V2/UD-503/NT-503 */
1563         case USB_ID(0x0644, 0x8044): /* Esoteric D-05X */
1564         case USB_ID(0x0644, 0x804a): /* TEAC UD-301 */
1565                 return true;
1566         }
1567         return false;
1568 }
1569
1570 int snd_usb_select_mode_quirk(struct snd_usb_audio *chip,
1571                               const struct audioformat *fmt)
1572 {
1573         struct usb_device *dev = chip->dev;
1574         int err;
1575
1576         if (is_itf_usb_dsd_dac(chip->usb_id)) {
1577                 /* First switch to alt set 0, otherwise the mode switch cmd
1578                  * will not be accepted by the DAC
1579                  */
1580                 err = usb_set_interface(dev, fmt->iface, 0);
1581                 if (err < 0)
1582                         return err;
1583
1584                 msleep(20); /* Delay needed after setting the interface */
1585
1586                 /* Vendor mode switch cmd is required. */
1587                 if (fmt->formats & SNDRV_PCM_FMTBIT_DSD_U32_BE) {
1588                         /* DSD mode (DSD_U32) requested */
1589                         err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1590                                               USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1591                                               1, 1, NULL, 0);
1592                         if (err < 0)
1593                                 return err;
1594
1595                 } else {
1596                         /* PCM or DOP mode (S32) requested */
1597                         /* PCM mode (S16) requested */
1598                         err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1599                                               USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1600                                               0, 1, NULL, 0);
1601                         if (err < 0)
1602                                 return err;
1603
1604                 }
1605                 msleep(20);
1606         }
1607         return 0;
1608 }
1609
1610 void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep)
1611 {
1612         /*
1613          * "Playback Design" products send bogus feedback data at the start
1614          * of the stream. Ignore them.
1615          */
1616         if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba &&
1617             ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
1618                 ep->skip_packets = 4;
1619
1620         /*
1621          * M-Audio Fast Track C400/C600 - when packets are not skipped, real
1622          * world latency varies by approx. +/- 50 frames (at 96kHz) each time
1623          * the stream is (re)started. When skipping packets 16 at endpoint
1624          * start up, the real world latency is stable within +/- 1 frame (also
1625          * across power cycles).
1626          */
1627         if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) ||
1628              ep->chip->usb_id == USB_ID(0x0763, 0x2031)) &&
1629             ep->type == SND_USB_ENDPOINT_TYPE_DATA)
1630                 ep->skip_packets = 16;
1631
1632         /* Work around devices that report unreasonable feedback data */
1633         if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) ||  /* TEAC UD-H01 */
1634              ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */
1635             ep->syncmaxsize == 4)
1636                 ep->tenor_fb_quirk = 1;
1637 }
1638
1639 void snd_usb_set_interface_quirk(struct snd_usb_audio *chip)
1640 {
1641         if (!chip)
1642                 return;
1643         /*
1644          * "Playback Design" products need a 50ms delay after setting the
1645          * USB interface.
1646          */
1647         switch (USB_ID_VENDOR(chip->usb_id)) {
1648         case 0x23ba: /* Playback Design */
1649         case 0x0644: /* TEAC Corp. */
1650                 msleep(50);
1651                 break;
1652         }
1653 }
1654
1655 /* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */
1656 void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
1657                            __u8 request, __u8 requesttype, __u16 value,
1658                            __u16 index, void *data, __u16 size)
1659 {
1660         struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1661
1662         if (!chip)
1663                 return;
1664         /*
1665          * "Playback Design" products need a 20ms delay after each
1666          * class compliant request
1667          */
1668         if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
1669             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1670                 msleep(20);
1671
1672         /*
1673          * "TEAC Corp." products need a 20ms delay after each
1674          * class compliant request
1675          */
1676         if (USB_ID_VENDOR(chip->usb_id) == 0x0644 &&
1677             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1678                 msleep(20);
1679
1680         /* ITF-USB DSD based DACs functionality need a delay
1681          * after each class compliant request
1682          */
1683         if (is_itf_usb_dsd_dac(chip->usb_id)
1684             && (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1685                 msleep(20);
1686
1687         /*
1688          * Plantronics headsets (C320, C320-M, etc) need a delay to avoid
1689          * random microhpone failures.
1690          */
1691         if (USB_ID_VENDOR(chip->usb_id) == 0x047f &&
1692             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1693                 msleep(20);
1694
1695         /* Zoom R16/24, many Logitech(at least H650e/H570e/BCC950),
1696          * Jabra 550a, Kingston HyperX needs a tiny delay here,
1697          * otherwise requests like get/set frequency return
1698          * as failed despite actually succeeding.
1699          */
1700         if ((chip->usb_id == USB_ID(0x1686, 0x00dd) ||
1701              USB_ID_VENDOR(chip->usb_id) == 0x046d  || /* Logitech */
1702              chip->usb_id == USB_ID(0x0b0e, 0x0349) ||
1703              chip->usb_id == USB_ID(0x0951, 0x16ad)) &&
1704             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1705                 usleep_range(1000, 2000);
1706
1707         /*
1708          * Samsung USBC Headset (AKG) need a tiny delay after each
1709          * class compliant request. (Model number: AAM625R or AAM627R)
1710          */
1711         if (chip->usb_id == USB_ID(0x04e8, 0xa051) &&
1712             (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1713                 usleep_range(5000, 6000);
1714 }
1715
1716 /*
1717  * snd_usb_interface_dsd_format_quirks() is called from format.c to
1718  * augment the PCM format bit-field for DSD types. The UAC standards
1719  * don't have a designated bit field to denote DSD-capable interfaces,
1720  * hence all hardware that is known to support this format has to be
1721  * listed here.
1722  */
1723 u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
1724                                         struct audioformat *fp,
1725                                         unsigned int sample_bytes)
1726 {
1727         struct usb_interface *iface;
1728
1729         /* Playback Designs */
1730         if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
1731             USB_ID_PRODUCT(chip->usb_id) < 0x0110) {
1732                 switch (fp->altsetting) {
1733                 case 1:
1734                         fp->dsd_dop = true;
1735                         return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1736                 case 2:
1737                         fp->dsd_bitrev = true;
1738                         return SNDRV_PCM_FMTBIT_DSD_U8;
1739                 case 3:
1740                         fp->dsd_bitrev = true;
1741                         return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1742                 }
1743         }
1744
1745         /* XMOS based USB DACs */
1746         switch (chip->usb_id) {
1747         case USB_ID(0x1511, 0x0037): /* AURALiC VEGA */
1748         case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */
1749         case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */
1750                 if (fp->altsetting == 2)
1751                         return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1752                 break;
1753
1754         case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
1755         case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
1756         case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
1757         case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
1758         case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1759         case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */
1760         case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */
1761         case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */
1762         case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */
1763         case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */
1764         case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */
1765         case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */
1766         case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */
1767         case USB_ID(0x6b42, 0x0042): /* MSB Technology */
1768                 if (fp->altsetting == 3)
1769                         return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1770                 break;
1771
1772         /* Amanero Combo384 USB based DACs with native DSD support */
1773         case USB_ID(0x16d0, 0x071a):  /* Amanero - Combo384 */
1774         case USB_ID(0x2ab6, 0x0004):  /* T+A DAC8DSD-V2.0, MP1000E-V2.0, MP2000R-V2.0, MP2500R-V2.0, MP3100HV-V2.0 */
1775         case USB_ID(0x2ab6, 0x0005):  /* T+A USB HD Audio 1 */
1776         case USB_ID(0x2ab6, 0x0006):  /* T+A USB HD Audio 2 */
1777                 if (fp->altsetting == 2) {
1778                         switch (le16_to_cpu(chip->dev->descriptor.bcdDevice)) {
1779                         case 0x199:
1780                                 return SNDRV_PCM_FMTBIT_DSD_U32_LE;
1781                         case 0x19b:
1782                         case 0x203:
1783                                 return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1784                         default:
1785                                 break;
1786                         }
1787                 }
1788                 break;
1789         case USB_ID(0x16d0, 0x0a23):
1790                 if (fp->altsetting == 2)
1791                         return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1792                 break;
1793
1794         default:
1795                 break;
1796         }
1797
1798         /* ITF-USB DSD based DACs */
1799         if (is_itf_usb_dsd_dac(chip->usb_id)) {
1800                 iface = usb_ifnum_to_if(chip->dev, fp->iface);
1801
1802                 /* Altsetting 2 support native DSD if the num of altsets is
1803                  * three (0-2),
1804                  * Altsetting 3 support native DSD if the num of altsets is
1805                  * four (0-3).
1806                  */
1807                 if (fp->altsetting == iface->num_altsetting - 1)
1808                         return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1809         }
1810
1811         /* Mostly generic method to detect many DSD-capable implementations -
1812          * from XMOS/Thesycon
1813          */
1814         switch (USB_ID_VENDOR(chip->usb_id)) {
1815         case 0x152a:  /* Thesycon devices */
1816         case 0x20b1:  /* XMOS based devices */
1817         case 0x22d9:  /* Oppo */
1818         case 0x23ba:  /* Playback Designs */
1819         case 0x25ce:  /* Mytek devices */
1820         case 0x278b:  /* Rotel? */
1821         case 0x292b:  /* Gustard/Ess based devices */
1822         case 0x2972:  /* FiiO devices */
1823         case 0x2ab6:  /* T+A devices */
1824         case 0x3353:  /* Khadas devices */
1825         case 0x3842:  /* EVGA */
1826         case 0xc502:  /* HiBy devices */
1827                 if (fp->dsd_raw)
1828                         return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1829                 break;
1830         default:
1831                 break;
1832
1833         }
1834
1835         return 0;
1836 }
1837
1838 void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip,
1839                                           struct audioformat *fp,
1840                                           int stream)
1841 {
1842         switch (chip->usb_id) {
1843         case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
1844                 /* Optoplay sets the sample rate attribute although
1845                  * it seems not supporting it in fact.
1846                  */
1847                 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;
1848                 break;
1849         case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
1850         case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1851                 /* doesn't set the sample rate attribute, but supports it */
1852                 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;
1853                 break;
1854         case USB_ID(0x0763, 0x2001):  /* M-Audio Quattro USB */
1855         case USB_ID(0x0763, 0x2012):  /* M-Audio Fast Track Pro USB */
1856         case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
1857         case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
1858                                         an older model 77d:223) */
1859         /*
1860          * plantronics headset and Griffin iMic have set adaptive-in
1861          * although it's really not...
1862          */
1863                 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;
1864                 if (stream == SNDRV_PCM_STREAM_PLAYBACK)
1865                         fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;
1866                 else
1867                         fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;
1868                 break;
1869         case USB_ID(0x07fd, 0x0004):  /* MOTU MicroBook IIc */
1870                 /*
1871                  * MaxPacketsOnly attribute is erroneously set in endpoint
1872                  * descriptors. As a result this card produces noise with
1873                  * all sample rates other than 96 kHz.
1874                  */
1875                 fp->attributes &= ~UAC_EP_CS_ATTR_FILL_MAX;
1876                 break;
1877         }
1878 }
1879
1880 /*
1881  * registration quirk:
1882  * the registration is skipped if a device matches with the given ID,
1883  * unless the interface reaches to the defined one.  This is for delaying
1884  * the registration until the last known interface, so that the card and
1885  * devices appear at the same time.
1886  */
1887
1888 struct registration_quirk {
1889         unsigned int usb_id;    /* composed via USB_ID() */
1890         unsigned int interface; /* the interface to trigger register */
1891 };
1892
1893 #define REG_QUIRK_ENTRY(vendor, product, iface) \
1894         { .usb_id = USB_ID(vendor, product), .interface = (iface) }
1895
1896 static const struct registration_quirk registration_quirks[] = {
1897         REG_QUIRK_ENTRY(0x0951, 0x16d8, 2),     /* Kingston HyperX AMP */
1898         REG_QUIRK_ENTRY(0x0951, 0x16ed, 2),     /* Kingston HyperX Cloud Alpha S */
1899         REG_QUIRK_ENTRY(0x0951, 0x16ea, 2),     /* Kingston HyperX Cloud Flight S */
1900         REG_QUIRK_ENTRY(0x0ecb, 0x1f46, 2),     /* JBL Quantum 600 */
1901         REG_QUIRK_ENTRY(0x0ecb, 0x2039, 2),     /* JBL Quantum 400 */
1902         REG_QUIRK_ENTRY(0x0ecb, 0x203e, 2),     /* JBL Quantum 800 */
1903         { 0 }                                   /* terminator */
1904 };
1905
1906 /* return true if skipping registration */
1907 bool snd_usb_registration_quirk(struct snd_usb_audio *chip, int iface)
1908 {
1909         const struct registration_quirk *q;
1910
1911         for (q = registration_quirks; q->usb_id; q++)
1912                 if (chip->usb_id == q->usb_id)
1913                         return iface != q->interface;
1914
1915         /* Register as normal */
1916         return false;
1917 }