sound/usb/quirks-table.h

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