LXR linux/sound/usb/quirks-table.h

   1/* SPDX-License-Identifier: GPL-2.0-or-later */
   2/*
   3 * ALSA USB Audio Driver
   4 *
   5 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   6 *                       Clemens Ladisch <clemens@ladisch.de>
   7 */
   8
   9/*
  10 * The contents of this file are part of the driver's id_table.
  11 *
  12 * In a perfect world, this file would be empty.
  13 */
  14
  15/*
  16 * Use this for devices where other interfaces are standard compliant,
  17 * to prevent the quirk being applied to those interfaces. (To work with
  18 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  19 */
  20#define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  21        .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  22                       USB_DEVICE_ID_MATCH_PRODUCT | \
  23                       USB_DEVICE_ID_MATCH_INT_CLASS, \
  24        .idVendor = vend, \
  25        .idProduct = prod, \
  26        .bInterfaceClass = USB_CLASS_VENDOR_SPEC
  27
  28/* A standard entry matching with vid/pid and the audio class/subclass */
  29#define USB_AUDIO_DEVICE(vend, prod) \
  30        .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
  31                       USB_DEVICE_ID_MATCH_INT_CLASS | \
  32                       USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
  33        .idVendor = vend, \
  34        .idProduct = prod, \
  35        .bInterfaceClass = USB_CLASS_AUDIO, \
  36        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  37
  38/* FTDI devices */
  39{
  40        USB_DEVICE(0x0403, 0xb8d8),
  41        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  42                /* .vendor_name = "STARR LABS", */
  43                /* .product_name = "Starr Labs MIDI USB device", */
  44                .ifnum = 0,
  45                .type = QUIRK_MIDI_FTDI
  46        }
  47},
  48
  49{
  50        /* Creative BT-D1 */
  51        USB_DEVICE(0x041e, 0x0005),
  52        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  53                .ifnum = 1,
  54                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  55                .data = &(const struct audioformat) {
  56                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
  57                        .channels = 2,
  58                        .iface = 1,
  59                        .altsetting = 1,
  60                        .altset_idx = 1,
  61                        .endpoint = 0x03,
  62                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
  63                        .attributes = 0,
  64                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
  65                        .rate_min = 48000,
  66                        .rate_max = 48000,
  67                }
  68        }
  69},
  70
  71/* E-Mu 0202 USB */
  72{ USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f02) },
  73/* E-Mu 0404 USB */
  74{ USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f04) },
  75/* E-Mu Tracker Pre */
  76{ USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f0a) },
  77/* E-Mu 0204 USB */
  78{ USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f19) },
  79
  80/*
  81 * Creative Technology, Ltd Live! Cam Sync HD [VF0770]
  82 * The device advertises 8 formats, but only a rate of 48kHz is honored by the
  83 * hardware and 24 bits give chopped audio, so only report the one working
  84 * combination.
  85 */
  86{
  87        USB_DEVICE(0x041e, 0x4095),
  88        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  89                .ifnum = QUIRK_ANY_INTERFACE,
  90                .type = QUIRK_COMPOSITE,
  91                .data = &(const struct snd_usb_audio_quirk[]) {
  92                        {
  93                                .ifnum = 2,
  94                                .type = QUIRK_AUDIO_STANDARD_MIXER,
  95                        },
  96                        {
  97                                .ifnum = 3,
  98                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  99                                .data = &(const struct audioformat) {
 100                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
 101                                        .channels = 2,
 102                                        .fmt_bits = 16,
 103                                        .iface = 3,
 104                                        .altsetting = 4,
 105                                        .altset_idx = 4,
 106                                        .endpoint = 0x82,
 107                                        .ep_attr = 0x05,
 108                                        .rates = SNDRV_PCM_RATE_48000,
 109                                        .rate_min = 48000,
 110                                        .rate_max = 48000,
 111                                        .nr_rates = 1,
 112                                        .rate_table = (unsigned int[]) { 48000 },
 113                                },
 114                        },
 115                        {
 116                                .ifnum = -1
 117                        },
 118                },
 119        },
 120},
 121
 122/*
 123 * HP Wireless Audio
 124 * When not ignored, causes instability issues for some users, forcing them to
 125 * skip the entire module.
 126 */
 127{
 128        USB_DEVICE(0x0424, 0xb832),
 129        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 130                .vendor_name = "Standard Microsystems Corp.",
 131                .product_name = "HP Wireless Audio",
 132                .ifnum = QUIRK_ANY_INTERFACE,
 133                .type = QUIRK_COMPOSITE,
 134                .data = (const struct snd_usb_audio_quirk[]) {
 135                        /* Mixer */
 136                        {
 137                                .ifnum = 0,
 138                                .type = QUIRK_IGNORE_INTERFACE,
 139                        },
 140                        /* Playback */
 141                        {
 142                                .ifnum = 1,
 143                                .type = QUIRK_IGNORE_INTERFACE,
 144                        },
 145                        /* Capture */
 146                        {
 147                                .ifnum = 2,
 148                                .type = QUIRK_IGNORE_INTERFACE,
 149                        },
 150                        /* HID Device, .ifnum = 3 */
 151                        {
 152                                .ifnum = -1,
 153                        }
 154                }
 155        }
 156},
 157
 158/*
 159 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
 160 * class matches do not take effect without an explicit ID match.
 161 */
 162{ USB_AUDIO_DEVICE(0x046d, 0x0850) },
 163{ USB_AUDIO_DEVICE(0x046d, 0x08ae) },
 164{ USB_AUDIO_DEVICE(0x046d, 0x08c6) },
 165{ USB_AUDIO_DEVICE(0x046d, 0x08f0) },
 166{ USB_AUDIO_DEVICE(0x046d, 0x08f5) },
 167{ USB_AUDIO_DEVICE(0x046d, 0x08f6) },
 168{ USB_AUDIO_DEVICE(0x046d, 0x0990) },
 169
 170/*
 171 * Yamaha devices
 172 */
 173
 174#define YAMAHA_DEVICE(id, name) { \
 175        USB_DEVICE(0x0499, id), \
 176        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 177                .vendor_name = "Yamaha", \
 178                .product_name = name, \
 179                .ifnum = QUIRK_ANY_INTERFACE, \
 180                .type = QUIRK_MIDI_YAMAHA \
 181        } \
 182}
 183#define YAMAHA_INTERFACE(id, intf, name) { \
 184        USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 185        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 186                .vendor_name = "Yamaha", \
 187                .product_name = name, \
 188                .ifnum = intf, \
 189                .type = QUIRK_MIDI_YAMAHA \
 190        } \
 191}
 192YAMAHA_DEVICE(0x1000, "UX256"),
 193YAMAHA_DEVICE(0x1001, "MU1000"),
 194YAMAHA_DEVICE(0x1002, "MU2000"),
 195YAMAHA_DEVICE(0x1003, "MU500"),
 196YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 197YAMAHA_DEVICE(0x1005, "MOTIF6"),
 198YAMAHA_DEVICE(0x1006, "MOTIF7"),
 199YAMAHA_DEVICE(0x1007, "MOTIF8"),
 200YAMAHA_DEVICE(0x1008, "UX96"),
 201YAMAHA_DEVICE(0x1009, "UX16"),
 202YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 203YAMAHA_DEVICE(0x100c, "UC-MX"),
 204YAMAHA_DEVICE(0x100d, "UC-KX"),
 205YAMAHA_DEVICE(0x100e, "S08"),
 206YAMAHA_DEVICE(0x100f, "CLP-150"),
 207YAMAHA_DEVICE(0x1010, "CLP-170"),
 208YAMAHA_DEVICE(0x1011, "P-250"),
 209YAMAHA_DEVICE(0x1012, "TYROS"),
 210YAMAHA_DEVICE(0x1013, "PF-500"),
 211YAMAHA_DEVICE(0x1014, "S90"),
 212YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 213YAMAHA_DEVICE(0x1016, "MDP-5"),
 214YAMAHA_DEVICE(0x1017, "CVP-204"),
 215YAMAHA_DEVICE(0x1018, "CVP-206"),
 216YAMAHA_DEVICE(0x1019, "CVP-208"),
 217YAMAHA_DEVICE(0x101a, "CVP-210"),
 218YAMAHA_DEVICE(0x101b, "PSR-1100"),
 219YAMAHA_DEVICE(0x101c, "PSR-2100"),
 220YAMAHA_DEVICE(0x101d, "CLP-175"),
 221YAMAHA_DEVICE(0x101e, "PSR-K1"),
 222YAMAHA_DEVICE(0x101f, "EZ-J24"),
 223YAMAHA_DEVICE(0x1020, "EZ-250i"),
 224YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 225YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 226YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 227YAMAHA_DEVICE(0x1024, "CVP-301"),
 228YAMAHA_DEVICE(0x1025, "CVP-303"),
 229YAMAHA_DEVICE(0x1026, "CVP-305"),
 230YAMAHA_DEVICE(0x1027, "CVP-307"),
 231YAMAHA_DEVICE(0x1028, "CVP-309"),
 232YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 233YAMAHA_DEVICE(0x102a, "PSR-1500"),
 234YAMAHA_DEVICE(0x102b, "PSR-3000"),
 235YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 236YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 237YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 238YAMAHA_DEVICE(0x1032, "DGX-305"),
 239YAMAHA_DEVICE(0x1033, "DGX-505"),
 240YAMAHA_DEVICE(0x1034, NULL),
 241YAMAHA_DEVICE(0x1035, NULL),
 242YAMAHA_DEVICE(0x1036, NULL),
 243YAMAHA_DEVICE(0x1037, NULL),
 244YAMAHA_DEVICE(0x1038, NULL),
 245YAMAHA_DEVICE(0x1039, NULL),
 246YAMAHA_DEVICE(0x103a, NULL),
 247YAMAHA_DEVICE(0x103b, NULL),
 248YAMAHA_DEVICE(0x103c, NULL),
 249YAMAHA_DEVICE(0x103d, NULL),
 250YAMAHA_DEVICE(0x103e, NULL),
 251YAMAHA_DEVICE(0x103f, NULL),
 252YAMAHA_DEVICE(0x1040, NULL),
 253YAMAHA_DEVICE(0x1041, NULL),
 254YAMAHA_DEVICE(0x1042, NULL),
 255YAMAHA_DEVICE(0x1043, NULL),
 256YAMAHA_DEVICE(0x1044, NULL),
 257YAMAHA_DEVICE(0x1045, NULL),
 258YAMAHA_INTERFACE(0x104e, 0, NULL),
 259YAMAHA_DEVICE(0x104f, NULL),
 260YAMAHA_DEVICE(0x1050, NULL),
 261YAMAHA_DEVICE(0x1051, NULL),
 262YAMAHA_DEVICE(0x1052, NULL),
 263YAMAHA_INTERFACE(0x1053, 0, NULL),
 264YAMAHA_INTERFACE(0x1054, 0, NULL),
 265YAMAHA_DEVICE(0x1055, NULL),
 266YAMAHA_DEVICE(0x1056, NULL),
 267YAMAHA_DEVICE(0x1057, NULL),
 268YAMAHA_DEVICE(0x1058, NULL),
 269YAMAHA_DEVICE(0x1059, NULL),
 270YAMAHA_DEVICE(0x105a, NULL),
 271YAMAHA_DEVICE(0x105b, NULL),
 272YAMAHA_DEVICE(0x105c, NULL),
 273YAMAHA_DEVICE(0x105d, NULL),
 274{
 275        USB_DEVICE(0x0499, 0x1503),
 276        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 277                /* .vendor_name = "Yamaha", */
 278                /* .product_name = "MOX6/MOX8", */
 279                .ifnum = QUIRK_ANY_INTERFACE,
 280                .type = QUIRK_COMPOSITE,
 281                .data = (const struct snd_usb_audio_quirk[]) {
 282                        {
 283                                .ifnum = 1,
 284                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 285                        },
 286                        {
 287                                .ifnum = 2,
 288                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 289                        },
 290                        {
 291                                .ifnum = 3,
 292                                .type = QUIRK_MIDI_YAMAHA
 293                        },
 294                        {
 295                                .ifnum = -1
 296                        }
 297                }
 298        }
 299},
 300{
 301        USB_DEVICE(0x0499, 0x1507),
 302        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 303                /* .vendor_name = "Yamaha", */
 304                /* .product_name = "THR10", */
 305                .ifnum = QUIRK_ANY_INTERFACE,
 306                .type = QUIRK_COMPOSITE,
 307                .data = (const struct snd_usb_audio_quirk[]) {
 308                        {
 309                                .ifnum = 1,
 310                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 311                        },
 312                        {
 313                                .ifnum = 2,
 314                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 315                        },
 316                        {
 317                                .ifnum = 3,
 318                                .type = QUIRK_MIDI_YAMAHA
 319                        },
 320                        {
 321                                .ifnum = -1
 322                        }
 323                }
 324        }
 325},
 326{
 327        USB_DEVICE(0x0499, 0x1509),
 328        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 329                /* .vendor_name = "Yamaha", */
 330                /* .product_name = "Steinberg UR22", */
 331                .ifnum = QUIRK_ANY_INTERFACE,
 332                .type = QUIRK_COMPOSITE,
 333                .data = (const struct snd_usb_audio_quirk[]) {
 334                        {
 335                                .ifnum = 1,
 336                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 337                        },
 338                        {
 339                                .ifnum = 2,
 340                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 341                        },
 342                        {
 343                                .ifnum = 3,
 344                                .type = QUIRK_MIDI_YAMAHA
 345                        },
 346                        {
 347                                .ifnum = 4,
 348                                .type = QUIRK_IGNORE_INTERFACE
 349                        },
 350                        {
 351                                .ifnum = -1
 352                        }
 353                }
 354        }
 355},
 356{
 357        USB_DEVICE(0x0499, 0x150a),
 358        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 359                /* .vendor_name = "Yamaha", */
 360                /* .product_name = "THR5A", */
 361                .ifnum = QUIRK_ANY_INTERFACE,
 362                .type = QUIRK_COMPOSITE,
 363                .data = (const struct snd_usb_audio_quirk[]) {
 364                        {
 365                                .ifnum = 1,
 366                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 367                        },
 368                        {
 369                                .ifnum = 2,
 370                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 371                        },
 372                        {
 373                                .ifnum = 3,
 374                                .type = QUIRK_MIDI_YAMAHA
 375                        },
 376                        {
 377                                .ifnum = -1
 378                        }
 379                }
 380        }
 381},
 382{
 383        USB_DEVICE(0x0499, 0x150c),
 384        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 385                /* .vendor_name = "Yamaha", */
 386                /* .product_name = "THR10C", */
 387                .ifnum = QUIRK_ANY_INTERFACE,
 388                .type = QUIRK_COMPOSITE,
 389                .data = (const struct snd_usb_audio_quirk[]) {
 390                        {
 391                                .ifnum = 1,
 392                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 393                        },
 394                        {
 395                                .ifnum = 2,
 396                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 397                        },
 398                        {
 399                                .ifnum = 3,
 400                                .type = QUIRK_MIDI_YAMAHA
 401                        },
 402                        {
 403                                .ifnum = -1
 404                        }
 405                }
 406        }
 407},
 408YAMAHA_DEVICE(0x2000, "DGP-7"),
 409YAMAHA_DEVICE(0x2001, "DGP-5"),
 410YAMAHA_DEVICE(0x2002, NULL),
 411YAMAHA_DEVICE(0x2003, NULL),
 412YAMAHA_DEVICE(0x5000, "CS1D"),
 413YAMAHA_DEVICE(0x5001, "DSP1D"),
 414YAMAHA_DEVICE(0x5002, "DME32"),
 415YAMAHA_DEVICE(0x5003, "DM2000"),
 416YAMAHA_DEVICE(0x5004, "02R96"),
 417YAMAHA_DEVICE(0x5005, "ACU16-C"),
 418YAMAHA_DEVICE(0x5006, "NHB32-C"),
 419YAMAHA_DEVICE(0x5007, "DM1000"),
 420YAMAHA_DEVICE(0x5008, "01V96"),
 421YAMAHA_DEVICE(0x5009, "SPX2000"),
 422YAMAHA_DEVICE(0x500a, "PM5D"),
 423YAMAHA_DEVICE(0x500b, "DME64N"),
 424YAMAHA_DEVICE(0x500c, "DME24N"),
 425YAMAHA_DEVICE(0x500d, NULL),
 426YAMAHA_DEVICE(0x500e, NULL),
 427YAMAHA_DEVICE(0x500f, NULL),
 428YAMAHA_DEVICE(0x7000, "DTX"),
 429YAMAHA_DEVICE(0x7010, "UB99"),
 430#undef YAMAHA_DEVICE
 431#undef YAMAHA_INTERFACE
 432/* this catches most recent vendor-specific Yamaha devices */
 433{
 434        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
 435                       USB_DEVICE_ID_MATCH_INT_CLASS,
 436        .idVendor = 0x0499,
 437        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
 438        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 439                .ifnum = QUIRK_ANY_INTERFACE,
 440                .type = QUIRK_AUTODETECT
 441        }
 442},
 443
 444/*
 445 * Roland/RolandED/Edirol/BOSS devices
 446 */
 447{
 448        USB_DEVICE(0x0582, 0x0000),
 449        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 450                .vendor_name = "Roland",
 451                .product_name = "UA-100",
 452                .ifnum = QUIRK_ANY_INTERFACE,
 453                .type = QUIRK_COMPOSITE,
 454                .data = (const struct snd_usb_audio_quirk[]) {
 455                        {
 456                                .ifnum = 0,
 457                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 458                                .data = & (const struct audioformat) {
 459                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
 460                                        .channels = 4,
 461                                        .iface = 0,
 462                                        .altsetting = 1,
 463                                        .altset_idx = 1,
 464                                        .attributes = 0,
 465                                        .endpoint = 0x01,
 466                                        .ep_attr = 0x09,
 467                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 468                                        .rate_min = 44100,
 469                                        .rate_max = 44100,
 470                                }
 471                        },
 472                        {
 473                                .ifnum = 1,
 474                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 475                                .data = & (const struct audioformat) {
 476                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
 477                                        .channels = 2,
 478                                        .iface = 1,
 479                                        .altsetting = 1,
 480                                        .altset_idx = 1,
 481                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX,
 482                                        .endpoint = 0x81,
 483                                        .ep_attr = 0x05,
 484                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 485                                        .rate_min = 44100,
 486                                        .rate_max = 44100,
 487                                }
 488                        },
 489                        {
 490                                .ifnum = 2,
 491                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 492                                .data = & (const struct snd_usb_midi_endpoint_info) {
 493                                        .out_cables = 0x0007,
 494                                        .in_cables  = 0x0007
 495                                }
 496                        },
 497                        {
 498                                .ifnum = -1
 499                        }
 500                }
 501        }
 502},
 503{
 504        USB_DEVICE(0x0582, 0x0002),
 505        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 506                .vendor_name = "EDIROL",
 507                .product_name = "UM-4",
 508                .ifnum = QUIRK_ANY_INTERFACE,
 509                .type = QUIRK_COMPOSITE,
 510                .data = (const struct snd_usb_audio_quirk[]) {
 511                        {
 512                                .ifnum = 0,
 513                                .type = QUIRK_IGNORE_INTERFACE
 514                        },
 515                        {
 516                                .ifnum = 1,
 517                                .type = QUIRK_IGNORE_INTERFACE
 518                        },
 519                        {
 520                                .ifnum = 2,
 521                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 522                                .data = & (const struct snd_usb_midi_endpoint_info) {
 523                                        .out_cables = 0x000f,
 524                                        .in_cables  = 0x000f
 525                                }
 526                        },
 527                        {
 528                                .ifnum = -1
 529                        }
 530                }
 531        }
 532},
 533{
 534        USB_DEVICE(0x0582, 0x0003),
 535        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 536                .vendor_name = "Roland",
 537                .product_name = "SC-8850",
 538                .ifnum = QUIRK_ANY_INTERFACE,
 539                .type = QUIRK_COMPOSITE,
 540                .data = (const struct snd_usb_audio_quirk[]) {
 541                        {
 542                                .ifnum = 0,
 543                                .type = QUIRK_IGNORE_INTERFACE
 544                        },
 545                        {
 546                                .ifnum = 1,
 547                                .type = QUIRK_IGNORE_INTERFACE
 548                        },
 549                        {
 550                                .ifnum = 2,
 551                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 552                                .data = & (const struct snd_usb_midi_endpoint_info) {
 553                                        .out_cables = 0x003f,
 554                                        .in_cables  = 0x003f
 555                                }
 556                        },
 557                        {
 558                                .ifnum = -1
 559                        }
 560                }
 561        }
 562},
 563{
 564        USB_DEVICE(0x0582, 0x0004),
 565        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 566                .vendor_name = "Roland",
 567                .product_name = "U-8",
 568                .ifnum = QUIRK_ANY_INTERFACE,
 569                .type = QUIRK_COMPOSITE,
 570                .data = (const struct snd_usb_audio_quirk[]) {
 571                        {
 572                                .ifnum = 0,
 573                                .type = QUIRK_IGNORE_INTERFACE
 574                        },
 575                        {
 576                                .ifnum = 1,
 577                                .type = QUIRK_IGNORE_INTERFACE
 578                        },
 579                        {
 580                                .ifnum = 2,
 581                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 582                                .data = & (const struct snd_usb_midi_endpoint_info) {
 583                                        .out_cables = 0x0005,
 584                                        .in_cables  = 0x0005
 585                                }
 586                        },
 587                        {
 588                                .ifnum = -1
 589                        }
 590                }
 591        }
 592},
 593{
 594        /* Has ID 0x0099 when not in "Advanced Driver" mode.
 595         * The UM-2EX has only one input, but we cannot detect this. */
 596        USB_DEVICE(0x0582, 0x0005),
 597        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 598                .vendor_name = "EDIROL",
 599                .product_name = "UM-2",
 600                .ifnum = QUIRK_ANY_INTERFACE,
 601                .type = QUIRK_COMPOSITE,
 602                .data = (const struct snd_usb_audio_quirk[]) {
 603                        {
 604                                .ifnum = 0,
 605                                .type = QUIRK_IGNORE_INTERFACE
 606                        },
 607                        {
 608                                .ifnum = 1,
 609                                .type = QUIRK_IGNORE_INTERFACE
 610                        },
 611                        {
 612                                .ifnum = 2,
 613                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 614                                .data = & (const struct snd_usb_midi_endpoint_info) {
 615                                        .out_cables = 0x0003,
 616                                        .in_cables  = 0x0003
 617                                }
 618                        },
 619                        {
 620                                .ifnum = -1
 621                        }
 622                }
 623        }
 624},
 625{
 626        USB_DEVICE(0x0582, 0x0007),
 627        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 628                .vendor_name = "Roland",
 629                .product_name = "SC-8820",
 630                .ifnum = QUIRK_ANY_INTERFACE,
 631                .type = QUIRK_COMPOSITE,
 632                .data = (const struct snd_usb_audio_quirk[]) {
 633                        {
 634                                .ifnum = 0,
 635                                .type = QUIRK_IGNORE_INTERFACE
 636                        },
 637                        {
 638                                .ifnum = 1,
 639                                .type = QUIRK_IGNORE_INTERFACE
 640                        },
 641                        {
 642                                .ifnum = 2,
 643                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 644                                .data = & (const struct snd_usb_midi_endpoint_info) {
 645                                        .out_cables = 0x0013,
 646                                        .in_cables  = 0x0013
 647                                }
 648                        },
 649                        {
 650                                .ifnum = -1
 651                        }
 652                }
 653        }
 654},
 655{
 656        USB_DEVICE(0x0582, 0x0008),
 657        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 658                .vendor_name = "Roland",
 659                .product_name = "PC-300",
 660                .ifnum = QUIRK_ANY_INTERFACE,
 661                .type = QUIRK_COMPOSITE,
 662                .data = (const struct snd_usb_audio_quirk[]) {
 663                        {
 664                                .ifnum = 0,
 665                                .type = QUIRK_IGNORE_INTERFACE
 666                        },
 667                        {
 668                                .ifnum = 1,
 669                                .type = QUIRK_IGNORE_INTERFACE
 670                        },
 671                        {
 672                                .ifnum = 2,
 673                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 674                                .data = & (const struct snd_usb_midi_endpoint_info) {
 675                                        .out_cables = 0x0001,
 676                                        .in_cables  = 0x0001
 677                                }
 678                        },
 679                        {
 680                                .ifnum = -1
 681                        }
 682                }
 683        }
 684},
 685{
 686        /* has ID 0x009d when not in "Advanced Driver" mode */
 687        USB_DEVICE(0x0582, 0x0009),
 688        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 689                .vendor_name = "EDIROL",
 690                .product_name = "UM-1",
 691                .ifnum = QUIRK_ANY_INTERFACE,
 692                .type = QUIRK_COMPOSITE,
 693                .data = (const struct snd_usb_audio_quirk[]) {
 694                        {
 695                                .ifnum = 0,
 696                                .type = QUIRK_IGNORE_INTERFACE
 697                        },
 698                        {
 699                                .ifnum = 1,
 700                                .type = QUIRK_IGNORE_INTERFACE
 701                        },
 702                        {
 703                                .ifnum = 2,
 704                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 705                                .data = & (const struct snd_usb_midi_endpoint_info) {
 706                                        .out_cables = 0x0001,
 707                                        .in_cables  = 0x0001
 708                                }
 709                        },
 710                        {
 711                                .ifnum = -1
 712                        }
 713                }
 714        }
 715},
 716{
 717        USB_DEVICE(0x0582, 0x000b),
 718        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 719                .vendor_name = "Roland",
 720                .product_name = "SK-500",
 721                .ifnum = QUIRK_ANY_INTERFACE,
 722                .type = QUIRK_COMPOSITE,
 723                .data = (const struct snd_usb_audio_quirk[]) {
 724                        {
 725                                .ifnum = 0,
 726                                .type = QUIRK_IGNORE_INTERFACE
 727                        },
 728                        {
 729                                .ifnum = 1,
 730                                .type = QUIRK_IGNORE_INTERFACE
 731                        },
 732                        {
 733                                .ifnum = 2,
 734                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 735                                .data = & (const struct snd_usb_midi_endpoint_info) {
 736                                        .out_cables = 0x0013,
 737                                        .in_cables  = 0x0013
 738                                }
 739                        },
 740                        {
 741                                .ifnum = -1
 742                        }
 743                }
 744        }
 745},
 746{
 747        /* thanks to Emiliano Grilli <emillo@libero.it>
 748         * for helping researching this data */
 749        USB_DEVICE(0x0582, 0x000c),
 750        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 751                .vendor_name = "Roland",
 752                .product_name = "SC-D70",
 753                .ifnum = QUIRK_ANY_INTERFACE,
 754                .type = QUIRK_COMPOSITE,
 755                .data = (const struct snd_usb_audio_quirk[]) {
 756                        {
 757                                .ifnum = 0,
 758                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 759                        },
 760                        {
 761                                .ifnum = 1,
 762                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 763                        },
 764                        {
 765                                .ifnum = 2,
 766                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 767                                .data = & (const struct snd_usb_midi_endpoint_info) {
 768                                        .out_cables = 0x0007,
 769                                        .in_cables  = 0x0007
 770                                }
 771                        },
 772                        {
 773                                .ifnum = -1
 774                        }
 775                }
 776        }
 777},
 778{       /*
 779         * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 780         * If the advanced mode switch at the back of the unit is off, the
 781         * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 782         * but offers only 16-bit PCM.
 783         * In advanced mode, the UA-5 will output S24_3LE samples (two
 784         * channels) at the rate indicated on the front switch, including
 785         * the 96kHz sample rate.
 786         */
 787        USB_DEVICE(0x0582, 0x0010),
 788        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 789                .vendor_name = "EDIROL",
 790                .product_name = "UA-5",
 791                .ifnum = QUIRK_ANY_INTERFACE,
 792                .type = QUIRK_COMPOSITE,
 793                .data = (const struct snd_usb_audio_quirk[]) {
 794                        {
 795                                .ifnum = 1,
 796                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 797                        },
 798                        {
 799                                .ifnum = 2,
 800                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 801                        },
 802                        {
 803                                .ifnum = -1
 804                        }
 805                }
 806        }
 807},
 808{
 809        /* has ID 0x0013 when not in "Advanced Driver" mode */
 810        USB_DEVICE(0x0582, 0x0012),
 811        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 812                .vendor_name = "Roland",
 813                .product_name = "XV-5050",
 814                .ifnum = 0,
 815                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 816                .data = & (const struct snd_usb_midi_endpoint_info) {
 817                        .out_cables = 0x0001,
 818                        .in_cables  = 0x0001
 819                }
 820        }
 821},
 822{
 823        /* has ID 0x0015 when not in "Advanced Driver" mode */
 824        USB_DEVICE(0x0582, 0x0014),
 825        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 826                .vendor_name = "EDIROL",
 827                .product_name = "UM-880",
 828                .ifnum = 0,
 829                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 830                .data = & (const struct snd_usb_midi_endpoint_info) {
 831                        .out_cables = 0x01ff,
 832                        .in_cables  = 0x01ff
 833                }
 834        }
 835},
 836{
 837        /* has ID 0x0017 when not in "Advanced Driver" mode */
 838        USB_DEVICE(0x0582, 0x0016),
 839        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 840                .vendor_name = "EDIROL",
 841                .product_name = "SD-90",
 842                .ifnum = QUIRK_ANY_INTERFACE,
 843                .type = QUIRK_COMPOSITE,
 844                .data = (const struct snd_usb_audio_quirk[]) {
 845                        {
 846                                .ifnum = 0,
 847                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 848                        },
 849                        {
 850                                .ifnum = 1,
 851                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 852                        },
 853                        {
 854                                .ifnum = 2,
 855                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 856                                .data = & (const struct snd_usb_midi_endpoint_info) {
 857                                        .out_cables = 0x000f,
 858                                        .in_cables  = 0x000f
 859                                }
 860                        },
 861                        {
 862                                .ifnum = -1
 863                        }
 864                }
 865        }
 866},
 867{
 868        /* has ID 0x001c when not in "Advanced Driver" mode */
 869        USB_DEVICE(0x0582, 0x001b),
 870        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 871                .vendor_name = "Roland",
 872                .product_name = "MMP-2",
 873                .ifnum = QUIRK_ANY_INTERFACE,
 874                .type = QUIRK_COMPOSITE,
 875                .data = (const struct snd_usb_audio_quirk[]) {
 876                        {
 877                                .ifnum = 0,
 878                                .type = QUIRK_IGNORE_INTERFACE
 879                        },
 880                        {
 881                                .ifnum = 1,
 882                                .type = QUIRK_IGNORE_INTERFACE
 883                        },
 884                        {
 885                                .ifnum = 2,
 886                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 887                                .data = & (const struct snd_usb_midi_endpoint_info) {
 888                                        .out_cables = 0x0001,
 889                                        .in_cables  = 0x0001
 890                                }
 891                        },
 892                        {
 893                                .ifnum = -1
 894                        }
 895                }
 896        }
 897},
 898{
 899        /* has ID 0x001e when not in "Advanced Driver" mode */
 900        USB_DEVICE(0x0582, 0x001d),
 901        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 902                .vendor_name = "Roland",
 903                .product_name = "V-SYNTH",
 904                .ifnum = 0,
 905                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 906                .data = & (const struct snd_usb_midi_endpoint_info) {
 907                        .out_cables = 0x0001,
 908                        .in_cables  = 0x0001
 909                }
 910        }
 911},
 912{
 913        /* has ID 0x0024 when not in "Advanced Driver" mode */
 914        USB_DEVICE(0x0582, 0x0023),
 915        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 916                .vendor_name = "EDIROL",
 917                .product_name = "UM-550",
 918                .ifnum = 0,
 919                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 920                .data = & (const struct snd_usb_midi_endpoint_info) {
 921                        .out_cables = 0x003f,
 922                        .in_cables  = 0x003f
 923                }
 924        }
 925},
 926{
 927        /*
 928         * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 929         * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 930         * and no MIDI.
 931         */
 932        USB_DEVICE(0x0582, 0x0025),
 933        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 934                .vendor_name = "EDIROL",
 935                .product_name = "UA-20",
 936                .ifnum = QUIRK_ANY_INTERFACE,
 937                .type = QUIRK_COMPOSITE,
 938                .data = (const struct snd_usb_audio_quirk[]) {
 939                        {
 940                                .ifnum = 0,
 941                                .type = QUIRK_IGNORE_INTERFACE
 942                        },
 943                        {
 944                                .ifnum = 1,
 945                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 946                                .data = & (const struct audioformat) {
 947                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 948                                        .channels = 2,
 949                                        .iface = 1,
 950                                        .altsetting = 1,
 951                                        .altset_idx = 1,
 952                                        .attributes = 0,
 953                                        .endpoint = 0x01,
 954                                        .ep_attr = 0x01,
 955                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 956                                        .rate_min = 44100,
 957                                        .rate_max = 44100,
 958                                }
 959                        },
 960                        {
 961                                .ifnum = 2,
 962                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 963                                .data = & (const struct audioformat) {
 964                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 965                                        .channels = 2,
 966                                        .iface = 2,
 967                                        .altsetting = 1,
 968                                        .altset_idx = 1,
 969                                        .attributes = 0,
 970                                        .endpoint = 0x82,
 971                                        .ep_attr = 0x01,
 972                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 973                                        .rate_min = 44100,
 974                                        .rate_max = 44100,
 975                                }
 976                        },
 977                        {
 978                                .ifnum = 3,
 979                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 980                                .data = & (const struct snd_usb_midi_endpoint_info) {
 981                                        .out_cables = 0x0001,
 982                                        .in_cables  = 0x0001
 983                                }
 984                        },
 985                        {
 986                                .ifnum = -1
 987                        }
 988                }
 989        }
 990},
 991{
 992        /* has ID 0x0028 when not in "Advanced Driver" mode */
 993        USB_DEVICE(0x0582, 0x0027),
 994        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 995                .vendor_name = "EDIROL",
 996                .product_name = "SD-20",
 997                .ifnum = 0,
 998                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 999                .data = & (const struct snd_usb_midi_endpoint_info) {
1000                        .out_cables = 0x0003,

1001                        .in_cables  = 0x0007
1002                }
1003        }
1004},
1005{
1006        /* has ID 0x002a when not in "Advanced Driver" mode */
1007        USB_DEVICE(0x0582, 0x0029),
1008        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1009                .vendor_name = "EDIROL",
1010                .product_name = "SD-80",
1011                .ifnum = 0,
1012                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1013                .data = & (const struct snd_usb_midi_endpoint_info) {
1014                        .out_cables = 0x000f,
1015                        .in_cables  = 0x000f
1016                }
1017        }
1018},
1019{       /*
1020         * This quirk is for the "Advanced" modes of the Edirol UA-700.
1021         * If the sample format switch is not in an advanced setting, the
1022         * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1023         * but offers only 16-bit PCM and no MIDI.
1024         */
1025        USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1026        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1027                .vendor_name = "EDIROL",
1028                .product_name = "UA-700",
1029                .ifnum = QUIRK_ANY_INTERFACE,
1030                .type = QUIRK_COMPOSITE,
1031                .data = (const struct snd_usb_audio_quirk[]) {
1032                        {
1033                                .ifnum = 1,
1034                                .type = QUIRK_AUDIO_EDIROL_UAXX
1035                        },
1036                        {
1037                                .ifnum = 2,
1038                                .type = QUIRK_AUDIO_EDIROL_UAXX
1039                        },
1040                        {
1041                                .ifnum = 3,
1042                                .type = QUIRK_AUDIO_EDIROL_UAXX
1043                        },
1044                        {
1045                                .ifnum = -1
1046                        }
1047                }
1048        }
1049},
1050{
1051        /* has ID 0x002e when not in "Advanced Driver" mode */
1052        USB_DEVICE(0x0582, 0x002d),
1053        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1054                .vendor_name = "Roland",
1055                .product_name = "XV-2020",
1056                .ifnum = 0,
1057                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1058                .data = & (const struct snd_usb_midi_endpoint_info) {
1059                        .out_cables = 0x0001,
1060                        .in_cables  = 0x0001
1061                }
1062        }
1063},
1064{
1065        /* has ID 0x0030 when not in "Advanced Driver" mode */
1066        USB_DEVICE(0x0582, 0x002f),
1067        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1068                .vendor_name = "Roland",
1069                .product_name = "VariOS",
1070                .ifnum = 0,
1071                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1072                .data = & (const struct snd_usb_midi_endpoint_info) {
1073                        .out_cables = 0x0007,
1074                        .in_cables  = 0x0007
1075                }
1076        }
1077},
1078{
1079        /* has ID 0x0034 when not in "Advanced Driver" mode */
1080        USB_DEVICE(0x0582, 0x0033),
1081        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1082                .vendor_name = "EDIROL",
1083                .product_name = "PCR",
1084                .ifnum = 0,
1085                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1086                .data = & (const struct snd_usb_midi_endpoint_info) {
1087                        .out_cables = 0x0003,
1088                        .in_cables  = 0x0007
1089                }
1090        }
1091},
1092{
1093        /*
1094         * Has ID 0x0038 when not in "Advanced Driver" mode;
1095         * later revisions use IDs 0x0054 and 0x00a2.
1096         */
1097        USB_DEVICE(0x0582, 0x0037),
1098        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1099                .vendor_name = "Roland",
1100                .product_name = "Digital Piano",
1101                .ifnum = 0,
1102                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1103                .data = & (const struct snd_usb_midi_endpoint_info) {
1104                        .out_cables = 0x0001,
1105                        .in_cables  = 0x0001
1106                }
1107        }
1108},
1109{
1110        /*
1111         * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1112         * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1113         * and no MIDI.
1114         */
1115        USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1116        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117                .vendor_name = "BOSS",
1118                .product_name = "GS-10",
1119                .ifnum = QUIRK_ANY_INTERFACE,
1120                .type = QUIRK_COMPOSITE,
1121                .data = & (const struct snd_usb_audio_quirk[]) {
1122                        {
1123                                .ifnum = 1,
1124                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1125                        },
1126                        {
1127                                .ifnum = 2,
1128                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1129                        },
1130                        {
1131                                .ifnum = 3,
1132                                .type = QUIRK_MIDI_STANDARD_INTERFACE
1133                        },
1134                        {
1135                                .ifnum = -1
1136                        }
1137                }
1138        }
1139},
1140{
1141        /* has ID 0x0041 when not in "Advanced Driver" mode */
1142        USB_DEVICE(0x0582, 0x0040),
1143        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1144                .vendor_name = "Roland",
1145                .product_name = "GI-20",
1146                .ifnum = 0,
1147                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1148                .data = & (const struct snd_usb_midi_endpoint_info) {
1149                        .out_cables = 0x0001,
1150                        .in_cables  = 0x0001
1151                }
1152        }
1153},
1154{
1155        /* has ID 0x0043 when not in "Advanced Driver" mode */
1156        USB_DEVICE(0x0582, 0x0042),
1157        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1158                .vendor_name = "Roland",
1159                .product_name = "RS-70",
1160                .ifnum = 0,
1161                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1162                .data = & (const struct snd_usb_midi_endpoint_info) {
1163                        .out_cables = 0x0001,
1164                        .in_cables  = 0x0001
1165                }
1166        }
1167},
1168{
1169        /* has ID 0x0049 when not in "Advanced Driver" mode */
1170        USB_DEVICE(0x0582, 0x0047),
1171        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1172                /* .vendor_name = "EDIROL", */
1173                /* .product_name = "UR-80", */
1174                .ifnum = QUIRK_ANY_INTERFACE,
1175                .type = QUIRK_COMPOSITE,
1176                .data = (const struct snd_usb_audio_quirk[]) {
1177                        /* in the 96 kHz modes, only interface 1 is there */
1178                        {
1179                                .ifnum = 1,
1180                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1181                        },
1182                        {
1183                                .ifnum = 2,
1184                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1185                        },
1186                        {
1187                                .ifnum = -1
1188                        }
1189                }
1190        }
1191},
1192{
1193        /* has ID 0x004a when not in "Advanced Driver" mode */
1194        USB_DEVICE(0x0582, 0x0048),
1195        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1196                /* .vendor_name = "EDIROL", */
1197                /* .product_name = "UR-80", */
1198                .ifnum = 0,
1199                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1200                .data = & (const struct snd_usb_midi_endpoint_info) {
1201                        .out_cables = 0x0003,
1202                        .in_cables  = 0x0007
1203                }
1204        }
1205},
1206{
1207        /* has ID 0x004e when not in "Advanced Driver" mode */
1208        USB_DEVICE(0x0582, 0x004c),
1209        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1210                .vendor_name = "EDIROL",
1211                .product_name = "PCR-A",
1212                .ifnum = QUIRK_ANY_INTERFACE,
1213                .type = QUIRK_COMPOSITE,
1214                .data = (const struct snd_usb_audio_quirk[]) {
1215                        {
1216                                .ifnum = 1,
1217                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1218                        },
1219                        {
1220                                .ifnum = 2,
1221                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1222                        },
1223                        {
1224                                .ifnum = -1
1225                        }
1226                }
1227        }
1228},
1229{
1230        /* has ID 0x004f when not in "Advanced Driver" mode */
1231        USB_DEVICE(0x0582, 0x004d),
1232        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1233                .vendor_name = "EDIROL",
1234                .product_name = "PCR-A",
1235                .ifnum = 0,
1236                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1237                .data = & (const struct snd_usb_midi_endpoint_info) {
1238                        .out_cables = 0x0003,
1239                        .in_cables  = 0x0007
1240                }
1241        }
1242},
1243{
1244        /*
1245         * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1246         * is standard compliant, but has only 16-bit PCM.
1247         */
1248        USB_DEVICE(0x0582, 0x0050),
1249        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1250                .vendor_name = "EDIROL",
1251                .product_name = "UA-3FX",
1252                .ifnum = QUIRK_ANY_INTERFACE,
1253                .type = QUIRK_COMPOSITE,
1254                .data = (const struct snd_usb_audio_quirk[]) {
1255                        {
1256                                .ifnum = 1,
1257                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1258                        },
1259                        {
1260                                .ifnum = 2,
1261                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1262                        },
1263                        {
1264                                .ifnum = -1
1265                        }
1266                }
1267        }
1268},
1269{
1270        USB_DEVICE(0x0582, 0x0052),
1271        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1272                .vendor_name = "EDIROL",
1273                .product_name = "UM-1SX",
1274                .ifnum = 0,
1275                .type = QUIRK_MIDI_STANDARD_INTERFACE
1276        }
1277},
1278{
1279        USB_DEVICE(0x0582, 0x0060),
1280        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1281                .vendor_name = "Roland",
1282                .product_name = "EXR Series",
1283                .ifnum = 0,
1284                .type = QUIRK_MIDI_STANDARD_INTERFACE
1285        }
1286},
1287{
1288        /* has ID 0x0066 when not in "Advanced Driver" mode */
1289        USB_DEVICE(0x0582, 0x0064),
1290        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1291                /* .vendor_name = "EDIROL", */
1292                /* .product_name = "PCR-1", */
1293                .ifnum = QUIRK_ANY_INTERFACE,
1294                .type = QUIRK_COMPOSITE,
1295                .data = (const struct snd_usb_audio_quirk[]) {
1296                        {
1297                                .ifnum = 1,
1298                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1299                        },
1300                        {
1301                                .ifnum = 2,
1302                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1303                        },
1304                        {
1305                                .ifnum = -1
1306                        }
1307                }
1308        }
1309},
1310{
1311        /* has ID 0x0067 when not in "Advanced Driver" mode */
1312        USB_DEVICE(0x0582, 0x0065),
1313        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1314                /* .vendor_name = "EDIROL", */
1315                /* .product_name = "PCR-1", */
1316                .ifnum = 0,
1317                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1318                .data = & (const struct snd_usb_midi_endpoint_info) {
1319                        .out_cables = 0x0001,
1320                        .in_cables  = 0x0003
1321                }
1322        }
1323},
1324{
1325        /* has ID 0x006e when not in "Advanced Driver" mode */
1326        USB_DEVICE(0x0582, 0x006d),
1327        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1328                .vendor_name = "Roland",
1329                .product_name = "FANTOM-X",
1330                .ifnum = 0,
1331                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1332                .data = & (const struct snd_usb_midi_endpoint_info) {
1333                        .out_cables = 0x0001,
1334                        .in_cables  = 0x0001
1335                }
1336        }
1337},
1338{       /*
1339         * This quirk is for the "Advanced" modes of the Edirol UA-25.
1340         * If the switch is not in an advanced setting, the UA-25 has
1341         * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1342         * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1343         */
1344        USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1345        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1346                .vendor_name = "EDIROL",
1347                .product_name = "UA-25",
1348                .ifnum = QUIRK_ANY_INTERFACE,
1349                .type = QUIRK_COMPOSITE,
1350                .data = (const struct snd_usb_audio_quirk[]) {
1351                        {
1352                                .ifnum = 0,
1353                                .type = QUIRK_AUDIO_EDIROL_UAXX
1354                        },
1355                        {
1356                                .ifnum = 1,
1357                                .type = QUIRK_AUDIO_EDIROL_UAXX
1358                        },
1359                        {
1360                                .ifnum = 2,
1361                                .type = QUIRK_AUDIO_EDIROL_UAXX
1362                        },
1363                        {
1364                                .ifnum = -1
1365                        }
1366                }
1367        }
1368},
1369{
1370        /* has ID 0x0076 when not in "Advanced Driver" mode */
1371        USB_DEVICE(0x0582, 0x0075),
1372        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1373                .vendor_name = "BOSS",
1374                .product_name = "DR-880",
1375                .ifnum = 0,
1376                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1377                .data = & (const struct snd_usb_midi_endpoint_info) {
1378                        .out_cables = 0x0001,
1379                        .in_cables  = 0x0001
1380                }
1381        }
1382},
1383{
1384        /* has ID 0x007b when not in "Advanced Driver" mode */
1385        USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1386        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1387                .vendor_name = "Roland",
1388                /* "RD" or "RD-700SX"? */
1389                .ifnum = 0,
1390                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1391                .data = & (const struct snd_usb_midi_endpoint_info) {
1392                        .out_cables = 0x0003,
1393                        .in_cables  = 0x0003
1394                }
1395        }
1396},
1397{
1398        /* has ID 0x0081 when not in "Advanced Driver" mode */
1399        USB_DEVICE(0x0582, 0x0080),
1400        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1401                .vendor_name = "Roland",
1402                .product_name = "G-70",
1403                .ifnum = 0,
1404                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1405                .data = & (const struct snd_usb_midi_endpoint_info) {
1406                        .out_cables = 0x0001,
1407                        .in_cables  = 0x0001
1408                }
1409        }
1410},
1411{
1412        /* has ID 0x008c when not in "Advanced Driver" mode */
1413        USB_DEVICE(0x0582, 0x008b),
1414        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1415                .vendor_name = "EDIROL",
1416                .product_name = "PC-50",
1417                .ifnum = 0,
1418                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1419                .data = & (const struct snd_usb_midi_endpoint_info) {
1420                        .out_cables = 0x0001,
1421                        .in_cables  = 0x0001
1422                }
1423        }
1424},
1425{
1426        /*
1427         * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1428         * is standard compliant, but has only 16-bit PCM and no MIDI.
1429         */
1430        USB_DEVICE(0x0582, 0x00a3),
1431        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432                .vendor_name = "EDIROL",
1433                .product_name = "UA-4FX",
1434                .ifnum = QUIRK_ANY_INTERFACE,
1435                .type = QUIRK_COMPOSITE,
1436                .data = (const struct snd_usb_audio_quirk[]) {
1437                        {
1438                                .ifnum = 0,
1439                                .type = QUIRK_AUDIO_EDIROL_UAXX
1440                        },
1441                        {
1442                                .ifnum = 1,
1443                                .type = QUIRK_AUDIO_EDIROL_UAXX
1444                        },
1445                        {
1446                                .ifnum = 2,
1447                                .type = QUIRK_AUDIO_EDIROL_UAXX
1448                        },
1449                        {
1450                                .ifnum = -1
1451                        }
1452                }
1453        }
1454},
1455{
1456        /* Edirol M-16DX */
1457        USB_DEVICE(0x0582, 0x00c4),
1458        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1459                .ifnum = QUIRK_ANY_INTERFACE,
1460                .type = QUIRK_COMPOSITE,
1461                .data = (const struct snd_usb_audio_quirk[]) {
1462                        {
1463                                .ifnum = 0,
1464                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1465                        },
1466                        {
1467                                .ifnum = 1,
1468                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1469                        },
1470                        {
1471                                .ifnum = 2,
1472                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1473                                .data = & (const struct snd_usb_midi_endpoint_info) {
1474                                        .out_cables = 0x0001,
1475                                        .in_cables  = 0x0001
1476                                }
1477                        },
1478                        {
1479                                .ifnum = -1
1480                        }
1481                }
1482        }
1483},
1484{
1485        /* Advanced modes of the Edirol UA-25EX.
1486         * For the standard mode, UA-25EX has ID 0582:00e7, which
1487         * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1488         */
1489        USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1490        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1491                .vendor_name = "EDIROL",
1492                .product_name = "UA-25EX",
1493                .ifnum = QUIRK_ANY_INTERFACE,
1494                .type = QUIRK_COMPOSITE,
1495                .data = (const struct snd_usb_audio_quirk[]) {
1496                        {
1497                                .ifnum = 0,
1498                                .type = QUIRK_AUDIO_EDIROL_UAXX
1499                        },
1500                        {
1501                                .ifnum = 1,
1502                                .type = QUIRK_AUDIO_EDIROL_UAXX
1503                        },
1504                        {
1505                                .ifnum = 2,
1506                                .type = QUIRK_AUDIO_EDIROL_UAXX
1507                        },
1508                        {
1509                                .ifnum = -1
1510                        }
1511                }
1512        }
1513},
1514{
1515        /* Edirol UM-3G */
1516        USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1517        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1518                .ifnum = 0,
1519                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1520                .data = & (const struct snd_usb_midi_endpoint_info) {
1521                        .out_cables = 0x0007,
1522                        .in_cables  = 0x0007
1523                }
1524        }
1525},
1526{
1527        /* BOSS ME-25 */
1528        USB_DEVICE(0x0582, 0x0113),
1529        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1530                .ifnum = QUIRK_ANY_INTERFACE,
1531                .type = QUIRK_COMPOSITE,
1532                .data = (const struct snd_usb_audio_quirk[]) {
1533                        {
1534                                .ifnum = 0,
1535                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1536                        },
1537                        {
1538                                .ifnum = 1,
1539                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1540                        },
1541                        {
1542                                .ifnum = 2,
1543                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1544                                .data = & (const struct snd_usb_midi_endpoint_info) {
1545                                        .out_cables = 0x0001,
1546                                        .in_cables  = 0x0001
1547                                }
1548                        },
1549                        {
1550                                .ifnum = -1
1551                        }
1552                }
1553        }
1554},
1555{
1556        /* only 44.1 kHz works at the moment */
1557        USB_DEVICE(0x0582, 0x0120),
1558        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1559                /* .vendor_name = "Roland", */
1560                /* .product_name = "OCTO-CAPTURE", */
1561                .ifnum = QUIRK_ANY_INTERFACE,
1562                .type = QUIRK_COMPOSITE,
1563                .data = (const struct snd_usb_audio_quirk[]) {
1564                        {
1565                                .ifnum = 0,
1566                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1567                                .data = & (const struct audioformat) {
1568                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1569                                        .channels = 10,
1570                                        .iface = 0,
1571                                        .altsetting = 1,
1572                                        .altset_idx = 1,
1573                                        .endpoint = 0x05,
1574                                        .ep_attr = 0x05,
1575                                        .rates = SNDRV_PCM_RATE_44100,
1576                                        .rate_min = 44100,
1577                                        .rate_max = 44100,
1578                                        .nr_rates = 1,
1579                                        .rate_table = (unsigned int[]) { 44100 }
1580                                }
1581                        },
1582                        {
1583                                .ifnum = 1,
1584                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1585                                .data = & (const struct audioformat) {
1586                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1587                                        .channels = 12,
1588                                        .iface = 1,
1589                                        .altsetting = 1,
1590                                        .altset_idx = 1,
1591                                        .endpoint = 0x85,
1592                                        .ep_attr = 0x25,
1593                                        .rates = SNDRV_PCM_RATE_44100,
1594                                        .rate_min = 44100,
1595                                        .rate_max = 44100,
1596                                        .nr_rates = 1,
1597                                        .rate_table = (unsigned int[]) { 44100 }
1598                                }
1599                        },
1600                        {
1601                                .ifnum = 2,
1602                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1603                                .data = & (const struct snd_usb_midi_endpoint_info) {
1604                                        .out_cables = 0x0001,
1605                                        .in_cables  = 0x0001
1606                                }
1607                        },
1608                        {
1609                                .ifnum = 3,
1610                                .type = QUIRK_IGNORE_INTERFACE
1611                        },
1612                        {
1613                                .ifnum = 4,
1614                                .type = QUIRK_IGNORE_INTERFACE
1615                        },
1616                        {
1617                                .ifnum = -1
1618                        }
1619                }
1620        }
1621},
1622{
1623        /* only 44.1 kHz works at the moment */
1624        USB_DEVICE(0x0582, 0x012f),
1625        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1626                /* .vendor_name = "Roland", */
1627                /* .product_name = "QUAD-CAPTURE", */
1628                .ifnum = QUIRK_ANY_INTERFACE,
1629                .type = QUIRK_COMPOSITE,
1630                .data = (const struct snd_usb_audio_quirk[]) {
1631                        {
1632                                .ifnum = 0,
1633                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1634                                .data = & (const struct audioformat) {
1635                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1636                                        .channels = 4,
1637                                        .iface = 0,
1638                                        .altsetting = 1,
1639                                        .altset_idx = 1,
1640                                        .endpoint = 0x05,
1641                                        .ep_attr = 0x05,
1642                                        .rates = SNDRV_PCM_RATE_44100,
1643                                        .rate_min = 44100,
1644                                        .rate_max = 44100,
1645                                        .nr_rates = 1,
1646                                        .rate_table = (unsigned int[]) { 44100 }
1647                                }
1648                        },
1649                        {
1650                                .ifnum = 1,
1651                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1652                                .data = & (const struct audioformat) {
1653                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
1654                                        .channels = 6,
1655                                        .iface = 1,
1656                                        .altsetting = 1,
1657                                        .altset_idx = 1,
1658                                        .endpoint = 0x85,
1659                                        .ep_attr = 0x25,
1660                                        .rates = SNDRV_PCM_RATE_44100,
1661                                        .rate_min = 44100,
1662                                        .rate_max = 44100,
1663                                        .nr_rates = 1,
1664                                        .rate_table = (unsigned int[]) { 44100 }
1665                                }
1666                        },
1667                        {
1668                                .ifnum = 2,
1669                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1670                                .data = & (const struct snd_usb_midi_endpoint_info) {
1671                                        .out_cables = 0x0001,
1672                                        .in_cables  = 0x0001
1673                                }
1674                        },
1675                        {
1676                                .ifnum = 3,
1677                                .type = QUIRK_IGNORE_INTERFACE
1678                        },
1679                        {
1680                                .ifnum = 4,
1681                                .type = QUIRK_IGNORE_INTERFACE
1682                        },
1683                        {
1684                                .ifnum = -1
1685                        }
1686                }
1687        }
1688},
1689{
1690        USB_DEVICE(0x0582, 0x0159),
1691        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1692                /* .vendor_name = "Roland", */
1693                /* .product_name = "UA-22", */
1694                .ifnum = QUIRK_ANY_INTERFACE,
1695                .type = QUIRK_COMPOSITE,
1696                .data = (const struct snd_usb_audio_quirk[]) {
1697                        {
1698                                .ifnum = 0,
1699                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1700                        },
1701                        {
1702                                .ifnum = 1,
1703                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1704                        },
1705                        {
1706                                .ifnum = 2,
1707                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1708                                .data = & (const struct snd_usb_midi_endpoint_info) {
1709                                        .out_cables = 0x0001,
1710                                        .in_cables = 0x0001
1711                                }
1712                        },
1713                        {
1714                                .ifnum = -1
1715                        }
1716                }
1717        }
1718},
1719
1720/* UA101 and co are supported by another driver */
1721{
1722        USB_DEVICE(0x0582, 0x0044), /* UA-1000 high speed */
1723        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1724                .ifnum = QUIRK_NODEV_INTERFACE
1725        },
1726},
1727{
1728        USB_DEVICE(0x0582, 0x007d), /* UA-101 high speed */
1729        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1730                .ifnum = QUIRK_NODEV_INTERFACE
1731        },
1732},
1733{
1734        USB_DEVICE(0x0582, 0x008d), /* UA-101 full speed */
1735        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1736                .ifnum = QUIRK_NODEV_INTERFACE
1737        },
1738},
1739
1740/* this catches most recent vendor-specific Roland devices */
1741{
1742        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1743                       USB_DEVICE_ID_MATCH_INT_CLASS,
1744        .idVendor = 0x0582,
1745        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1746        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1747                .ifnum = QUIRK_ANY_INTERFACE,
1748                .type = QUIRK_AUTODETECT
1749        }
1750},
1751
1752/* Guillemot devices */
1753{
1754        /*
1755         * This is for the "Windows Edition" where the external MIDI ports are
1756         * the only MIDI ports; the control data is reported through HID
1757         * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1758         * compliant USB MIDI ports for external MIDI and controls.
1759         */
1760        USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1761        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1762                .vendor_name = "Hercules",
1763                .product_name = "DJ Console (WE)",
1764                .ifnum = 4,
1765                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1766                .data = & (const struct snd_usb_midi_endpoint_info) {
1767                        .out_cables = 0x0001,
1768                        .in_cables = 0x0001
1769                }
1770        }
1771},
1772
1773/* Midiman/M-Audio devices */
1774{
1775        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1776        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1777                .vendor_name = "M-Audio",
1778                .product_name = "MidiSport 2x2",
1779                .ifnum = QUIRK_ANY_INTERFACE,
1780                .type = QUIRK_MIDI_MIDIMAN,
1781                .data = & (const struct snd_usb_midi_endpoint_info) {
1782                        .out_cables = 0x0003,
1783                        .in_cables  = 0x0003
1784                }
1785        }
1786},
1787{
1788        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1789        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1790                .vendor_name = "M-Audio",
1791                .product_name = "MidiSport 1x1",
1792                .ifnum = QUIRK_ANY_INTERFACE,
1793                .type = QUIRK_MIDI_MIDIMAN,
1794                .data = & (const struct snd_usb_midi_endpoint_info) {
1795                        .out_cables = 0x0001,
1796                        .in_cables  = 0x0001
1797                }
1798        }
1799},
1800{
1801        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1802        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1803                .vendor_name = "M-Audio",
1804                .product_name = "Keystation",
1805                .ifnum = QUIRK_ANY_INTERFACE,
1806                .type = QUIRK_MIDI_MIDIMAN,
1807                .data = & (const struct snd_usb_midi_endpoint_info) {
1808                        .out_cables = 0x0001,
1809                        .in_cables  = 0x0001
1810                }
1811        }
1812},
1813{
1814        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1815        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1816                .vendor_name = "M-Audio",
1817                .product_name = "MidiSport 4x4",
1818                .ifnum = QUIRK_ANY_INTERFACE,
1819                .type = QUIRK_MIDI_MIDIMAN,
1820                .data = & (const struct snd_usb_midi_endpoint_info) {
1821                        .out_cables = 0x000f,
1822                        .in_cables  = 0x000f
1823                }
1824        }
1825},
1826{
1827        /*
1828         * For hardware revision 1.05; in the later revisions (1.10 and
1829         * 1.21), 0x1031 is the ID for the device without firmware.
1830         * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1831         */
1832        USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1833        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1834                .vendor_name = "M-Audio",
1835                .product_name = "MidiSport 8x8",
1836                .ifnum = QUIRK_ANY_INTERFACE,
1837                .type = QUIRK_MIDI_MIDIMAN,
1838                .data = & (const struct snd_usb_midi_endpoint_info) {
1839                        .out_cables = 0x01ff,
1840                        .in_cables  = 0x01ff
1841                }
1842        }
1843},
1844{
1845        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1846        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1847                .vendor_name = "M-Audio",
1848                .product_name = "MidiSport 8x8",
1849                .ifnum = QUIRK_ANY_INTERFACE,
1850                .type = QUIRK_MIDI_MIDIMAN,
1851                .data = & (const struct snd_usb_midi_endpoint_info) {
1852                        .out_cables = 0x01ff,
1853                        .in_cables  = 0x01ff
1854                }
1855        }
1856},
1857{
1858        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1859        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1860                .vendor_name = "M-Audio",
1861                .product_name = "MidiSport 2x4",
1862                .ifnum = QUIRK_ANY_INTERFACE,
1863                .type = QUIRK_MIDI_MIDIMAN,
1864                .data = & (const struct snd_usb_midi_endpoint_info) {
1865                        .out_cables = 0x000f,
1866                        .in_cables  = 0x0003
1867                }
1868        }
1869},
1870{
1871        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1872        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1873                .vendor_name = "M-Audio",
1874                .product_name = "Quattro",
1875                .ifnum = QUIRK_ANY_INTERFACE,
1876                .type = QUIRK_COMPOSITE,
1877                .data = & (const struct snd_usb_audio_quirk[]) {
1878                        /*
1879                         * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1880                         * and share endpoints with the other interfaces.
1881                         * Ignore them.  The other interfaces can do 24 bits,
1882                         * but captured samples are big-endian (see usbaudio.c).
1883                         */
1884                        {
1885                                .ifnum = 0,
1886                                .type = QUIRK_IGNORE_INTERFACE
1887                        },
1888                        {
1889                                .ifnum = 1,
1890                                .type = QUIRK_IGNORE_INTERFACE
1891                        },
1892                        {
1893                                .ifnum = 2,
1894                                .type = QUIRK_IGNORE_INTERFACE
1895                        },
1896                        {
1897                                .ifnum = 3,
1898                                .type = QUIRK_IGNORE_INTERFACE
1899                        },
1900                        {
1901                                .ifnum = 4,
1902                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1903                        },
1904                        {
1905                                .ifnum = 5,
1906                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1907                        },
1908                        {
1909                                .ifnum = 6,
1910                                .type = QUIRK_IGNORE_INTERFACE
1911                        },
1912                        {
1913                                .ifnum = 7,
1914                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1915                        },
1916                        {
1917                                .ifnum = 8,
1918                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1919                        },
1920                        {
1921                                .ifnum = 9,
1922                                .type = QUIRK_MIDI_MIDIMAN,
1923                                .data = & (const struct snd_usb_midi_endpoint_info) {
1924                                        .out_cables = 0x0001,
1925                                        .in_cables  = 0x0001
1926                                }
1927                        },
1928                        {
1929                                .ifnum = -1
1930                        }
1931                }
1932        }
1933},
1934{
1935        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1936        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1937                .vendor_name = "M-Audio",
1938                .product_name = "AudioPhile",
1939                .ifnum = 6,
1940                .type = QUIRK_MIDI_MIDIMAN,
1941                .data = & (const struct snd_usb_midi_endpoint_info) {
1942                        .out_cables = 0x0001,
1943                        .in_cables  = 0x0001
1944                }
1945        }
1946},
1947{
1948        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1949        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1950                .vendor_name = "M-Audio",
1951                .product_name = "Ozone",
1952                .ifnum = 3,
1953                .type = QUIRK_MIDI_MIDIMAN,
1954                .data = & (const struct snd_usb_midi_endpoint_info) {
1955                        .out_cables = 0x0001,
1956                        .in_cables  = 0x0001
1957                }
1958        }
1959},
1960{
1961        USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1962        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1963                .vendor_name = "M-Audio",
1964                .product_name = "OmniStudio",
1965                .ifnum = QUIRK_ANY_INTERFACE,
1966                .type = QUIRK_COMPOSITE,
1967                .data = & (const struct snd_usb_audio_quirk[]) {
1968                        {
1969                                .ifnum = 0,
1970                                .type = QUIRK_IGNORE_INTERFACE
1971                        },
1972                        {
1973                                .ifnum = 1,
1974                                .type = QUIRK_IGNORE_INTERFACE
1975                        },
1976                        {
1977                                .ifnum = 2,
1978                                .type = QUIRK_IGNORE_INTERFACE
1979                        },
1980                        {
1981                                .ifnum = 3,
1982                                .type = QUIRK_IGNORE_INTERFACE
1983                        },
1984                        {
1985                                .ifnum = 4,
1986                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1987                        },
1988                        {
1989                                .ifnum = 5,
1990                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1991                        },
1992                        {
1993                                .ifnum = 6,
1994                                .type = QUIRK_IGNORE_INTERFACE
1995                        },
1996                        {
1997                                .ifnum = 7,
1998                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1999                        },
2000                        {

2001                                .ifnum = 8,
2002                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2003                        },
2004                        {
2005                                .ifnum = 9,
2006                                .type = QUIRK_MIDI_MIDIMAN,
2007                                .data = & (const struct snd_usb_midi_endpoint_info) {
2008                                        .out_cables = 0x0001,
2009                                        .in_cables  = 0x0001
2010                                }
2011                        },
2012                        {
2013                                .ifnum = -1
2014                        }
2015                }
2016        }
2017},
2018{
2019        USB_DEVICE(0x0763, 0x2019),
2020        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2021                /* .vendor_name = "M-Audio", */
2022                /* .product_name = "Ozone Academic", */
2023                .ifnum = QUIRK_ANY_INTERFACE,
2024                .type = QUIRK_COMPOSITE,
2025                .data = & (const struct snd_usb_audio_quirk[]) {
2026                        {
2027                                .ifnum = 0,
2028                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2029                        },
2030                        {
2031                                .ifnum = 1,
2032                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2033                        },
2034                        {
2035                                .ifnum = 2,
2036                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2037                        },
2038                        {
2039                                .ifnum = 3,
2040                                .type = QUIRK_MIDI_MIDIMAN,
2041                                .data = & (const struct snd_usb_midi_endpoint_info) {
2042                                        .out_cables = 0x0001,
2043                                        .in_cables  = 0x0001
2044                                }
2045                        },
2046                        {
2047                                .ifnum = -1
2048                        }
2049                }
2050        }
2051},
2052{
2053        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2054        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2055                /* .vendor_name = "M-Audio", */
2056                /* .product_name = "Fast Track C400", */
2057                .ifnum = QUIRK_ANY_INTERFACE,
2058                .type = QUIRK_COMPOSITE,
2059                .data = &(const struct snd_usb_audio_quirk[]) {
2060                        {
2061                                .ifnum = 1,
2062                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2063                        },
2064                        /* Playback */
2065                        {
2066                                .ifnum = 2,
2067                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2068                                .data = &(const struct audioformat) {
2069                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2070                                        .channels = 6,
2071                                        .iface = 2,
2072                                        .altsetting = 1,
2073                                        .altset_idx = 1,
2074                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2075                                        .endpoint = 0x01,
2076                                        .ep_attr = 0x09,
2077                                        .rates = SNDRV_PCM_RATE_44100 |
2078                                                 SNDRV_PCM_RATE_48000 |
2079                                                 SNDRV_PCM_RATE_88200 |
2080                                                 SNDRV_PCM_RATE_96000,
2081                                        .rate_min = 44100,
2082                                        .rate_max = 96000,
2083                                        .nr_rates = 4,
2084                                        .rate_table = (unsigned int[]) {
2085                                                        44100, 48000, 88200, 96000
2086                                        },
2087                                        .clock = 0x80,
2088                                }
2089                        },
2090                        /* Capture */
2091                        {
2092                                .ifnum = 3,
2093                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2094                                .data = &(const struct audioformat) {
2095                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2096                                        .channels = 4,
2097                                        .iface = 3,
2098                                        .altsetting = 1,
2099                                        .altset_idx = 1,
2100                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2101                                        .endpoint = 0x81,
2102                                        .ep_attr = 0x05,
2103                                        .rates = SNDRV_PCM_RATE_44100 |
2104                                                 SNDRV_PCM_RATE_48000 |
2105                                                 SNDRV_PCM_RATE_88200 |
2106                                                 SNDRV_PCM_RATE_96000,
2107                                        .rate_min = 44100,
2108                                        .rate_max = 96000,
2109                                        .nr_rates = 4,
2110                                        .rate_table = (unsigned int[]) {
2111                                                44100, 48000, 88200, 96000
2112                                        },
2113                                        .clock = 0x80,
2114                                }
2115                        },
2116                        /* MIDI */
2117                        {
2118                                .ifnum = -1 /* Interface = 4 */
2119                        }
2120                }
2121        }
2122},
2123{
2124        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2125        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2126                /* .vendor_name = "M-Audio", */
2127                /* .product_name = "Fast Track C600", */
2128                .ifnum = QUIRK_ANY_INTERFACE,
2129                .type = QUIRK_COMPOSITE,
2130                .data = &(const struct snd_usb_audio_quirk[]) {
2131                        {
2132                                .ifnum = 1,
2133                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2134                        },
2135                        /* Playback */
2136                        {
2137                                .ifnum = 2,
2138                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2139                                .data = &(const struct audioformat) {
2140                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2141                                        .channels = 8,
2142                                        .iface = 2,
2143                                        .altsetting = 1,
2144                                        .altset_idx = 1,
2145                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2146                                        .endpoint = 0x01,
2147                                        .ep_attr = 0x09,
2148                                        .rates = SNDRV_PCM_RATE_44100 |
2149                                                 SNDRV_PCM_RATE_48000 |
2150                                                 SNDRV_PCM_RATE_88200 |
2151                                                 SNDRV_PCM_RATE_96000,
2152                                        .rate_min = 44100,
2153                                        .rate_max = 96000,
2154                                        .nr_rates = 4,
2155                                        .rate_table = (unsigned int[]) {
2156                                                        44100, 48000, 88200, 96000
2157                                        },
2158                                        .clock = 0x80,
2159                                }
2160                        },
2161                        /* Capture */
2162                        {
2163                                .ifnum = 3,
2164                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2165                                .data = &(const struct audioformat) {
2166                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2167                                        .channels = 6,
2168                                        .iface = 3,
2169                                        .altsetting = 1,
2170                                        .altset_idx = 1,
2171                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2172                                        .endpoint = 0x81,
2173                                        .ep_attr = 0x05,
2174                                        .rates = SNDRV_PCM_RATE_44100 |
2175                                                 SNDRV_PCM_RATE_48000 |
2176                                                 SNDRV_PCM_RATE_88200 |
2177                                                 SNDRV_PCM_RATE_96000,
2178                                        .rate_min = 44100,
2179                                        .rate_max = 96000,
2180                                        .nr_rates = 4,
2181                                        .rate_table = (unsigned int[]) {
2182                                                44100, 48000, 88200, 96000
2183                                        },
2184                                        .clock = 0x80,
2185                                }
2186                        },
2187                        /* MIDI */
2188                        {
2189                                .ifnum = -1 /* Interface = 4 */
2190                        }
2191                }
2192        }
2193},
2194{
2195        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2196        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2197                /* .vendor_name = "M-Audio", */
2198                /* .product_name = "Fast Track Ultra", */
2199                .ifnum = QUIRK_ANY_INTERFACE,
2200                .type = QUIRK_COMPOSITE,
2201                .data = & (const struct snd_usb_audio_quirk[]) {
2202                        {
2203                                .ifnum = 0,
2204                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2205                        },
2206                        {
2207                                .ifnum = 1,
2208                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2209                                .data = & (const struct audioformat) {
2210                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2211                                        .channels = 8,
2212                                        .iface = 1,
2213                                        .altsetting = 1,
2214                                        .altset_idx = 1,
2215                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2216                                        .endpoint = 0x01,
2217                                        .ep_attr = 0x09,
2218                                        .rates = SNDRV_PCM_RATE_44100 |
2219                                                 SNDRV_PCM_RATE_48000 |
2220                                                 SNDRV_PCM_RATE_88200 |
2221                                                 SNDRV_PCM_RATE_96000,
2222                                        .rate_min = 44100,
2223                                        .rate_max = 96000,
2224                                        .nr_rates = 4,
2225                                        .rate_table = (unsigned int[]) {
2226                                                44100, 48000, 88200, 96000
2227                                        }
2228                                }
2229                        },
2230                        {
2231                                .ifnum = 2,
2232                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2233                                .data = & (const struct audioformat) {
2234                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2235                                        .channels = 8,
2236                                        .iface = 2,
2237                                        .altsetting = 1,
2238                                        .altset_idx = 1,
2239                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2240                                        .endpoint = 0x81,
2241                                        .ep_attr = 0x05,
2242                                        .rates = SNDRV_PCM_RATE_44100 |
2243                                                 SNDRV_PCM_RATE_48000 |
2244                                                 SNDRV_PCM_RATE_88200 |
2245                                                 SNDRV_PCM_RATE_96000,
2246                                        .rate_min = 44100,
2247                                        .rate_max = 96000,
2248                                        .nr_rates = 4,
2249                                        .rate_table = (unsigned int[]) {
2250                                                44100, 48000, 88200, 96000
2251                                        }
2252                                }
2253                        },
2254                        /* interface 3 (MIDI) is standard compliant */
2255                        {
2256                                .ifnum = -1
2257                        }
2258                }
2259        }
2260},
2261{
2262        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2263        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2264                /* .vendor_name = "M-Audio", */
2265                /* .product_name = "Fast Track Ultra 8R", */
2266                .ifnum = QUIRK_ANY_INTERFACE,
2267                .type = QUIRK_COMPOSITE,
2268                .data = & (const struct snd_usb_audio_quirk[]) {
2269                        {
2270                                .ifnum = 0,
2271                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2272                        },
2273                        {
2274                                .ifnum = 1,
2275                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2276                                .data = & (const struct audioformat) {
2277                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2278                                        .channels = 8,
2279                                        .iface = 1,
2280                                        .altsetting = 1,
2281                                        .altset_idx = 1,
2282                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2283                                        .endpoint = 0x01,
2284                                        .ep_attr = 0x09,
2285                                        .rates = SNDRV_PCM_RATE_44100 |
2286                                                 SNDRV_PCM_RATE_48000 |
2287                                                 SNDRV_PCM_RATE_88200 |
2288                                                 SNDRV_PCM_RATE_96000,
2289                                        .rate_min = 44100,
2290                                        .rate_max = 96000,
2291                                        .nr_rates = 4,
2292                                        .rate_table = (unsigned int[]) {
2293                                                        44100, 48000, 88200, 96000
2294                                        }
2295                                }
2296                        },
2297                        {
2298                                .ifnum = 2,
2299                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2300                                .data = & (const struct audioformat) {
2301                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2302                                        .channels = 8,
2303                                        .iface = 2,
2304                                        .altsetting = 1,
2305                                        .altset_idx = 1,
2306                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2307                                        .endpoint = 0x81,
2308                                        .ep_attr = 0x05,
2309                                        .rates = SNDRV_PCM_RATE_44100 |
2310                                                 SNDRV_PCM_RATE_48000 |
2311                                                 SNDRV_PCM_RATE_88200 |
2312                                                 SNDRV_PCM_RATE_96000,
2313                                        .rate_min = 44100,
2314                                        .rate_max = 96000,
2315                                        .nr_rates = 4,
2316                                        .rate_table = (unsigned int[]) {
2317                                                44100, 48000, 88200, 96000
2318                                        }
2319                                }
2320                        },
2321                        /* interface 3 (MIDI) is standard compliant */
2322                        {
2323                                .ifnum = -1
2324                        }
2325                }
2326        }
2327},
2328
2329/* Casio devices */
2330{
2331        USB_DEVICE(0x07cf, 0x6801),
2332        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2333                .vendor_name = "Casio",
2334                .product_name = "PL-40R",
2335                .ifnum = 0,
2336                .type = QUIRK_MIDI_YAMAHA
2337        }
2338},
2339{
2340        /* this ID is used by several devices without a product ID */
2341        USB_DEVICE(0x07cf, 0x6802),
2342        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2343                .vendor_name = "Casio",
2344                .product_name = "Keyboard",
2345                .ifnum = 0,
2346                .type = QUIRK_MIDI_YAMAHA
2347        }
2348},
2349
2350/* Mark of the Unicorn devices */
2351{
2352        /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2353        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2354                       USB_DEVICE_ID_MATCH_PRODUCT |
2355                       USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2356        .idVendor = 0x07fd,
2357        .idProduct = 0x0001,
2358        .bDeviceSubClass = 2,
2359        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2360                .vendor_name = "MOTU",
2361                .product_name = "Fastlane",
2362                .ifnum = QUIRK_ANY_INTERFACE,
2363                .type = QUIRK_COMPOSITE,
2364                .data = & (const struct snd_usb_audio_quirk[]) {
2365                        {
2366                                .ifnum = 0,
2367                                .type = QUIRK_MIDI_RAW_BYTES
2368                        },
2369                        {
2370                                .ifnum = 1,
2371                                .type = QUIRK_IGNORE_INTERFACE
2372                        },
2373                        {
2374                                .ifnum = -1
2375                        }
2376                }
2377        }
2378},
2379
2380/* Emagic devices */
2381{
2382        USB_DEVICE(0x086a, 0x0001),
2383        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2384                .vendor_name = "Emagic",
2385                .product_name = "Unitor8",
2386                .ifnum = 2,
2387                .type = QUIRK_MIDI_EMAGIC,
2388                .data = & (const struct snd_usb_midi_endpoint_info) {
2389                        .out_cables = 0x80ff,
2390                        .in_cables  = 0x80ff
2391                }
2392        }
2393},
2394{
2395        USB_DEVICE(0x086a, 0x0002),
2396        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2397                .vendor_name = "Emagic",
2398                /* .product_name = "AMT8", */
2399                .ifnum = 2,
2400                .type = QUIRK_MIDI_EMAGIC,
2401                .data = & (const struct snd_usb_midi_endpoint_info) {
2402                        .out_cables = 0x80ff,
2403                        .in_cables  = 0x80ff
2404                }
2405        }
2406},
2407{
2408        USB_DEVICE(0x086a, 0x0003),
2409        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2410                .vendor_name = "Emagic",
2411                /* .product_name = "MT4", */
2412                .ifnum = 2,
2413                .type = QUIRK_MIDI_EMAGIC,
2414                .data = & (const struct snd_usb_midi_endpoint_info) {
2415                        .out_cables = 0x800f,
2416                        .in_cables  = 0x8003
2417                }
2418        }
2419},
2420
2421/* KORG devices */
2422{
2423        USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2424        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2425                .vendor_name = "KORG, Inc.",
2426                /* .product_name = "PANDORA PX5D", */
2427                .ifnum = 3,
2428                .type = QUIRK_MIDI_STANDARD_INTERFACE,
2429        }
2430},
2431
2432{
2433        USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2434        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2435                .vendor_name = "KORG, Inc.",
2436                /* .product_name = "ToneLab ST", */
2437                .ifnum = 3,
2438                .type = QUIRK_MIDI_STANDARD_INTERFACE,
2439        }
2440},
2441
2442{
2443        USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2444        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2445                .vendor_name = "KORG, Inc.",
2446                /* .product_name = "ToneLab EX", */
2447                .ifnum = 3,
2448                .type = QUIRK_MIDI_STANDARD_INTERFACE,
2449        }
2450},
2451
2452/* AKAI devices */
2453{
2454        USB_DEVICE(0x09e8, 0x0062),
2455        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2456                .vendor_name = "AKAI",
2457                .product_name = "MPD16",
2458                .ifnum = 0,
2459                .type = QUIRK_MIDI_AKAI,
2460        }
2461},
2462
2463{
2464        /* Akai MPC Element */
2465        USB_DEVICE(0x09e8, 0x0021),
2466        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2467                .ifnum = QUIRK_ANY_INTERFACE,
2468                .type = QUIRK_COMPOSITE,
2469                .data = & (const struct snd_usb_audio_quirk[]) {
2470                        {
2471                                .ifnum = 0,
2472                                .type = QUIRK_IGNORE_INTERFACE
2473                        },
2474                        {
2475                                .ifnum = 1,
2476                                .type = QUIRK_MIDI_STANDARD_INTERFACE
2477                        },
2478                        {
2479                                .ifnum = -1
2480                        }
2481                }
2482        }
2483},
2484
2485/* Steinberg devices */
2486{
2487        /* Steinberg MI2 */
2488        USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2489        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2490                .ifnum = QUIRK_ANY_INTERFACE,
2491                .type = QUIRK_COMPOSITE,
2492                .data = & (const struct snd_usb_audio_quirk[]) {
2493                        {
2494                                .ifnum = 0,
2495                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2496                        },
2497                        {
2498                                .ifnum = 1,
2499                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2500                        },
2501                        {
2502                                .ifnum = 2,
2503                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2504                        },
2505                        {
2506                                .ifnum = 3,
2507                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2508                                .data = &(const struct snd_usb_midi_endpoint_info) {
2509                                        .out_cables = 0x0001,
2510                                        .in_cables  = 0x0001
2511                                }
2512                        },
2513                        {
2514                                .ifnum = -1
2515                        }
2516                }
2517        }
2518},
2519{
2520        /* Steinberg MI4 */
2521        USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2522        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2523                .ifnum = QUIRK_ANY_INTERFACE,
2524                .type = QUIRK_COMPOSITE,
2525                .data = & (const struct snd_usb_audio_quirk[]) {
2526                        {
2527                                .ifnum = 0,
2528                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2529                        },
2530                        {
2531                                .ifnum = 1,
2532                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2533                        },
2534                        {
2535                                .ifnum = 2,
2536                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
2537                        },
2538                        {
2539                                .ifnum = 3,
2540                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2541                                .data = &(const struct snd_usb_midi_endpoint_info) {
2542                                        .out_cables = 0x0001,
2543                                        .in_cables  = 0x0001
2544                                }
2545                        },
2546                        {
2547                                .ifnum = -1
2548                        }
2549                }
2550        }
2551},
2552
2553/* TerraTec devices */
2554{
2555        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2556        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2557                .vendor_name = "TerraTec",
2558                .product_name = "PHASE 26",
2559                .ifnum = 3,
2560                .type = QUIRK_MIDI_STANDARD_INTERFACE
2561        }
2562},
2563{
2564        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2565        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2566                .vendor_name = "TerraTec",
2567                .product_name = "PHASE 26",
2568                .ifnum = 3,
2569                .type = QUIRK_MIDI_STANDARD_INTERFACE
2570        }
2571},
2572{
2573        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2574        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2575                .vendor_name = "TerraTec",
2576                .product_name = "PHASE 26",
2577                .ifnum = 3,
2578                .type = QUIRK_MIDI_STANDARD_INTERFACE
2579        }
2580},
2581{
2582        USB_DEVICE(0x0ccd, 0x0035),
2583        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2584                .vendor_name = "Miditech",
2585                .product_name = "Play'n Roll",
2586                .ifnum = 0,
2587                .type = QUIRK_MIDI_CME
2588        }
2589},
2590
2591/* Novation EMS devices */
2592{
2593        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2594        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2595                .vendor_name = "Novation",
2596                .product_name = "ReMOTE Audio/XStation",
2597                .ifnum = 4,
2598                .type = QUIRK_MIDI_NOVATION
2599        }
2600},
2601{
2602        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2603        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2604                .vendor_name = "Novation",
2605                .product_name = "Speedio",
2606                .ifnum = 3,
2607                .type = QUIRK_MIDI_NOVATION
2608        }
2609},
2610{
2611        USB_DEVICE(0x1235, 0x000a),
2612        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2613                /* .vendor_name = "Novation", */
2614                /* .product_name = "Nocturn", */
2615                .ifnum = 0,
2616                .type = QUIRK_MIDI_RAW_BYTES
2617        }
2618},
2619{
2620        USB_DEVICE(0x1235, 0x000e),
2621        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2622                /* .vendor_name = "Novation", */
2623                /* .product_name = "Launchpad", */
2624                .ifnum = 0,
2625                .type = QUIRK_MIDI_RAW_BYTES
2626        }
2627},
2628{
2629        USB_DEVICE(0x1235, 0x0010),
2630        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2631                .vendor_name = "Focusrite",
2632                .product_name = "Saffire 6 USB",
2633                .ifnum = QUIRK_ANY_INTERFACE,
2634                .type = QUIRK_COMPOSITE,
2635                .data = (const struct snd_usb_audio_quirk[]) {
2636                        {
2637                                .ifnum = 0,
2638                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2639                        },
2640                        {
2641                                .ifnum = 0,
2642                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2643                                .data = &(const struct audioformat) {
2644                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2645                                        .channels = 4,
2646                                        .iface = 0,
2647                                        .altsetting = 1,
2648                                        .altset_idx = 1,
2649                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2650                                        .endpoint = 0x01,
2651                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
2652                                        .datainterval = 1,
2653                                        .maxpacksize = 0x024c,
2654                                        .rates = SNDRV_PCM_RATE_44100 |
2655                                                 SNDRV_PCM_RATE_48000,
2656                                        .rate_min = 44100,
2657                                        .rate_max = 48000,
2658                                        .nr_rates = 2,
2659                                        .rate_table = (unsigned int[]) {
2660                                                44100, 48000
2661                                        }
2662                                }
2663                        },
2664                        {
2665                                .ifnum = 0,
2666                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2667                                .data = &(const struct audioformat) {
2668                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2669                                        .channels = 2,
2670                                        .iface = 0,
2671                                        .altsetting = 1,
2672                                        .altset_idx = 1,
2673                                        .attributes = 0,
2674                                        .endpoint = 0x82,
2675                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
2676                                        .datainterval = 1,
2677                                        .maxpacksize = 0x0126,
2678                                        .rates = SNDRV_PCM_RATE_44100 |
2679                                                 SNDRV_PCM_RATE_48000,
2680                                        .rate_min = 44100,
2681                                        .rate_max = 48000,
2682                                        .nr_rates = 2,
2683                                        .rate_table = (unsigned int[]) {
2684                                                44100, 48000
2685                                        }
2686                                }
2687                        },
2688                        {
2689                                .ifnum = 1,
2690                                .type = QUIRK_MIDI_RAW_BYTES
2691                        },
2692                        {
2693                                .ifnum = -1
2694                        }
2695                }
2696        }
2697},
2698{
2699        USB_DEVICE(0x1235, 0x0018),
2700        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2701                .vendor_name = "Novation",
2702                .product_name = "Twitch",
2703                .ifnum = QUIRK_ANY_INTERFACE,
2704                .type = QUIRK_COMPOSITE,
2705                .data = (const struct snd_usb_audio_quirk[]) {
2706                        {
2707                                .ifnum = 0,
2708                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2709                                .data = & (const struct audioformat) {
2710                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2711                                        .channels = 4,
2712                                        .iface = 0,
2713                                        .altsetting = 1,
2714                                        .altset_idx = 1,
2715                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2716                                        .endpoint = 0x01,
2717                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
2718                                        .rates = SNDRV_PCM_RATE_44100 |
2719                                                 SNDRV_PCM_RATE_48000,
2720                                        .rate_min = 44100,
2721                                        .rate_max = 48000,
2722                                        .nr_rates = 2,
2723                                        .rate_table = (unsigned int[]) {
2724                                                44100, 48000
2725                                        }
2726                                }
2727                        },
2728                        {
2729                                .ifnum = 1,
2730                                .type = QUIRK_MIDI_RAW_BYTES
2731                        },
2732                        {
2733                                .ifnum = -1
2734                        }
2735                }
2736        }
2737},
2738{
2739        USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2740        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2741                .vendor_name = "Novation",
2742                .product_name = "ReMOTE25",
2743                .ifnum = 0,
2744                .type = QUIRK_MIDI_NOVATION
2745        }
2746},
2747
2748/* Access Music devices */
2749{
2750        /* VirusTI Desktop */
2751        USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2752        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2753                .ifnum = QUIRK_ANY_INTERFACE,
2754                .type = QUIRK_COMPOSITE,
2755                .data = &(const struct snd_usb_audio_quirk[]) {
2756                        {
2757                                .ifnum = 3,
2758                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2759                                .data = &(const struct snd_usb_midi_endpoint_info) {
2760                                        .out_cables = 0x0003,
2761                                        .in_cables  = 0x0003
2762                                }
2763                        },
2764                        {
2765                                .ifnum = 4,
2766                                .type = QUIRK_IGNORE_INTERFACE
2767                        },
2768                        {
2769                                .ifnum = -1
2770                        }
2771                }
2772        }
2773},
2774
2775/* Native Instruments MK2 series */
2776{
2777        /* Komplete Audio 6 */
2778        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2779        .idVendor = 0x17cc,
2780        .idProduct = 0x1000,
2781},
2782{
2783        /* Traktor Audio 6 */
2784        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2785        .idVendor = 0x17cc,
2786        .idProduct = 0x1010,
2787},
2788{
2789        /* Traktor Audio 10 */
2790        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2791        .idVendor = 0x17cc,
2792        .idProduct = 0x1020,
2793},
2794
2795/* QinHeng devices */
2796{
2797        USB_DEVICE(0x1a86, 0x752d),
2798        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2799                .vendor_name = "QinHeng",
2800                .product_name = "CH345",
2801                .ifnum = 1,
2802                .type = QUIRK_MIDI_CH345
2803        }
2804},
2805
2806/* KeithMcMillen Stringport */
2807{ USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
2808
2809/* Miditech devices */
2810{
2811        USB_DEVICE(0x4752, 0x0011),
2812        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2813                .vendor_name = "Miditech",
2814                .product_name = "Midistart-2",
2815                .ifnum = 0,
2816                .type = QUIRK_MIDI_CME
2817        }
2818},
2819
2820/* Central Music devices */
2821{
2822        /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2823        USB_DEVICE(0x7104, 0x2202),
2824        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2825                .ifnum = 0,
2826                .type = QUIRK_MIDI_CME
2827        }
2828},
2829
2830/* Digidesign Mbox */
2831{
2832        /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2833        USB_DEVICE(0x0dba, 0x1000),
2834        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2835                .vendor_name = "Digidesign",
2836                .product_name = "MBox",
2837                .ifnum = QUIRK_ANY_INTERFACE,
2838                .type = QUIRK_COMPOSITE,
2839                .data = (const struct snd_usb_audio_quirk[]){
2840                        {
2841                                .ifnum = 0,
2842                                .type = QUIRK_AUDIO_STANDARD_MIXER,
2843                        },
2844                        {
2845                                .ifnum = 1,
2846                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2847                                .data = &(const struct audioformat) {
2848                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2849                                        .channels = 2,
2850                                        .iface = 1,
2851                                        .altsetting = 1,
2852                                        .altset_idx = 1,
2853                                        .attributes = 0x4,
2854                                        .endpoint = 0x02,
2855                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
2856                                                USB_ENDPOINT_SYNC_SYNC,
2857                                        .maxpacksize = 0x130,
2858                                        .rates = SNDRV_PCM_RATE_48000,
2859                                        .rate_min = 48000,
2860                                        .rate_max = 48000,
2861                                        .nr_rates = 1,
2862                                        .rate_table = (unsigned int[]) {
2863                                                48000
2864                                        }
2865                                }
2866                        },
2867                        {
2868                                .ifnum = 1,
2869                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2870                                .data = &(const struct audioformat) {
2871                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2872                                        .channels = 2,
2873                                        .iface = 1,
2874                                        .altsetting = 1,
2875                                        .altset_idx = 1,
2876                                        .attributes = 0x4,
2877                                        .endpoint = 0x81,
2878                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
2879                                                USB_ENDPOINT_SYNC_ASYNC,
2880                                        .maxpacksize = 0x130,
2881                                        .rates = SNDRV_PCM_RATE_48000,
2882                                        .rate_min = 48000,
2883                                        .rate_max = 48000,
2884                                        .nr_rates = 1,
2885                                        .rate_table = (unsigned int[]) {
2886                                                48000
2887                                        }
2888                                }
2889                        },
2890                        {
2891                                .ifnum = -1
2892                        }
2893                }
2894        }
2895},
2896
2897/* DIGIDESIGN MBOX 2 */
2898{
2899        USB_DEVICE(0x0dba, 0x3000),
2900        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2901                .vendor_name = "Digidesign",
2902                .product_name = "Mbox 2",
2903                .ifnum = QUIRK_ANY_INTERFACE,
2904                .type = QUIRK_COMPOSITE,
2905                .data = (const struct snd_usb_audio_quirk[]) {
2906                        {
2907                                .ifnum = 0,
2908                                .type = QUIRK_IGNORE_INTERFACE
2909                        },
2910                        {
2911                                .ifnum = 1,
2912                                .type = QUIRK_IGNORE_INTERFACE
2913                        },
2914                        {
2915                                .ifnum = 2,
2916                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2917                                .data = &(const struct audioformat) {
2918                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2919                                        .channels = 2,
2920                                        .iface = 2,
2921                                        .altsetting = 2,
2922                                        .altset_idx = 1,
2923                                        .attributes = 0x00,
2924                                        .endpoint = 0x03,
2925                                        .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2926                                        .rates = SNDRV_PCM_RATE_48000,
2927                                        .rate_min = 48000,
2928                                        .rate_max = 48000,
2929                                        .nr_rates = 1,
2930                                        .rate_table = (unsigned int[]) {
2931                                                48000
2932                                        }
2933                                }
2934                        },
2935                        {
2936                                .ifnum = 3,
2937                                .type = QUIRK_IGNORE_INTERFACE
2938                        },
2939                        {
2940                                .ifnum = 4,
2941                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2942                                .data = &(const struct audioformat) {
2943                                .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2944                                        .channels = 2,
2945                                        .iface = 4,
2946                                        .altsetting = 2,
2947                                        .altset_idx = 1,
2948                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2949                                        .endpoint = 0x85,
2950                                        .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2951                                        .rates = SNDRV_PCM_RATE_48000,
2952                                        .rate_min = 48000,
2953                                        .rate_max = 48000,
2954                                        .nr_rates = 1,
2955                                        .rate_table = (unsigned int[]) {
2956                                                48000
2957                                        }
2958                                }
2959                        },
2960                        {
2961                                .ifnum = 5,
2962                                .type = QUIRK_IGNORE_INTERFACE
2963                        },
2964                        {
2965                                .ifnum = 6,
2966                                .type = QUIRK_MIDI_MIDIMAN,
2967                                .data = &(const struct snd_usb_midi_endpoint_info) {
2968                                        .out_ep =  0x02,
2969                                        .out_cables = 0x0001,
2970                                        .in_ep = 0x81,
2971                                        .in_interval = 0x01,
2972                                        .in_cables = 0x0001
2973                                }
2974                        },
2975                        {
2976                                .ifnum = -1
2977                        }
2978                }
2979        }
2980},
2981{
2982        /* Tascam US122 MKII - playback-only support */
2983        USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
2984        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2985                .vendor_name = "TASCAM",
2986                .product_name = "US122 MKII",
2987                .ifnum = QUIRK_ANY_INTERFACE,
2988                .type = QUIRK_COMPOSITE,
2989                .data = (const struct snd_usb_audio_quirk[]) {
2990                        {
2991                                .ifnum = 0,
2992                                .type = QUIRK_IGNORE_INTERFACE
2993                        },
2994                        {
2995                                .ifnum = 1,
2996                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2997                                .data = &(const struct audioformat) {
2998                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2999                                        .channels = 2,
3000                                        .iface = 1,

3001                                        .altsetting = 1,
3002                                        .altset_idx = 1,
3003                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3004                                        .endpoint = 0x02,
3005                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
3006                                        .rates = SNDRV_PCM_RATE_44100 |
3007                                                 SNDRV_PCM_RATE_48000 |
3008                                                 SNDRV_PCM_RATE_88200 |
3009                                                 SNDRV_PCM_RATE_96000,
3010                                        .rate_min = 44100,
3011                                        .rate_max = 96000,
3012                                        .nr_rates = 4,
3013                                        .rate_table = (unsigned int[]) {
3014                                                44100, 48000, 88200, 96000
3015                                        }
3016                                }
3017                        },
3018                        {
3019                                .ifnum = -1
3020                        }
3021                }
3022        }
3023},
3024
3025/* Denon DN-X1600 */
3026{
3027        USB_AUDIO_DEVICE(0x154e, 0x500e),
3028        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3029                .vendor_name = "Denon",
3030                .product_name = "DN-X1600",
3031                .ifnum = QUIRK_ANY_INTERFACE,
3032                .type = QUIRK_COMPOSITE,
3033                .data = (const struct snd_usb_audio_quirk[]){
3034                        {
3035                                .ifnum = 0,
3036                                .type = QUIRK_IGNORE_INTERFACE,
3037                        },
3038                        {
3039                                .ifnum = 1,
3040                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3041                                .data = &(const struct audioformat) {
3042                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3043                                        .channels = 8,
3044                                        .iface = 1,
3045                                        .altsetting = 1,
3046                                        .altset_idx = 1,
3047                                        .attributes = 0x0,
3048                                        .endpoint = 0x01,
3049                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
3050                                                USB_ENDPOINT_SYNC_ADAPTIVE,
3051                                        .maxpacksize = 0x138,
3052                                        .rates = SNDRV_PCM_RATE_48000,
3053                                        .rate_min = 48000,
3054                                        .rate_max = 48000,
3055                                        .nr_rates = 1,
3056                                        .rate_table = (unsigned int[]) {
3057                                                48000
3058                                        }
3059                                }
3060                        },
3061                        {
3062                                .ifnum = 2,
3063                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3064                                .data = &(const struct audioformat) {
3065                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3066                                        .channels = 8,
3067                                        .iface = 2,
3068                                        .altsetting = 1,
3069                                        .altset_idx = 1,
3070                                        .attributes = 0x0,
3071                                        .endpoint = 0x85,
3072                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
3073                                                USB_ENDPOINT_SYNC_ADAPTIVE,
3074                                        .maxpacksize = 0x138,
3075                                        .rates = SNDRV_PCM_RATE_48000,
3076                                        .rate_min = 48000,
3077                                        .rate_max = 48000,
3078                                        .nr_rates = 1,
3079                                        .rate_table = (unsigned int[]) {
3080                                                48000
3081                                        }
3082                                }
3083                        },
3084                        {
3085                                .ifnum = 4,
3086                                .type = QUIRK_MIDI_STANDARD_INTERFACE,
3087                        },
3088                        {
3089                                .ifnum = -1
3090                        }
3091                }
3092        }
3093},
3094
3095/* Microsoft XboxLive Headset/Xbox Communicator */
3096{
3097        USB_DEVICE(0x045e, 0x0283),
3098        .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3099        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3100                .vendor_name = "Microsoft",
3101                .product_name = "XboxLive Headset/Xbox Communicator",
3102                .ifnum = QUIRK_ANY_INTERFACE,
3103                .type = QUIRK_COMPOSITE,
3104                .data = &(const struct snd_usb_audio_quirk[]) {
3105                        {
3106                                /* playback */
3107                                .ifnum = 0,
3108                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3109                                .data = &(const struct audioformat) {
3110                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3111                                        .channels = 1,
3112                                        .iface = 0,
3113                                        .altsetting = 0,
3114                                        .altset_idx = 0,
3115                                        .attributes = 0,
3116                                        .endpoint = 0x04,
3117                                        .ep_attr = 0x05,
3118                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
3119                                        .rate_min = 22050,
3120                                        .rate_max = 22050
3121                                }
3122                        },
3123                        {
3124                                /* capture */
3125                                .ifnum = 1,
3126                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3127                                .data = &(const struct audioformat) {
3128                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3129                                        .channels = 1,
3130                                        .iface = 1,
3131                                        .altsetting = 0,
3132                                        .altset_idx = 0,
3133                                        .attributes = 0,
3134                                        .endpoint = 0x85,
3135                                        .ep_attr = 0x05,
3136                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
3137                                        .rate_min = 16000,
3138                                        .rate_max = 16000
3139                                }
3140                        },
3141                        {
3142                                .ifnum = -1
3143                        }
3144                }
3145        }
3146},
3147
3148/* Reloop Play */
3149{
3150        USB_DEVICE(0x200c, 0x100b),
3151        .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3152        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3153                .ifnum = QUIRK_ANY_INTERFACE,
3154                .type = QUIRK_COMPOSITE,
3155                .data = &(const struct snd_usb_audio_quirk[]) {
3156                        {
3157                                .ifnum = 0,
3158                                .type = QUIRK_AUDIO_STANDARD_MIXER,
3159                        },
3160                        {
3161                                .ifnum = 1,
3162                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3163                                .data = &(const struct audioformat) {
3164                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3165                                        .channels = 4,
3166                                        .iface = 1,
3167                                        .altsetting = 1,
3168                                        .altset_idx = 1,
3169                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3170                                        .endpoint = 0x01,
3171                                        .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3172                                        .rates = SNDRV_PCM_RATE_44100 |
3173                                                 SNDRV_PCM_RATE_48000,
3174                                        .rate_min = 44100,
3175                                        .rate_max = 48000,
3176                                        .nr_rates = 2,
3177                                        .rate_table = (unsigned int[]) {
3178                                                44100, 48000
3179                                        }
3180                                }
3181                        },
3182                        {
3183                                .ifnum = -1
3184                        }
3185                }
3186        }
3187},
3188
3189{
3190        /*
3191         * ZOOM R16/24 in audio interface mode.
3192         * Playback requires an extra four byte LE length indicator
3193         * at the start of each isochronous packet. This quirk is
3194         * enabled in create_standard_audio_quirk().
3195         */
3196        USB_DEVICE(0x1686, 0x00dd),
3197        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3198                .ifnum = QUIRK_ANY_INTERFACE,
3199                .type = QUIRK_COMPOSITE,
3200                .data = (const struct snd_usb_audio_quirk[]) {
3201                        {
3202                                /* Playback  */
3203                                .ifnum = 1,
3204                                .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3205                        },
3206                        {
3207                                /* Capture */
3208                                .ifnum = 2,
3209                                .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3210                        },
3211                        {
3212                                /* Midi */
3213                                .ifnum = 3,
3214                                .type = QUIRK_MIDI_STANDARD_INTERFACE
3215                        },
3216                        {
3217                                .ifnum = -1
3218                        },
3219                }
3220        }
3221},
3222
3223{
3224        /*
3225         * Some USB MIDI devices don't have an audio control interface,
3226         * so we have to grab MIDI streaming interfaces here.
3227         */
3228        .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3229                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3230        .bInterfaceClass = USB_CLASS_AUDIO,
3231        .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3232        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3233                .ifnum = QUIRK_ANY_INTERFACE,
3234                .type = QUIRK_MIDI_STANDARD_INTERFACE
3235        }
3236},
3237
3238/* disabled due to regression for other devices;
3239 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3240 */
3241#if 0
3242{
3243        /*
3244         * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3245         * ID, but it looks like the product ID actually is only for Nura.
3246         * The capture interface does not work at all (even on Windows),
3247         * and only the 48 kHz sample rate works for the playback interface.
3248         */
3249        USB_DEVICE(0x0a12, 0x1243),
3250        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3251                .ifnum = QUIRK_ANY_INTERFACE,
3252                .type = QUIRK_COMPOSITE,
3253                .data = (const struct snd_usb_audio_quirk[]) {
3254                        {
3255                                .ifnum = 0,
3256                                .type = QUIRK_AUDIO_STANDARD_MIXER,
3257                        },
3258                        /* Capture */
3259                        {
3260                                .ifnum = 1,
3261                                .type = QUIRK_IGNORE_INTERFACE,
3262                        },
3263                        /* Playback */
3264                        {
3265                                .ifnum = 2,
3266                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3267                                .data = &(const struct audioformat) {
3268                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3269                                        .channels = 2,
3270                                        .iface = 2,
3271                                        .altsetting = 1,
3272                                        .altset_idx = 1,
3273                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3274                                                UAC_EP_CS_ATTR_SAMPLE_RATE,
3275                                        .endpoint = 0x03,
3276                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
3277                                        .rates = SNDRV_PCM_RATE_48000,
3278                                        .rate_min = 48000,
3279                                        .rate_max = 48000,
3280                                        .nr_rates = 1,
3281                                        .rate_table = (unsigned int[]) {
3282                                                48000
3283                                        }
3284                                }
3285                        },
3286                        {
3287                                .ifnum = -1
3288                        },
3289                }
3290        }
3291},
3292#endif /* disabled */
3293
3294{
3295        /*
3296         * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3297         * even though it advertises more. The capture interface doesn't work
3298         * even on windows.
3299         */
3300        USB_DEVICE(0x19b5, 0x0021),
3301        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3302                .ifnum = QUIRK_ANY_INTERFACE,
3303                .type = QUIRK_COMPOSITE,
3304                .data = (const struct snd_usb_audio_quirk[]) {
3305                        {
3306                                .ifnum = 0,
3307                                .type = QUIRK_AUDIO_STANDARD_MIXER,
3308                        },
3309                        /* Playback */
3310                        {
3311                                .ifnum = 1,
3312                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3313                                .data = &(const struct audioformat) {
3314                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3315                                        .channels = 2,
3316                                        .iface = 1,
3317                                        .altsetting = 1,
3318                                        .altset_idx = 1,
3319                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3320                                                UAC_EP_CS_ATTR_SAMPLE_RATE,
3321                                        .endpoint = 0x03,
3322                                        .ep_attr = USB_ENDPOINT_XFER_ISOC,
3323                                        .rates = SNDRV_PCM_RATE_48000,
3324                                        .rate_min = 48000,
3325                                        .rate_max = 48000,
3326                                        .nr_rates = 1,
3327                                        .rate_table = (unsigned int[]) {
3328                                                48000
3329                                        }
3330                                }
3331                        },
3332                        {
3333                                .ifnum = -1
3334                        },
3335                }
3336        }
3337},
3338/* MOTU Microbook II */
3339{
3340        USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3341        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3342                .vendor_name = "MOTU",
3343                .product_name = "MicroBookII",
3344                .ifnum = QUIRK_ANY_INTERFACE,
3345                .type = QUIRK_COMPOSITE,
3346                .data = (const struct snd_usb_audio_quirk[]) {
3347                        {
3348                                .ifnum = 0,
3349                                .type = QUIRK_AUDIO_STANDARD_MIXER,
3350                        },
3351                        {
3352                                .ifnum = 0,
3353                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3354                                .data = &(const struct audioformat) {
3355                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3356                                        .channels = 6,
3357                                        .iface = 0,
3358                                        .altsetting = 1,
3359                                        .altset_idx = 1,
3360                                        .attributes = 0,
3361                                        .endpoint = 0x84,
3362                                        .rates = SNDRV_PCM_RATE_96000,
3363                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
3364                                                   USB_ENDPOINT_SYNC_ASYNC,
3365                                        .rate_min = 96000,
3366                                        .rate_max = 96000,
3367                                        .nr_rates = 1,
3368                                        .maxpacksize = 0x00d8,
3369                                        .rate_table = (unsigned int[]) {
3370                                                96000
3371                                        }
3372                                }
3373                        },
3374                        {
3375                                .ifnum = 0,
3376                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3377                                .data = &(const struct audioformat) {
3378                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3379                                        .channels = 8,
3380                                        .iface = 0,
3381                                        .altsetting = 1,
3382                                        .altset_idx = 1,
3383                                        .attributes = 0,
3384                                        .endpoint = 0x03,
3385                                        .rates = SNDRV_PCM_RATE_96000,
3386                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
3387                                                   USB_ENDPOINT_SYNC_ASYNC,
3388                                        .rate_min = 96000,
3389                                        .rate_max = 96000,
3390                                        .nr_rates = 1,
3391                                        .maxpacksize = 0x0120,
3392                                        .rate_table = (unsigned int[]) {
3393                                                96000
3394                                        }
3395                                }
3396                        },
3397                        {
3398                                .ifnum = -1
3399                        }
3400                }
3401        }
3402},
3403{
3404        /*
3405         * PIONEER DJ DDJ-SX3
3406         * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3407         * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3408         * The feedback for the output is the input.
3409         */
3410        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3411        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3412                .ifnum = QUIRK_ANY_INTERFACE,
3413                .type = QUIRK_COMPOSITE,
3414                .data = (const struct snd_usb_audio_quirk[]) {
3415                        {
3416                                .ifnum = 0,
3417                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3418                                .data = &(const struct audioformat) {
3419                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
3420                                        .channels = 12,
3421                                        .iface = 0,
3422                                        .altsetting = 1,
3423                                        .altset_idx = 1,
3424                                        .endpoint = 0x05,
3425                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3426                                                   USB_ENDPOINT_SYNC_ASYNC,
3427                                        .rates = SNDRV_PCM_RATE_44100,
3428                                        .rate_min = 44100,
3429                                        .rate_max = 44100,
3430                                        .nr_rates = 1,
3431                                        .rate_table = (unsigned int[]) { 44100 }
3432                                }
3433                        },
3434                        {
3435                                .ifnum = 0,
3436                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3437                                .data = &(const struct audioformat) {
3438                                        .formats = SNDRV_PCM_FMTBIT_S32_LE,
3439                                        .channels = 10,
3440                                        .iface = 0,
3441                                        .altsetting = 1,
3442                                        .altset_idx = 1,
3443                                        .endpoint = 0x86,
3444                                        .ep_idx = 1,
3445                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3446                                                 USB_ENDPOINT_SYNC_ASYNC|
3447                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3448                                        .rates = SNDRV_PCM_RATE_44100,
3449                                        .rate_min = 44100,
3450                                        .rate_max = 44100,
3451                                        .nr_rates = 1,
3452                                        .rate_table = (unsigned int[]) { 44100 }
3453                                }
3454                        },
3455                        {
3456                                .ifnum = -1
3457                        }
3458                }
3459        }
3460},
3461{
3462        /*
3463         * Pioneer DJ DJM-250MK2
3464         * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3465         * and 8 channels in @ 48 fixed (endpoint 0x82).
3466         *
3467         * Both playback and recording is working, even simultaneously.
3468         *
3469         * Playback channels could be mapped to:
3470         *  - CH1
3471         *  - CH2
3472         *  - AUX
3473         *
3474         * Recording channels could be mapped to:
3475         *  - Post CH1 Fader
3476         *  - Post CH2 Fader
3477         *  - Cross Fader A
3478         *  - Cross Fader B
3479         *  - MIC
3480         *  - AUX
3481         *  - REC OUT
3482         *
3483         * There is remaining problem with recording directly from PHONO/LINE.
3484         * If we map a channel to:
3485         *  - CH1 Control Tone PHONO
3486         *  - CH1 Control Tone LINE
3487         *  - CH2 Control Tone PHONO
3488         *  - CH2 Control Tone LINE
3489         * it is silent.
3490         * There is no signal even on other operating systems with official drivers.
3491         * The signal appears only when a supported application is started.
3492         * This needs to be investigated yet...
3493         * (there is quite a lot communication on the USB in both directions)
3494         *
3495         * In current version this mixer could be used for playback
3496         * and for recording from vinyls (through Post CH* Fader)
3497         * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3498         */
3499        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3500        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3501                .ifnum = QUIRK_ANY_INTERFACE,
3502                .type = QUIRK_COMPOSITE,
3503                .data = (const struct snd_usb_audio_quirk[]) {
3504                        {
3505                                .ifnum = 0,
3506                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3507                                .data = &(const struct audioformat) {
3508                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3509                                        .channels = 8, // outputs
3510                                        .iface = 0,
3511                                        .altsetting = 1,
3512                                        .altset_idx = 1,
3513                                        .endpoint = 0x01,
3514                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3515                                                USB_ENDPOINT_SYNC_ASYNC,
3516                                        .rates = SNDRV_PCM_RATE_48000,
3517                                        .rate_min = 48000,
3518                                        .rate_max = 48000,
3519                                        .nr_rates = 1,
3520                                        .rate_table = (unsigned int[]) { 48000 }
3521                                        }
3522                        },
3523                        {
3524                                .ifnum = 0,
3525                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3526                                .data = &(const struct audioformat) {
3527                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3528                                        .channels = 8, // inputs
3529                                        .iface = 0,
3530                                        .altsetting = 1,
3531                                        .altset_idx = 1,
3532                                        .endpoint = 0x82,
3533                                        .ep_idx = 1,
3534                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3535                                                USB_ENDPOINT_SYNC_ASYNC|
3536                                                USB_ENDPOINT_USAGE_IMPLICIT_FB,
3537                                        .rates = SNDRV_PCM_RATE_48000,
3538                                        .rate_min = 48000,
3539                                        .rate_max = 48000,
3540                                        .nr_rates = 1,
3541                                        .rate_table = (unsigned int[]) { 48000 }
3542                                }
3543                        },
3544                        {
3545                                .ifnum = -1
3546                        }
3547                }
3548        }
3549},
3550{
3551        /*
3552         * PIONEER DJ DDJ-RB
3553         * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3554         * The feedback for the output is the dummy input.
3555         */
3556        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3557        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3558                .ifnum = QUIRK_ANY_INTERFACE,
3559                .type = QUIRK_COMPOSITE,
3560                .data = (const struct snd_usb_audio_quirk[]) {
3561                        {
3562                                .ifnum = 0,
3563                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3564                                .data = &(const struct audioformat) {
3565                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3566                                        .channels = 4,
3567                                        .iface = 0,
3568                                        .altsetting = 1,
3569                                        .altset_idx = 1,
3570                                        .endpoint = 0x01,
3571                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3572                                                   USB_ENDPOINT_SYNC_ASYNC,
3573                                        .rates = SNDRV_PCM_RATE_44100,
3574                                        .rate_min = 44100,
3575                                        .rate_max = 44100,
3576                                        .nr_rates = 1,
3577                                        .rate_table = (unsigned int[]) { 44100 }
3578                                }
3579                        },
3580                        {
3581                                .ifnum = 0,
3582                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3583                                .data = &(const struct audioformat) {
3584                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3585                                        .channels = 2,
3586                                        .iface = 0,
3587                                        .altsetting = 1,
3588                                        .altset_idx = 1,
3589                                        .endpoint = 0x82,
3590                                        .ep_idx = 1,
3591                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3592                                                 USB_ENDPOINT_SYNC_ASYNC|
3593                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3594                                        .rates = SNDRV_PCM_RATE_44100,
3595                                        .rate_min = 44100,
3596                                        .rate_max = 44100,
3597                                        .nr_rates = 1,
3598                                        .rate_table = (unsigned int[]) { 44100 }
3599                                }
3600                        },
3601                        {
3602                                .ifnum = -1
3603                        }
3604                }
3605        }
3606},
3607
3608{
3609        /*
3610         * PIONEER DJ DDJ-RR
3611         * PCM is 6 channels out & 4 channels in @ 44.1 fixed
3612         */
3613        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000d),
3614        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3615                .ifnum = QUIRK_ANY_INTERFACE,
3616                .type = QUIRK_COMPOSITE,
3617                .data = (const struct snd_usb_audio_quirk[]) {
3618                        {
3619                                .ifnum = 0,
3620                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3621                                .data = &(const struct audioformat) {
3622                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3623                                        .channels = 6, //Master, Headphones & Booth
3624                                        .iface = 0,
3625                                        .altsetting = 1,
3626                                        .altset_idx = 1,
3627                                        .endpoint = 0x01,
3628                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3629                                                   USB_ENDPOINT_SYNC_ASYNC,
3630                                        .rates = SNDRV_PCM_RATE_44100,
3631                                        .rate_min = 44100,
3632                                        .rate_max = 44100,
3633                                        .nr_rates = 1,
3634                                        .rate_table = (unsigned int[]) { 44100 }
3635                                }
3636                        },
3637                        {
3638                                .ifnum = 0,
3639                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3640                                .data = &(const struct audioformat) {
3641                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3642                                        .channels = 4, //2x RCA inputs (CH1 & CH2)
3643                                        .iface = 0,
3644                                        .altsetting = 1,
3645                                        .altset_idx = 1,
3646                                        .endpoint = 0x82,
3647                                        .ep_idx = 1,
3648                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3649                                                 USB_ENDPOINT_SYNC_ASYNC|
3650                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3651                                        .rates = SNDRV_PCM_RATE_44100,
3652                                        .rate_min = 44100,
3653                                        .rate_max = 44100,
3654                                        .nr_rates = 1,
3655                                        .rate_table = (unsigned int[]) { 44100 }
3656                                }
3657                        },
3658                        {
3659                                .ifnum = -1
3660                        }
3661                }
3662        }
3663},
3664
3665{
3666        /*
3667         * PIONEER DJ DDJ-SR2
3668         * PCM is 4 channels out, 6 channels in @ 44.1 fixed
3669         * The Feedback for the output is the input
3670         */
3671        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001e),
3672                .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3673                .ifnum = QUIRK_ANY_INTERFACE,
3674                .type = QUIRK_COMPOSITE,
3675                .data = (const struct snd_usb_audio_quirk[]) {
3676                        {
3677                                .ifnum = 0,
3678                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3679                                .data = &(const struct audioformat) {
3680                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3681                                        .channels = 4,
3682                                        .iface = 0,
3683                                        .altsetting = 1,
3684                                        .altset_idx = 1,
3685                                        .endpoint = 0x01,
3686                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3687                                                USB_ENDPOINT_SYNC_ASYNC,
3688                                        .rates = SNDRV_PCM_RATE_44100,
3689                                        .rate_min = 44100,
3690                                        .rate_max = 44100,
3691                                        .nr_rates = 1,
3692                                        .rate_table = (unsigned int[]) { 44100 }
3693                                }
3694                        },
3695                        {
3696                                .ifnum = 0,
3697                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3698                                .data = &(const struct audioformat) {
3699                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3700                                        .channels = 6,
3701                                        .iface = 0,
3702                                        .altsetting = 1,
3703                                        .altset_idx = 1,
3704                                        .endpoint = 0x82,
3705                                        .ep_idx = 1,
3706                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3707                                                USB_ENDPOINT_SYNC_ASYNC|
3708                                        USB_ENDPOINT_USAGE_IMPLICIT_FB,
3709                                        .rates = SNDRV_PCM_RATE_44100,
3710                                        .rate_min = 44100,
3711                                        .rate_max = 44100,
3712                                        .nr_rates = 1,
3713                                        .rate_table = (unsigned int[]) { 44100 }
3714                                }
3715                        },
3716                        {
3717                                .ifnum = -1
3718                        }
3719                }
3720        }
3721},
3722
3723{
3724        /*
3725         * Pioneer DJ DJM-900NXS2
3726         * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3727         */
3728        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3729        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3730                .ifnum = QUIRK_ANY_INTERFACE,
3731                .type = QUIRK_COMPOSITE,
3732                .data = (const struct snd_usb_audio_quirk[]) {
3733                        {
3734                                .ifnum = 0,
3735                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3736                                .data = &(const struct audioformat) {
3737                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3738                                        .channels = 10,
3739                                        .iface = 0,
3740                                        .altsetting = 1,
3741                                        .altset_idx = 1,
3742                                        .endpoint = 0x01,
3743                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3744                                            USB_ENDPOINT_SYNC_ASYNC,
3745                                        .rates = SNDRV_PCM_RATE_44100|
3746                                            SNDRV_PCM_RATE_48000|
3747                                            SNDRV_PCM_RATE_96000,
3748                                        .rate_min = 44100,
3749                                        .rate_max = 96000,
3750                                        .nr_rates = 3,
3751                                        .rate_table = (unsigned int[]) {
3752                                                44100, 48000, 96000
3753                                        }
3754                                }
3755                        },
3756                        {
3757                                .ifnum = 0,
3758                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3759                                .data = &(const struct audioformat) {
3760                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3761                                        .channels = 12,
3762                                        .iface = 0,
3763                                        .altsetting = 1,
3764                                        .altset_idx = 1,
3765                                        .endpoint = 0x82,
3766                                        .ep_idx = 1,
3767                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3768                                            USB_ENDPOINT_SYNC_ASYNC|
3769                                            USB_ENDPOINT_USAGE_IMPLICIT_FB,
3770                                        .rates = SNDRV_PCM_RATE_44100|
3771                                            SNDRV_PCM_RATE_48000|
3772                                            SNDRV_PCM_RATE_96000,
3773                                        .rate_min = 44100,
3774                                        .rate_max = 96000,
3775                                        .nr_rates = 3,
3776                                        .rate_table = (unsigned int[]) {
3777                                                44100, 48000, 96000
3778                                        }
3779                                }
3780                        },
3781                        {
3782                                .ifnum = -1
3783                        }
3784                }
3785        }
3786},
3787
3788/*
3789 * MacroSilicon MS2109 based HDMI capture cards
3790 *
3791 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3792 * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
3793 * they pretend to be 96kHz mono as a workaround for stereo being broken
3794 * by that...
3795 *
3796 * They also have an issue with initial stream alignment that causes the
3797 * channels to be swapped and out of phase, which is dealt with in quirks.c.
3798 */
3799{
3800        USB_AUDIO_DEVICE(0x534d, 0x2109),
3801        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3802                .vendor_name = "MacroSilicon",
3803                .product_name = "MS2109",
3804                .ifnum = QUIRK_ANY_INTERFACE,
3805                .type = QUIRK_COMPOSITE,
3806                .data = &(const struct snd_usb_audio_quirk[]) {
3807                        {
3808                                .ifnum = 2,
3809                                .type = QUIRK_AUDIO_STANDARD_MIXER,
3810                        },
3811                        {
3812                                .ifnum = 3,
3813                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3814                                .data = &(const struct audioformat) {
3815                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
3816                                        .channels = 2,
3817                                        .iface = 3,
3818                                        .altsetting = 1,
3819                                        .altset_idx = 1,
3820                                        .attributes = 0,
3821                                        .endpoint = 0x82,
3822                                        .ep_attr = USB_ENDPOINT_XFER_ISOC |
3823                                                USB_ENDPOINT_SYNC_ASYNC,
3824                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
3825                                        .rate_min = 48000,
3826                                        .rate_max = 48000,
3827                                }
3828                        },
3829                        {
3830                                .ifnum = -1
3831                        }
3832                }
3833        }
3834},
3835{
3836        /*
3837         * Pioneer DJ DJM-750
3838         * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE
3839         */
3840        USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f),
3841        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3842                .ifnum = QUIRK_ANY_INTERFACE,
3843                .type = QUIRK_COMPOSITE,
3844                .data = (const struct snd_usb_audio_quirk[]) {
3845                        {
3846                                .ifnum = 0,
3847                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3848                                .data = &(const struct audioformat) {
3849                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3850                                        .channels = 8,
3851                                        .iface = 0,
3852                                        .altsetting = 1,
3853                                        .altset_idx = 1,
3854                                        .endpoint = 0x05,
3855                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3856                                            USB_ENDPOINT_SYNC_ASYNC,
3857                                        .rates = SNDRV_PCM_RATE_44100|
3858                                                SNDRV_PCM_RATE_48000|
3859                                                SNDRV_PCM_RATE_96000,
3860                                        .rate_min = 44100,
3861                                        .rate_max = 96000,
3862                                        .nr_rates = 3,
3863                                        .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3864                                }
3865                        },
3866                        {
3867                                .ifnum = 0,
3868                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3869                                .data = &(const struct audioformat) {
3870                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3871                                        .channels = 8,
3872                                        .iface = 0,
3873                                        .altsetting = 1,
3874                                        .altset_idx = 1,
3875                                        .endpoint = 0x86,
3876                                        .ep_idx = 1,
3877                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3878                                                USB_ENDPOINT_SYNC_ASYNC|
3879                                                USB_ENDPOINT_USAGE_IMPLICIT_FB,
3880                                        .rates = SNDRV_PCM_RATE_44100|
3881                                                SNDRV_PCM_RATE_48000|
3882                                                SNDRV_PCM_RATE_96000,
3883                                        .rate_min = 44100,
3884                                        .rate_max = 96000,
3885                                        .nr_rates = 3,
3886                                        .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3887                                }
3888                        },
3889                        {
3890                                .ifnum = -1
3891                        }
3892                }
3893        }
3894},
3895{
3896        /*
3897         * Pioneer DJ DJM-850
3898         * 8 channels playback and 8 channels capture @ 44.1/48/96kHz S24LE
3899         * Playback on EP 0x05
3900         * Capture on EP 0x86
3901         */
3902        USB_DEVICE_VENDOR_SPEC(0x08e4, 0x0163),
3903        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3904                .ifnum = QUIRK_ANY_INTERFACE,
3905                .type = QUIRK_COMPOSITE,
3906                .data = (const struct snd_usb_audio_quirk[]) {
3907                        {
3908                                .ifnum = 0,
3909                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3910                                .data = &(const struct audioformat) {
3911                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3912                                        .channels = 8,
3913                                        .iface = 0,
3914                                        .altsetting = 1,
3915                                        .altset_idx = 1,
3916                                        .endpoint = 0x05,
3917                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3918                                            USB_ENDPOINT_SYNC_ASYNC|
3919                                                USB_ENDPOINT_USAGE_DATA,
3920                                        .rates = SNDRV_PCM_RATE_44100|
3921                                                SNDRV_PCM_RATE_48000|
3922                                                SNDRV_PCM_RATE_96000,
3923                                        .rate_min = 44100,
3924                                        .rate_max = 96000,
3925                                        .nr_rates = 3,
3926                                        .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3927                                }
3928                        },
3929                        {
3930                                .ifnum = 0,
3931                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3932                                .data = &(const struct audioformat) {
3933                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3934                                        .channels = 8,
3935                                        .iface = 0,
3936                                        .altsetting = 1,
3937                                        .altset_idx = 1,
3938                                        .endpoint = 0x86,
3939                                        .ep_idx = 1,
3940                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3941                                                USB_ENDPOINT_SYNC_ASYNC|
3942                                                USB_ENDPOINT_USAGE_DATA,
3943                                        .rates = SNDRV_PCM_RATE_44100|
3944                                                SNDRV_PCM_RATE_48000|
3945                                                SNDRV_PCM_RATE_96000,
3946                                        .rate_min = 44100,
3947                                        .rate_max = 96000,
3948                                        .nr_rates = 3,
3949                                        .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3950                                }
3951                        },
3952                        {
3953                                .ifnum = -1
3954                        }
3955                }
3956        }
3957},
3958{
3959        /*
3960         * Pioneer DJ DJM-450
3961         * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3962         * and 8 channels in @ 48 fixed (endpoint 0x82).
3963         */
3964        USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013),
3965        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3966                .ifnum = QUIRK_ANY_INTERFACE,
3967                .type = QUIRK_COMPOSITE,
3968                .data = (const struct snd_usb_audio_quirk[]) {
3969                        {
3970                                .ifnum = 0,
3971                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3972                                .data = &(const struct audioformat) {
3973                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3974                                        .channels = 8, // outputs
3975                                        .iface = 0,
3976                                        .altsetting = 1,
3977                                        .altset_idx = 1,
3978                                        .endpoint = 0x01,
3979                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
3980                                                USB_ENDPOINT_SYNC_ASYNC,
3981                                        .rates = SNDRV_PCM_RATE_48000,
3982                                        .rate_min = 48000,
3983                                        .rate_max = 48000,
3984                                        .nr_rates = 1,
3985                                        .rate_table = (unsigned int[]) { 48000 }
3986                                        }
3987                        },
3988                        {
3989                                .ifnum = 0,
3990                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3991                                .data = &(const struct audioformat) {
3992                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3993                                        .channels = 8, // inputs
3994                                        .iface = 0,
3995                                        .altsetting = 1,
3996                                        .altset_idx = 1,
3997                                        .endpoint = 0x82,
3998                                        .ep_idx = 1,
3999                                        .ep_attr = USB_ENDPOINT_XFER_ISOC|
4000                                                USB_ENDPOINT_SYNC_ASYNC|

4001                                                USB_ENDPOINT_USAGE_IMPLICIT_FB,
4002                                        .rates = SNDRV_PCM_RATE_48000,
4003                                        .rate_min = 48000,
4004                                        .rate_max = 48000,
4005                                        .nr_rates = 1,
4006                                        .rate_table = (unsigned int[]) { 48000 }
4007                                }
4008                        },
4009                        {
4010                                .ifnum = -1
4011                        }
4012                }
4013        }
4014},
4015{
4016        /*
4017         * Sennheiser GSP670
4018         * Change order of interfaces loaded
4019         */
4020        USB_DEVICE(0x1395, 0x0300),
4021        .bInterfaceClass = USB_CLASS_PER_INTERFACE,
4022        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4023                .ifnum = QUIRK_ANY_INTERFACE,
4024                .type = QUIRK_COMPOSITE,
4025                .data = &(const struct snd_usb_audio_quirk[]) {
4026                        // Communication
4027                        {
4028                                .ifnum = 3,
4029                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
4030                        },
4031                        // Recording
4032                        {
4033                                .ifnum = 4,
4034                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
4035                        },
4036                        // Main
4037                        {
4038                                .ifnum = 1,
4039                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
4040                        },
4041                        {
4042                                .ifnum = -1
4043                        }
4044                }
4045        }
4046},
4047
4048#undef USB_DEVICE_VENDOR_SPEC
4049#undef USB_AUDIO_DEVICE
4050