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