sound/usb/quirks-table.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * ALSA USB Audio Driver
   4  *
   5  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   6  *                       Clemens Ladisch <clemens@ladisch.de>
   7  */
   8
   9 /*
  10  * The contents of this file are part of the driver's id_table.
  11  *
  12  * In a perfect world, this file would be empty.
  13  */
  14
  15 /*
  16  * Use this for devices where other interfaces are standard compliant,
  17  * to prevent the quirk being applied to those interfaces. (To work with
  18  * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  19  */
  20 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  21         .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  22                        USB_DEVICE_ID_MATCH_PRODUCT | \
  23                        USB_DEVICE_ID_MATCH_INT_CLASS, \
  24         .idVendor = vend, \
  25         .idProduct = prod, \
  26         .bInterfaceClass = USB_CLASS_VENDOR_SPEC
  27
  28 /* A standard entry matching with vid/pid and the audio class/subclass */
  29 #define USB_AUDIO_DEVICE(vend, prod) \
  30         .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
  31                        USB_DEVICE_ID_MATCH_INT_CLASS | \
  32                        USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
  33         .idVendor = vend, \
  34         .idProduct = prod, \
  35         .bInterfaceClass = USB_CLASS_AUDIO, \
  36         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  37
  38 /* 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
1722 /* UA101 and co are supported by another driver */
1723 {
1724         USB_DEVICE(0x0582, 0x0044), /* UA-1000 high speed */
1725         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1726                 .ifnum = QUIRK_NODEV_INTERFACE
1727         },
1728 },
1729 {
1730         USB_DEVICE(0x0582, 0x007d), /* UA-101 high speed */
1731         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1732                 .ifnum = QUIRK_NODEV_INTERFACE
1733         },
1734 },
1735 {
1736         USB_DEVICE(0x0582, 0x008d), /* UA-101 full speed */
1737         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1738                 .ifnum = QUIRK_NODEV_INTERFACE
1739         },
1740 },
1741
1742 /* this catches most recent vendor-specific Roland devices */
1743 {
1744         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1745                        USB_DEVICE_ID_MATCH_INT_CLASS,
1746         .idVendor = 0x0582,
1747         .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1748         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1749                 .ifnum = QUIRK_ANY_INTERFACE,
1750                 .type = QUIRK_AUTODETECT
1751         }
1752 },
1753
1754 /* Guillemot devices */
1755 {
1756         /*
1757          * This is for the "Windows Edition" where the external MIDI ports are
1758          * the only MIDI ports; the control data is reported through HID
1759          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1760          * compliant USB MIDI ports for external MIDI and controls.
1761          */
1762         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1763         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1764                 .vendor_name = "Hercules",
1765                 .product_name = "DJ Console (WE)",
1766                 .ifnum = 4,
1767                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1768                 .data = & (const struct snd_usb_midi_endpoint_info) {
1769                         .out_cables = 0x0001,
1770                         .in_cables = 0x0001
1771                 }
1772         }
1773 },
1774
1775 /* Midiman/M-Audio devices */
1776 {
1777         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1778         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1779                 .vendor_name = "M-Audio",
1780                 .product_name = "MidiSport 2x2",
1781                 .ifnum = QUIRK_ANY_INTERFACE,
1782                 .type = QUIRK_MIDI_MIDIMAN,
1783                 .data = & (const struct snd_usb_midi_endpoint_info) {
1784                         .out_cables = 0x0003,
1785                         .in_cables  = 0x0003
1786                 }
1787         }
1788 },
1789 {
1790         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1791         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1792                 .vendor_name = "M-Audio",
1793                 .product_name = "MidiSport 1x1",
1794                 .ifnum = QUIRK_ANY_INTERFACE,
1795                 .type = QUIRK_MIDI_MIDIMAN,
1796                 .data = & (const struct snd_usb_midi_endpoint_info) {
1797                         .out_cables = 0x0001,
1798                         .in_cables  = 0x0001
1799                 }
1800         }
1801 },
1802 {
1803         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1804         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1805                 .vendor_name = "M-Audio",
1806                 .product_name = "Keystation",
1807                 .ifnum = QUIRK_ANY_INTERFACE,
1808                 .type = QUIRK_MIDI_MIDIMAN,
1809                 .data = & (const struct snd_usb_midi_endpoint_info) {
1810                         .out_cables = 0x0001,
1811                         .in_cables  = 0x0001
1812                 }
1813         }
1814 },
1815 {
1816         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1817         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1818                 .vendor_name = "M-Audio",
1819                 .product_name = "MidiSport 4x4",
1820                 .ifnum = QUIRK_ANY_INTERFACE,
1821                 .type = QUIRK_MIDI_MIDIMAN,
1822                 .data = & (const struct snd_usb_midi_endpoint_info) {
1823                         .out_cables = 0x000f,
1824                         .in_cables  = 0x000f
1825                 }
1826         }
1827 },
1828 {
1829         /*
1830          * For hardware revision 1.05; in the later revisions (1.10 and
1831          * 1.21), 0x1031 is the ID for the device without firmware.
1832          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1833          */
1834         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1835         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1836                 .vendor_name = "M-Audio",
1837                 .product_name = "MidiSport 8x8",
1838                 .ifnum = QUIRK_ANY_INTERFACE,
1839                 .type = QUIRK_MIDI_MIDIMAN,
1840                 .data = & (const struct snd_usb_midi_endpoint_info) {
1841                         .out_cables = 0x01ff,
1842                         .in_cables  = 0x01ff
1843                 }
1844         }
1845 },
1846 {
1847         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1848         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1849                 .vendor_name = "M-Audio",
1850                 .product_name = "MidiSport 8x8",
1851                 .ifnum = QUIRK_ANY_INTERFACE,
1852                 .type = QUIRK_MIDI_MIDIMAN,
1853                 .data = & (const struct snd_usb_midi_endpoint_info) {
1854                         .out_cables = 0x01ff,
1855                         .in_cables  = 0x01ff
1856                 }
1857         }
1858 },
1859 {
1860         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1861         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1862                 .vendor_name = "M-Audio",
1863                 .product_name = "MidiSport 2x4",
1864                 .ifnum = QUIRK_ANY_INTERFACE,
1865                 .type = QUIRK_MIDI_MIDIMAN,
1866                 .data = & (const struct snd_usb_midi_endpoint_info) {
1867                         .out_cables = 0x000f,
1868                         .in_cables  = 0x0003
1869                 }
1870         }
1871 },
1872 {
1873         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1874         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1875                 .vendor_name = "M-Audio",
1876                 .product_name = "Quattro",
1877                 .ifnum = QUIRK_ANY_INTERFACE,
1878                 .type = QUIRK_COMPOSITE,
1879                 .data = & (const struct snd_usb_audio_quirk[]) {
1880                         /*
1881                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1882                          * and share endpoints with the other interfaces.
1883                          * Ignore them.  The other interfaces can do 24 bits,
1884                          * but captured samples are big-endian (see usbaudio.c).
1885                          */
1886                         {
1887                                 .ifnum = 0,
1888                                 .type = QUIRK_IGNORE_INTERFACE
1889                         },
1890                         {
1891                                 .ifnum = 1,
1892                                 .type = QUIRK_IGNORE_INTERFACE
1893                         },
1894                         {
1895                                 .ifnum = 2,
1896                                 .type = QUIRK_IGNORE_INTERFACE
1897                         },
1898                         {
1899                                 .ifnum = 3,
1900                                 .type = QUIRK_IGNORE_INTERFACE
1901                         },
1902                         {
1903                                 .ifnum = 4,
1904                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1905                         },
1906                         {
1907                                 .ifnum = 5,
1908                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1909                         },
1910                         {
1911                                 .ifnum = 6,
1912                                 .type = QUIRK_IGNORE_INTERFACE
1913                         },
1914                         {
1915                                 .ifnum = 7,
1916                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1917                         },
1918                         {
1919                                 .ifnum = 8,
1920                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1921                         },
1922                         {
1923                                 .ifnum = 9,
1924                                 .type = QUIRK_MIDI_MIDIMAN,
1925                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1926                                         .out_cables = 0x0001,
1927                                         .in_cables  = 0x0001
1928                                 }
1929                         },
1930                         {
1931                                 .ifnum = -1
1932                         }
1933                 }
1934         }
1935 },
1936 {
1937         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1938         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1939                 .vendor_name = "M-Audio",
1940                 .product_name = "AudioPhile",
1941                 .ifnum = 6,
1942                 .type = QUIRK_MIDI_MIDIMAN,
1943                 .data = & (const struct snd_usb_midi_endpoint_info) {
1944                         .out_cables = 0x0001,
1945                         .in_cables  = 0x0001
1946                 }
1947         }
1948 },
1949 {
1950         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1951         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1952                 .vendor_name = "M-Audio",
1953                 .product_name = "Ozone",
1954                 .ifnum = 3,
1955                 .type = QUIRK_MIDI_MIDIMAN,
1956                 .data = & (const struct snd_usb_midi_endpoint_info) {
1957                         .out_cables = 0x0001,
1958                         .in_cables  = 0x0001
1959                 }
1960         }
1961 },
1962 {
1963         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1964         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1965                 .vendor_name = "M-Audio",
1966                 .product_name = "OmniStudio",
1967                 .ifnum = QUIRK_ANY_INTERFACE,
1968                 .type = QUIRK_COMPOSITE,
1969                 .data = & (const struct snd_usb_audio_quirk[]) {
1970                         {
1971                                 .ifnum = 0,
1972                                 .type = QUIRK_IGNORE_INTERFACE
1973                         },
1974                         {
1975                                 .ifnum = 1,
1976                                 .type = QUIRK_IGNORE_INTERFACE
1977                         },
1978                         {
1979                                 .ifnum = 2,
1980                                 .type = QUIRK_IGNORE_INTERFACE
1981                         },
1982                         {
1983                                 .ifnum = 3,
1984                                 .type = QUIRK_IGNORE_INTERFACE
1985                         },
1986                         {
1987                                 .ifnum = 4,
1988                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1989                         },
1990                         {
1991                                 .ifnum = 5,
1992                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1993                         },
1994                         {
1995                                 .ifnum = 6,
1996                                 .type = QUIRK_IGNORE_INTERFACE
1997                         },
1998                         {
1999                                 .ifnum = 7,
2000                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2001                         },
2002                         {
2003                                 .ifnum = 8,
2004                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2005                         },
2006                         {
2007                                 .ifnum = 9,
2008                                 .type = QUIRK_MIDI_MIDIMAN,
2009                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2010                                         .out_cables = 0x0001,
2011                                         .in_cables  = 0x0001
2012                                 }
2013                         },
2014                         {
2015                                 .ifnum = -1
2016                         }
2017                 }
2018         }
2019 },
2020 {
2021         USB_DEVICE(0x0763, 0x2019),
2022         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2023                 /* .vendor_name = "M-Audio", */
2024                 /* .product_name = "Ozone Academic", */
2025                 .ifnum = QUIRK_ANY_INTERFACE,
2026                 .type = QUIRK_COMPOSITE,
2027                 .data = & (const struct snd_usb_audio_quirk[]) {
2028                         {
2029                                 .ifnum = 0,
2030                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2031                         },
2032                         {
2033                                 .ifnum = 1,
2034                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2035                         },
2036                         {
2037                                 .ifnum = 2,
2038                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2039                         },
2040                         {
2041                                 .ifnum = 3,
2042                                 .type = QUIRK_MIDI_MIDIMAN,
2043                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2044                                         .out_cables = 0x0001,
2045                                         .in_cables  = 0x0001
2046                                 }
2047                         },
2048                         {
2049                                 .ifnum = -1
2050                         }
2051                 }
2052         }
2053 },
2054 {
2055         /* M-Audio Micro */
2056         USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a),
2057 },
2058 {
2059         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2060         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2061                 /* .vendor_name = "M-Audio", */
2062                 /* .product_name = "Fast Track C400", */
2063                 .ifnum = QUIRK_ANY_INTERFACE,
2064                 .type = QUIRK_COMPOSITE,
2065                 .data = &(const struct snd_usb_audio_quirk[]) {
2066                         {
2067                                 .ifnum = 1,
2068                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2069                         },
2070                         /* Playback */
2071                         {
2072                                 .ifnum = 2,
2073                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2074                                 .data = &(const struct audioformat) {
2075                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2076                                         .channels = 6,
2077                                         .iface = 2,
2078                                         .altsetting = 1,
2079                                         .altset_idx = 1,
2080                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2081                                         .endpoint = 0x01,
2082                                         .ep_attr = 0x09,
2083                                         .rates = SNDRV_PCM_RATE_44100 |
2084                                                  SNDRV_PCM_RATE_48000 |
2085                                                  SNDRV_PCM_RATE_88200 |
2086                                                  SNDRV_PCM_RATE_96000,
2087                                         .rate_min = 44100,
2088                                         .rate_max = 96000,
2089                                         .nr_rates = 4,
2090                                         .rate_table = (unsigned int[]) {
2091                                                         44100, 48000, 88200, 96000
2092                                         },
2093                                         .clock = 0x80,
2094                                 }
2095                         },
2096                         /* Capture */
2097                         {
2098                                 .ifnum = 3,
2099                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2100                                 .data = &(const struct audioformat) {
2101                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2102                                         .channels = 4,
2103                                         .iface = 3,
2104                                         .altsetting = 1,
2105                                         .altset_idx = 1,
2106                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2107                                         .endpoint = 0x81,
2108                                         .ep_attr = 0x05,
2109                                         .rates = SNDRV_PCM_RATE_44100 |
2110                                                  SNDRV_PCM_RATE_48000 |
2111                                                  SNDRV_PCM_RATE_88200 |
2112                                                  SNDRV_PCM_RATE_96000,
2113                                         .rate_min = 44100,
2114                                         .rate_max = 96000,
2115                                         .nr_rates = 4,
2116                                         .rate_table = (unsigned int[]) {
2117                                                 44100, 48000, 88200, 96000
2118                                         },
2119                                         .clock = 0x80,
2120                                 }
2121                         },
2122                         /* MIDI */
2123                         {
2124                                 .ifnum = -1 /* Interface = 4 */
2125                         }
2126                 }
2127         }
2128 },
2129 {
2130         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2131         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2132                 /* .vendor_name = "M-Audio", */
2133                 /* .product_name = "Fast Track C600", */
2134                 .ifnum = QUIRK_ANY_INTERFACE,
2135                 .type = QUIRK_COMPOSITE,
2136                 .data = &(const struct snd_usb_audio_quirk[]) {
2137                         {
2138                                 .ifnum = 1,
2139                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2140                         },
2141                         /* Playback */
2142                         {
2143                                 .ifnum = 2,
2144                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2145                                 .data = &(const struct audioformat) {
2146                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2147                                         .channels = 8,
2148                                         .iface = 2,
2149                                         .altsetting = 1,
2150                                         .altset_idx = 1,
2151                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2152                                         .endpoint = 0x01,
2153                                         .ep_attr = 0x09,
2154                                         .rates = SNDRV_PCM_RATE_44100 |
2155                                                  SNDRV_PCM_RATE_48000 |
2156                                                  SNDRV_PCM_RATE_88200 |
2157                                                  SNDRV_PCM_RATE_96000,
2158                                         .rate_min = 44100,
2159                                         .rate_max = 96000,
2160                                         .nr_rates = 4,
2161                                         .rate_table = (unsigned int[]) {
2162                                                         44100, 48000, 88200, 96000
2163                                         },
2164                                         .clock = 0x80,
2165                                 }
2166                         },
2167                         /* Capture */
2168                         {
2169                                 .ifnum = 3,
2170                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2171                                 .data = &(const struct audioformat) {
2172                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2173                                         .channels = 6,
2174                                         .iface = 3,
2175                                         .altsetting = 1,
2176                                         .altset_idx = 1,
2177                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2178                                         .endpoint = 0x81,
2179                                         .ep_attr = 0x05,
2180                                         .rates = SNDRV_PCM_RATE_44100 |
2181                                                  SNDRV_PCM_RATE_48000 |
2182                                                  SNDRV_PCM_RATE_88200 |
2183                                                  SNDRV_PCM_RATE_96000,
2184                                         .rate_min = 44100,
2185                                         .rate_max = 96000,
2186                                         .nr_rates = 4,
2187                                         .rate_table = (unsigned int[]) {
2188                                                 44100, 48000, 88200, 96000
2189                                         },
2190                                         .clock = 0x80,
2191                                 }
2192                         },
2193                         /* MIDI */
2194                         {
2195                                 .ifnum = -1 /* Interface = 4 */
2196                         }
2197                 }
2198         }
2199 },
2200 {
2201         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2202         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2203                 /* .vendor_name = "M-Audio", */
2204                 /* .product_name = "Fast Track Ultra", */
2205                 .ifnum = QUIRK_ANY_INTERFACE,
2206                 .type = QUIRK_COMPOSITE,
2207                 .data = & (const struct snd_usb_audio_quirk[]) {
2208                         {
2209                                 .ifnum = 0,
2210                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2211                         },
2212                         {
2213                                 .ifnum = 1,
2214                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2215                                 .data = & (const struct audioformat) {
2216                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2217                                         .channels = 8,
2218                                         .iface = 1,
2219                                         .altsetting = 1,
2220                                         .altset_idx = 1,
2221                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2222                                         .endpoint = 0x01,
2223                                         .ep_attr = 0x09,
2224                                         .rates = SNDRV_PCM_RATE_44100 |
2225                                                  SNDRV_PCM_RATE_48000 |
2226                                                  SNDRV_PCM_RATE_88200 |
2227                                                  SNDRV_PCM_RATE_96000,
2228                                         .rate_min = 44100,
2229                                         .rate_max = 96000,
2230                                         .nr_rates = 4,
2231                                         .rate_table = (unsigned int[]) {
2232                                                 44100, 48000, 88200, 96000
2233                                         }
2234                                 }
2235                         },
2236                         {
2237                                 .ifnum = 2,
2238                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2239                                 .data = & (const struct audioformat) {
2240                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2241                                         .channels = 8,
2242                                         .iface = 2,
2243                                         .altsetting = 1,
2244                                         .altset_idx = 1,
2245                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2246                                         .endpoint = 0x81,
2247                                         .ep_attr = 0x05,
2248                                         .rates = SNDRV_PCM_RATE_44100 |
2249                                                  SNDRV_PCM_RATE_48000 |
2250                                                  SNDRV_PCM_RATE_88200 |
2251                                                  SNDRV_PCM_RATE_96000,
2252                                         .rate_min = 44100,
2253                                         .rate_max = 96000,
2254                                         .nr_rates = 4,
2255                                         .rate_table = (unsigned int[]) {
2256                                                 44100, 48000, 88200, 96000
2257                                         }
2258                                 }
2259                         },
2260                         /* interface 3 (MIDI) is standard compliant */
2261                         {
2262                                 .ifnum = -1
2263                         }
2264                 }
2265         }
2266 },
2267 {
2268         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2269         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2270                 /* .vendor_name = "M-Audio", */
2271                 /* .product_name = "Fast Track Ultra 8R", */
2272                 .ifnum = QUIRK_ANY_INTERFACE,
2273                 .type = QUIRK_COMPOSITE,
2274                 .data = & (const struct snd_usb_audio_quirk[]) {
2275                         {
2276                                 .ifnum = 0,
2277                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2278                         },
2279                         {
2280                                 .ifnum = 1,
2281                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2282                                 .data = & (const struct audioformat) {
2283                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2284                                         .channels = 8,
2285                                         .iface = 1,
2286                                         .altsetting = 1,
2287                                         .altset_idx = 1,
2288                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2289                                         .endpoint = 0x01,
2290                                         .ep_attr = 0x09,
2291                                         .rates = SNDRV_PCM_RATE_44100 |
2292                                                  SNDRV_PCM_RATE_48000 |
2293                                                  SNDRV_PCM_RATE_88200 |
2294                                                  SNDRV_PCM_RATE_96000,
2295                                         .rate_min = 44100,
2296                                         .rate_max = 96000,
2297                                         .nr_rates = 4,
2298                                         .rate_table = (unsigned int[]) {
2299                                                         44100, 48000, 88200, 96000
2300                                         }
2301                                 }
2302                         },
2303                         {
2304                                 .ifnum = 2,
2305                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2306                                 .data = & (const struct audioformat) {
2307                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2308                                         .channels = 8,
2309                                         .iface = 2,
2310                                         .altsetting = 1,
2311                                         .altset_idx = 1,
2312                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2313                                         .endpoint = 0x81,
2314                                         .ep_attr = 0x05,
2315                                         .rates = SNDRV_PCM_RATE_44100 |
2316                                                  SNDRV_PCM_RATE_48000 |
2317                                                  SNDRV_PCM_RATE_88200 |
2318                                                  SNDRV_PCM_RATE_96000,
2319                                         .rate_min = 44100,
2320                                         .rate_max = 96000,
2321                                         .nr_rates = 4,
2322                                         .rate_table = (unsigned int[]) {
2323                                                 44100, 48000, 88200, 96000
2324                                         }
2325                                 }
2326                         },
2327                         /* interface 3 (MIDI) is standard compliant */
2328                         {
2329                                 .ifnum = -1
2330                         }
2331                 }
2332         }
2333 },
2334
2335 /* Casio devices */
2336 {
2337         USB_DEVICE(0x07cf, 0x6801),
2338         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2339                 .vendor_name = "Casio",
2340                 .product_name = "PL-40R",
2341                 .ifnum = 0,
2342                 .type = QUIRK_MIDI_YAMAHA
2343         }
2344 },
2345 {
2346         /* this ID is used by several devices without a product ID */
2347         USB_DEVICE(0x07cf, 0x6802),
2348         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2349                 .vendor_name = "Casio",
2350                 .product_name = "Keyboard",
2351                 .ifnum = 0,
2352                 .type = QUIRK_MIDI_YAMAHA
2353         }
2354 },
2355
2356 /* Mark of the Unicorn devices */
2357 {
2358         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2359         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2360                        USB_DEVICE_ID_MATCH_PRODUCT |
2361                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2362         .idVendor = 0x07fd,
2363         .idProduct = 0x0001,
2364         .bDeviceSubClass = 2,
2365         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2366                 .vendor_name = "MOTU",
2367                 .product_name = "Fastlane",
2368                 .ifnum = QUIRK_ANY_INTERFACE,
2369                 .type = QUIRK_COMPOSITE,
2370                 .data = & (const struct snd_usb_audio_quirk[]) {
2371                         {
2372                                 .ifnum = 0,
2373                                 .type = QUIRK_MIDI_RAW_BYTES
2374                         },
2375                         {
2376                                 .ifnum = 1,
2377                                 .type = QUIRK_IGNORE_INTERFACE
2378                         },
2379                         {
2380                                 .ifnum = -1
2381                         }
2382                 }
2383         }
2384 },
2385
2386 /* Emagic devices */
2387 {
2388         USB_DEVICE(0x086a, 0x0001),
2389         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2390                 .vendor_name = "Emagic",
2391                 .product_name = "Unitor8",
2392                 .ifnum = 2,
2393                 .type = QUIRK_MIDI_EMAGIC,
2394                 .data = & (const struct snd_usb_midi_endpoint_info) {
2395                         .out_cables = 0x80ff,
2396                         .in_cables  = 0x80ff
2397                 }
2398         }
2399 },
2400 {
2401         USB_DEVICE(0x086a, 0x0002),
2402         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2403                 .vendor_name = "Emagic",
2404                 /* .product_name = "AMT8", */
2405                 .ifnum = 2,
2406                 .type = QUIRK_MIDI_EMAGIC,
2407                 .data = & (const struct snd_usb_midi_endpoint_info) {
2408                         .out_cables = 0x80ff,
2409                         .in_cables  = 0x80ff
2410                 }
2411         }
2412 },
2413 {
2414         USB_DEVICE(0x086a, 0x0003),
2415         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2416                 .vendor_name = "Emagic",
2417                 /* .product_name = "MT4", */
2418                 .ifnum = 2,
2419                 .type = QUIRK_MIDI_EMAGIC,
2420                 .data = & (const struct snd_usb_midi_endpoint_info) {
2421                         .out_cables = 0x800f,
2422                         .in_cables  = 0x8003
2423                 }
2424         }
2425 },
2426
2427 /* KORG devices */
2428 {
2429         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2430         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2431                 .vendor_name = "KORG, Inc.",
2432                 /* .product_name = "PANDORA PX5D", */
2433                 .ifnum = 3,
2434                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2435         }
2436 },
2437
2438 {
2439         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2440         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2441                 .vendor_name = "KORG, Inc.",
2442                 /* .product_name = "ToneLab ST", */
2443                 .ifnum = 3,
2444                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2445         }
2446 },
2447
2448 {
2449         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2450         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2451                 .vendor_name = "KORG, Inc.",
2452                 /* .product_name = "ToneLab EX", */
2453                 .ifnum = 3,
2454                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2455         }
2456 },
2457
2458 /* AKAI devices */
2459 {
2460         USB_DEVICE(0x09e8, 0x0062),
2461         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2462                 .vendor_name = "AKAI",
2463                 .product_name = "MPD16",
2464                 .ifnum = 0,
2465                 .type = QUIRK_MIDI_AKAI,
2466         }
2467 },
2468
2469 {
2470         /* Akai MPC Element */
2471         USB_DEVICE(0x09e8, 0x0021),
2472         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2473                 .ifnum = QUIRK_ANY_INTERFACE,
2474                 .type = QUIRK_COMPOSITE,
2475                 .data = & (const struct snd_usb_audio_quirk[]) {
2476                         {
2477                                 .ifnum = 0,
2478                                 .type = QUIRK_IGNORE_INTERFACE
2479                         },
2480                         {
2481                                 .ifnum = 1,
2482                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2483                         },
2484                         {
2485                                 .ifnum = -1
2486                         }
2487                 }
2488         }
2489 },
2490
2491 /* Steinberg devices */
2492 {
2493         /* Steinberg MI2 */
2494         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2495         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2496                 .ifnum = QUIRK_ANY_INTERFACE,
2497                 .type = QUIRK_COMPOSITE,
2498                 .data = & (const struct snd_usb_audio_quirk[]) {
2499                         {
2500                                 .ifnum = 0,
2501                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2502                         },
2503                         {
2504                                 .ifnum = 1,
2505                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2506                         },
2507                         {
2508                                 .ifnum = 2,
2509                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2510                         },
2511                         {
2512                                 .ifnum = 3,
2513                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2514                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2515                                         .out_cables = 0x0001,
2516                                         .in_cables  = 0x0001
2517                                 }
2518                         },
2519                         {
2520                                 .ifnum = -1
2521                         }
2522                 }
2523         }
2524 },
2525 {
2526         /* Steinberg MI4 */
2527         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2528         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2529                 .ifnum = QUIRK_ANY_INTERFACE,
2530                 .type = QUIRK_COMPOSITE,
2531                 .data = & (const struct snd_usb_audio_quirk[]) {
2532                         {
2533                                 .ifnum = 0,
2534                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2535                         },
2536                         {
2537                                 .ifnum = 1,
2538                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2539                         },
2540                         {
2541                                 .ifnum = 2,
2542                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2543                         },
2544                         {
2545                                 .ifnum = 3,
2546                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2547                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2548                                         .out_cables = 0x0001,
2549                                         .in_cables  = 0x0001
2550                                 }
2551                         },
2552                         {
2553                                 .ifnum = -1
2554                         }
2555                 }
2556         }
2557 },
2558
2559 /* TerraTec devices */
2560 {
2561         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2562         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2563                 .vendor_name = "TerraTec",
2564                 .product_name = "PHASE 26",
2565                 .ifnum = 3,
2566                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2567         }
2568 },
2569 {
2570         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2571         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2572                 .vendor_name = "TerraTec",
2573                 .product_name = "PHASE 26",
2574                 .ifnum = 3,
2575                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2576         }
2577 },
2578 {
2579         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2580         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2581                 .vendor_name = "TerraTec",
2582                 .product_name = "PHASE 26",
2583                 .ifnum = 3,
2584                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2585         }
2586 },
2587 {
2588         USB_DEVICE(0x0ccd, 0x0035),
2589         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2590                 .vendor_name = "Miditech",
2591                 .product_name = "Play'n Roll",
2592                 .ifnum = 0,
2593                 .type = QUIRK_MIDI_CME
2594         }
2595 },
2596
2597 /* Novation EMS devices */
2598 {
2599         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2600         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2601                 .vendor_name = "Novation",
2602                 .product_name = "ReMOTE Audio/XStation",
2603                 .ifnum = 4,
2604                 .type = QUIRK_MIDI_NOVATION
2605         }
2606 },
2607 {
2608         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2609         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2610                 .vendor_name = "Novation",
2611                 .product_name = "Speedio",
2612                 .ifnum = 3,
2613                 .type = QUIRK_MIDI_NOVATION
2614         }
2615 },
2616 {
2617         USB_DEVICE(0x1235, 0x000a),
2618         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2619                 /* .vendor_name = "Novation", */
2620                 /* .product_name = "Nocturn", */
2621                 .ifnum = 0,
2622                 .type = QUIRK_MIDI_RAW_BYTES
2623         }
2624 },
2625 {
2626         USB_DEVICE(0x1235, 0x000e),
2627         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2628                 /* .vendor_name = "Novation", */
2629                 /* .product_name = "Launchpad", */
2630                 .ifnum = 0,
2631                 .type = QUIRK_MIDI_RAW_BYTES
2632         }
2633 },
2634 {
2635         USB_DEVICE(0x1235, 0x0010),
2636         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2637                 .vendor_name = "Focusrite",
2638                 .product_name = "Saffire 6 USB",
2639                 .ifnum = QUIRK_ANY_INTERFACE,
2640                 .type = QUIRK_COMPOSITE,
2641                 .data = (const struct snd_usb_audio_quirk[]) {
2642                         {
2643                                 .ifnum = 0,
2644                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2645                         },
2646                         {
2647                                 .ifnum = 0,
2648                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2649                                 .data = &(const struct audioformat) {
2650                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2651                                         .channels = 4,
2652                                         .iface = 0,
2653                                         .altsetting = 1,
2654                                         .altset_idx = 1,
2655                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2656                                         .endpoint = 0x01,
2657                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2658                                         .datainterval = 1,
2659                                         .maxpacksize = 0x024c,
2660                                         .rates = SNDRV_PCM_RATE_44100 |
2661                                                  SNDRV_PCM_RATE_48000,
2662                                         .rate_min = 44100,
2663                                         .rate_max = 48000,
2664                                         .nr_rates = 2,
2665                                         .rate_table = (unsigned int[]) {
2666                                                 44100, 48000
2667                                         },
2668                                         .sync_ep = 0x82,
2669                                         .sync_iface = 0,
2670                                         .sync_altsetting = 1,
2671                                         .sync_ep_idx = 1,
2672                                         .implicit_fb = 1,
2673                                 }
2674                         },
2675                         {
2676                                 .ifnum = 0,
2677                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2678                                 .data = &(const struct audioformat) {
2679                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2680                                         .channels = 2,
2681                                         .iface = 0,
2682                                         .altsetting = 1,
2683                                         .altset_idx = 1,
2684                                         .attributes = 0,
2685                                         .endpoint = 0x82,
2686                                         .ep_idx = 1,
2687                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2688                                         .datainterval = 1,
2689                                         .maxpacksize = 0x0126,
2690                                         .rates = SNDRV_PCM_RATE_44100 |
2691                                                  SNDRV_PCM_RATE_48000,
2692                                         .rate_min = 44100,
2693                                         .rate_max = 48000,
2694                                         .nr_rates = 2,
2695                                         .rate_table = (unsigned int[]) {
2696                                                 44100, 48000
2697                                         }
2698                                 }
2699                         },
2700                         {
2701                                 .ifnum = 1,
2702                                 .type = QUIRK_MIDI_RAW_BYTES
2703                         },
2704                         {
2705                                 .ifnum = -1
2706                         }
2707                 }
2708         }
2709 },
2710 {
2711         USB_DEVICE(0x1235, 0x0018),
2712         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2713                 .vendor_name = "Novation",
2714                 .product_name = "Twitch",
2715                 .ifnum = QUIRK_ANY_INTERFACE,
2716                 .type = QUIRK_COMPOSITE,
2717                 .data = (const struct snd_usb_audio_quirk[]) {
2718                         {
2719                                 .ifnum = 0,
2720                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2721                                 .data = & (const struct audioformat) {
2722                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2723                                         .channels = 4,
2724                                         .iface = 0,
2725                                         .altsetting = 1,
2726                                         .altset_idx = 1,
2727                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2728                                         .endpoint = 0x01,
2729                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2730                                         .rates = SNDRV_PCM_RATE_44100 |
2731                                                  SNDRV_PCM_RATE_48000,
2732                                         .rate_min = 44100,
2733                                         .rate_max = 48000,
2734                                         .nr_rates = 2,
2735                                         .rate_table = (unsigned int[]) {
2736                                                 44100, 48000
2737                                         }
2738                                 }
2739                         },
2740                         {
2741                                 .ifnum = 1,
2742                                 .type = QUIRK_MIDI_RAW_BYTES
2743                         },
2744                         {
2745                                 .ifnum = -1
2746                         }
2747                 }
2748         }
2749 },
2750 {
2751         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2752         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2753                 .vendor_name = "Novation",
2754                 .product_name = "ReMOTE25",
2755                 .ifnum = 0,
2756                 .type = QUIRK_MIDI_NOVATION
2757         }
2758 },
2759
2760 /* Access Music devices */
2761 {
2762         /* VirusTI Desktop */
2763         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2764         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2765                 .ifnum = QUIRK_ANY_INTERFACE,
2766                 .type = QUIRK_COMPOSITE,
2767                 .data = &(const struct snd_usb_audio_quirk[]) {
2768                         {
2769                                 .ifnum = 3,
2770                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2771                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2772                                         .out_cables = 0x0003,
2773                                         .in_cables  = 0x0003
2774                                 }
2775                         },
2776                         {
2777                                 .ifnum = 4,
2778                                 .type = QUIRK_IGNORE_INTERFACE
2779                         },
2780                         {
2781                                 .ifnum = -1
2782                         }
2783                 }
2784         }
2785 },
2786
2787 /* Native Instruments MK2 series */
2788 {
2789         /* Komplete Audio 6 */
2790         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2791         .idVendor = 0x17cc,
2792         .idProduct = 0x1000,
2793 },
2794 {
2795         /* Traktor Audio 6 */
2796         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2797         .idVendor = 0x17cc,
2798         .idProduct = 0x1010,
2799 },
2800 {
2801         /* Traktor Audio 10 */
2802         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2803         .idVendor = 0x17cc,
2804         .idProduct = 0x1020,
2805 },
2806
2807 /* QinHeng devices */
2808 {
2809         USB_DEVICE(0x1a86, 0x752d),
2810         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2811                 .vendor_name = "QinHeng",
2812                 .product_name = "CH345",
2813                 .ifnum = 1,
2814                 .type = QUIRK_MIDI_CH345
2815         }
2816 },
2817
2818 /* KeithMcMillen Stringport */
2819 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
2820
2821 /* Miditech devices */
2822 {
2823         USB_DEVICE(0x4752, 0x0011),
2824         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2825                 .vendor_name = "Miditech",
2826                 .product_name = "Midistart-2",
2827                 .ifnum = 0,
2828                 .type = QUIRK_MIDI_CME
2829         }
2830 },
2831
2832 /* Central Music devices */
2833 {
2834         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2835         USB_DEVICE(0x7104, 0x2202),
2836         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2837                 .ifnum = 0,
2838                 .type = QUIRK_MIDI_CME
2839         }
2840 },
2841
2842 /* Digidesign Mbox */
2843 {
2844         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2845         USB_DEVICE(0x0dba, 0x1000),
2846         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2847                 .vendor_name = "Digidesign",
2848                 .product_name = "MBox",
2849                 .ifnum = QUIRK_ANY_INTERFACE,
2850                 .type = QUIRK_COMPOSITE,
2851                 .data = (const struct snd_usb_audio_quirk[]){
2852                         {
2853                                 .ifnum = 0,
2854                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2855                         },
2856                         {
2857                                 .ifnum = 1,
2858                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2859                                 .data = &(const struct audioformat) {
2860                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2861                                         .channels = 2,
2862                                         .iface = 1,
2863                                         .altsetting = 1,
2864                                         .altset_idx = 1,
2865                                         .attributes = 0x4,
2866                                         .endpoint = 0x02,
2867                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
2868                                                 USB_ENDPOINT_SYNC_SYNC,
2869                                         .maxpacksize = 0x130,
2870                                         .rates = SNDRV_PCM_RATE_48000,
2871                                         .rate_min = 48000,
2872                                         .rate_max = 48000,
2873                                         .nr_rates = 1,
2874                                         .rate_table = (unsigned int[]) {
2875                                                 48000
2876                                         }
2877                                 }
2878                         },
2879                         {
2880                                 .ifnum = 1,
2881                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2882                                 .data = &(const struct audioformat) {
2883                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2884                                         .channels = 2,
2885                                         .iface = 1,
2886                                         .altsetting = 1,
2887                                         .altset_idx = 1,
2888                                         .attributes = 0x4,
2889                                         .endpoint = 0x81,
2890                                         .ep_idx = 1,
2891                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
2892                                                 USB_ENDPOINT_SYNC_ASYNC,
2893                                         .maxpacksize = 0x130,
2894                                         .rates = SNDRV_PCM_RATE_48000,
2895                                         .rate_min = 48000,
2896                                         .rate_max = 48000,
2897                                         .nr_rates = 1,
2898                                         .rate_table = (unsigned int[]) {
2899                                                 48000
2900                                         }
2901                                 }
2902                         },
2903                         {
2904                                 .ifnum = -1
2905                         }
2906                 }
2907         }
2908 },
2909
2910 /* DIGIDESIGN MBOX 2 */
2911 {
2912         USB_DEVICE(0x0dba, 0x3000),
2913         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2914                 .vendor_name = "Digidesign",
2915                 .product_name = "Mbox 2",
2916                 .ifnum = QUIRK_ANY_INTERFACE,
2917                 .type = QUIRK_COMPOSITE,
2918                 .data = (const struct snd_usb_audio_quirk[]) {
2919                         {
2920                                 .ifnum = 0,
2921                                 .type = QUIRK_IGNORE_INTERFACE
2922                         },
2923                         {
2924                                 .ifnum = 1,
2925                                 .type = QUIRK_IGNORE_INTERFACE
2926                         },
2927                         {
2928                                 .ifnum = 2,
2929                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2930                                 .data = &(const struct audioformat) {
2931                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2932                                         .channels = 2,
2933                                         .iface = 2,
2934                                         .altsetting = 2,
2935                                         .altset_idx = 1,
2936                                         .attributes = 0x00,
2937                                         .endpoint = 0x03,
2938                                         .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2939                                         .rates = SNDRV_PCM_RATE_48000,
2940                                         .rate_min = 48000,
2941                                         .rate_max = 48000,
2942                                         .nr_rates = 1,
2943                                         .rate_table = (unsigned int[]) {
2944                                                 48000
2945                                         }
2946                                 }
2947                         },
2948                         {
2949                                 .ifnum = 3,
2950                                 .type = QUIRK_IGNORE_INTERFACE
2951                         },
2952                         {
2953                                 .ifnum = 4,
2954                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2955                                 .data = &(const struct audioformat) {
2956                                 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2957                                         .channels = 2,
2958                                         .iface = 4,
2959                                         .altsetting = 2,
2960                                         .altset_idx = 1,
2961                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2962                                         .endpoint = 0x85,
2963                                         .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2964                                         .rates = SNDRV_PCM_RATE_48000,
2965                                         .rate_min = 48000,
2966                                         .rate_max = 48000,
2967                                         .nr_rates = 1,
2968                                         .rate_table = (unsigned int[]) {
2969                                                 48000
2970                                         }
2971                                 }
2972                         },
2973                         {
2974                                 .ifnum = 5,
2975                                 .type = QUIRK_IGNORE_INTERFACE
2976                         },
2977                         {
2978                                 .ifnum = 6,
2979                                 .type = QUIRK_MIDI_MIDIMAN,
2980                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2981                                         .out_ep =  0x02,
2982                                         .out_cables = 0x0001,
2983                                         .in_ep = 0x81,
2984                                         .in_interval = 0x01,
2985                                         .in_cables = 0x0001
2986                                 }
2987                         },
2988                         {
2989                                 .ifnum = -1
2990                         }
2991                 }
2992         }
2993 },
2994 /* DIGIDESIGN MBOX 3 */
2995 {
2996         USB_DEVICE(0x0dba, 0x5000),
2997         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2998                 .vendor_name = "Digidesign",
2999                 .product_name = "Mbox 3",
3000                 .ifnum = QUIRK_ANY_INTERFACE,
3001                 .type = QUIRK_COMPOSITE,
3002                 .data = (const struct snd_usb_audio_quirk[]) {
3003                         {
3004                                 .ifnum = 0,
3005                                 .type = QUIRK_IGNORE_INTERFACE
3006                         },
3007                         {
3008                                 .ifnum = 1,
3009                                 .type = QUIRK_IGNORE_INTERFACE
3010                         },
3011                         {
3012                                 .ifnum = 2,
3013                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3014                                 .data = &(const struct audioformat) {
3015                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3016                                         .fmt_bits = 24,
3017                                         .channels = 4,
3018                                         .iface = 2,
3019                                         .altsetting = 1,
3020                                         .altset_idx = 1,
3021                                         .attributes = 0x00,
3022                                         .endpoint = USB_RECIP_INTERFACE | USB_DIR_OUT,
3023                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3024                                                 USB_ENDPOINT_SYNC_ASYNC,
3025                                         .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
3026                                                         SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000,
3027                                         .rate_min = 44100,
3028                                         .rate_max = 96000,
3029                                         .nr_rates = 4,
3030                                         .rate_table = (unsigned int[]) {
3031                                                 44100, 48000, 88200, 96000
3032                                         },
3033                                         .sync_ep = USB_RECIP_INTERFACE | USB_DIR_IN,
3034                                         .sync_iface = 3,
3035                                         .sync_altsetting = 1,
3036                                         .sync_ep_idx = 1,
3037                                         .implicit_fb = 1,
3038                                 }
3039                         },
3040                         {
3041                                 .ifnum = 3,
3042                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3043                                 .data = &(const struct audioformat) {
3044                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3045                                         .fmt_bits = 24,
3046                                         .channels = 4,
3047                                         .iface = 3,
3048                                         .altsetting = 1,
3049                                         .altset_idx = 1,
3050                                         .attributes = 0x00,
3051                                         .endpoint = USB_RECIP_INTERFACE | USB_DIR_IN,
3052                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3053                                                 USB_ENDPOINT_SYNC_ASYNC,
3054                                         .maxpacksize = 0x009c,
3055                                         .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
3056                                                         SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000,
3057                                         .rate_min = 44100,
3058                                         .rate_max = 96000,
3059                                         .nr_rates = 4,
3060                                         .rate_table = (unsigned int[]) {
3061                                                 44100, 48000, 88200, 96000
3062                                         },
3063                                         .implicit_fb = 0,
3064                                 }
3065                         },
3066                         {
3067                                 .ifnum = 4,
3068                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
3069                                 .data = &(const struct snd_usb_midi_endpoint_info) {
3070                                         .out_cables = 0x0001,
3071                                         .in_cables  = 0x0001
3072                                 }
3073                         },
3074                         {
3075                                 .ifnum = -1
3076                         }
3077                 }
3078         }
3079 },
3080 {
3081         /* Tascam US122 MKII - playback-only support */
3082         USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
3083         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3084                 .vendor_name = "TASCAM",
3085                 .product_name = "US122 MKII",
3086                 .ifnum = QUIRK_ANY_INTERFACE,
3087                 .type = QUIRK_COMPOSITE,
3088                 .data = (const struct snd_usb_audio_quirk[]) {
3089                         {
3090                                 .ifnum = 0,
3091                                 .type = QUIRK_IGNORE_INTERFACE
3092                         },
3093                         {
3094                                 .ifnum = 1,
3095                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3096                                 .data = &(const struct audioformat) {
3097                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3098                                         .channels = 2,
3099                                         .iface = 1,
3100                                         .altsetting = 1,
3101                                         .altset_idx = 1,
3102                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3103                                         .endpoint = 0x02,
3104                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3105                                         .rates = SNDRV_PCM_RATE_44100 |
3106                                                  SNDRV_PCM_RATE_48000 |
3107                                                  SNDRV_PCM_RATE_88200 |
3108                                                  SNDRV_PCM_RATE_96000,
3109                                         .rate_min = 44100,
3110                                         .rate_max = 96000,
3111                                         .nr_rates = 4,
3112                                         .rate_table = (unsigned int[]) {
3113                                                 44100, 48000, 88200, 96000
3114                                         }
3115                                 }
3116                         },
3117                         {
3118                                 .ifnum = -1
3119                         }
3120                 }
3121         }
3122 },
3123
3124 /* Denon DN-X1600 */
3125 {
3126         USB_AUDIO_DEVICE(0x154e, 0x500e),
3127         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3128                 .vendor_name = "Denon",
3129                 .product_name = "DN-X1600",
3130                 .ifnum = QUIRK_ANY_INTERFACE,
3131                 .type = QUIRK_COMPOSITE,
3132                 .data = (const struct snd_usb_audio_quirk[]){
3133                         {
3134                                 .ifnum = 0,
3135                                 .type = QUIRK_IGNORE_INTERFACE,
3136                         },
3137                         {
3138                                 .ifnum = 1,
3139                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3140                                 .data = &(const struct audioformat) {
3141                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3142                                         .channels = 8,
3143                                         .iface = 1,
3144                                         .altsetting = 1,
3145                                         .altset_idx = 1,
3146                                         .attributes = 0x0,
3147                                         .endpoint = 0x01,
3148                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3149                                                 USB_ENDPOINT_SYNC_ADAPTIVE,
3150                                         .maxpacksize = 0x138,
3151                                         .rates = SNDRV_PCM_RATE_48000,
3152                                         .rate_min = 48000,
3153                                         .rate_max = 48000,
3154                                         .nr_rates = 1,
3155                                         .rate_table = (unsigned int[]) {
3156                                                 48000
3157                                         }
3158                                 }
3159                         },
3160                         {
3161                                 .ifnum = 2,
3162                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3163                                 .data = &(const struct audioformat) {
3164                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3165                                         .channels = 8,
3166                                         .iface = 2,
3167                                         .altsetting = 1,
3168                                         .altset_idx = 1,
3169                                         .attributes = 0x0,
3170                                         .endpoint = 0x85,
3171                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3172                                                 USB_ENDPOINT_SYNC_ADAPTIVE,
3173                                         .maxpacksize = 0x138,
3174                                         .rates = SNDRV_PCM_RATE_48000,
3175                                         .rate_min = 48000,
3176                                         .rate_max = 48000,
3177                                         .nr_rates = 1,
3178                                         .rate_table = (unsigned int[]) {
3179                                                 48000
3180                                         }
3181                                 }
3182                         },
3183                         {
3184                                 .ifnum = 4,
3185                                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
3186                         },
3187                         {
3188                                 .ifnum = -1
3189                         }
3190                 }
3191         }
3192 },
3193
3194 /* Microsoft XboxLive Headset/Xbox Communicator */
3195 {
3196         USB_DEVICE(0x045e, 0x0283),
3197         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3198         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3199                 .vendor_name = "Microsoft",
3200                 .product_name = "XboxLive Headset/Xbox Communicator",
3201                 .ifnum = QUIRK_ANY_INTERFACE,
3202                 .type = QUIRK_COMPOSITE,
3203                 .data = &(const struct snd_usb_audio_quirk[]) {
3204                         {
3205                                 /* playback */
3206                                 .ifnum = 0,
3207                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3208                                 .data = &(const struct audioformat) {
3209                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3210                                         .channels = 1,
3211                                         .iface = 0,
3212                                         .altsetting = 0,
3213                                         .altset_idx = 0,
3214                                         .attributes = 0,
3215                                         .endpoint = 0x04,
3216                                         .ep_attr = 0x05,
3217                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3218                                         .rate_min = 22050,
3219                                         .rate_max = 22050
3220                                 }
3221                         },
3222                         {
3223                                 /* capture */
3224                                 .ifnum = 1,
3225                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3226                                 .data = &(const struct audioformat) {
3227                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3228                                         .channels = 1,
3229                                         .iface = 1,
3230                                         .altsetting = 0,
3231                                         .altset_idx = 0,
3232                                         .attributes = 0,
3233                                         .endpoint = 0x85,
3234                                         .ep_attr = 0x05,
3235                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3236                                         .rate_min = 16000,
3237                                         .rate_max = 16000
3238                                 }
3239                         },
3240                         {
3241                                 .ifnum = -1
3242                         }
3243                 }
3244         }
3245 },
3246
3247 /* Reloop Play */
3248 {
3249         USB_DEVICE(0x200c, 0x100b),
3250         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3251         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3252                 .ifnum = QUIRK_ANY_INTERFACE,
3253                 .type = QUIRK_COMPOSITE,
3254                 .data = &(const struct snd_usb_audio_quirk[]) {
3255                         {
3256                                 .ifnum = 0,
3257                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3258                         },
3259                         {
3260                                 .ifnum = 1,
3261                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3262                                 .data = &(const struct audioformat) {
3263                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3264                                         .channels = 4,
3265                                         .iface = 1,
3266                                         .altsetting = 1,
3267                                         .altset_idx = 1,
3268                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3269                                         .endpoint = 0x01,
3270                                         .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3271                                         .rates = SNDRV_PCM_RATE_44100 |
3272                                                  SNDRV_PCM_RATE_48000,
3273                                         .rate_min = 44100,
3274                                         .rate_max = 48000,
3275                                         .nr_rates = 2,
3276                                         .rate_table = (unsigned int[]) {
3277                                                 44100, 48000
3278                                         }
3279                                 }
3280                         },
3281                         {
3282                                 .ifnum = -1
3283                         }
3284                 }
3285         }
3286 },
3287
3288 {
3289         /*
3290          * ZOOM R16/24 in audio interface mode.
3291          * Playback requires an extra four byte LE length indicator
3292          * at the start of each isochronous packet. This quirk is
3293          * enabled in create_standard_audio_quirk().
3294          */
3295         USB_DEVICE(0x1686, 0x00dd),
3296         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3297                 .ifnum = QUIRK_ANY_INTERFACE,
3298                 .type = QUIRK_COMPOSITE,
3299                 .data = (const struct snd_usb_audio_quirk[]) {
3300                         {
3301                                 /* Playback  */
3302                                 .ifnum = 1,
3303                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3304                         },
3305                         {
3306                                 /* Capture */
3307                                 .ifnum = 2,
3308                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3309                         },
3310                         {
3311                                 /* Midi */
3312                                 .ifnum = 3,
3313                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3314                         },
3315                         {
3316                                 .ifnum = -1
3317                         },
3318                 }
3319         }
3320 },
3321
3322 {
3323         /*
3324          * Some USB MIDI devices don't have an audio control interface,
3325          * so we have to grab MIDI streaming interfaces here.
3326          */
3327         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3328                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3329         .bInterfaceClass = USB_CLASS_AUDIO,
3330         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3331         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3332                 .ifnum = QUIRK_ANY_INTERFACE,
3333                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3334         }
3335 },
3336
3337 /* Rane SL-1 */
3338 {
3339         USB_DEVICE(0x13e5, 0x0001),
3340         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3341                 .ifnum = QUIRK_ANY_INTERFACE,
3342                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3343         }
3344 },
3345
3346 /* disabled due to regression for other devices;
3347  * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3348  */
3349 #if 0
3350 {
3351         /*
3352          * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3353          * ID, but it looks like the product ID actually is only for Nura.
3354          * The capture interface does not work at all (even on Windows),
3355          * and only the 48 kHz sample rate works for the playback interface.
3356          */
3357         USB_DEVICE(0x0a12, 0x1243),
3358         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3359                 .ifnum = QUIRK_ANY_INTERFACE,
3360                 .type = QUIRK_COMPOSITE,
3361                 .data = (const struct snd_usb_audio_quirk[]) {
3362                         {
3363                                 .ifnum = 0,
3364                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3365                         },
3366                         /* Capture */
3367                         {
3368                                 .ifnum = 1,
3369                                 .type = QUIRK_IGNORE_INTERFACE,
3370                         },
3371                         /* Playback */
3372                         {
3373                                 .ifnum = 2,
3374                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3375                                 .data = &(const struct audioformat) {
3376                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3377                                         .channels = 2,
3378                                         .iface = 2,
3379                                         .altsetting = 1,
3380                                         .altset_idx = 1,
3381                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3382                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3383                                         .endpoint = 0x03,
3384                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3385                                         .rates = SNDRV_PCM_RATE_48000,
3386                                         .rate_min = 48000,
3387                                         .rate_max = 48000,
3388                                         .nr_rates = 1,
3389                                         .rate_table = (unsigned int[]) {
3390                                                 48000
3391                                         }
3392                                 }
3393                         },
3394                         {
3395                                 .ifnum = -1
3396                         },
3397                 }
3398         }
3399 },
3400 #endif /* disabled */
3401
3402 {
3403         /*
3404          * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3405          * even though it advertises more. The capture interface doesn't work
3406          * even on windows.
3407          */
3408         USB_DEVICE(0x19b5, 0x0021),
3409         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3410                 .ifnum = QUIRK_ANY_INTERFACE,
3411                 .type = QUIRK_COMPOSITE,
3412                 .data = (const struct snd_usb_audio_quirk[]) {
3413                         {
3414                                 .ifnum = 0,
3415                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3416                         },
3417                         /* Playback */
3418                         {
3419                                 .ifnum = 1,
3420                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3421                                 .data = &(const struct audioformat) {
3422                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3423                                         .channels = 2,
3424                                         .iface = 1,
3425                                         .altsetting = 1,
3426                                         .altset_idx = 1,
3427                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3428                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3429                                         .endpoint = 0x03,
3430                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3431                                         .rates = SNDRV_PCM_RATE_48000,
3432                                         .rate_min = 48000,
3433                                         .rate_max = 48000,
3434                                         .nr_rates = 1,
3435                                         .rate_table = (unsigned int[]) {
3436                                                 48000
3437                                         }
3438                                 }
3439                         },
3440                         {
3441                                 .ifnum = -1
3442                         },
3443                 }
3444         }
3445 },
3446 /* MOTU Microbook II */
3447 {
3448         USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3449         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3450                 .vendor_name = "MOTU",
3451                 .product_name = "MicroBookII",
3452                 .ifnum = QUIRK_ANY_INTERFACE,
3453                 .type = QUIRK_COMPOSITE,
3454                 .data = (const struct snd_usb_audio_quirk[]) {
3455                         {
3456                                 .ifnum = 0,
3457                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3458                         },
3459                         {
3460                                 .ifnum = 0,
3461                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3462                                 .data = &(const struct audioformat) {
3463                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3464                                         .channels = 6,
3465                                         .iface = 0,
3466                                         .altsetting = 1,
3467                                         .altset_idx = 1,
3468                                         .attributes = 0,
3469                                         .endpoint = 0x84,
3470                                         .rates = SNDRV_PCM_RATE_96000,
3471                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3472                                                    USB_ENDPOINT_SYNC_ASYNC,
3473                                         .rate_min = 96000,
3474                                         .rate_max = 96000,
3475                                         .nr_rates = 1,
3476                                         .maxpacksize = 0x00d8,
3477                                         .rate_table = (unsigned int[]) {
3478                                                 96000
3479                                         }
3480                                 }
3481                         },
3482                         {
3483                                 .ifnum = 0,
3484                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3485                                 .data = &(const struct audioformat) {
3486                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3487                                         .channels = 8,
3488                                         .iface = 0,
3489                                         .altsetting = 1,
3490                                         .altset_idx = 1,
3491                                         .attributes = 0,
3492                                         .endpoint = 0x03,
3493                                         .ep_idx = 1,
3494                                         .rates = SNDRV_PCM_RATE_96000,
3495                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3496                                                    USB_ENDPOINT_SYNC_ASYNC,
3497                                         .rate_min = 96000,
3498                                         .rate_max = 96000,
3499                                         .nr_rates = 1,
3500                                         .maxpacksize = 0x0120,
3501                                         .rate_table = (unsigned int[]) {
3502                                                 96000
3503                                         }
3504                                 }
3505                         },
3506                         {
3507                                 .ifnum = -1
3508                         }
3509                 }
3510         }
3511 },
3512 {
3513         /*
3514          * PIONEER DJ DDJ-SX3
3515          * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3516          * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3517          * The feedback for the output is the input.
3518          */
3519         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3520         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3521                 .ifnum = QUIRK_ANY_INTERFACE,
3522                 .type = QUIRK_COMPOSITE,
3523                 .data = (const struct snd_usb_audio_quirk[]) {
3524                         {
3525                                 .ifnum = 0,
3526                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3527                                 .data = &(const struct audioformat) {
3528                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3529                                         .channels = 12,
3530                                         .iface = 0,
3531                                         .altsetting = 1,
3532                                         .altset_idx = 1,
3533                                         .endpoint = 0x05,
3534                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3535                                                    USB_ENDPOINT_SYNC_ASYNC,
3536                                         .rates = SNDRV_PCM_RATE_44100,
3537                                         .rate_min = 44100,
3538                                         .rate_max = 44100,
3539                                         .nr_rates = 1,
3540                                         .rate_table = (unsigned int[]) { 44100 }
3541                                 }
3542                         },
3543                         {
3544                                 .ifnum = 0,
3545                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3546                                 .data = &(const struct audioformat) {
3547                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3548                                         .channels = 10,
3549                                         .iface = 0,
3550                                         .altsetting = 1,
3551                                         .altset_idx = 1,
3552                                         .endpoint = 0x86,
3553                                         .ep_idx = 1,
3554                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3555                                                  USB_ENDPOINT_SYNC_ASYNC|
3556                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3557                                         .rates = SNDRV_PCM_RATE_44100,
3558                                         .rate_min = 44100,
3559                                         .rate_max = 44100,
3560                                         .nr_rates = 1,
3561                                         .rate_table = (unsigned int[]) { 44100 }
3562                                 }
3563                         },
3564                         {
3565                                 .ifnum = -1
3566                         }
3567                 }
3568         }
3569 },
3570 {
3571         /*
3572          * Pioneer DJ DJM-250MK2
3573          * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3574          * and 8 channels in @ 48 fixed (endpoint 0x82).
3575          *
3576          * Both playback and recording is working, even simultaneously.
3577          *
3578          * Playback channels could be mapped to:
3579          *  - CH1
3580          *  - CH2
3581          *  - AUX
3582          *
3583          * Recording channels could be mapped to:
3584          *  - Post CH1 Fader
3585          *  - Post CH2 Fader
3586          *  - Cross Fader A
3587          *  - Cross Fader B
3588          *  - MIC
3589          *  - AUX
3590          *  - REC OUT
3591          *
3592          * There is remaining problem with recording directly from PHONO/LINE.
3593          * If we map a channel to:
3594          *  - CH1 Control Tone PHONO
3595          *  - CH1 Control Tone LINE
3596          *  - CH2 Control Tone PHONO
3597          *  - CH2 Control Tone LINE
3598          * it is silent.
3599          * There is no signal even on other operating systems with official drivers.
3600          * The signal appears only when a supported application is started.
3601          * This needs to be investigated yet...
3602          * (there is quite a lot communication on the USB in both directions)
3603          *
3604          * In current version this mixer could be used for playback
3605          * and for recording from vinyls (through Post CH* Fader)
3606          * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3607          */
3608         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3609         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3610                 .ifnum = QUIRK_ANY_INTERFACE,
3611                 .type = QUIRK_COMPOSITE,
3612                 .data = (const struct snd_usb_audio_quirk[]) {
3613                         {
3614                                 .ifnum = 0,
3615                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3616                                 .data = &(const struct audioformat) {
3617                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3618                                         .channels = 8, // outputs
3619                                         .iface = 0,
3620                                         .altsetting = 1,
3621                                         .altset_idx = 1,
3622                                         .endpoint = 0x01,
3623                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3624                                                 USB_ENDPOINT_SYNC_ASYNC,
3625                                         .rates = SNDRV_PCM_RATE_48000,
3626                                         .rate_min = 48000,
3627                                         .rate_max = 48000,
3628                                         .nr_rates = 1,
3629                                         .rate_table = (unsigned int[]) { 48000 }
3630                                         }
3631                         },
3632                         {
3633                                 .ifnum = 0,
3634                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3635                                 .data = &(const struct audioformat) {
3636                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3637                                         .channels = 8, // inputs
3638                                         .iface = 0,
3639                                         .altsetting = 1,
3640                                         .altset_idx = 1,
3641                                         .endpoint = 0x82,
3642                                         .ep_idx = 1,
3643                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3644                                                 USB_ENDPOINT_SYNC_ASYNC|
3645                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3646                                         .rates = SNDRV_PCM_RATE_48000,
3647                                         .rate_min = 48000,
3648                                         .rate_max = 48000,
3649                                         .nr_rates = 1,
3650                                         .rate_table = (unsigned int[]) { 48000 }
3651                                 }
3652                         },
3653                         {
3654                                 .ifnum = -1
3655                         }
3656                 }
3657         }
3658 },
3659 {
3660         /*
3661          * PIONEER DJ DDJ-RB
3662          * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3663          * The feedback for the output is the dummy input.
3664          */
3665         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3666         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3667                 .ifnum = QUIRK_ANY_INTERFACE,
3668                 .type = QUIRK_COMPOSITE,
3669                 .data = (const struct snd_usb_audio_quirk[]) {
3670                         {
3671                                 .ifnum = 0,
3672                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3673                                 .data = &(const struct audioformat) {
3674                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3675                                         .channels = 4,
3676                                         .iface = 0,
3677                                         .altsetting = 1,
3678                                         .altset_idx = 1,
3679                                         .endpoint = 0x01,
3680                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3681                                                    USB_ENDPOINT_SYNC_ASYNC,
3682                                         .rates = SNDRV_PCM_RATE_44100,
3683                                         .rate_min = 44100,
3684                                         .rate_max = 44100,
3685                                         .nr_rates = 1,
3686                                         .rate_table = (unsigned int[]) { 44100 }
3687                                 }
3688                         },
3689                         {
3690                                 .ifnum = 0,
3691                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3692                                 .data = &(const struct audioformat) {
3693                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3694                                         .channels = 2,
3695                                         .iface = 0,
3696                                         .altsetting = 1,
3697                                         .altset_idx = 1,
3698                                         .endpoint = 0x82,
3699                                         .ep_idx = 1,
3700                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3701                                                  USB_ENDPOINT_SYNC_ASYNC|
3702                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3703                                         .rates = SNDRV_PCM_RATE_44100,
3704                                         .rate_min = 44100,
3705                                         .rate_max = 44100,
3706                                         .nr_rates = 1,
3707                                         .rate_table = (unsigned int[]) { 44100 }
3708                                 }
3709                         },
3710                         {
3711                                 .ifnum = -1
3712                         }
3713                 }
3714         }
3715 },
3716
3717 {
3718         /*
3719          * PIONEER DJ DDJ-RR
3720          * PCM is 6 channels out & 4 channels in @ 44.1 fixed
3721          */
3722         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000d),
3723         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3724                 .ifnum = QUIRK_ANY_INTERFACE,
3725                 .type = QUIRK_COMPOSITE,
3726                 .data = (const struct snd_usb_audio_quirk[]) {
3727                         {
3728                                 .ifnum = 0,
3729                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3730                                 .data = &(const struct audioformat) {
3731                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3732                                         .channels = 6, //Master, Headphones & Booth
3733                                         .iface = 0,
3734                                         .altsetting = 1,
3735                                         .altset_idx = 1,
3736                                         .endpoint = 0x01,
3737                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3738                                                    USB_ENDPOINT_SYNC_ASYNC,
3739                                         .rates = SNDRV_PCM_RATE_44100,
3740                                         .rate_min = 44100,
3741                                         .rate_max = 44100,
3742                                         .nr_rates = 1,
3743                                         .rate_table = (unsigned int[]) { 44100 }
3744                                 }
3745                         },
3746                         {
3747                                 .ifnum = 0,
3748                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3749                                 .data = &(const struct audioformat) {
3750                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3751                                         .channels = 4, //2x RCA inputs (CH1 & CH2)
3752                                         .iface = 0,
3753                                         .altsetting = 1,
3754                                         .altset_idx = 1,
3755                                         .endpoint = 0x82,
3756                                         .ep_idx = 1,
3757                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3758                                                  USB_ENDPOINT_SYNC_ASYNC|
3759                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3760                                         .rates = SNDRV_PCM_RATE_44100,
3761                                         .rate_min = 44100,
3762                                         .rate_max = 44100,
3763                                         .nr_rates = 1,
3764                                         .rate_table = (unsigned int[]) { 44100 }
3765                                 }
3766                         },
3767                         {
3768                                 .ifnum = -1
3769                         }
3770                 }
3771         }
3772 },
3773
3774 {
3775         /*
3776          * PIONEER DJ DDJ-SR2
3777          * PCM is 4 channels out, 6 channels in @ 44.1 fixed
3778          * The Feedback for the output is the input
3779          */
3780         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001e),
3781                 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3782                 .ifnum = QUIRK_ANY_INTERFACE,
3783                 .type = QUIRK_COMPOSITE,
3784                 .data = (const struct snd_usb_audio_quirk[]) {
3785                         {
3786                                 .ifnum = 0,
3787                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3788                                 .data = &(const struct audioformat) {
3789                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3790                                         .channels = 4,
3791                                         .iface = 0,
3792                                         .altsetting = 1,
3793                                         .altset_idx = 1,
3794                                         .endpoint = 0x01,
3795                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3796                                                 USB_ENDPOINT_SYNC_ASYNC,
3797                                         .rates = SNDRV_PCM_RATE_44100,
3798                                         .rate_min = 44100,
3799                                         .rate_max = 44100,
3800                                         .nr_rates = 1,
3801                                         .rate_table = (unsigned int[]) { 44100 }
3802                                 }
3803                         },
3804                         {
3805                                 .ifnum = 0,
3806                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3807                                 .data = &(const struct audioformat) {
3808                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3809                                         .channels = 6,
3810                                         .iface = 0,
3811                                         .altsetting = 1,
3812                                         .altset_idx = 1,
3813                                         .endpoint = 0x82,
3814                                         .ep_idx = 1,
3815                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3816                                                 USB_ENDPOINT_SYNC_ASYNC|
3817                                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3818                                         .rates = SNDRV_PCM_RATE_44100,
3819                                         .rate_min = 44100,
3820                                         .rate_max = 44100,
3821                                         .nr_rates = 1,
3822                                         .rate_table = (unsigned int[]) { 44100 }
3823                                 }
3824                         },
3825                         {
3826                                 .ifnum = -1
3827                         }
3828                 }
3829         }
3830 },
3831
3832 {
3833         /*
3834          * Pioneer DJ DJM-900NXS2
3835          * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3836          */
3837         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3838         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3839                 .ifnum = QUIRK_ANY_INTERFACE,
3840                 .type = QUIRK_COMPOSITE,
3841                 .data = (const struct snd_usb_audio_quirk[]) {
3842                         {
3843                                 .ifnum = 0,
3844                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3845                                 .data = &(const struct audioformat) {
3846                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3847                                         .channels = 10,
3848                                         .iface = 0,
3849                                         .altsetting = 1,
3850                                         .altset_idx = 1,
3851                                         .endpoint = 0x01,
3852                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3853                                             USB_ENDPOINT_SYNC_ASYNC,
3854                                         .rates = SNDRV_PCM_RATE_44100|
3855                                             SNDRV_PCM_RATE_48000|
3856                                             SNDRV_PCM_RATE_96000,
3857                                         .rate_min = 44100,
3858                                         .rate_max = 96000,
3859                                         .nr_rates = 3,
3860                                         .rate_table = (unsigned int[]) {
3861                                                 44100, 48000, 96000
3862                                         }
3863                                 }
3864                         },
3865                         {
3866                                 .ifnum = 0,
3867                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3868                                 .data = &(const struct audioformat) {
3869                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3870                                         .channels = 12,
3871                                         .iface = 0,
3872                                         .altsetting = 1,
3873                                         .altset_idx = 1,
3874                                         .endpoint = 0x82,
3875                                         .ep_idx = 1,
3876                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3877                                             USB_ENDPOINT_SYNC_ASYNC|
3878                                             USB_ENDPOINT_USAGE_IMPLICIT_FB,
3879                                         .rates = SNDRV_PCM_RATE_44100|
3880                                             SNDRV_PCM_RATE_48000|
3881                                             SNDRV_PCM_RATE_96000,
3882                                         .rate_min = 44100,
3883                                         .rate_max = 96000,
3884                                         .nr_rates = 3,
3885                                         .rate_table = (unsigned int[]) {
3886                                                 44100, 48000, 96000
3887                                         }
3888                                 }
3889                         },
3890                         {
3891                                 .ifnum = -1
3892                         }
3893                 }
3894         }
3895 },
3896
3897 {
3898         /*
3899          * PIONEER DJ DDJ-800
3900          * PCM is 6 channels out, 6 channels in @ 44.1 fixed
3901          * The Feedback for the output is the input
3902          */
3903         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0029),
3904                 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3905                 .ifnum = QUIRK_ANY_INTERFACE,
3906                 .type = QUIRK_COMPOSITE,
3907                 .data = (const struct snd_usb_audio_quirk[]) {
3908                         {
3909                                 .ifnum = 0,
3910                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3911                                 .data = &(const struct audioformat) {
3912                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3913                                         .channels = 6,
3914                                         .iface = 0,
3915                                         .altsetting = 1,
3916                                         .altset_idx = 1,
3917                                         .endpoint = 0x01,
3918                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3919                                                 USB_ENDPOINT_SYNC_ASYNC,
3920                                         .rates = SNDRV_PCM_RATE_44100,
3921                                         .rate_min = 44100,
3922                                         .rate_max = 44100,
3923                                         .nr_rates = 1,
3924                                         .rate_table = (unsigned int[]) { 44100 }
3925                                 }
3926                         },
3927                         {
3928                                 .ifnum = 0,
3929                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3930                                 .data = &(const struct audioformat) {
3931                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3932                                         .channels = 6,
3933                                         .iface = 0,
3934                                         .altsetting = 1,
3935                                         .altset_idx = 1,
3936                                         .endpoint = 0x82,
3937                                         .ep_idx = 1,
3938                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3939                                                 USB_ENDPOINT_SYNC_ASYNC|
3940                                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3941                                         .rates = SNDRV_PCM_RATE_44100,
3942                                         .rate_min = 44100,
3943                                         .rate_max = 44100,
3944                                         .nr_rates = 1,
3945                                         .rate_table = (unsigned int[]) { 44100 }
3946                                 }
3947                         },
3948                         {
3949                                 .ifnum = -1
3950                         }
3951                 }
3952         }
3953 },
3954
3955 /*
3956  * MacroSilicon MS2100/MS2106 based AV capture cards
3957  *
3958  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3959  * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
3960  * they pretend to be 96kHz mono as a workaround for stereo being broken
3961  * by that...
3962  *
3963  * They also have an issue with initial stream alignment that causes the
3964  * channels to be swapped and out of phase, which is dealt with in quirks.c.
3965  */
3966 {
3967         USB_AUDIO_DEVICE(0x534d, 0x0021),
3968         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3969                 .vendor_name = "MacroSilicon",
3970                 .product_name = "MS210x",
3971                 .ifnum = QUIRK_ANY_INTERFACE,
3972                 .type = QUIRK_COMPOSITE,
3973                 .data = &(const struct snd_usb_audio_quirk[]) {
3974                         {
3975                                 .ifnum = 2,
3976                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3977                         },
3978                         {
3979                                 .ifnum = 3,
3980                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3981                                 .data = &(const struct audioformat) {
3982                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3983                                         .channels = 2,
3984                                         .iface = 3,
3985                                         .altsetting = 1,
3986                                         .altset_idx = 1,
3987                                         .attributes = 0,
3988                                         .endpoint = 0x82,
3989                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3990                                                 USB_ENDPOINT_SYNC_ASYNC,
3991                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3992                                         .rate_min = 48000,
3993                                         .rate_max = 48000,
3994                                 }
3995                         },
3996                         {
3997                                 .ifnum = -1
3998                         }
3999                 }
4000         }
4001 },
4002
4003 /*
4004  * MacroSilicon MS2109 based HDMI capture cards
4005  *
4006  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
4007  * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
4008  * they pretend to be 96kHz mono as a workaround for stereo being broken
4009  * by that...
4010  *
4011  * They also have an issue with initial stream alignment that causes the
4012  * channels to be swapped and out of phase, which is dealt with in quirks.c.
4013  */
4014 {
4015         USB_AUDIO_DEVICE(0x534d, 0x2109),
4016         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4017                 .vendor_name = "MacroSilicon",
4018                 .product_name = "MS2109",
4019                 .ifnum = QUIRK_ANY_INTERFACE,
4020                 .type = QUIRK_COMPOSITE,
4021                 .data = &(const struct snd_usb_audio_quirk[]) {
4022                         {
4023                                 .ifnum = 2,
4024                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
4025                         },
4026                         {
4027                                 .ifnum = 3,
4028                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4029                                 .data = &(const struct audioformat) {
4030                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
4031                                         .channels = 2,
4032                                         .iface = 3,
4033                                         .altsetting = 1,
4034                                         .altset_idx = 1,
4035                                         .attributes = 0,
4036                                         .endpoint = 0x82,
4037                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4038                                                 USB_ENDPOINT_SYNC_ASYNC,
4039                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
4040                                         .rate_min = 48000,
4041                                         .rate_max = 48000,
4042                                 }
4043                         },
4044                         {
4045                                 .ifnum = -1
4046                         }
4047                 }
4048         }
4049 },
4050 {
4051         /*
4052          * Pioneer DJ DJM-750
4053          * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE
4054          */
4055         USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f),
4056         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4057                 .ifnum = QUIRK_ANY_INTERFACE,
4058                 .type = QUIRK_COMPOSITE,
4059                 .data = (const struct snd_usb_audio_quirk[]) {
4060                         {
4061                                 .ifnum = 0,
4062                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4063                                 .data = &(const struct audioformat) {
4064                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4065                                         .channels = 8,
4066                                         .iface = 0,
4067                                         .altsetting = 1,
4068                                         .altset_idx = 1,
4069                                         .endpoint = 0x05,
4070                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4071                                             USB_ENDPOINT_SYNC_ASYNC,
4072                                         .rates = SNDRV_PCM_RATE_44100|
4073                                                 SNDRV_PCM_RATE_48000|
4074                                                 SNDRV_PCM_RATE_96000,
4075                                         .rate_min = 44100,
4076                                         .rate_max = 96000,
4077                                         .nr_rates = 3,
4078                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4079                                 }
4080                         },
4081                         {
4082                                 .ifnum = 0,
4083                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4084                                 .data = &(const struct audioformat) {
4085                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4086                                         .channels = 8,
4087                                         .iface = 0,
4088                                         .altsetting = 1,
4089                                         .altset_idx = 1,
4090                                         .endpoint = 0x86,
4091                                         .ep_idx = 1,
4092                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4093                                                 USB_ENDPOINT_SYNC_ASYNC|
4094                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
4095                                         .rates = SNDRV_PCM_RATE_44100|
4096                                                 SNDRV_PCM_RATE_48000|
4097                                                 SNDRV_PCM_RATE_96000,
4098                                         .rate_min = 44100,
4099                                         .rate_max = 96000,
4100                                         .nr_rates = 3,
4101                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4102                                 }
4103                         },
4104                         {
4105                                 .ifnum = -1
4106                         }
4107                 }
4108         }
4109 },
4110 {
4111         /*
4112          * Pioneer DJ DJM-750MK2
4113          * 10 channels playback & 12 channels capture @ 48kHz S24LE
4114          */
4115         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001b),
4116         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4117                 .ifnum = QUIRK_ANY_INTERFACE,
4118                 .type = QUIRK_COMPOSITE,
4119                 .data = (const struct snd_usb_audio_quirk[]) {
4120                         {
4121                                 .ifnum = 0,
4122                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4123                                 .data = &(const struct audioformat) {
4124                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4125                                         .channels = 10,
4126                                         .iface = 0,
4127                                         .altsetting = 1,
4128                                         .altset_idx = 1,
4129                                         .endpoint = 0x01,
4130                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4131                                             USB_ENDPOINT_SYNC_ASYNC,
4132                                         .rates = SNDRV_PCM_RATE_48000,
4133                                         .rate_min = 48000,
4134                                         .rate_max = 48000,
4135                                         .nr_rates = 1,
4136                                         .rate_table = (unsigned int[]) {
4137                                                 48000
4138                                         }
4139                                 }
4140                         },
4141                         {
4142                                 .ifnum = 0,
4143                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4144                                 .data = &(const struct audioformat) {
4145                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4146                                         .channels = 12,
4147                                         .iface = 0,
4148                                         .altsetting = 1,
4149                                         .altset_idx = 1,
4150                                         .endpoint = 0x82,
4151                                         .ep_idx = 1,
4152                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4153                                                 USB_ENDPOINT_SYNC_ASYNC|
4154                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
4155                                         .rates = SNDRV_PCM_RATE_48000,
4156                                         .rate_min = 48000,
4157                                         .rate_max = 48000,
4158                                         .nr_rates = 1,
4159                                         .rate_table = (unsigned int[]) { 48000 }
4160                                 }
4161                         },
4162                         {
4163                                 .ifnum = -1
4164                         }
4165                 }
4166         }
4167 },
4168 {
4169         /*
4170          * Pioneer DJ DJM-850
4171          * 8 channels playback and 8 channels capture @ 44.1/48/96kHz S24LE
4172          * Playback on EP 0x05
4173          * Capture on EP 0x86
4174          */
4175         USB_DEVICE_VENDOR_SPEC(0x08e4, 0x0163),
4176         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4177                 .ifnum = QUIRK_ANY_INTERFACE,
4178                 .type = QUIRK_COMPOSITE,
4179                 .data = (const struct snd_usb_audio_quirk[]) {
4180                         {
4181                                 .ifnum = 0,
4182                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4183                                 .data = &(const struct audioformat) {
4184                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4185                                         .channels = 8,
4186                                         .iface = 0,
4187                                         .altsetting = 1,
4188                                         .altset_idx = 1,
4189                                         .endpoint = 0x05,
4190                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4191                                             USB_ENDPOINT_SYNC_ASYNC|
4192                                                 USB_ENDPOINT_USAGE_DATA,
4193                                         .rates = SNDRV_PCM_RATE_44100|
4194                                                 SNDRV_PCM_RATE_48000|
4195                                                 SNDRV_PCM_RATE_96000,
4196                                         .rate_min = 44100,
4197                                         .rate_max = 96000,
4198                                         .nr_rates = 3,
4199                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4200                                 }
4201                         },
4202                         {
4203                                 .ifnum = 0,
4204                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4205                                 .data = &(const struct audioformat) {
4206                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4207                                         .channels = 8,
4208                                         .iface = 0,
4209                                         .altsetting = 1,
4210                                         .altset_idx = 1,
4211                                         .endpoint = 0x86,
4212                                         .ep_idx = 1,
4213                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4214                                                 USB_ENDPOINT_SYNC_ASYNC|
4215                                                 USB_ENDPOINT_USAGE_DATA,
4216                                         .rates = SNDRV_PCM_RATE_44100|
4217                                                 SNDRV_PCM_RATE_48000|
4218                                                 SNDRV_PCM_RATE_96000,
4219                                         .rate_min = 44100,
4220                                         .rate_max = 96000,
4221                                         .nr_rates = 3,
4222                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4223                                 }
4224                         },
4225                         {
4226                                 .ifnum = -1
4227                         }
4228                 }
4229         }
4230 },
4231 {
4232         /*
4233          * Pioneer DJ DJM-450
4234          * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
4235          * and 8 channels in @ 48 fixed (endpoint 0x82).
4236          */
4237         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013),
4238         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4239                 .ifnum = QUIRK_ANY_INTERFACE,
4240                 .type = QUIRK_COMPOSITE,
4241                 .data = (const struct snd_usb_audio_quirk[]) {
4242                         {
4243                                 .ifnum = 0,
4244                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4245                                 .data = &(const struct audioformat) {
4246                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4247                                         .channels = 8, // outputs
4248                                         .iface = 0,
4249                                         .altsetting = 1,
4250                                         .altset_idx = 1,
4251                                         .endpoint = 0x01,
4252                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4253                                                 USB_ENDPOINT_SYNC_ASYNC,
4254                                         .rates = SNDRV_PCM_RATE_48000,
4255                                         .rate_min = 48000,
4256                                         .rate_max = 48000,
4257                                         .nr_rates = 1,
4258                                         .rate_table = (unsigned int[]) { 48000 }
4259                                         }
4260                         },
4261                         {
4262                                 .ifnum = 0,
4263                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4264                                 .data = &(const struct audioformat) {
4265                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4266                                         .channels = 8, // inputs
4267                                         .iface = 0,
4268                                         .altsetting = 1,
4269                                         .altset_idx = 1,
4270                                         .endpoint = 0x82,
4271                                         .ep_idx = 1,
4272                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4273                                                 USB_ENDPOINT_SYNC_ASYNC|
4274                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
4275                                         .rates = SNDRV_PCM_RATE_48000,
4276                                         .rate_min = 48000,
4277                                         .rate_max = 48000,
4278                                         .nr_rates = 1,
4279                                         .rate_table = (unsigned int[]) { 48000 }
4280                                 }
4281                         },
4282                         {
4283                                 .ifnum = -1
4284                         }
4285                 }
4286         }
4287 },
4288 {
4289         /*
4290          * Sennheiser GSP670
4291          * Change order of interfaces loaded
4292          */
4293         USB_DEVICE(0x1395, 0x0300),
4294         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
4295         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4296                 .ifnum = QUIRK_ANY_INTERFACE,
4297                 .type = QUIRK_COMPOSITE,
4298                 .data = &(const struct snd_usb_audio_quirk[]) {
4299                         // Communication
4300                         {
4301                                 .ifnum = 3,
4302                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4303                         },
4304                         // Recording
4305                         {
4306                                 .ifnum = 4,
4307                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4308                         },
4309                         // Main
4310                         {
4311                                 .ifnum = 1,
4312                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4313                         },
4314                         {
4315                                 .ifnum = -1
4316                         }
4317                 }
4318         }
4319 },
4320 {
4321         /*
4322          * Fiero SC-01 (firmware v1.0.0 @ 48 kHz)
4323          */
4324         USB_DEVICE(0x2b53, 0x0023),
4325         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4326                 .vendor_name = "Fiero",
4327                 .product_name = "SC-01",
4328                 .ifnum = QUIRK_ANY_INTERFACE,
4329                 .type = QUIRK_COMPOSITE,
4330                 .data = &(const struct snd_usb_audio_quirk[]) {
4331                         {
4332                                 .ifnum = 0,
4333                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4334                         },
4335                         /* Playback */
4336                         {
4337                                 .ifnum = 1,
4338                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4339                                 .data = &(const struct audioformat) {
4340                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4341                                         .channels = 2,
4342                                         .fmt_bits = 24,
4343                                         .iface = 1,
4344                                         .altsetting = 1,
4345                                         .altset_idx = 1,
4346                                         .endpoint = 0x01,
4347                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4348                                                    USB_ENDPOINT_SYNC_ASYNC,
4349                                         .rates = SNDRV_PCM_RATE_48000,
4350                                         .rate_min = 48000,
4351                                         .rate_max = 48000,
4352                                         .nr_rates = 1,
4353                                         .rate_table = (unsigned int[]) { 48000 },
4354                                         .clock = 0x29
4355                                 }
4356                         },
4357                         /* Capture */
4358                         {
4359                                 .ifnum = 2,
4360                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4361                                 .data = &(const struct audioformat) {
4362                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4363                                         .channels = 2,
4364                                         .fmt_bits = 24,
4365                                         .iface = 2,
4366                                         .altsetting = 1,
4367                                         .altset_idx = 1,
4368                                         .endpoint = 0x82,
4369                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4370                                                    USB_ENDPOINT_SYNC_ASYNC |
4371                                                    USB_ENDPOINT_USAGE_IMPLICIT_FB,
4372                                         .rates = SNDRV_PCM_RATE_48000,
4373                                         .rate_min = 48000,
4374                                         .rate_max = 48000,
4375                                         .nr_rates = 1,
4376                                         .rate_table = (unsigned int[]) { 48000 },
4377                                         .clock = 0x29
4378                                 }
4379                         },
4380                         {
4381                                 .ifnum = -1
4382                         }
4383                 }
4384         }
4385 },
4386 {
4387         /*
4388          * Fiero SC-01 (firmware v1.0.0 @ 96 kHz)
4389          */
4390         USB_DEVICE(0x2b53, 0x0024),
4391         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4392                 .vendor_name = "Fiero",
4393                 .product_name = "SC-01",
4394                 .ifnum = QUIRK_ANY_INTERFACE,
4395                 .type = QUIRK_COMPOSITE,
4396                 .data = &(const struct snd_usb_audio_quirk[]) {
4397                         {
4398                                 .ifnum = 0,
4399                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4400                         },
4401                         /* Playback */
4402                         {
4403                                 .ifnum = 1,
4404                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4405                                 .data = &(const struct audioformat) {
4406                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4407                                         .channels = 2,
4408                                         .fmt_bits = 24,
4409                                         .iface = 1,
4410                                         .altsetting = 1,
4411                                         .altset_idx = 1,
4412                                         .endpoint = 0x01,
4413                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4414                                                    USB_ENDPOINT_SYNC_ASYNC,
4415                                         .rates = SNDRV_PCM_RATE_96000,
4416                                         .rate_min = 96000,
4417                                         .rate_max = 96000,
4418                                         .nr_rates = 1,
4419                                         .rate_table = (unsigned int[]) { 96000 },
4420                                         .clock = 0x29
4421                                 }
4422                         },
4423                         /* Capture */
4424                         {
4425                                 .ifnum = 2,
4426                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4427                                 .data = &(const struct audioformat) {
4428                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4429                                         .channels = 2,
4430                                         .fmt_bits = 24,
4431                                         .iface = 2,
4432                                         .altsetting = 1,
4433                                         .altset_idx = 1,
4434                                         .endpoint = 0x82,
4435                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4436                                                    USB_ENDPOINT_SYNC_ASYNC |
4437                                                    USB_ENDPOINT_USAGE_IMPLICIT_FB,
4438                                         .rates = SNDRV_PCM_RATE_96000,
4439                                         .rate_min = 96000,
4440                                         .rate_max = 96000,
4441                                         .nr_rates = 1,
4442                                         .rate_table = (unsigned int[]) { 96000 },
4443                                         .clock = 0x29
4444                                 }
4445                         },
4446                         {
4447                                 .ifnum = -1
4448                         }
4449                 }
4450         }
4451 },
4452 {
4453         /*
4454          * Fiero SC-01 (firmware v1.1.0)
4455          */
4456         USB_DEVICE(0x2b53, 0x0031),
4457         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4458                 .vendor_name = "Fiero",
4459                 .product_name = "SC-01",
4460                 .ifnum = QUIRK_ANY_INTERFACE,
4461                 .type = QUIRK_COMPOSITE,
4462                 .data = &(const struct snd_usb_audio_quirk[]) {
4463                         {
4464                                 .ifnum = 0,
4465                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4466                         },
4467                         /* Playback */
4468                         {
4469                                 .ifnum = 1,
4470                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4471                                 .data = &(const struct audioformat) {
4472                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4473                                         .channels = 2,
4474                                         .fmt_bits = 24,
4475                                         .iface = 1,
4476                                         .altsetting = 1,
4477                                         .altset_idx = 1,
4478                                         .endpoint = 0x01,
4479                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4480                                                    USB_ENDPOINT_SYNC_ASYNC,
4481                                         .rates = SNDRV_PCM_RATE_48000 |
4482                                                  SNDRV_PCM_RATE_96000,
4483                                         .rate_min = 48000,
4484                                         .rate_max = 96000,
4485                                         .nr_rates = 2,
4486                                         .rate_table = (unsigned int[]) { 48000, 96000 },
4487                                         .clock = 0x29
4488                                 }
4489                         },
4490                         /* Capture */
4491                         {
4492                                 .ifnum = 2,
4493                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4494                                 .data = &(const struct audioformat) {
4495                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4496                                         .channels = 2,
4497                                         .fmt_bits = 24,
4498                                         .iface = 2,
4499                                         .altsetting = 1,
4500                                         .altset_idx = 1,
4501                                         .endpoint = 0x82,
4502                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4503                                                    USB_ENDPOINT_SYNC_ASYNC |
4504                                                    USB_ENDPOINT_USAGE_IMPLICIT_FB,
4505                                         .rates = SNDRV_PCM_RATE_48000 |
4506                                                  SNDRV_PCM_RATE_96000,
4507                                         .rate_min = 48000,
4508                                         .rate_max = 96000,
4509                                         .nr_rates = 2,
4510                                         .rate_table = (unsigned int[]) { 48000, 96000 },
4511                                         .clock = 0x29
4512                                 }
4513                         },
4514                         {
4515                                 .ifnum = -1
4516                         }
4517                 }
4518         }
4519 },
4520 {
4521         /* Advanced modes of the Mythware XA001AU.
4522          * For the standard mode, Mythware XA001AU has ID ffad:a001
4523          */
4524         USB_DEVICE_VENDOR_SPEC(0xffad, 0xa001),
4525         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4526                 .vendor_name = "Mythware",
4527                 .product_name = "XA001AU",
4528                 .ifnum = QUIRK_ANY_INTERFACE,
4529                 .type = QUIRK_COMPOSITE,
4530                 .data = (const struct snd_usb_audio_quirk[]) {
4531                         {
4532                                 .ifnum = 0,
4533                                 .type = QUIRK_IGNORE_INTERFACE,
4534                         },
4535                         {
4536                                 .ifnum = 1,
4537                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
4538                         },
4539                         {
4540                                 .ifnum = 2,
4541                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
4542                         },
4543                         {
4544                                 .ifnum = -1
4545                         }
4546                 }
4547         }
4548 },
4549
4550 #undef USB_DEVICE_VENDOR_SPEC
4551 #undef USB_AUDIO_DEVICE