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 /* Another standard entry matching with vid/pid and the audio class */
  39 #define USB_AUDIO_CLASS(vend, prod) \
  40         .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
  41                        USB_DEVICE_ID_MATCH_INT_CLASS, \
  42         .idVendor = vend, \
  43         .idProduct = prod, \
  44         .bInterfaceClass = USB_CLASS_AUDIO
  45
  46 /* FTDI devices */
  47 {
  48         USB_DEVICE(0x0403, 0xb8d8),
  49         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  50                 /* .vendor_name = "STARR LABS", */
  51                 /* .product_name = "Starr Labs MIDI USB device", */
  52                 .ifnum = 0,
  53                 .type = QUIRK_MIDI_FTDI
  54         }
  55 },
  56
  57 {
  58         /* Creative BT-D1 */
  59         USB_DEVICE(0x041e, 0x0005),
  60         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  61                 .ifnum = 1,
  62                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  63                 .data = &(const struct audioformat) {
  64                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
  65                         .channels = 2,
  66                         .iface = 1,
  67                         .altsetting = 1,
  68                         .altset_idx = 1,
  69                         .endpoint = 0x03,
  70                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
  71                         .attributes = 0,
  72                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
  73                         .rate_min = 48000,
  74                         .rate_max = 48000,
  75                 }
  76         }
  77 },
  78
  79 /* E-Mu 0202 USB */
  80 { USB_AUDIO_CLASS(0x041e, 0x3f02) },
  81 /* E-Mu 0404 USB */
  82 { USB_AUDIO_CLASS(0x041e, 0x3f04) },
  83 /* E-Mu Tracker Pre */
  84 { USB_AUDIO_CLASS(0x041e, 0x3f0a) },
  85 /* E-Mu 0204 USB */
  86 { USB_AUDIO_CLASS(0x041e, 0x3f19) },
  87
  88 /*
  89  * HP Wireless Audio
  90  * When not ignored, causes instability issues for some users, forcing them to
  91  * skip the entire module.
  92  */
  93 {
  94         USB_DEVICE(0x0424, 0xb832),
  95         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  96                 .vendor_name = "Standard Microsystems Corp.",
  97                 .product_name = "HP Wireless Audio",
  98                 .ifnum = QUIRK_ANY_INTERFACE,
  99                 .type = QUIRK_COMPOSITE,
 100                 .data = (const struct snd_usb_audio_quirk[]) {
 101                         /* Mixer */
 102                         {
 103                                 .ifnum = 0,
 104                                 .type = QUIRK_IGNORE_INTERFACE,
 105                         },
 106                         /* Playback */
 107                         {
 108                                 .ifnum = 1,
 109                                 .type = QUIRK_IGNORE_INTERFACE,
 110                         },
 111                         /* Capture */
 112                         {
 113                                 .ifnum = 2,
 114                                 .type = QUIRK_IGNORE_INTERFACE,
 115                         },
 116                         /* HID Device, .ifnum = 3 */
 117                         {
 118                                 .ifnum = -1,
 119                         }
 120                 }
 121         }
 122 },
 123
 124 /*
 125  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
 126  * class matches do not take effect without an explicit ID match.
 127  */
 128 { USB_AUDIO_DEVICE(0x046d, 0x0850) },
 129 { USB_AUDIO_DEVICE(0x046d, 0x08ae) },
 130 { USB_AUDIO_DEVICE(0x046d, 0x08c6) },
 131 { USB_AUDIO_DEVICE(0x046d, 0x08f0) },
 132 { USB_AUDIO_DEVICE(0x046d, 0x08f5) },
 133 { USB_AUDIO_DEVICE(0x046d, 0x08f6) },
 134 { USB_AUDIO_DEVICE(0x046d, 0x0990) },
 135
 136 /*
 137  * Yamaha devices
 138  */
 139
 140 #define YAMAHA_DEVICE(id, name) { \
 141         USB_DEVICE(0x0499, id), \
 142         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 143                 .vendor_name = "Yamaha", \
 144                 .product_name = name, \
 145                 .ifnum = QUIRK_ANY_INTERFACE, \
 146                 .type = QUIRK_MIDI_YAMAHA \
 147         } \
 148 }
 149 #define YAMAHA_INTERFACE(id, intf, name) { \
 150         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 151         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 152                 .vendor_name = "Yamaha", \
 153                 .product_name = name, \
 154                 .ifnum = intf, \
 155                 .type = QUIRK_MIDI_YAMAHA \
 156         } \
 157 }
 158 YAMAHA_DEVICE(0x1000, "UX256"),
 159 YAMAHA_DEVICE(0x1001, "MU1000"),
 160 YAMAHA_DEVICE(0x1002, "MU2000"),
 161 YAMAHA_DEVICE(0x1003, "MU500"),
 162 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 163 YAMAHA_DEVICE(0x1005, "MOTIF6"),
 164 YAMAHA_DEVICE(0x1006, "MOTIF7"),
 165 YAMAHA_DEVICE(0x1007, "MOTIF8"),
 166 YAMAHA_DEVICE(0x1008, "UX96"),
 167 YAMAHA_DEVICE(0x1009, "UX16"),
 168 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 169 YAMAHA_DEVICE(0x100c, "UC-MX"),
 170 YAMAHA_DEVICE(0x100d, "UC-KX"),
 171 YAMAHA_DEVICE(0x100e, "S08"),
 172 YAMAHA_DEVICE(0x100f, "CLP-150"),
 173 YAMAHA_DEVICE(0x1010, "CLP-170"),
 174 YAMAHA_DEVICE(0x1011, "P-250"),
 175 YAMAHA_DEVICE(0x1012, "TYROS"),
 176 YAMAHA_DEVICE(0x1013, "PF-500"),
 177 YAMAHA_DEVICE(0x1014, "S90"),
 178 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 179 YAMAHA_DEVICE(0x1016, "MDP-5"),
 180 YAMAHA_DEVICE(0x1017, "CVP-204"),
 181 YAMAHA_DEVICE(0x1018, "CVP-206"),
 182 YAMAHA_DEVICE(0x1019, "CVP-208"),
 183 YAMAHA_DEVICE(0x101a, "CVP-210"),
 184 YAMAHA_DEVICE(0x101b, "PSR-1100"),
 185 YAMAHA_DEVICE(0x101c, "PSR-2100"),
 186 YAMAHA_DEVICE(0x101d, "CLP-175"),
 187 YAMAHA_DEVICE(0x101e, "PSR-K1"),
 188 YAMAHA_DEVICE(0x101f, "EZ-J24"),
 189 YAMAHA_DEVICE(0x1020, "EZ-250i"),
 190 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 191 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 192 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 193 YAMAHA_DEVICE(0x1024, "CVP-301"),
 194 YAMAHA_DEVICE(0x1025, "CVP-303"),
 195 YAMAHA_DEVICE(0x1026, "CVP-305"),
 196 YAMAHA_DEVICE(0x1027, "CVP-307"),
 197 YAMAHA_DEVICE(0x1028, "CVP-309"),
 198 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 199 YAMAHA_DEVICE(0x102a, "PSR-1500"),
 200 YAMAHA_DEVICE(0x102b, "PSR-3000"),
 201 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 202 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 203 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 204 YAMAHA_DEVICE(0x1032, "DGX-305"),
 205 YAMAHA_DEVICE(0x1033, "DGX-505"),
 206 YAMAHA_DEVICE(0x1034, NULL),
 207 YAMAHA_DEVICE(0x1035, NULL),
 208 YAMAHA_DEVICE(0x1036, NULL),
 209 YAMAHA_DEVICE(0x1037, NULL),
 210 YAMAHA_DEVICE(0x1038, NULL),
 211 YAMAHA_DEVICE(0x1039, NULL),
 212 YAMAHA_DEVICE(0x103a, NULL),
 213 YAMAHA_DEVICE(0x103b, NULL),
 214 YAMAHA_DEVICE(0x103c, NULL),
 215 YAMAHA_DEVICE(0x103d, NULL),
 216 YAMAHA_DEVICE(0x103e, NULL),
 217 YAMAHA_DEVICE(0x103f, NULL),
 218 YAMAHA_DEVICE(0x1040, NULL),
 219 YAMAHA_DEVICE(0x1041, NULL),
 220 YAMAHA_DEVICE(0x1042, NULL),
 221 YAMAHA_DEVICE(0x1043, NULL),
 222 YAMAHA_DEVICE(0x1044, NULL),
 223 YAMAHA_DEVICE(0x1045, NULL),
 224 YAMAHA_INTERFACE(0x104e, 0, NULL),
 225 YAMAHA_DEVICE(0x104f, NULL),
 226 YAMAHA_DEVICE(0x1050, NULL),
 227 YAMAHA_DEVICE(0x1051, NULL),
 228 YAMAHA_DEVICE(0x1052, NULL),
 229 YAMAHA_INTERFACE(0x1053, 0, NULL),
 230 YAMAHA_INTERFACE(0x1054, 0, NULL),
 231 YAMAHA_DEVICE(0x1055, NULL),
 232 YAMAHA_DEVICE(0x1056, NULL),
 233 YAMAHA_DEVICE(0x1057, NULL),
 234 YAMAHA_DEVICE(0x1058, NULL),
 235 YAMAHA_DEVICE(0x1059, NULL),
 236 YAMAHA_DEVICE(0x105a, NULL),
 237 YAMAHA_DEVICE(0x105b, NULL),
 238 YAMAHA_DEVICE(0x105c, NULL),
 239 YAMAHA_DEVICE(0x105d, NULL),
 240 {
 241         USB_DEVICE(0x0499, 0x1503),
 242         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 243                 /* .vendor_name = "Yamaha", */
 244                 /* .product_name = "MOX6/MOX8", */
 245                 .ifnum = QUIRK_ANY_INTERFACE,
 246                 .type = QUIRK_COMPOSITE,
 247                 .data = (const struct snd_usb_audio_quirk[]) {
 248                         {
 249                                 .ifnum = 1,
 250                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 251                         },
 252                         {
 253                                 .ifnum = 2,
 254                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 255                         },
 256                         {
 257                                 .ifnum = 3,
 258                                 .type = QUIRK_MIDI_YAMAHA
 259                         },
 260                         {
 261                                 .ifnum = -1
 262                         }
 263                 }
 264         }
 265 },
 266 {
 267         USB_DEVICE(0x0499, 0x1507),
 268         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 269                 /* .vendor_name = "Yamaha", */
 270                 /* .product_name = "THR10", */
 271                 .ifnum = QUIRK_ANY_INTERFACE,
 272                 .type = QUIRK_COMPOSITE,
 273                 .data = (const struct snd_usb_audio_quirk[]) {
 274                         {
 275                                 .ifnum = 1,
 276                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 277                         },
 278                         {
 279                                 .ifnum = 2,
 280                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 281                         },
 282                         {
 283                                 .ifnum = 3,
 284                                 .type = QUIRK_MIDI_YAMAHA
 285                         },
 286                         {
 287                                 .ifnum = -1
 288                         }
 289                 }
 290         }
 291 },
 292 {
 293         USB_DEVICE(0x0499, 0x1509),
 294         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 295                 /* .vendor_name = "Yamaha", */
 296                 /* .product_name = "Steinberg UR22", */
 297                 .ifnum = QUIRK_ANY_INTERFACE,
 298                 .type = QUIRK_COMPOSITE,
 299                 .data = (const struct snd_usb_audio_quirk[]) {
 300                         {
 301                                 .ifnum = 1,
 302                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 303                         },
 304                         {
 305                                 .ifnum = 2,
 306                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 307                         },
 308                         {
 309                                 .ifnum = 3,
 310                                 .type = QUIRK_MIDI_YAMAHA
 311                         },
 312                         {
 313                                 .ifnum = 4,
 314                                 .type = QUIRK_IGNORE_INTERFACE
 315                         },
 316                         {
 317                                 .ifnum = -1
 318                         }
 319                 }
 320         }
 321 },
 322 {
 323         USB_DEVICE(0x0499, 0x150a),
 324         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 325                 /* .vendor_name = "Yamaha", */
 326                 /* .product_name = "THR5A", */
 327                 .ifnum = QUIRK_ANY_INTERFACE,
 328                 .type = QUIRK_COMPOSITE,
 329                 .data = (const struct snd_usb_audio_quirk[]) {
 330                         {
 331                                 .ifnum = 1,
 332                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 333                         },
 334                         {
 335                                 .ifnum = 2,
 336                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 337                         },
 338                         {
 339                                 .ifnum = 3,
 340                                 .type = QUIRK_MIDI_YAMAHA
 341                         },
 342                         {
 343                                 .ifnum = -1
 344                         }
 345                 }
 346         }
 347 },
 348 {
 349         USB_DEVICE(0x0499, 0x150c),
 350         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 351                 /* .vendor_name = "Yamaha", */
 352                 /* .product_name = "THR10C", */
 353                 .ifnum = QUIRK_ANY_INTERFACE,
 354                 .type = QUIRK_COMPOSITE,
 355                 .data = (const struct snd_usb_audio_quirk[]) {
 356                         {
 357                                 .ifnum = 1,
 358                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 359                         },
 360                         {
 361                                 .ifnum = 2,
 362                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 363                         },
 364                         {
 365                                 .ifnum = 3,
 366                                 .type = QUIRK_MIDI_YAMAHA
 367                         },
 368                         {
 369                                 .ifnum = -1
 370                         }
 371                 }
 372         }
 373 },
 374 YAMAHA_DEVICE(0x2000, "DGP-7"),
 375 YAMAHA_DEVICE(0x2001, "DGP-5"),
 376 YAMAHA_DEVICE(0x2002, NULL),
 377 YAMAHA_DEVICE(0x2003, NULL),
 378 YAMAHA_DEVICE(0x5000, "CS1D"),
 379 YAMAHA_DEVICE(0x5001, "DSP1D"),
 380 YAMAHA_DEVICE(0x5002, "DME32"),
 381 YAMAHA_DEVICE(0x5003, "DM2000"),
 382 YAMAHA_DEVICE(0x5004, "02R96"),
 383 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 384 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 385 YAMAHA_DEVICE(0x5007, "DM1000"),
 386 YAMAHA_DEVICE(0x5008, "01V96"),
 387 YAMAHA_DEVICE(0x5009, "SPX2000"),
 388 YAMAHA_DEVICE(0x500a, "PM5D"),
 389 YAMAHA_DEVICE(0x500b, "DME64N"),
 390 YAMAHA_DEVICE(0x500c, "DME24N"),
 391 YAMAHA_DEVICE(0x500d, NULL),
 392 YAMAHA_DEVICE(0x500e, NULL),
 393 YAMAHA_DEVICE(0x500f, NULL),
 394 YAMAHA_DEVICE(0x7000, "DTX"),
 395 YAMAHA_DEVICE(0x7010, "UB99"),
 396 #undef YAMAHA_DEVICE
 397 #undef YAMAHA_INTERFACE
 398 /* this catches most recent vendor-specific Yamaha devices */
 399 {
 400         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
 401                        USB_DEVICE_ID_MATCH_INT_CLASS,
 402         .idVendor = 0x0499,
 403         .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
 404         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
 405                 .ifnum = QUIRK_ANY_INTERFACE,
 406                 .type = QUIRK_AUTODETECT
 407         }
 408 },
 409
 410 /*
 411  * Roland/RolandED/Edirol/BOSS devices
 412  */
 413 {
 414         USB_DEVICE(0x0582, 0x0000),
 415         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 416                 .vendor_name = "Roland",
 417                 .product_name = "UA-100",
 418                 .ifnum = QUIRK_ANY_INTERFACE,
 419                 .type = QUIRK_COMPOSITE,
 420                 .data = (const struct snd_usb_audio_quirk[]) {
 421                         {
 422                                 .ifnum = 0,
 423                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 424                                 .data = & (const struct audioformat) {
 425                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 426                                         .channels = 4,
 427                                         .iface = 0,
 428                                         .altsetting = 1,
 429                                         .altset_idx = 1,
 430                                         .attributes = 0,
 431                                         .endpoint = 0x01,
 432                                         .ep_attr = 0x09,
 433                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 434                                         .rate_min = 44100,
 435                                         .rate_max = 44100,
 436                                 }
 437                         },
 438                         {
 439                                 .ifnum = 1,
 440                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 441                                 .data = & (const struct audioformat) {
 442                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 443                                         .channels = 2,
 444                                         .iface = 1,
 445                                         .altsetting = 1,
 446                                         .altset_idx = 1,
 447                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX,
 448                                         .endpoint = 0x81,
 449                                         .ep_attr = 0x05,
 450                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 451                                         .rate_min = 44100,
 452                                         .rate_max = 44100,
 453                                 }
 454                         },
 455                         {
 456                                 .ifnum = 2,
 457                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 458                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 459                                         .out_cables = 0x0007,
 460                                         .in_cables  = 0x0007
 461                                 }
 462                         },
 463                         {
 464                                 .ifnum = -1
 465                         }
 466                 }
 467         }
 468 },
 469 {
 470         USB_DEVICE(0x0582, 0x0002),
 471         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 472                 .vendor_name = "EDIROL",
 473                 .product_name = "UM-4",
 474                 .ifnum = QUIRK_ANY_INTERFACE,
 475                 .type = QUIRK_COMPOSITE,
 476                 .data = (const struct snd_usb_audio_quirk[]) {
 477                         {
 478                                 .ifnum = 0,
 479                                 .type = QUIRK_IGNORE_INTERFACE
 480                         },
 481                         {
 482                                 .ifnum = 1,
 483                                 .type = QUIRK_IGNORE_INTERFACE
 484                         },
 485                         {
 486                                 .ifnum = 2,
 487                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 488                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 489                                         .out_cables = 0x000f,
 490                                         .in_cables  = 0x000f
 491                                 }
 492                         },
 493                         {
 494                                 .ifnum = -1
 495                         }
 496                 }
 497         }
 498 },
 499 {
 500         USB_DEVICE(0x0582, 0x0003),
 501         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 502                 .vendor_name = "Roland",
 503                 .product_name = "SC-8850",
 504                 .ifnum = QUIRK_ANY_INTERFACE,
 505                 .type = QUIRK_COMPOSITE,
 506                 .data = (const struct snd_usb_audio_quirk[]) {
 507                         {
 508                                 .ifnum = 0,
 509                                 .type = QUIRK_IGNORE_INTERFACE
 510                         },
 511                         {
 512                                 .ifnum = 1,
 513                                 .type = QUIRK_IGNORE_INTERFACE
 514                         },
 515                         {
 516                                 .ifnum = 2,
 517                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 518                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 519                                         .out_cables = 0x003f,
 520                                         .in_cables  = 0x003f
 521                                 }
 522                         },
 523                         {
 524                                 .ifnum = -1
 525                         }
 526                 }
 527         }
 528 },
 529 {
 530         USB_DEVICE(0x0582, 0x0004),
 531         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 532                 .vendor_name = "Roland",
 533                 .product_name = "U-8",
 534                 .ifnum = QUIRK_ANY_INTERFACE,
 535                 .type = QUIRK_COMPOSITE,
 536                 .data = (const struct snd_usb_audio_quirk[]) {
 537                         {
 538                                 .ifnum = 0,
 539                                 .type = QUIRK_IGNORE_INTERFACE
 540                         },
 541                         {
 542                                 .ifnum = 1,
 543                                 .type = QUIRK_IGNORE_INTERFACE
 544                         },
 545                         {
 546                                 .ifnum = 2,
 547                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 548                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 549                                         .out_cables = 0x0005,
 550                                         .in_cables  = 0x0005
 551                                 }
 552                         },
 553                         {
 554                                 .ifnum = -1
 555                         }
 556                 }
 557         }
 558 },
 559 {
 560         /* Has ID 0x0099 when not in "Advanced Driver" mode.
 561          * The UM-2EX has only one input, but we cannot detect this. */
 562         USB_DEVICE(0x0582, 0x0005),
 563         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 564                 .vendor_name = "EDIROL",
 565                 .product_name = "UM-2",
 566                 .ifnum = QUIRK_ANY_INTERFACE,
 567                 .type = QUIRK_COMPOSITE,
 568                 .data = (const struct snd_usb_audio_quirk[]) {
 569                         {
 570                                 .ifnum = 0,
 571                                 .type = QUIRK_IGNORE_INTERFACE
 572                         },
 573                         {
 574                                 .ifnum = 1,
 575                                 .type = QUIRK_IGNORE_INTERFACE
 576                         },
 577                         {
 578                                 .ifnum = 2,
 579                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 580                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 581                                         .out_cables = 0x0003,
 582                                         .in_cables  = 0x0003
 583                                 }
 584                         },
 585                         {
 586                                 .ifnum = -1
 587                         }
 588                 }
 589         }
 590 },
 591 {
 592         USB_DEVICE(0x0582, 0x0007),
 593         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 594                 .vendor_name = "Roland",
 595                 .product_name = "SC-8820",
 596                 .ifnum = QUIRK_ANY_INTERFACE,
 597                 .type = QUIRK_COMPOSITE,
 598                 .data = (const struct snd_usb_audio_quirk[]) {
 599                         {
 600                                 .ifnum = 0,
 601                                 .type = QUIRK_IGNORE_INTERFACE
 602                         },
 603                         {
 604                                 .ifnum = 1,
 605                                 .type = QUIRK_IGNORE_INTERFACE
 606                         },
 607                         {
 608                                 .ifnum = 2,
 609                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 610                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 611                                         .out_cables = 0x0013,
 612                                         .in_cables  = 0x0013
 613                                 }
 614                         },
 615                         {
 616                                 .ifnum = -1
 617                         }
 618                 }
 619         }
 620 },
 621 {
 622         USB_DEVICE(0x0582, 0x0008),
 623         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 624                 .vendor_name = "Roland",
 625                 .product_name = "PC-300",
 626                 .ifnum = QUIRK_ANY_INTERFACE,
 627                 .type = QUIRK_COMPOSITE,
 628                 .data = (const struct snd_usb_audio_quirk[]) {
 629                         {
 630                                 .ifnum = 0,
 631                                 .type = QUIRK_IGNORE_INTERFACE
 632                         },
 633                         {
 634                                 .ifnum = 1,
 635                                 .type = QUIRK_IGNORE_INTERFACE
 636                         },
 637                         {
 638                                 .ifnum = 2,
 639                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 640                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 641                                         .out_cables = 0x0001,
 642                                         .in_cables  = 0x0001
 643                                 }
 644                         },
 645                         {
 646                                 .ifnum = -1
 647                         }
 648                 }
 649         }
 650 },
 651 {
 652         /* has ID 0x009d when not in "Advanced Driver" mode */
 653         USB_DEVICE(0x0582, 0x0009),
 654         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 655                 .vendor_name = "EDIROL",
 656                 .product_name = "UM-1",
 657                 .ifnum = QUIRK_ANY_INTERFACE,
 658                 .type = QUIRK_COMPOSITE,
 659                 .data = (const struct snd_usb_audio_quirk[]) {
 660                         {
 661                                 .ifnum = 0,
 662                                 .type = QUIRK_IGNORE_INTERFACE
 663                         },
 664                         {
 665                                 .ifnum = 1,
 666                                 .type = QUIRK_IGNORE_INTERFACE
 667                         },
 668                         {
 669                                 .ifnum = 2,
 670                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 671                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 672                                         .out_cables = 0x0001,
 673                                         .in_cables  = 0x0001
 674                                 }
 675                         },
 676                         {
 677                                 .ifnum = -1
 678                         }
 679                 }
 680         }
 681 },
 682 {
 683         USB_DEVICE(0x0582, 0x000b),
 684         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 685                 .vendor_name = "Roland",
 686                 .product_name = "SK-500",
 687                 .ifnum = QUIRK_ANY_INTERFACE,
 688                 .type = QUIRK_COMPOSITE,
 689                 .data = (const struct snd_usb_audio_quirk[]) {
 690                         {
 691                                 .ifnum = 0,
 692                                 .type = QUIRK_IGNORE_INTERFACE
 693                         },
 694                         {
 695                                 .ifnum = 1,
 696                                 .type = QUIRK_IGNORE_INTERFACE
 697                         },
 698                         {
 699                                 .ifnum = 2,
 700                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 701                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 702                                         .out_cables = 0x0013,
 703                                         .in_cables  = 0x0013
 704                                 }
 705                         },
 706                         {
 707                                 .ifnum = -1
 708                         }
 709                 }
 710         }
 711 },
 712 {
 713         /* thanks to Emiliano Grilli <emillo@libero.it>
 714          * for helping researching this data */
 715         USB_DEVICE(0x0582, 0x000c),
 716         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 717                 .vendor_name = "Roland",
 718                 .product_name = "SC-D70",
 719                 .ifnum = QUIRK_ANY_INTERFACE,
 720                 .type = QUIRK_COMPOSITE,
 721                 .data = (const struct snd_usb_audio_quirk[]) {
 722                         {
 723                                 .ifnum = 0,
 724                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 725                         },
 726                         {
 727                                 .ifnum = 1,
 728                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 729                         },
 730                         {
 731                                 .ifnum = 2,
 732                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 733                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 734                                         .out_cables = 0x0007,
 735                                         .in_cables  = 0x0007
 736                                 }
 737                         },
 738                         {
 739                                 .ifnum = -1
 740                         }
 741                 }
 742         }
 743 },
 744 {       /*
 745          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 746          * If the advanced mode switch at the back of the unit is off, the
 747          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 748          * but offers only 16-bit PCM.
 749          * In advanced mode, the UA-5 will output S24_3LE samples (two
 750          * channels) at the rate indicated on the front switch, including
 751          * the 96kHz sample rate.
 752          */
 753         USB_DEVICE(0x0582, 0x0010),
 754         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 755                 .vendor_name = "EDIROL",
 756                 .product_name = "UA-5",
 757                 .ifnum = QUIRK_ANY_INTERFACE,
 758                 .type = QUIRK_COMPOSITE,
 759                 .data = (const struct snd_usb_audio_quirk[]) {
 760                         {
 761                                 .ifnum = 1,
 762                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 763                         },
 764                         {
 765                                 .ifnum = 2,
 766                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 767                         },
 768                         {
 769                                 .ifnum = -1
 770                         }
 771                 }
 772         }
 773 },
 774 {
 775         /* has ID 0x0013 when not in "Advanced Driver" mode */
 776         USB_DEVICE(0x0582, 0x0012),
 777         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 778                 .vendor_name = "Roland",
 779                 .product_name = "XV-5050",
 780                 .ifnum = 0,
 781                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 782                 .data = & (const struct snd_usb_midi_endpoint_info) {
 783                         .out_cables = 0x0001,
 784                         .in_cables  = 0x0001
 785                 }
 786         }
 787 },
 788 {
 789         /* has ID 0x0015 when not in "Advanced Driver" mode */
 790         USB_DEVICE(0x0582, 0x0014),
 791         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 792                 .vendor_name = "EDIROL",
 793                 .product_name = "UM-880",
 794                 .ifnum = 0,
 795                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 796                 .data = & (const struct snd_usb_midi_endpoint_info) {
 797                         .out_cables = 0x01ff,
 798                         .in_cables  = 0x01ff
 799                 }
 800         }
 801 },
 802 {
 803         /* has ID 0x0017 when not in "Advanced Driver" mode */
 804         USB_DEVICE(0x0582, 0x0016),
 805         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 806                 .vendor_name = "EDIROL",
 807                 .product_name = "SD-90",
 808                 .ifnum = QUIRK_ANY_INTERFACE,
 809                 .type = QUIRK_COMPOSITE,
 810                 .data = (const struct snd_usb_audio_quirk[]) {
 811                         {
 812                                 .ifnum = 0,
 813                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 814                         },
 815                         {
 816                                 .ifnum = 1,
 817                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 818                         },
 819                         {
 820                                 .ifnum = 2,
 821                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 822                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 823                                         .out_cables = 0x000f,
 824                                         .in_cables  = 0x000f
 825                                 }
 826                         },
 827                         {
 828                                 .ifnum = -1
 829                         }
 830                 }
 831         }
 832 },
 833 {
 834         /* has ID 0x001c when not in "Advanced Driver" mode */
 835         USB_DEVICE(0x0582, 0x001b),
 836         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 837                 .vendor_name = "Roland",
 838                 .product_name = "MMP-2",
 839                 .ifnum = QUIRK_ANY_INTERFACE,
 840                 .type = QUIRK_COMPOSITE,
 841                 .data = (const struct snd_usb_audio_quirk[]) {
 842                         {
 843                                 .ifnum = 0,
 844                                 .type = QUIRK_IGNORE_INTERFACE
 845                         },
 846                         {
 847                                 .ifnum = 1,
 848                                 .type = QUIRK_IGNORE_INTERFACE
 849                         },
 850                         {
 851                                 .ifnum = 2,
 852                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 853                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 854                                         .out_cables = 0x0001,
 855                                         .in_cables  = 0x0001
 856                                 }
 857                         },
 858                         {
 859                                 .ifnum = -1
 860                         }
 861                 }
 862         }
 863 },
 864 {
 865         /* has ID 0x001e when not in "Advanced Driver" mode */
 866         USB_DEVICE(0x0582, 0x001d),
 867         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 868                 .vendor_name = "Roland",
 869                 .product_name = "V-SYNTH",
 870                 .ifnum = 0,
 871                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 872                 .data = & (const struct snd_usb_midi_endpoint_info) {
 873                         .out_cables = 0x0001,
 874                         .in_cables  = 0x0001
 875                 }
 876         }
 877 },
 878 {
 879         /* has ID 0x0024 when not in "Advanced Driver" mode */
 880         USB_DEVICE(0x0582, 0x0023),
 881         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 882                 .vendor_name = "EDIROL",
 883                 .product_name = "UM-550",
 884                 .ifnum = 0,
 885                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 886                 .data = & (const struct snd_usb_midi_endpoint_info) {
 887                         .out_cables = 0x003f,
 888                         .in_cables  = 0x003f
 889                 }
 890         }
 891 },
 892 {
 893         /*
 894          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 895          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 896          * and no MIDI.
 897          */
 898         USB_DEVICE(0x0582, 0x0025),
 899         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 900                 .vendor_name = "EDIROL",
 901                 .product_name = "UA-20",
 902                 .ifnum = QUIRK_ANY_INTERFACE,
 903                 .type = QUIRK_COMPOSITE,
 904                 .data = (const struct snd_usb_audio_quirk[]) {
 905                         {
 906                                 .ifnum = 0,
 907                                 .type = QUIRK_IGNORE_INTERFACE
 908                         },
 909                         {
 910                                 .ifnum = 1,
 911                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 912                                 .data = & (const struct audioformat) {
 913                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 914                                         .channels = 2,
 915                                         .iface = 1,
 916                                         .altsetting = 1,
 917                                         .altset_idx = 1,
 918                                         .attributes = 0,
 919                                         .endpoint = 0x01,
 920                                         .ep_attr = 0x01,
 921                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 922                                         .rate_min = 44100,
 923                                         .rate_max = 44100,
 924                                 }
 925                         },
 926                         {
 927                                 .ifnum = 2,
 928                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 929                                 .data = & (const struct audioformat) {
 930                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 931                                         .channels = 2,
 932                                         .iface = 2,
 933                                         .altsetting = 1,
 934                                         .altset_idx = 1,
 935                                         .attributes = 0,
 936                                         .endpoint = 0x82,
 937                                         .ep_attr = 0x01,
 938                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 939                                         .rate_min = 44100,
 940                                         .rate_max = 44100,
 941                                 }
 942                         },
 943                         {
 944                                 .ifnum = 3,
 945                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 946                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 947                                         .out_cables = 0x0001,
 948                                         .in_cables  = 0x0001
 949                                 }
 950                         },
 951                         {
 952                                 .ifnum = -1
 953                         }
 954                 }
 955         }
 956 },
 957 {
 958         /* has ID 0x0028 when not in "Advanced Driver" mode */
 959         USB_DEVICE(0x0582, 0x0027),
 960         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 961                 .vendor_name = "EDIROL",
 962                 .product_name = "SD-20",
 963                 .ifnum = 0,
 964                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 965                 .data = & (const struct snd_usb_midi_endpoint_info) {
 966                         .out_cables = 0x0003,
 967                         .in_cables  = 0x0007
 968                 }
 969         }
 970 },
 971 {
 972         /* has ID 0x002a when not in "Advanced Driver" mode */
 973         USB_DEVICE(0x0582, 0x0029),
 974         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 975                 .vendor_name = "EDIROL",
 976                 .product_name = "SD-80",
 977                 .ifnum = 0,
 978                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 979                 .data = & (const struct snd_usb_midi_endpoint_info) {
 980                         .out_cables = 0x000f,
 981                         .in_cables  = 0x000f
 982                 }
 983         }
 984 },
 985 {       /*
 986          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 987          * If the sample format switch is not in an advanced setting, the
 988          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 989          * but offers only 16-bit PCM and no MIDI.
 990          */
 991         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 992         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 993                 .vendor_name = "EDIROL",
 994                 .product_name = "UA-700",
 995                 .ifnum = QUIRK_ANY_INTERFACE,
 996                 .type = QUIRK_COMPOSITE,
 997                 .data = (const struct snd_usb_audio_quirk[]) {
 998                         {
 999                                 .ifnum = 1,
1000                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1001                         },
1002                         {
1003                                 .ifnum = 2,
1004                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1005                         },
1006                         {
1007                                 .ifnum = 3,
1008                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1009                         },
1010                         {
1011                                 .ifnum = -1
1012                         }
1013                 }
1014         }
1015 },
1016 {
1017         /* has ID 0x002e when not in "Advanced Driver" mode */
1018         USB_DEVICE(0x0582, 0x002d),
1019         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1020                 .vendor_name = "Roland",
1021                 .product_name = "XV-2020",
1022                 .ifnum = 0,
1023                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1024                 .data = & (const struct snd_usb_midi_endpoint_info) {
1025                         .out_cables = 0x0001,
1026                         .in_cables  = 0x0001
1027                 }
1028         }
1029 },
1030 {
1031         /* has ID 0x0030 when not in "Advanced Driver" mode */
1032         USB_DEVICE(0x0582, 0x002f),
1033         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1034                 .vendor_name = "Roland",
1035                 .product_name = "VariOS",
1036                 .ifnum = 0,
1037                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1038                 .data = & (const struct snd_usb_midi_endpoint_info) {
1039                         .out_cables = 0x0007,
1040                         .in_cables  = 0x0007
1041                 }
1042         }
1043 },
1044 {
1045         /* has ID 0x0034 when not in "Advanced Driver" mode */
1046         USB_DEVICE(0x0582, 0x0033),
1047         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1048                 .vendor_name = "EDIROL",
1049                 .product_name = "PCR",
1050                 .ifnum = 0,
1051                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1052                 .data = & (const struct snd_usb_midi_endpoint_info) {
1053                         .out_cables = 0x0003,
1054                         .in_cables  = 0x0007
1055                 }
1056         }
1057 },
1058 {
1059         /*
1060          * Has ID 0x0038 when not in "Advanced Driver" mode;
1061          * later revisions use IDs 0x0054 and 0x00a2.
1062          */
1063         USB_DEVICE(0x0582, 0x0037),
1064         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1065                 .vendor_name = "Roland",
1066                 .product_name = "Digital Piano",
1067                 .ifnum = 0,
1068                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1069                 .data = & (const struct snd_usb_midi_endpoint_info) {
1070                         .out_cables = 0x0001,
1071                         .in_cables  = 0x0001
1072                 }
1073         }
1074 },
1075 {
1076         /*
1077          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1078          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1079          * and no MIDI.
1080          */
1081         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1082         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1083                 .vendor_name = "BOSS",
1084                 .product_name = "GS-10",
1085                 .ifnum = QUIRK_ANY_INTERFACE,
1086                 .type = QUIRK_COMPOSITE,
1087                 .data = & (const struct snd_usb_audio_quirk[]) {
1088                         {
1089                                 .ifnum = 1,
1090                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1091                         },
1092                         {
1093                                 .ifnum = 2,
1094                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1095                         },
1096                         {
1097                                 .ifnum = 3,
1098                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1099                         },
1100                         {
1101                                 .ifnum = -1
1102                         }
1103                 }
1104         }
1105 },
1106 {
1107         /* has ID 0x0041 when not in "Advanced Driver" mode */
1108         USB_DEVICE(0x0582, 0x0040),
1109         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1110                 .vendor_name = "Roland",
1111                 .product_name = "GI-20",
1112                 .ifnum = 0,
1113                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1114                 .data = & (const struct snd_usb_midi_endpoint_info) {
1115                         .out_cables = 0x0001,
1116                         .in_cables  = 0x0001
1117                 }
1118         }
1119 },
1120 {
1121         /* has ID 0x0043 when not in "Advanced Driver" mode */
1122         USB_DEVICE(0x0582, 0x0042),
1123         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1124                 .vendor_name = "Roland",
1125                 .product_name = "RS-70",
1126                 .ifnum = 0,
1127                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1128                 .data = & (const struct snd_usb_midi_endpoint_info) {
1129                         .out_cables = 0x0001,
1130                         .in_cables  = 0x0001
1131                 }
1132         }
1133 },
1134 {
1135         /* has ID 0x0049 when not in "Advanced Driver" mode */
1136         USB_DEVICE(0x0582, 0x0047),
1137         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1138                 /* .vendor_name = "EDIROL", */
1139                 /* .product_name = "UR-80", */
1140                 .ifnum = QUIRK_ANY_INTERFACE,
1141                 .type = QUIRK_COMPOSITE,
1142                 .data = (const struct snd_usb_audio_quirk[]) {
1143                         /* in the 96 kHz modes, only interface 1 is there */
1144                         {
1145                                 .ifnum = 1,
1146                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1147                         },
1148                         {
1149                                 .ifnum = 2,
1150                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1151                         },
1152                         {
1153                                 .ifnum = -1
1154                         }
1155                 }
1156         }
1157 },
1158 {
1159         /* has ID 0x004a when not in "Advanced Driver" mode */
1160         USB_DEVICE(0x0582, 0x0048),
1161         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1162                 /* .vendor_name = "EDIROL", */
1163                 /* .product_name = "UR-80", */
1164                 .ifnum = 0,
1165                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1166                 .data = & (const struct snd_usb_midi_endpoint_info) {
1167                         .out_cables = 0x0003,
1168                         .in_cables  = 0x0007
1169                 }
1170         }
1171 },
1172 {
1173         /* has ID 0x004e when not in "Advanced Driver" mode */
1174         USB_DEVICE(0x0582, 0x004c),
1175         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1176                 .vendor_name = "EDIROL",
1177                 .product_name = "PCR-A",
1178                 .ifnum = QUIRK_ANY_INTERFACE,
1179                 .type = QUIRK_COMPOSITE,
1180                 .data = (const struct snd_usb_audio_quirk[]) {
1181                         {
1182                                 .ifnum = 1,
1183                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1184                         },
1185                         {
1186                                 .ifnum = 2,
1187                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1188                         },
1189                         {
1190                                 .ifnum = -1
1191                         }
1192                 }
1193         }
1194 },
1195 {
1196         /* has ID 0x004f when not in "Advanced Driver" mode */
1197         USB_DEVICE(0x0582, 0x004d),
1198         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1199                 .vendor_name = "EDIROL",
1200                 .product_name = "PCR-A",
1201                 .ifnum = 0,
1202                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1203                 .data = & (const struct snd_usb_midi_endpoint_info) {
1204                         .out_cables = 0x0003,
1205                         .in_cables  = 0x0007
1206                 }
1207         }
1208 },
1209 {
1210         /*
1211          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1212          * is standard compliant, but has only 16-bit PCM.
1213          */
1214         USB_DEVICE(0x0582, 0x0050),
1215         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1216                 .vendor_name = "EDIROL",
1217                 .product_name = "UA-3FX",
1218                 .ifnum = QUIRK_ANY_INTERFACE,
1219                 .type = QUIRK_COMPOSITE,
1220                 .data = (const struct snd_usb_audio_quirk[]) {
1221                         {
1222                                 .ifnum = 1,
1223                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1224                         },
1225                         {
1226                                 .ifnum = 2,
1227                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1228                         },
1229                         {
1230                                 .ifnum = -1
1231                         }
1232                 }
1233         }
1234 },
1235 {
1236         USB_DEVICE(0x0582, 0x0052),
1237         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1238                 .vendor_name = "EDIROL",
1239                 .product_name = "UM-1SX",
1240                 .ifnum = 0,
1241                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1242         }
1243 },
1244 {
1245         USB_DEVICE(0x0582, 0x0060),
1246         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1247                 .vendor_name = "Roland",
1248                 .product_name = "EXR Series",
1249                 .ifnum = 0,
1250                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1251         }
1252 },
1253 {
1254         /* has ID 0x0066 when not in "Advanced Driver" mode */
1255         USB_DEVICE(0x0582, 0x0064),
1256         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1257                 /* .vendor_name = "EDIROL", */
1258                 /* .product_name = "PCR-1", */
1259                 .ifnum = QUIRK_ANY_INTERFACE,
1260                 .type = QUIRK_COMPOSITE,
1261                 .data = (const struct snd_usb_audio_quirk[]) {
1262                         {
1263                                 .ifnum = 1,
1264                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1265                         },
1266                         {
1267                                 .ifnum = 2,
1268                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1269                         },
1270                         {
1271                                 .ifnum = -1
1272                         }
1273                 }
1274         }
1275 },
1276 {
1277         /* has ID 0x0067 when not in "Advanced Driver" mode */
1278         USB_DEVICE(0x0582, 0x0065),
1279         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1280                 /* .vendor_name = "EDIROL", */
1281                 /* .product_name = "PCR-1", */
1282                 .ifnum = 0,
1283                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1284                 .data = & (const struct snd_usb_midi_endpoint_info) {
1285                         .out_cables = 0x0001,
1286                         .in_cables  = 0x0003
1287                 }
1288         }
1289 },
1290 {
1291         /* has ID 0x006e when not in "Advanced Driver" mode */
1292         USB_DEVICE(0x0582, 0x006d),
1293         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294                 .vendor_name = "Roland",
1295                 .product_name = "FANTOM-X",
1296                 .ifnum = 0,
1297                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1298                 .data = & (const struct snd_usb_midi_endpoint_info) {
1299                         .out_cables = 0x0001,
1300                         .in_cables  = 0x0001
1301                 }
1302         }
1303 },
1304 {       /*
1305          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1306          * If the switch is not in an advanced setting, the UA-25 has
1307          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1308          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1309          */
1310         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1311         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1312                 .vendor_name = "EDIROL",
1313                 .product_name = "UA-25",
1314                 .ifnum = QUIRK_ANY_INTERFACE,
1315                 .type = QUIRK_COMPOSITE,
1316                 .data = (const struct snd_usb_audio_quirk[]) {
1317                         {
1318                                 .ifnum = 0,
1319                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1320                         },
1321                         {
1322                                 .ifnum = 1,
1323                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1324                         },
1325                         {
1326                                 .ifnum = 2,
1327                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1328                         },
1329                         {
1330                                 .ifnum = -1
1331                         }
1332                 }
1333         }
1334 },
1335 {
1336         /* has ID 0x0076 when not in "Advanced Driver" mode */
1337         USB_DEVICE(0x0582, 0x0075),
1338         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1339                 .vendor_name = "BOSS",
1340                 .product_name = "DR-880",
1341                 .ifnum = 0,
1342                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1343                 .data = & (const struct snd_usb_midi_endpoint_info) {
1344                         .out_cables = 0x0001,
1345                         .in_cables  = 0x0001
1346                 }
1347         }
1348 },
1349 {
1350         /* has ID 0x007b when not in "Advanced Driver" mode */
1351         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1352         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1353                 .vendor_name = "Roland",
1354                 /* "RD" or "RD-700SX"? */
1355                 .ifnum = 0,
1356                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1357                 .data = & (const struct snd_usb_midi_endpoint_info) {
1358                         .out_cables = 0x0003,
1359                         .in_cables  = 0x0003
1360                 }
1361         }
1362 },
1363 {
1364         /* has ID 0x0081 when not in "Advanced Driver" mode */
1365         USB_DEVICE(0x0582, 0x0080),
1366         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1367                 .vendor_name = "Roland",
1368                 .product_name = "G-70",
1369                 .ifnum = 0,
1370                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1371                 .data = & (const struct snd_usb_midi_endpoint_info) {
1372                         .out_cables = 0x0001,
1373                         .in_cables  = 0x0001
1374                 }
1375         }
1376 },
1377 {
1378         /* has ID 0x008c when not in "Advanced Driver" mode */
1379         USB_DEVICE(0x0582, 0x008b),
1380         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1381                 .vendor_name = "EDIROL",
1382                 .product_name = "PC-50",
1383                 .ifnum = 0,
1384                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1385                 .data = & (const struct snd_usb_midi_endpoint_info) {
1386                         .out_cables = 0x0001,
1387                         .in_cables  = 0x0001
1388                 }
1389         }
1390 },
1391 {
1392         /*
1393          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1394          * is standard compliant, but has only 16-bit PCM and no MIDI.
1395          */
1396         USB_DEVICE(0x0582, 0x00a3),
1397         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1398                 .vendor_name = "EDIROL",
1399                 .product_name = "UA-4FX",
1400                 .ifnum = QUIRK_ANY_INTERFACE,
1401                 .type = QUIRK_COMPOSITE,
1402                 .data = (const struct snd_usb_audio_quirk[]) {
1403                         {
1404                                 .ifnum = 0,
1405                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1406                         },
1407                         {
1408                                 .ifnum = 1,
1409                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1410                         },
1411                         {
1412                                 .ifnum = 2,
1413                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1414                         },
1415                         {
1416                                 .ifnum = -1
1417                         }
1418                 }
1419         }
1420 },
1421 {
1422         /* Edirol M-16DX */
1423         USB_DEVICE(0x0582, 0x00c4),
1424         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1425                 .ifnum = QUIRK_ANY_INTERFACE,
1426                 .type = QUIRK_COMPOSITE,
1427                 .data = (const struct snd_usb_audio_quirk[]) {
1428                         {
1429                                 .ifnum = 0,
1430                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1431                         },
1432                         {
1433                                 .ifnum = 1,
1434                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1435                         },
1436                         {
1437                                 .ifnum = 2,
1438                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1439                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1440                                         .out_cables = 0x0001,
1441                                         .in_cables  = 0x0001
1442                                 }
1443                         },
1444                         {
1445                                 .ifnum = -1
1446                         }
1447                 }
1448         }
1449 },
1450 {
1451         /* Advanced modes of the Edirol UA-25EX.
1452          * For the standard mode, UA-25EX has ID 0582:00e7, which
1453          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1454          */
1455         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1456         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1457                 .vendor_name = "EDIROL",
1458                 .product_name = "UA-25EX",
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_EDIROL_UAXX
1465                         },
1466                         {
1467                                 .ifnum = 1,
1468                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1469                         },
1470                         {
1471                                 .ifnum = 2,
1472                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1473                         },
1474                         {
1475                                 .ifnum = -1
1476                         }
1477                 }
1478         }
1479 },
1480 {
1481         /* Edirol UM-3G */
1482         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1483         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1484                 .ifnum = 0,
1485                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1486                 .data = & (const struct snd_usb_midi_endpoint_info) {
1487                         .out_cables = 0x0007,
1488                         .in_cables  = 0x0007
1489                 }
1490         }
1491 },
1492 {
1493         /* BOSS ME-25 */
1494         USB_DEVICE(0x0582, 0x0113),
1495         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1496                 .ifnum = QUIRK_ANY_INTERFACE,
1497                 .type = QUIRK_COMPOSITE,
1498                 .data = (const struct snd_usb_audio_quirk[]) {
1499                         {
1500                                 .ifnum = 0,
1501                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1502                         },
1503                         {
1504                                 .ifnum = 1,
1505                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1506                         },
1507                         {
1508                                 .ifnum = 2,
1509                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1510                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1511                                         .out_cables = 0x0001,
1512                                         .in_cables  = 0x0001
1513                                 }
1514                         },
1515                         {
1516                                 .ifnum = -1
1517                         }
1518                 }
1519         }
1520 },
1521 {
1522         /* only 44.1 kHz works at the moment */
1523         USB_DEVICE(0x0582, 0x0120),
1524         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1525                 /* .vendor_name = "Roland", */
1526                 /* .product_name = "OCTO-CAPTURE", */
1527                 .ifnum = QUIRK_ANY_INTERFACE,
1528                 .type = QUIRK_COMPOSITE,
1529                 .data = (const struct snd_usb_audio_quirk[]) {
1530                         {
1531                                 .ifnum = 0,
1532                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1533                                 .data = & (const struct audioformat) {
1534                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
1535                                         .channels = 10,
1536                                         .iface = 0,
1537                                         .altsetting = 1,
1538                                         .altset_idx = 1,
1539                                         .endpoint = 0x05,
1540                                         .ep_attr = 0x05,
1541                                         .rates = SNDRV_PCM_RATE_44100,
1542                                         .rate_min = 44100,
1543                                         .rate_max = 44100,
1544                                         .nr_rates = 1,
1545                                         .rate_table = (unsigned int[]) { 44100 }
1546                                 }
1547                         },
1548                         {
1549                                 .ifnum = 1,
1550                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1551                                 .data = & (const struct audioformat) {
1552                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
1553                                         .channels = 12,
1554                                         .iface = 1,
1555                                         .altsetting = 1,
1556                                         .altset_idx = 1,
1557                                         .endpoint = 0x85,
1558                                         .ep_attr = 0x25,
1559                                         .rates = SNDRV_PCM_RATE_44100,
1560                                         .rate_min = 44100,
1561                                         .rate_max = 44100,
1562                                         .nr_rates = 1,
1563                                         .rate_table = (unsigned int[]) { 44100 }
1564                                 }
1565                         },
1566                         {
1567                                 .ifnum = 2,
1568                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1569                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1570                                         .out_cables = 0x0001,
1571                                         .in_cables  = 0x0001
1572                                 }
1573                         },
1574                         {
1575                                 .ifnum = 3,
1576                                 .type = QUIRK_IGNORE_INTERFACE
1577                         },
1578                         {
1579                                 .ifnum = 4,
1580                                 .type = QUIRK_IGNORE_INTERFACE
1581                         },
1582                         {
1583                                 .ifnum = -1
1584                         }
1585                 }
1586         }
1587 },
1588 {
1589         /* only 44.1 kHz works at the moment */
1590         USB_DEVICE(0x0582, 0x012f),
1591         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1592                 /* .vendor_name = "Roland", */
1593                 /* .product_name = "QUAD-CAPTURE", */
1594                 .ifnum = QUIRK_ANY_INTERFACE,
1595                 .type = QUIRK_COMPOSITE,
1596                 .data = (const struct snd_usb_audio_quirk[]) {
1597                         {
1598                                 .ifnum = 0,
1599                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1600                                 .data = & (const struct audioformat) {
1601                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
1602                                         .channels = 4,
1603                                         .iface = 0,
1604                                         .altsetting = 1,
1605                                         .altset_idx = 1,
1606                                         .endpoint = 0x05,
1607                                         .ep_attr = 0x05,
1608                                         .rates = SNDRV_PCM_RATE_44100,
1609                                         .rate_min = 44100,
1610                                         .rate_max = 44100,
1611                                         .nr_rates = 1,
1612                                         .rate_table = (unsigned int[]) { 44100 }
1613                                 }
1614                         },
1615                         {
1616                                 .ifnum = 1,
1617                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1618                                 .data = & (const struct audioformat) {
1619                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
1620                                         .channels = 6,
1621                                         .iface = 1,
1622                                         .altsetting = 1,
1623                                         .altset_idx = 1,
1624                                         .endpoint = 0x85,
1625                                         .ep_attr = 0x25,
1626                                         .rates = SNDRV_PCM_RATE_44100,
1627                                         .rate_min = 44100,
1628                                         .rate_max = 44100,
1629                                         .nr_rates = 1,
1630                                         .rate_table = (unsigned int[]) { 44100 }
1631                                 }
1632                         },
1633                         {
1634                                 .ifnum = 2,
1635                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1636                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1637                                         .out_cables = 0x0001,
1638                                         .in_cables  = 0x0001
1639                                 }
1640                         },
1641                         {
1642                                 .ifnum = 3,
1643                                 .type = QUIRK_IGNORE_INTERFACE
1644                         },
1645                         {
1646                                 .ifnum = 4,
1647                                 .type = QUIRK_IGNORE_INTERFACE
1648                         },
1649                         {
1650                                 .ifnum = -1
1651                         }
1652                 }
1653         }
1654 },
1655 {
1656         USB_DEVICE(0x0582, 0x0159),
1657         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1658                 /* .vendor_name = "Roland", */
1659                 /* .product_name = "UA-22", */
1660                 .ifnum = QUIRK_ANY_INTERFACE,
1661                 .type = QUIRK_COMPOSITE,
1662                 .data = (const struct snd_usb_audio_quirk[]) {
1663                         {
1664                                 .ifnum = 0,
1665                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1666                         },
1667                         {
1668                                 .ifnum = 1,
1669                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1670                         },
1671                         {
1672                                 .ifnum = 2,
1673                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1674                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1675                                         .out_cables = 0x0001,
1676                                         .in_cables = 0x0001
1677                                 }
1678                         },
1679                         {
1680                                 .ifnum = -1
1681                         }
1682                 }
1683         }
1684 },
1685 /* this catches most recent vendor-specific Roland devices */
1686 {
1687         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1688                        USB_DEVICE_ID_MATCH_INT_CLASS,
1689         .idVendor = 0x0582,
1690         .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1691         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1692                 .ifnum = QUIRK_ANY_INTERFACE,
1693                 .type = QUIRK_AUTODETECT
1694         }
1695 },
1696
1697 /* Guillemot devices */
1698 {
1699         /*
1700          * This is for the "Windows Edition" where the external MIDI ports are
1701          * the only MIDI ports; the control data is reported through HID
1702          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1703          * compliant USB MIDI ports for external MIDI and controls.
1704          */
1705         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1706         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1707                 .vendor_name = "Hercules",
1708                 .product_name = "DJ Console (WE)",
1709                 .ifnum = 4,
1710                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1711                 .data = & (const struct snd_usb_midi_endpoint_info) {
1712                         .out_cables = 0x0001,
1713                         .in_cables = 0x0001
1714                 }
1715         }
1716 },
1717
1718 /* Midiman/M-Audio devices */
1719 {
1720         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1721         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1722                 .vendor_name = "M-Audio",
1723                 .product_name = "MidiSport 2x2",
1724                 .ifnum = QUIRK_ANY_INTERFACE,
1725                 .type = QUIRK_MIDI_MIDIMAN,
1726                 .data = & (const struct snd_usb_midi_endpoint_info) {
1727                         .out_cables = 0x0003,
1728                         .in_cables  = 0x0003
1729                 }
1730         }
1731 },
1732 {
1733         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1734         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1735                 .vendor_name = "M-Audio",
1736                 .product_name = "MidiSport 1x1",
1737                 .ifnum = QUIRK_ANY_INTERFACE,
1738                 .type = QUIRK_MIDI_MIDIMAN,
1739                 .data = & (const struct snd_usb_midi_endpoint_info) {
1740                         .out_cables = 0x0001,
1741                         .in_cables  = 0x0001
1742                 }
1743         }
1744 },
1745 {
1746         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1747         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1748                 .vendor_name = "M-Audio",
1749                 .product_name = "Keystation",
1750                 .ifnum = QUIRK_ANY_INTERFACE,
1751                 .type = QUIRK_MIDI_MIDIMAN,
1752                 .data = & (const struct snd_usb_midi_endpoint_info) {
1753                         .out_cables = 0x0001,
1754                         .in_cables  = 0x0001
1755                 }
1756         }
1757 },
1758 {
1759         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1760         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1761                 .vendor_name = "M-Audio",
1762                 .product_name = "MidiSport 4x4",
1763                 .ifnum = QUIRK_ANY_INTERFACE,
1764                 .type = QUIRK_MIDI_MIDIMAN,
1765                 .data = & (const struct snd_usb_midi_endpoint_info) {
1766                         .out_cables = 0x000f,
1767                         .in_cables  = 0x000f
1768                 }
1769         }
1770 },
1771 {
1772         /*
1773          * For hardware revision 1.05; in the later revisions (1.10 and
1774          * 1.21), 0x1031 is the ID for the device without firmware.
1775          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1776          */
1777         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1778         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1779                 .vendor_name = "M-Audio",
1780                 .product_name = "MidiSport 8x8",
1781                 .ifnum = QUIRK_ANY_INTERFACE,
1782                 .type = QUIRK_MIDI_MIDIMAN,
1783                 .data = & (const struct snd_usb_midi_endpoint_info) {
1784                         .out_cables = 0x01ff,
1785                         .in_cables  = 0x01ff
1786                 }
1787         }
1788 },
1789 {
1790         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1791         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1792                 .vendor_name = "M-Audio",
1793                 .product_name = "MidiSport 8x8",
1794                 .ifnum = QUIRK_ANY_INTERFACE,
1795                 .type = QUIRK_MIDI_MIDIMAN,
1796                 .data = & (const struct snd_usb_midi_endpoint_info) {
1797                         .out_cables = 0x01ff,
1798                         .in_cables  = 0x01ff
1799                 }
1800         }
1801 },
1802 {
1803         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1804         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1805                 .vendor_name = "M-Audio",
1806                 .product_name = "MidiSport 2x4",
1807                 .ifnum = QUIRK_ANY_INTERFACE,
1808                 .type = QUIRK_MIDI_MIDIMAN,
1809                 .data = & (const struct snd_usb_midi_endpoint_info) {
1810                         .out_cables = 0x000f,
1811                         .in_cables  = 0x0003
1812                 }
1813         }
1814 },
1815 {
1816         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1817         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1818                 .vendor_name = "M-Audio",
1819                 .product_name = "Quattro",
1820                 .ifnum = QUIRK_ANY_INTERFACE,
1821                 .type = QUIRK_COMPOSITE,
1822                 .data = & (const struct snd_usb_audio_quirk[]) {
1823                         /*
1824                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1825                          * and share endpoints with the other interfaces.
1826                          * Ignore them.  The other interfaces can do 24 bits,
1827                          * but captured samples are big-endian (see usbaudio.c).
1828                          */
1829                         {
1830                                 .ifnum = 0,
1831                                 .type = QUIRK_IGNORE_INTERFACE
1832                         },
1833                         {
1834                                 .ifnum = 1,
1835                                 .type = QUIRK_IGNORE_INTERFACE
1836                         },
1837                         {
1838                                 .ifnum = 2,
1839                                 .type = QUIRK_IGNORE_INTERFACE
1840                         },
1841                         {
1842                                 .ifnum = 3,
1843                                 .type = QUIRK_IGNORE_INTERFACE
1844                         },
1845                         {
1846                                 .ifnum = 4,
1847                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1848                         },
1849                         {
1850                                 .ifnum = 5,
1851                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1852                         },
1853                         {
1854                                 .ifnum = 6,
1855                                 .type = QUIRK_IGNORE_INTERFACE
1856                         },
1857                         {
1858                                 .ifnum = 7,
1859                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1860                         },
1861                         {
1862                                 .ifnum = 8,
1863                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1864                         },
1865                         {
1866                                 .ifnum = 9,
1867                                 .type = QUIRK_MIDI_MIDIMAN,
1868                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1869                                         .out_cables = 0x0001,
1870                                         .in_cables  = 0x0001
1871                                 }
1872                         },
1873                         {
1874                                 .ifnum = -1
1875                         }
1876                 }
1877         }
1878 },
1879 {
1880         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1881         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1882                 .vendor_name = "M-Audio",
1883                 .product_name = "AudioPhile",
1884                 .ifnum = 6,
1885                 .type = QUIRK_MIDI_MIDIMAN,
1886                 .data = & (const struct snd_usb_midi_endpoint_info) {
1887                         .out_cables = 0x0001,
1888                         .in_cables  = 0x0001
1889                 }
1890         }
1891 },
1892 {
1893         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1894         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1895                 .vendor_name = "M-Audio",
1896                 .product_name = "Ozone",
1897                 .ifnum = 3,
1898                 .type = QUIRK_MIDI_MIDIMAN,
1899                 .data = & (const struct snd_usb_midi_endpoint_info) {
1900                         .out_cables = 0x0001,
1901                         .in_cables  = 0x0001
1902                 }
1903         }
1904 },
1905 {
1906         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1907         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1908                 .vendor_name = "M-Audio",
1909                 .product_name = "OmniStudio",
1910                 .ifnum = QUIRK_ANY_INTERFACE,
1911                 .type = QUIRK_COMPOSITE,
1912                 .data = & (const struct snd_usb_audio_quirk[]) {
1913                         {
1914                                 .ifnum = 0,
1915                                 .type = QUIRK_IGNORE_INTERFACE
1916                         },
1917                         {
1918                                 .ifnum = 1,
1919                                 .type = QUIRK_IGNORE_INTERFACE
1920                         },
1921                         {
1922                                 .ifnum = 2,
1923                                 .type = QUIRK_IGNORE_INTERFACE
1924                         },
1925                         {
1926                                 .ifnum = 3,
1927                                 .type = QUIRK_IGNORE_INTERFACE
1928                         },
1929                         {
1930                                 .ifnum = 4,
1931                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1932                         },
1933                         {
1934                                 .ifnum = 5,
1935                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1936                         },
1937                         {
1938                                 .ifnum = 6,
1939                                 .type = QUIRK_IGNORE_INTERFACE
1940                         },
1941                         {
1942                                 .ifnum = 7,
1943                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1944                         },
1945                         {
1946                                 .ifnum = 8,
1947                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1948                         },
1949                         {
1950                                 .ifnum = 9,
1951                                 .type = QUIRK_MIDI_MIDIMAN,
1952                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1953                                         .out_cables = 0x0001,
1954                                         .in_cables  = 0x0001
1955                                 }
1956                         },
1957                         {
1958                                 .ifnum = -1
1959                         }
1960                 }
1961         }
1962 },
1963 {
1964         USB_DEVICE(0x0763, 0x2019),
1965         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1966                 /* .vendor_name = "M-Audio", */
1967                 /* .product_name = "Ozone Academic", */
1968                 .ifnum = QUIRK_ANY_INTERFACE,
1969                 .type = QUIRK_COMPOSITE,
1970                 .data = & (const struct snd_usb_audio_quirk[]) {
1971                         {
1972                                 .ifnum = 0,
1973                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1974                         },
1975                         {
1976                                 .ifnum = 1,
1977                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1978                         },
1979                         {
1980                                 .ifnum = 2,
1981                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1982                         },
1983                         {
1984                                 .ifnum = 3,
1985                                 .type = QUIRK_MIDI_MIDIMAN,
1986                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1987                                         .out_cables = 0x0001,
1988                                         .in_cables  = 0x0001
1989                                 }
1990                         },
1991                         {
1992                                 .ifnum = -1
1993                         }
1994                 }
1995         }
1996 },
1997 {
1998         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
1999         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2000                 /* .vendor_name = "M-Audio", */
2001                 /* .product_name = "Fast Track C400", */
2002                 .ifnum = QUIRK_ANY_INTERFACE,
2003                 .type = QUIRK_COMPOSITE,
2004                 .data = &(const struct snd_usb_audio_quirk[]) {
2005                         {
2006                                 .ifnum = 1,
2007                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2008                         },
2009                         /* Playback */
2010                         {
2011                                 .ifnum = 2,
2012                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2013                                 .data = &(const struct audioformat) {
2014                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2015                                         .channels = 6,
2016                                         .iface = 2,
2017                                         .altsetting = 1,
2018                                         .altset_idx = 1,
2019                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2020                                         .endpoint = 0x01,
2021                                         .ep_attr = 0x09,
2022                                         .rates = SNDRV_PCM_RATE_44100 |
2023                                                  SNDRV_PCM_RATE_48000 |
2024                                                  SNDRV_PCM_RATE_88200 |
2025                                                  SNDRV_PCM_RATE_96000,
2026                                         .rate_min = 44100,
2027                                         .rate_max = 96000,
2028                                         .nr_rates = 4,
2029                                         .rate_table = (unsigned int[]) {
2030                                                         44100, 48000, 88200, 96000
2031                                         },
2032                                         .clock = 0x80,
2033                                 }
2034                         },
2035                         /* Capture */
2036                         {
2037                                 .ifnum = 3,
2038                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2039                                 .data = &(const struct audioformat) {
2040                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2041                                         .channels = 4,
2042                                         .iface = 3,
2043                                         .altsetting = 1,
2044                                         .altset_idx = 1,
2045                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2046                                         .endpoint = 0x81,
2047                                         .ep_attr = 0x05,
2048                                         .rates = SNDRV_PCM_RATE_44100 |
2049                                                  SNDRV_PCM_RATE_48000 |
2050                                                  SNDRV_PCM_RATE_88200 |
2051                                                  SNDRV_PCM_RATE_96000,
2052                                         .rate_min = 44100,
2053                                         .rate_max = 96000,
2054                                         .nr_rates = 4,
2055                                         .rate_table = (unsigned int[]) {
2056                                                 44100, 48000, 88200, 96000
2057                                         },
2058                                         .clock = 0x80,
2059                                 }
2060                         },
2061                         /* MIDI */
2062                         {
2063                                 .ifnum = -1 /* Interface = 4 */
2064                         }
2065                 }
2066         }
2067 },
2068 {
2069         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2070         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2071                 /* .vendor_name = "M-Audio", */
2072                 /* .product_name = "Fast Track C600", */
2073                 .ifnum = QUIRK_ANY_INTERFACE,
2074                 .type = QUIRK_COMPOSITE,
2075                 .data = &(const struct snd_usb_audio_quirk[]) {
2076                         {
2077                                 .ifnum = 1,
2078                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2079                         },
2080                         /* Playback */
2081                         {
2082                                 .ifnum = 2,
2083                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2084                                 .data = &(const struct audioformat) {
2085                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2086                                         .channels = 8,
2087                                         .iface = 2,
2088                                         .altsetting = 1,
2089                                         .altset_idx = 1,
2090                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2091                                         .endpoint = 0x01,
2092                                         .ep_attr = 0x09,
2093                                         .rates = SNDRV_PCM_RATE_44100 |
2094                                                  SNDRV_PCM_RATE_48000 |
2095                                                  SNDRV_PCM_RATE_88200 |
2096                                                  SNDRV_PCM_RATE_96000,
2097                                         .rate_min = 44100,
2098                                         .rate_max = 96000,
2099                                         .nr_rates = 4,
2100                                         .rate_table = (unsigned int[]) {
2101                                                         44100, 48000, 88200, 96000
2102                                         },
2103                                         .clock = 0x80,
2104                                 }
2105                         },
2106                         /* Capture */
2107                         {
2108                                 .ifnum = 3,
2109                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2110                                 .data = &(const struct audioformat) {
2111                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2112                                         .channels = 6,
2113                                         .iface = 3,
2114                                         .altsetting = 1,
2115                                         .altset_idx = 1,
2116                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2117                                         .endpoint = 0x81,
2118                                         .ep_attr = 0x05,
2119                                         .rates = SNDRV_PCM_RATE_44100 |
2120                                                  SNDRV_PCM_RATE_48000 |
2121                                                  SNDRV_PCM_RATE_88200 |
2122                                                  SNDRV_PCM_RATE_96000,
2123                                         .rate_min = 44100,
2124                                         .rate_max = 96000,
2125                                         .nr_rates = 4,
2126                                         .rate_table = (unsigned int[]) {
2127                                                 44100, 48000, 88200, 96000
2128                                         },
2129                                         .clock = 0x80,
2130                                 }
2131                         },
2132                         /* MIDI */
2133                         {
2134                                 .ifnum = -1 /* Interface = 4 */
2135                         }
2136                 }
2137         }
2138 },
2139 {
2140         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2141         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2142                 /* .vendor_name = "M-Audio", */
2143                 /* .product_name = "Fast Track Ultra", */
2144                 .ifnum = QUIRK_ANY_INTERFACE,
2145                 .type = QUIRK_COMPOSITE,
2146                 .data = & (const struct snd_usb_audio_quirk[]) {
2147                         {
2148                                 .ifnum = 0,
2149                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2150                         },
2151                         {
2152                                 .ifnum = 1,
2153                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2154                                 .data = & (const struct audioformat) {
2155                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2156                                         .channels = 8,
2157                                         .iface = 1,
2158                                         .altsetting = 1,
2159                                         .altset_idx = 1,
2160                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2161                                         .endpoint = 0x01,
2162                                         .ep_attr = 0x09,
2163                                         .rates = SNDRV_PCM_RATE_44100 |
2164                                                  SNDRV_PCM_RATE_48000 |
2165                                                  SNDRV_PCM_RATE_88200 |
2166                                                  SNDRV_PCM_RATE_96000,
2167                                         .rate_min = 44100,
2168                                         .rate_max = 96000,
2169                                         .nr_rates = 4,
2170                                         .rate_table = (unsigned int[]) {
2171                                                 44100, 48000, 88200, 96000
2172                                         }
2173                                 }
2174                         },
2175                         {
2176                                 .ifnum = 2,
2177                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2178                                 .data = & (const struct audioformat) {
2179                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2180                                         .channels = 8,
2181                                         .iface = 2,
2182                                         .altsetting = 1,
2183                                         .altset_idx = 1,
2184                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2185                                         .endpoint = 0x81,
2186                                         .ep_attr = 0x05,
2187                                         .rates = SNDRV_PCM_RATE_44100 |
2188                                                  SNDRV_PCM_RATE_48000 |
2189                                                  SNDRV_PCM_RATE_88200 |
2190                                                  SNDRV_PCM_RATE_96000,
2191                                         .rate_min = 44100,
2192                                         .rate_max = 96000,
2193                                         .nr_rates = 4,
2194                                         .rate_table = (unsigned int[]) {
2195                                                 44100, 48000, 88200, 96000
2196                                         }
2197                                 }
2198                         },
2199                         /* interface 3 (MIDI) is standard compliant */
2200                         {
2201                                 .ifnum = -1
2202                         }
2203                 }
2204         }
2205 },
2206 {
2207         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2208         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2209                 /* .vendor_name = "M-Audio", */
2210                 /* .product_name = "Fast Track Ultra 8R", */
2211                 .ifnum = QUIRK_ANY_INTERFACE,
2212                 .type = QUIRK_COMPOSITE,
2213                 .data = & (const struct snd_usb_audio_quirk[]) {
2214                         {
2215                                 .ifnum = 0,
2216                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2217                         },
2218                         {
2219                                 .ifnum = 1,
2220                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2221                                 .data = & (const struct audioformat) {
2222                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2223                                         .channels = 8,
2224                                         .iface = 1,
2225                                         .altsetting = 1,
2226                                         .altset_idx = 1,
2227                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2228                                         .endpoint = 0x01,
2229                                         .ep_attr = 0x09,
2230                                         .rates = SNDRV_PCM_RATE_44100 |
2231                                                  SNDRV_PCM_RATE_48000 |
2232                                                  SNDRV_PCM_RATE_88200 |
2233                                                  SNDRV_PCM_RATE_96000,
2234                                         .rate_min = 44100,
2235                                         .rate_max = 96000,
2236                                         .nr_rates = 4,
2237                                         .rate_table = (unsigned int[]) {
2238                                                         44100, 48000, 88200, 96000
2239                                         }
2240                                 }
2241                         },
2242                         {
2243                                 .ifnum = 2,
2244                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2245                                 .data = & (const struct audioformat) {
2246                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2247                                         .channels = 8,
2248                                         .iface = 2,
2249                                         .altsetting = 1,
2250                                         .altset_idx = 1,
2251                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2252                                         .endpoint = 0x81,
2253                                         .ep_attr = 0x05,
2254                                         .rates = SNDRV_PCM_RATE_44100 |
2255                                                  SNDRV_PCM_RATE_48000 |
2256                                                  SNDRV_PCM_RATE_88200 |
2257                                                  SNDRV_PCM_RATE_96000,
2258                                         .rate_min = 44100,
2259                                         .rate_max = 96000,
2260                                         .nr_rates = 4,
2261                                         .rate_table = (unsigned int[]) {
2262                                                 44100, 48000, 88200, 96000
2263                                         }
2264                                 }
2265                         },
2266                         /* interface 3 (MIDI) is standard compliant */
2267                         {
2268                                 .ifnum = -1
2269                         }
2270                 }
2271         }
2272 },
2273
2274 /* Casio devices */
2275 {
2276         USB_DEVICE(0x07cf, 0x6801),
2277         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2278                 .vendor_name = "Casio",
2279                 .product_name = "PL-40R",
2280                 .ifnum = 0,
2281                 .type = QUIRK_MIDI_YAMAHA
2282         }
2283 },
2284 {
2285         /* this ID is used by several devices without a product ID */
2286         USB_DEVICE(0x07cf, 0x6802),
2287         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2288                 .vendor_name = "Casio",
2289                 .product_name = "Keyboard",
2290                 .ifnum = 0,
2291                 .type = QUIRK_MIDI_YAMAHA
2292         }
2293 },
2294
2295 /* Mark of the Unicorn devices */
2296 {
2297         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2298         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2299                        USB_DEVICE_ID_MATCH_PRODUCT |
2300                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2301         .idVendor = 0x07fd,
2302         .idProduct = 0x0001,
2303         .bDeviceSubClass = 2,
2304         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2305                 .vendor_name = "MOTU",
2306                 .product_name = "Fastlane",
2307                 .ifnum = QUIRK_ANY_INTERFACE,
2308                 .type = QUIRK_COMPOSITE,
2309                 .data = & (const struct snd_usb_audio_quirk[]) {
2310                         {
2311                                 .ifnum = 0,
2312                                 .type = QUIRK_MIDI_RAW_BYTES
2313                         },
2314                         {
2315                                 .ifnum = 1,
2316                                 .type = QUIRK_IGNORE_INTERFACE
2317                         },
2318                         {
2319                                 .ifnum = -1
2320                         }
2321                 }
2322         }
2323 },
2324
2325 /* Emagic devices */
2326 {
2327         USB_DEVICE(0x086a, 0x0001),
2328         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2329                 .vendor_name = "Emagic",
2330                 .product_name = "Unitor8",
2331                 .ifnum = 2,
2332                 .type = QUIRK_MIDI_EMAGIC,
2333                 .data = & (const struct snd_usb_midi_endpoint_info) {
2334                         .out_cables = 0x80ff,
2335                         .in_cables  = 0x80ff
2336                 }
2337         }
2338 },
2339 {
2340         USB_DEVICE(0x086a, 0x0002),
2341         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2342                 .vendor_name = "Emagic",
2343                 /* .product_name = "AMT8", */
2344                 .ifnum = 2,
2345                 .type = QUIRK_MIDI_EMAGIC,
2346                 .data = & (const struct snd_usb_midi_endpoint_info) {
2347                         .out_cables = 0x80ff,
2348                         .in_cables  = 0x80ff
2349                 }
2350         }
2351 },
2352 {
2353         USB_DEVICE(0x086a, 0x0003),
2354         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2355                 .vendor_name = "Emagic",
2356                 /* .product_name = "MT4", */
2357                 .ifnum = 2,
2358                 .type = QUIRK_MIDI_EMAGIC,
2359                 .data = & (const struct snd_usb_midi_endpoint_info) {
2360                         .out_cables = 0x800f,
2361                         .in_cables  = 0x8003
2362                 }
2363         }
2364 },
2365
2366 /* KORG devices */
2367 {
2368         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2369         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2370                 .vendor_name = "KORG, Inc.",
2371                 /* .product_name = "PANDORA PX5D", */
2372                 .ifnum = 3,
2373                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2374         }
2375 },
2376
2377 {
2378         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2379         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2380                 .vendor_name = "KORG, Inc.",
2381                 /* .product_name = "ToneLab ST", */
2382                 .ifnum = 3,
2383                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2384         }
2385 },
2386
2387 /* AKAI devices */
2388 {
2389         USB_DEVICE(0x09e8, 0x0062),
2390         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2391                 .vendor_name = "AKAI",
2392                 .product_name = "MPD16",
2393                 .ifnum = 0,
2394                 .type = QUIRK_MIDI_AKAI,
2395         }
2396 },
2397
2398 {
2399         /* Akai MPC Element */
2400         USB_DEVICE(0x09e8, 0x0021),
2401         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2402                 .ifnum = QUIRK_ANY_INTERFACE,
2403                 .type = QUIRK_COMPOSITE,
2404                 .data = & (const struct snd_usb_audio_quirk[]) {
2405                         {
2406                                 .ifnum = 0,
2407                                 .type = QUIRK_IGNORE_INTERFACE
2408                         },
2409                         {
2410                                 .ifnum = 1,
2411                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2412                         },
2413                         {
2414                                 .ifnum = -1
2415                         }
2416                 }
2417         }
2418 },
2419
2420 /* Steinberg devices */
2421 {
2422         /* Steinberg MI2 */
2423         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2424         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2425                 .ifnum = QUIRK_ANY_INTERFACE,
2426                 .type = QUIRK_COMPOSITE,
2427                 .data = & (const struct snd_usb_audio_quirk[]) {
2428                         {
2429                                 .ifnum = 0,
2430                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2431                         },
2432                         {
2433                                 .ifnum = 1,
2434                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2435                         },
2436                         {
2437                                 .ifnum = 2,
2438                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2439                         },
2440                         {
2441                                 .ifnum = 3,
2442                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2443                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2444                                         .out_cables = 0x0001,
2445                                         .in_cables  = 0x0001
2446                                 }
2447                         },
2448                         {
2449                                 .ifnum = -1
2450                         }
2451                 }
2452         }
2453 },
2454 {
2455         /* Steinberg MI4 */
2456         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2457         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2458                 .ifnum = QUIRK_ANY_INTERFACE,
2459                 .type = QUIRK_COMPOSITE,
2460                 .data = & (const struct snd_usb_audio_quirk[]) {
2461                         {
2462                                 .ifnum = 0,
2463                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2464                         },
2465                         {
2466                                 .ifnum = 1,
2467                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2468                         },
2469                         {
2470                                 .ifnum = 2,
2471                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2472                         },
2473                         {
2474                                 .ifnum = 3,
2475                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2476                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2477                                         .out_cables = 0x0001,
2478                                         .in_cables  = 0x0001
2479                                 }
2480                         },
2481                         {
2482                                 .ifnum = -1
2483                         }
2484                 }
2485         }
2486 },
2487
2488 /* TerraTec devices */
2489 {
2490         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2491         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2492                 .vendor_name = "TerraTec",
2493                 .product_name = "PHASE 26",
2494                 .ifnum = 3,
2495                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2496         }
2497 },
2498 {
2499         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2500         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2501                 .vendor_name = "TerraTec",
2502                 .product_name = "PHASE 26",
2503                 .ifnum = 3,
2504                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2505         }
2506 },
2507 {
2508         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2509         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2510                 .vendor_name = "TerraTec",
2511                 .product_name = "PHASE 26",
2512                 .ifnum = 3,
2513                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2514         }
2515 },
2516 {
2517         USB_DEVICE(0x0ccd, 0x0035),
2518         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2519                 .vendor_name = "Miditech",
2520                 .product_name = "Play'n Roll",
2521                 .ifnum = 0,
2522                 .type = QUIRK_MIDI_CME
2523         }
2524 },
2525
2526 /* Novation EMS devices */
2527 {
2528         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2529         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2530                 .vendor_name = "Novation",
2531                 .product_name = "ReMOTE Audio/XStation",
2532                 .ifnum = 4,
2533                 .type = QUIRK_MIDI_NOVATION
2534         }
2535 },
2536 {
2537         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2538         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2539                 .vendor_name = "Novation",
2540                 .product_name = "Speedio",
2541                 .ifnum = 3,
2542                 .type = QUIRK_MIDI_NOVATION
2543         }
2544 },
2545 {
2546         USB_DEVICE(0x1235, 0x000a),
2547         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2548                 /* .vendor_name = "Novation", */
2549                 /* .product_name = "Nocturn", */
2550                 .ifnum = 0,
2551                 .type = QUIRK_MIDI_RAW_BYTES
2552         }
2553 },
2554 {
2555         USB_DEVICE(0x1235, 0x000e),
2556         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2557                 /* .vendor_name = "Novation", */
2558                 /* .product_name = "Launchpad", */
2559                 .ifnum = 0,
2560                 .type = QUIRK_MIDI_RAW_BYTES
2561         }
2562 },
2563 {
2564         USB_DEVICE(0x1235, 0x0010),
2565         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2566                 .vendor_name = "Focusrite",
2567                 .product_name = "Saffire 6 USB",
2568                 .ifnum = QUIRK_ANY_INTERFACE,
2569                 .type = QUIRK_COMPOSITE,
2570                 .data = (const struct snd_usb_audio_quirk[]) {
2571                         {
2572                                 .ifnum = 0,
2573                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2574                         },
2575                         {
2576                                 .ifnum = 0,
2577                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2578                                 .data = &(const struct audioformat) {
2579                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2580                                         .channels = 4,
2581                                         .iface = 0,
2582                                         .altsetting = 1,
2583                                         .altset_idx = 1,
2584                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2585                                         .endpoint = 0x01,
2586                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2587                                         .datainterval = 1,
2588                                         .maxpacksize = 0x024c,
2589                                         .rates = SNDRV_PCM_RATE_44100 |
2590                                                  SNDRV_PCM_RATE_48000,
2591                                         .rate_min = 44100,
2592                                         .rate_max = 48000,
2593                                         .nr_rates = 2,
2594                                         .rate_table = (unsigned int[]) {
2595                                                 44100, 48000
2596                                         }
2597                                 }
2598                         },
2599                         {
2600                                 .ifnum = 0,
2601                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2602                                 .data = &(const struct audioformat) {
2603                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2604                                         .channels = 2,
2605                                         .iface = 0,
2606                                         .altsetting = 1,
2607                                         .altset_idx = 1,
2608                                         .attributes = 0,
2609                                         .endpoint = 0x82,
2610                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2611                                         .datainterval = 1,
2612                                         .maxpacksize = 0x0126,
2613                                         .rates = SNDRV_PCM_RATE_44100 |
2614                                                  SNDRV_PCM_RATE_48000,
2615                                         .rate_min = 44100,
2616                                         .rate_max = 48000,
2617                                         .nr_rates = 2,
2618                                         .rate_table = (unsigned int[]) {
2619                                                 44100, 48000
2620                                         }
2621                                 }
2622                         },
2623                         {
2624                                 .ifnum = 1,
2625                                 .type = QUIRK_MIDI_RAW_BYTES
2626                         },
2627                         {
2628                                 .ifnum = -1
2629                         }
2630                 }
2631         }
2632 },
2633 {
2634         USB_DEVICE(0x1235, 0x0018),
2635         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2636                 .vendor_name = "Novation",
2637                 .product_name = "Twitch",
2638                 .ifnum = QUIRK_ANY_INTERFACE,
2639                 .type = QUIRK_COMPOSITE,
2640                 .data = (const struct snd_usb_audio_quirk[]) {
2641                         {
2642                                 .ifnum = 0,
2643                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2644                                 .data = & (const struct audioformat) {
2645                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2646                                         .channels = 4,
2647                                         .iface = 0,
2648                                         .altsetting = 1,
2649                                         .altset_idx = 1,
2650                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2651                                         .endpoint = 0x01,
2652                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2653                                         .rates = SNDRV_PCM_RATE_44100 |
2654                                                  SNDRV_PCM_RATE_48000,
2655                                         .rate_min = 44100,
2656                                         .rate_max = 48000,
2657                                         .nr_rates = 2,
2658                                         .rate_table = (unsigned int[]) {
2659                                                 44100, 48000
2660                                         }
2661                                 }
2662                         },
2663                         {
2664                                 .ifnum = 1,
2665                                 .type = QUIRK_MIDI_RAW_BYTES
2666                         },
2667                         {
2668                                 .ifnum = -1
2669                         }
2670                 }
2671         }
2672 },
2673 {
2674         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2675         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2676                 .vendor_name = "Novation",
2677                 .product_name = "ReMOTE25",
2678                 .ifnum = 0,
2679                 .type = QUIRK_MIDI_NOVATION
2680         }
2681 },
2682
2683 /* Access Music devices */
2684 {
2685         /* VirusTI Desktop */
2686         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2687         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2688                 .ifnum = QUIRK_ANY_INTERFACE,
2689                 .type = QUIRK_COMPOSITE,
2690                 .data = &(const struct snd_usb_audio_quirk[]) {
2691                         {
2692                                 .ifnum = 3,
2693                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2694                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2695                                         .out_cables = 0x0003,
2696                                         .in_cables  = 0x0003
2697                                 }
2698                         },
2699                         {
2700                                 .ifnum = 4,
2701                                 .type = QUIRK_IGNORE_INTERFACE
2702                         },
2703                         {
2704                                 .ifnum = -1
2705                         }
2706                 }
2707         }
2708 },
2709
2710 /* Native Instruments MK2 series */
2711 {
2712         /* Komplete Audio 6 */
2713         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2714         .idVendor = 0x17cc,
2715         .idProduct = 0x1000,
2716 },
2717 {
2718         /* Traktor Audio 6 */
2719         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2720         .idVendor = 0x17cc,
2721         .idProduct = 0x1010,
2722 },
2723 {
2724         /* Traktor Audio 10 */
2725         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2726         .idVendor = 0x17cc,
2727         .idProduct = 0x1020,
2728 },
2729
2730 /* QinHeng devices */
2731 {
2732         USB_DEVICE(0x1a86, 0x752d),
2733         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2734                 .vendor_name = "QinHeng",
2735                 .product_name = "CH345",
2736                 .ifnum = 1,
2737                 .type = QUIRK_MIDI_CH345
2738         }
2739 },
2740
2741 /* KeithMcMillen Stringport */
2742 { USB_AUDIO_CLASS(0x1f38, 0x0001) },
2743
2744 /* Miditech devices */
2745 {
2746         USB_DEVICE(0x4752, 0x0011),
2747         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2748                 .vendor_name = "Miditech",
2749                 .product_name = "Midistart-2",
2750                 .ifnum = 0,
2751                 .type = QUIRK_MIDI_CME
2752         }
2753 },
2754
2755 /* Central Music devices */
2756 {
2757         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2758         USB_DEVICE(0x7104, 0x2202),
2759         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2760                 .ifnum = 0,
2761                 .type = QUIRK_MIDI_CME
2762         }
2763 },
2764
2765 /*
2766  * Auvitek au0828 devices with audio interface.
2767  * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2768  * Please notice that some drivers are DVB only, and don't need to be
2769  * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2770  */
2771
2772 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2773         USB_AUDIO_DEVICE(vid, pid), \
2774         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2775                 .vendor_name = vname, \
2776                 .product_name = pname, \
2777                 .ifnum = QUIRK_ANY_INTERFACE, \
2778                 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2779                 .shares_media_device = 1, \
2780         } \
2781 }
2782
2783 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2784 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2785 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2786 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2787 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2788 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2789 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2790 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2791 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2792 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2793 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2794 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2795 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2796 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2797 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2798 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2799 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2800
2801 /* Syntek STK1160 */
2802 {
2803         USB_AUDIO_DEVICE(0x05e1, 0x0408),
2804         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2805                 .vendor_name = "Syntek",
2806                 .product_name = "STK1160",
2807                 .ifnum = QUIRK_ANY_INTERFACE,
2808                 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2809         }
2810 },
2811
2812 /* Digidesign Mbox */
2813 {
2814         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2815         USB_DEVICE(0x0dba, 0x1000),
2816         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2817                 .vendor_name = "Digidesign",
2818                 .product_name = "MBox",
2819                 .ifnum = QUIRK_ANY_INTERFACE,
2820                 .type = QUIRK_COMPOSITE,
2821                 .data = (const struct snd_usb_audio_quirk[]){
2822                         {
2823                                 .ifnum = 0,
2824                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2825                         },
2826                         {
2827                                 .ifnum = 1,
2828                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2829                                 .data = &(const struct audioformat) {
2830                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2831                                         .channels = 2,
2832                                         .iface = 1,
2833                                         .altsetting = 1,
2834                                         .altset_idx = 1,
2835                                         .attributes = 0x4,
2836                                         .endpoint = 0x02,
2837                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
2838                                                 USB_ENDPOINT_SYNC_SYNC,
2839                                         .maxpacksize = 0x130,
2840                                         .rates = SNDRV_PCM_RATE_48000,
2841                                         .rate_min = 48000,
2842                                         .rate_max = 48000,
2843                                         .nr_rates = 1,
2844                                         .rate_table = (unsigned int[]) {
2845                                                 48000
2846                                         }
2847                                 }
2848                         },
2849                         {
2850                                 .ifnum = 1,
2851                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2852                                 .data = &(const struct audioformat) {
2853                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2854                                         .channels = 2,
2855                                         .iface = 1,
2856                                         .altsetting = 1,
2857                                         .altset_idx = 1,
2858                                         .attributes = 0x4,
2859                                         .endpoint = 0x81,
2860                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
2861                                                 USB_ENDPOINT_SYNC_ASYNC,
2862                                         .maxpacksize = 0x130,
2863                                         .rates = SNDRV_PCM_RATE_48000,
2864                                         .rate_min = 48000,
2865                                         .rate_max = 48000,
2866                                         .nr_rates = 1,
2867                                         .rate_table = (unsigned int[]) {
2868                                                 48000
2869                                         }
2870                                 }
2871                         },
2872                         {
2873                                 .ifnum = -1
2874                         }
2875                 }
2876         }
2877 },
2878
2879 /* DIGIDESIGN MBOX 2 */
2880 {
2881         USB_DEVICE(0x0dba, 0x3000),
2882         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2883                 .vendor_name = "Digidesign",
2884                 .product_name = "Mbox 2",
2885                 .ifnum = QUIRK_ANY_INTERFACE,
2886                 .type = QUIRK_COMPOSITE,
2887                 .data = (const struct snd_usb_audio_quirk[]) {
2888                         {
2889                                 .ifnum = 0,
2890                                 .type = QUIRK_IGNORE_INTERFACE
2891                         },
2892                         {
2893                                 .ifnum = 1,
2894                                 .type = QUIRK_IGNORE_INTERFACE
2895                         },
2896                         {
2897                                 .ifnum = 2,
2898                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2899                                 .data = &(const struct audioformat) {
2900                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2901                                         .channels = 2,
2902                                         .iface = 2,
2903                                         .altsetting = 2,
2904                                         .altset_idx = 1,
2905                                         .attributes = 0x00,
2906                                         .endpoint = 0x03,
2907                                         .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2908                                         .rates = SNDRV_PCM_RATE_48000,
2909                                         .rate_min = 48000,
2910                                         .rate_max = 48000,
2911                                         .nr_rates = 1,
2912                                         .rate_table = (unsigned int[]) {
2913                                                 48000
2914                                         }
2915                                 }
2916                         },
2917                         {
2918                                 .ifnum = 3,
2919                                 .type = QUIRK_IGNORE_INTERFACE
2920                         },
2921                         {
2922                                 .ifnum = 4,
2923                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2924                                 .data = &(const struct audioformat) {
2925                                 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2926                                         .channels = 2,
2927                                         .iface = 4,
2928                                         .altsetting = 2,
2929                                         .altset_idx = 1,
2930                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2931                                         .endpoint = 0x85,
2932                                         .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2933                                         .rates = SNDRV_PCM_RATE_48000,
2934                                         .rate_min = 48000,
2935                                         .rate_max = 48000,
2936                                         .nr_rates = 1,
2937                                         .rate_table = (unsigned int[]) {
2938                                                 48000
2939                                         }
2940                                 }
2941                         },
2942                         {
2943                                 .ifnum = 5,
2944                                 .type = QUIRK_IGNORE_INTERFACE
2945                         },
2946                         {
2947                                 .ifnum = 6,
2948                                 .type = QUIRK_MIDI_MIDIMAN,
2949                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2950                                         .out_ep =  0x02,
2951                                         .out_cables = 0x0001,
2952                                         .in_ep = 0x81,
2953                                         .in_interval = 0x01,
2954                                         .in_cables = 0x0001
2955                                 }
2956                         },
2957                         {
2958                                 .ifnum = -1
2959                         }
2960                 }
2961         }
2962 },
2963 {
2964         /* Tascam US122 MKII - playback-only support */
2965         USB_AUDIO_CLASS(0x0644, 0x8021),
2966         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2967                 .vendor_name = "TASCAM",
2968                 .product_name = "US122 MKII",
2969                 .ifnum = QUIRK_ANY_INTERFACE,
2970                 .type = QUIRK_COMPOSITE,
2971                 .data = (const struct snd_usb_audio_quirk[]) {
2972                         {
2973                                 .ifnum = 0,
2974                                 .type = QUIRK_IGNORE_INTERFACE
2975                         },
2976                         {
2977                                 .ifnum = 1,
2978                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2979                                 .data = &(const struct audioformat) {
2980                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2981                                         .channels = 2,
2982                                         .iface = 1,
2983                                         .altsetting = 1,
2984                                         .altset_idx = 1,
2985                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2986                                         .endpoint = 0x02,
2987                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2988                                         .rates = SNDRV_PCM_RATE_44100 |
2989                                                  SNDRV_PCM_RATE_48000 |
2990                                                  SNDRV_PCM_RATE_88200 |
2991                                                  SNDRV_PCM_RATE_96000,
2992                                         .rate_min = 44100,
2993                                         .rate_max = 96000,
2994                                         .nr_rates = 4,
2995                                         .rate_table = (unsigned int[]) {
2996                                                 44100, 48000, 88200, 96000
2997                                         }
2998                                 }
2999                         },
3000                         {
3001                                 .ifnum = -1
3002                         }
3003                 }
3004         }
3005 },
3006
3007 /* Microsoft XboxLive Headset/Xbox Communicator */
3008 {
3009         USB_DEVICE(0x045e, 0x0283),
3010         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3011         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3012                 .vendor_name = "Microsoft",
3013                 .product_name = "XboxLive Headset/Xbox Communicator",
3014                 .ifnum = QUIRK_ANY_INTERFACE,
3015                 .type = QUIRK_COMPOSITE,
3016                 .data = &(const struct snd_usb_audio_quirk[]) {
3017                         {
3018                                 /* playback */
3019                                 .ifnum = 0,
3020                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3021                                 .data = &(const struct audioformat) {
3022                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3023                                         .channels = 1,
3024                                         .iface = 0,
3025                                         .altsetting = 0,
3026                                         .altset_idx = 0,
3027                                         .attributes = 0,
3028                                         .endpoint = 0x04,
3029                                         .ep_attr = 0x05,
3030                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3031                                         .rate_min = 22050,
3032                                         .rate_max = 22050
3033                                 }
3034                         },
3035                         {
3036                                 /* capture */
3037                                 .ifnum = 1,
3038                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3039                                 .data = &(const struct audioformat) {
3040                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3041                                         .channels = 1,
3042                                         .iface = 1,
3043                                         .altsetting = 0,
3044                                         .altset_idx = 0,
3045                                         .attributes = 0,
3046                                         .endpoint = 0x85,
3047                                         .ep_attr = 0x05,
3048                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3049                                         .rate_min = 16000,
3050                                         .rate_max = 16000
3051                                 }
3052                         },
3053                         {
3054                                 .ifnum = -1
3055                         }
3056                 }
3057         }
3058 },
3059
3060 /* Reloop Play */
3061 {
3062         USB_DEVICE(0x200c, 0x100b),
3063         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3064         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3065                 .ifnum = QUIRK_ANY_INTERFACE,
3066                 .type = QUIRK_COMPOSITE,
3067                 .data = &(const struct snd_usb_audio_quirk[]) {
3068                         {
3069                                 .ifnum = 0,
3070                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3071                         },
3072                         {
3073                                 .ifnum = 1,
3074                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3075                                 .data = &(const struct audioformat) {
3076                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3077                                         .channels = 4,
3078                                         .iface = 1,
3079                                         .altsetting = 1,
3080                                         .altset_idx = 1,
3081                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3082                                         .endpoint = 0x01,
3083                                         .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3084                                         .rates = SNDRV_PCM_RATE_44100 |
3085                                                  SNDRV_PCM_RATE_48000,
3086                                         .rate_min = 44100,
3087                                         .rate_max = 48000,
3088                                         .nr_rates = 2,
3089                                         .rate_table = (unsigned int[]) {
3090                                                 44100, 48000
3091                                         }
3092                                 }
3093                         },
3094                         {
3095                                 .ifnum = -1
3096                         }
3097                 }
3098         }
3099 },
3100
3101 {
3102         /*
3103          * ZOOM R16/24 in audio interface mode.
3104          * Playback requires an extra four byte LE length indicator
3105          * at the start of each isochronous packet. This quirk is
3106          * enabled in create_standard_audio_quirk().
3107          */
3108         USB_DEVICE(0x1686, 0x00dd),
3109         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3110                 .ifnum = QUIRK_ANY_INTERFACE,
3111                 .type = QUIRK_COMPOSITE,
3112                 .data = (const struct snd_usb_audio_quirk[]) {
3113                         {
3114                                 /* Playback  */
3115                                 .ifnum = 1,
3116                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3117                         },
3118                         {
3119                                 /* Capture */
3120                                 .ifnum = 2,
3121                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3122                         },
3123                         {
3124                                 /* Midi */
3125                                 .ifnum = 3,
3126                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3127                         },
3128                         {
3129                                 .ifnum = -1
3130                         },
3131                 }
3132         }
3133 },
3134
3135 {
3136         /*
3137          * Some USB MIDI devices don't have an audio control interface,
3138          * so we have to grab MIDI streaming interfaces here.
3139          */
3140         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3141                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3142         .bInterfaceClass = USB_CLASS_AUDIO,
3143         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3144         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3145                 .ifnum = QUIRK_ANY_INTERFACE,
3146                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3147         }
3148 },
3149
3150 /* disabled due to regression for other devices;
3151  * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3152  */
3153 #if 0
3154 {
3155         /*
3156          * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3157          * ID, but it looks like the product ID actually is only for Nura.
3158          * The capture interface does not work at all (even on Windows),
3159          * and only the 48 kHz sample rate works for the playback interface.
3160          */
3161         USB_DEVICE(0x0a12, 0x1243),
3162         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3163                 .ifnum = QUIRK_ANY_INTERFACE,
3164                 .type = QUIRK_COMPOSITE,
3165                 .data = (const struct snd_usb_audio_quirk[]) {
3166                         {
3167                                 .ifnum = 0,
3168                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3169                         },
3170                         /* Capture */
3171                         {
3172                                 .ifnum = 1,
3173                                 .type = QUIRK_IGNORE_INTERFACE,
3174                         },
3175                         /* Playback */
3176                         {
3177                                 .ifnum = 2,
3178                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3179                                 .data = &(const struct audioformat) {
3180                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3181                                         .channels = 2,
3182                                         .iface = 2,
3183                                         .altsetting = 1,
3184                                         .altset_idx = 1,
3185                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3186                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3187                                         .endpoint = 0x03,
3188                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3189                                         .rates = SNDRV_PCM_RATE_48000,
3190                                         .rate_min = 48000,
3191                                         .rate_max = 48000,
3192                                         .nr_rates = 1,
3193                                         .rate_table = (unsigned int[]) {
3194                                                 48000
3195                                         }
3196                                 }
3197                         },
3198                         {
3199                                 .ifnum = -1
3200                         },
3201                 }
3202         }
3203 },
3204 #endif /* disabled */
3205
3206 {
3207         /*
3208          * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3209          * even though it advertises more. The capture interface doesn't work
3210          * even on windows.
3211          */
3212         USB_DEVICE(0x19b5, 0x0021),
3213         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3214                 .ifnum = QUIRK_ANY_INTERFACE,
3215                 .type = QUIRK_COMPOSITE,
3216                 .data = (const struct snd_usb_audio_quirk[]) {
3217                         {
3218                                 .ifnum = 0,
3219                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3220                         },
3221                         /* Playback */
3222                         {
3223                                 .ifnum = 1,
3224                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3225                                 .data = &(const struct audioformat) {
3226                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3227                                         .channels = 2,
3228                                         .iface = 1,
3229                                         .altsetting = 1,
3230                                         .altset_idx = 1,
3231                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3232                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3233                                         .endpoint = 0x03,
3234                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3235                                         .rates = SNDRV_PCM_RATE_48000,
3236                                         .rate_min = 48000,
3237                                         .rate_max = 48000,
3238                                         .nr_rates = 1,
3239                                         .rate_table = (unsigned int[]) {
3240                                                 48000
3241                                         }
3242                                 }
3243                         },
3244                         {
3245                                 .ifnum = -1
3246                         },
3247                 }
3248         }
3249 },
3250 /* Dell WD19 Dock */
3251 {
3252         USB_DEVICE(0x0bda, 0x402e),
3253         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3254                 .ifnum = QUIRK_ANY_INTERFACE,
3255                 .type = QUIRK_SETUP_FMT_AFTER_RESUME
3256         }
3257 },
3258 /* MOTU Microbook II */
3259 {
3260         USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3261         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3262                 .vendor_name = "MOTU",
3263                 .product_name = "MicroBookII",
3264                 .ifnum = QUIRK_ANY_INTERFACE,
3265                 .type = QUIRK_COMPOSITE,
3266                 .data = (const struct snd_usb_audio_quirk[]) {
3267                         {
3268                                 .ifnum = 0,
3269                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3270                         },
3271                         {
3272                                 .ifnum = 0,
3273                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3274                                 .data = &(const struct audioformat) {
3275                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3276                                         .channels = 6,
3277                                         .iface = 0,
3278                                         .altsetting = 1,
3279                                         .altset_idx = 1,
3280                                         .attributes = 0,
3281                                         .endpoint = 0x84,
3282                                         .rates = SNDRV_PCM_RATE_96000,
3283                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3284                                                    USB_ENDPOINT_SYNC_ASYNC,
3285                                         .rate_min = 96000,
3286                                         .rate_max = 96000,
3287                                         .nr_rates = 1,
3288                                         .maxpacksize = 0x00d8,
3289                                         .rate_table = (unsigned int[]) {
3290                                                 96000
3291                                         }
3292                                 }
3293                         },
3294                         {
3295                                 .ifnum = 0,
3296                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3297                                 .data = &(const struct audioformat) {
3298                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3299                                         .channels = 8,
3300                                         .iface = 0,
3301                                         .altsetting = 1,
3302                                         .altset_idx = 1,
3303                                         .attributes = 0,
3304                                         .endpoint = 0x03,
3305                                         .rates = SNDRV_PCM_RATE_96000,
3306                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3307                                                    USB_ENDPOINT_SYNC_ASYNC,
3308                                         .rate_min = 96000,
3309                                         .rate_max = 96000,
3310                                         .nr_rates = 1,
3311                                         .maxpacksize = 0x0120,
3312                                         .rate_table = (unsigned int[]) {
3313                                                 96000
3314                                         }
3315                                 }
3316                         },
3317                         {
3318                                 .ifnum = -1
3319                         }
3320                 }
3321         }
3322 },
3323 {
3324         /*
3325          * PIONEER DJ DDJ-SX3
3326          * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3327          * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3328          * The feedback for the output is the input.
3329          */
3330         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3331         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3332                 .ifnum = QUIRK_ANY_INTERFACE,
3333                 .type = QUIRK_COMPOSITE,
3334                 .data = (const struct snd_usb_audio_quirk[]) {
3335                         {
3336                                 .ifnum = 0,
3337                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3338                                 .data = &(const struct audioformat) {
3339                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3340                                         .channels = 12,
3341                                         .iface = 0,
3342                                         .altsetting = 1,
3343                                         .altset_idx = 1,
3344                                         .endpoint = 0x05,
3345                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3346                                                    USB_ENDPOINT_SYNC_ASYNC,
3347                                         .rates = SNDRV_PCM_RATE_44100,
3348                                         .rate_min = 44100,
3349                                         .rate_max = 44100,
3350                                         .nr_rates = 1,
3351                                         .rate_table = (unsigned int[]) { 44100 }
3352                                 }
3353                         },
3354                         {
3355                                 .ifnum = 0,
3356                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3357                                 .data = &(const struct audioformat) {
3358                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3359                                         .channels = 10,
3360                                         .iface = 0,
3361                                         .altsetting = 1,
3362                                         .altset_idx = 1,
3363                                         .endpoint = 0x86,
3364                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3365                                                  USB_ENDPOINT_SYNC_ASYNC|
3366                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3367                                         .rates = SNDRV_PCM_RATE_44100,
3368                                         .rate_min = 44100,
3369                                         .rate_max = 44100,
3370                                         .nr_rates = 1,
3371                                         .rate_table = (unsigned int[]) { 44100 }
3372                                 }
3373                         },
3374                         {
3375                                 .ifnum = -1
3376                         }
3377                 }
3378         }
3379 },
3380 {
3381         /*
3382          * Pioneer DJ DJM-250MK2
3383          * PCM is 8 channels out @ 48 fixed (endpoints 0x01).
3384          * The output from computer to the mixer is usable.
3385          *
3386          * The input (phono or line to computer) is not working.
3387          * It should be at endpoint 0x82 and probably also 8 channels,
3388          * but it seems that it works only with Pioneer proprietary software.
3389          * Even on officially supported OS, the Audacity was unable to record
3390          * and Mixxx to recognize the control vinyls.
3391          */
3392         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3393         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3394                 .ifnum = QUIRK_ANY_INTERFACE,
3395                 .type = QUIRK_COMPOSITE,
3396                 .data = (const struct snd_usb_audio_quirk[]) {
3397                         {
3398                                 .ifnum = 0,
3399                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3400                                 .data = &(const struct audioformat) {
3401                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3402                                         .channels = 8, // outputs
3403                                         .iface = 0,
3404                                         .altsetting = 1,
3405                                         .altset_idx = 1,
3406                                         .endpoint = 0x01,
3407                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3408                                                 USB_ENDPOINT_SYNC_ASYNC,
3409                                         .rates = SNDRV_PCM_RATE_48000,
3410                                         .rate_min = 48000,
3411                                         .rate_max = 48000,
3412                                         .nr_rates = 1,
3413                                         .rate_table = (unsigned int[]) { 48000 }
3414                                 }
3415                         },
3416                         {
3417                                 .ifnum = -1
3418                         }
3419                 }
3420         }
3421 },
3422 {
3423         /*
3424          * PIONEER DJ DDJ-RB
3425          * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3426          * The feedback for the output is the dummy input.
3427          */
3428         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3429         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3430                 .ifnum = QUIRK_ANY_INTERFACE,
3431                 .type = QUIRK_COMPOSITE,
3432                 .data = (const struct snd_usb_audio_quirk[]) {
3433                         {
3434                                 .ifnum = 0,
3435                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3436                                 .data = &(const struct audioformat) {
3437                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3438                                         .channels = 4,
3439                                         .iface = 0,
3440                                         .altsetting = 1,
3441                                         .altset_idx = 1,
3442                                         .endpoint = 0x01,
3443                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3444                                                    USB_ENDPOINT_SYNC_ASYNC,
3445                                         .rates = SNDRV_PCM_RATE_44100,
3446                                         .rate_min = 44100,
3447                                         .rate_max = 44100,
3448                                         .nr_rates = 1,
3449                                         .rate_table = (unsigned int[]) { 44100 }
3450                                 }
3451                         },
3452                         {
3453                                 .ifnum = 0,
3454                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3455                                 .data = &(const struct audioformat) {
3456                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3457                                         .channels = 2,
3458                                         .iface = 0,
3459                                         .altsetting = 1,
3460                                         .altset_idx = 1,
3461                                         .endpoint = 0x82,
3462                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3463                                                  USB_ENDPOINT_SYNC_ASYNC|
3464                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3465                                         .rates = SNDRV_PCM_RATE_44100,
3466                                         .rate_min = 44100,
3467                                         .rate_max = 44100,
3468                                         .nr_rates = 1,
3469                                         .rate_table = (unsigned int[]) { 44100 }
3470                                 }
3471                         },
3472                         {
3473                                 .ifnum = -1
3474                         }
3475                 }
3476         }
3477 },
3478
3479 {
3480         /*
3481          * Pioneer DJ DJM-900NXS2
3482          * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3483          */
3484         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3485         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3486                 .ifnum = QUIRK_ANY_INTERFACE,
3487                 .type = QUIRK_COMPOSITE,
3488                 .data = (const struct snd_usb_audio_quirk[]) {
3489                         {
3490                                 .ifnum = 0,
3491                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3492                                 .data = &(const struct audioformat) {
3493                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3494                                         .channels = 10,
3495                                         .iface = 0,
3496                                         .altsetting = 1,
3497                                         .altset_idx = 1,
3498                                         .endpoint = 0x01,
3499                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3500                                             USB_ENDPOINT_SYNC_ASYNC,
3501                                         .rates = SNDRV_PCM_RATE_44100|
3502                                             SNDRV_PCM_RATE_48000|
3503                                             SNDRV_PCM_RATE_96000,
3504                                         .rate_min = 44100,
3505                                         .rate_max = 96000,
3506                                         .nr_rates = 3,
3507                                         .rate_table = (unsigned int[]) {
3508                                                 44100, 48000, 96000
3509                                         }
3510                                 }
3511                         },
3512                         {
3513                                 .ifnum = 0,
3514                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3515                                 .data = &(const struct audioformat) {
3516                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3517                                         .channels = 12,
3518                                         .iface = 0,
3519                                         .altsetting = 1,
3520                                         .altset_idx = 1,
3521                                         .endpoint = 0x82,
3522                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3523                                             USB_ENDPOINT_SYNC_ASYNC|
3524                                             USB_ENDPOINT_USAGE_IMPLICIT_FB,
3525                                         .rates = SNDRV_PCM_RATE_44100|
3526                                             SNDRV_PCM_RATE_48000|
3527                                             SNDRV_PCM_RATE_96000,
3528                                         .rate_min = 44100,
3529                                         .rate_max = 96000,
3530                                         .nr_rates = 3,
3531                                         .rate_table = (unsigned int[]) {
3532                                                 44100, 48000, 96000
3533                                         }
3534                                 }
3535                         },
3536                         {
3537                                 .ifnum = -1
3538                         }
3539                 }
3540         }
3541 },
3542
3543 /*
3544  * MacroSilicon MS2109 based HDMI capture cards
3545  *
3546  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3547  * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3548  * they pretend to be 96kHz mono as a workaround for stereo being broken
3549  * by that...
3550  *
3551  * They also have an issue with initial stream alignment that causes the
3552  * channels to be swapped and out of phase, which is dealt with in quirks.c.
3553  */
3554 {
3555         USB_AUDIO_DEVICE(0x534d, 0x2109),
3556         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3557                 .vendor_name = "MacroSilicon",
3558                 .product_name = "MS2109",
3559                 .ifnum = QUIRK_ANY_INTERFACE,
3560                 .type = QUIRK_COMPOSITE,
3561                 .data = &(const struct snd_usb_audio_quirk[]) {
3562                         {
3563                                 .ifnum = 2,
3564                                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3565                         },
3566                         {
3567                                 .ifnum = 2,
3568                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3569                         },
3570                         {
3571                                 .ifnum = 3,
3572                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3573                                 .data = &(const struct audioformat) {
3574                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3575                                         .channels = 2,
3576                                         .iface = 3,
3577                                         .altsetting = 1,
3578                                         .altset_idx = 1,
3579                                         .attributes = 0,
3580                                         .endpoint = 0x82,
3581                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3582                                                 USB_ENDPOINT_SYNC_ASYNC,
3583                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3584                                         .rate_min = 48000,
3585                                         .rate_max = 48000,
3586                                 }
3587                         },
3588                         {
3589                                 .ifnum = -1
3590                         }
3591                 }
3592         }
3593 },
3594
3595 #undef USB_DEVICE_VENDOR_SPEC
3596 #undef USB_AUDIO_DEVICE
3597 #undef USB_AUDIO_CLASS