usb/quirks-table.h

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