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