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                                         .channels = 4,
3017                                         .iface = 2,
3018                                         .altsetting = 1,
3019                                         .altset_idx = 1,
3020                                         .attributes = 0x00,
3021                                         .endpoint = 0x01,
3022                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3023                                                 USB_ENDPOINT_SYNC_ASYNC,
3024                                         .rates = SNDRV_PCM_RATE_48000,
3025                                         .rate_min = 48000,
3026                                         .rate_max = 48000,
3027                                         .nr_rates = 1,
3028                                         .rate_table = (unsigned int[]) {
3029                                                 48000
3030                                         }
3031                                 }
3032                         },
3033                         {
3034                                 .ifnum = 3,
3035                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3036                                 .data = &(const struct audioformat) {
3037                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3038                                         .channels = 4,
3039                                         .iface = 3,
3040                                         .altsetting = 1,
3041                                         .altset_idx = 1,
3042                                         .endpoint = 0x81,
3043                                         .attributes = 0x00,
3044                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3045                                                 USB_ENDPOINT_SYNC_ASYNC,
3046                                         .maxpacksize = 0x009c,
3047                                         .rates = SNDRV_PCM_RATE_48000,
3048                                         .rate_min = 48000,
3049                                         .rate_max = 48000,
3050                                         .nr_rates = 1,
3051                                         .rate_table = (unsigned int[]) {
3052                                                 48000
3053                                         }
3054                                 }
3055                         },
3056                         {
3057                                 .ifnum = 4,
3058                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
3059                                 .data = &(const struct snd_usb_midi_endpoint_info) {
3060                                         .out_cables = 0x0001,
3061                                         .in_cables  = 0x0001
3062                                 }
3063                         },
3064                         {
3065                                 .ifnum = -1
3066                         }
3067                 }
3068         }
3069 },
3070 {
3071         /* Tascam US122 MKII - playback-only support */
3072         USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
3073         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3074                 .vendor_name = "TASCAM",
3075                 .product_name = "US122 MKII",
3076                 .ifnum = QUIRK_ANY_INTERFACE,
3077                 .type = QUIRK_COMPOSITE,
3078                 .data = (const struct snd_usb_audio_quirk[]) {
3079                         {
3080                                 .ifnum = 0,
3081                                 .type = QUIRK_IGNORE_INTERFACE
3082                         },
3083                         {
3084                                 .ifnum = 1,
3085                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3086                                 .data = &(const struct audioformat) {
3087                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3088                                         .channels = 2,
3089                                         .iface = 1,
3090                                         .altsetting = 1,
3091                                         .altset_idx = 1,
3092                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3093                                         .endpoint = 0x02,
3094                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3095                                         .rates = SNDRV_PCM_RATE_44100 |
3096                                                  SNDRV_PCM_RATE_48000 |
3097                                                  SNDRV_PCM_RATE_88200 |
3098                                                  SNDRV_PCM_RATE_96000,
3099                                         .rate_min = 44100,
3100                                         .rate_max = 96000,
3101                                         .nr_rates = 4,
3102                                         .rate_table = (unsigned int[]) {
3103                                                 44100, 48000, 88200, 96000
3104                                         }
3105                                 }
3106                         },
3107                         {
3108                                 .ifnum = -1
3109                         }
3110                 }
3111         }
3112 },
3113
3114 /* Denon DN-X1600 */
3115 {
3116         USB_AUDIO_DEVICE(0x154e, 0x500e),
3117         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3118                 .vendor_name = "Denon",
3119                 .product_name = "DN-X1600",
3120                 .ifnum = QUIRK_ANY_INTERFACE,
3121                 .type = QUIRK_COMPOSITE,
3122                 .data = (const struct snd_usb_audio_quirk[]){
3123                         {
3124                                 .ifnum = 0,
3125                                 .type = QUIRK_IGNORE_INTERFACE,
3126                         },
3127                         {
3128                                 .ifnum = 1,
3129                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3130                                 .data = &(const struct audioformat) {
3131                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3132                                         .channels = 8,
3133                                         .iface = 1,
3134                                         .altsetting = 1,
3135                                         .altset_idx = 1,
3136                                         .attributes = 0x0,
3137                                         .endpoint = 0x01,
3138                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3139                                                 USB_ENDPOINT_SYNC_ADAPTIVE,
3140                                         .maxpacksize = 0x138,
3141                                         .rates = SNDRV_PCM_RATE_48000,
3142                                         .rate_min = 48000,
3143                                         .rate_max = 48000,
3144                                         .nr_rates = 1,
3145                                         .rate_table = (unsigned int[]) {
3146                                                 48000
3147                                         }
3148                                 }
3149                         },
3150                         {
3151                                 .ifnum = 2,
3152                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3153                                 .data = &(const struct audioformat) {
3154                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3155                                         .channels = 8,
3156                                         .iface = 2,
3157                                         .altsetting = 1,
3158                                         .altset_idx = 1,
3159                                         .attributes = 0x0,
3160                                         .endpoint = 0x85,
3161                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3162                                                 USB_ENDPOINT_SYNC_ADAPTIVE,
3163                                         .maxpacksize = 0x138,
3164                                         .rates = SNDRV_PCM_RATE_48000,
3165                                         .rate_min = 48000,
3166                                         .rate_max = 48000,
3167                                         .nr_rates = 1,
3168                                         .rate_table = (unsigned int[]) {
3169                                                 48000
3170                                         }
3171                                 }
3172                         },
3173                         {
3174                                 .ifnum = 4,
3175                                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
3176                         },
3177                         {
3178                                 .ifnum = -1
3179                         }
3180                 }
3181         }
3182 },
3183
3184 /* Microsoft XboxLive Headset/Xbox Communicator */
3185 {
3186         USB_DEVICE(0x045e, 0x0283),
3187         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3188         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3189                 .vendor_name = "Microsoft",
3190                 .product_name = "XboxLive Headset/Xbox Communicator",
3191                 .ifnum = QUIRK_ANY_INTERFACE,
3192                 .type = QUIRK_COMPOSITE,
3193                 .data = &(const struct snd_usb_audio_quirk[]) {
3194                         {
3195                                 /* playback */
3196                                 .ifnum = 0,
3197                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3198                                 .data = &(const struct audioformat) {
3199                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3200                                         .channels = 1,
3201                                         .iface = 0,
3202                                         .altsetting = 0,
3203                                         .altset_idx = 0,
3204                                         .attributes = 0,
3205                                         .endpoint = 0x04,
3206                                         .ep_attr = 0x05,
3207                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3208                                         .rate_min = 22050,
3209                                         .rate_max = 22050
3210                                 }
3211                         },
3212                         {
3213                                 /* capture */
3214                                 .ifnum = 1,
3215                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3216                                 .data = &(const struct audioformat) {
3217                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3218                                         .channels = 1,
3219                                         .iface = 1,
3220                                         .altsetting = 0,
3221                                         .altset_idx = 0,
3222                                         .attributes = 0,
3223                                         .endpoint = 0x85,
3224                                         .ep_attr = 0x05,
3225                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3226                                         .rate_min = 16000,
3227                                         .rate_max = 16000
3228                                 }
3229                         },
3230                         {
3231                                 .ifnum = -1
3232                         }
3233                 }
3234         }
3235 },
3236
3237 /* Reloop Play */
3238 {
3239         USB_DEVICE(0x200c, 0x100b),
3240         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3241         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3242                 .ifnum = QUIRK_ANY_INTERFACE,
3243                 .type = QUIRK_COMPOSITE,
3244                 .data = &(const struct snd_usb_audio_quirk[]) {
3245                         {
3246                                 .ifnum = 0,
3247                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3248                         },
3249                         {
3250                                 .ifnum = 1,
3251                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3252                                 .data = &(const struct audioformat) {
3253                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3254                                         .channels = 4,
3255                                         .iface = 1,
3256                                         .altsetting = 1,
3257                                         .altset_idx = 1,
3258                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3259                                         .endpoint = 0x01,
3260                                         .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3261                                         .rates = SNDRV_PCM_RATE_44100 |
3262                                                  SNDRV_PCM_RATE_48000,
3263                                         .rate_min = 44100,
3264                                         .rate_max = 48000,
3265                                         .nr_rates = 2,
3266                                         .rate_table = (unsigned int[]) {
3267                                                 44100, 48000
3268                                         }
3269                                 }
3270                         },
3271                         {
3272                                 .ifnum = -1
3273                         }
3274                 }
3275         }
3276 },
3277
3278 {
3279         /*
3280          * ZOOM R16/24 in audio interface mode.
3281          * Playback requires an extra four byte LE length indicator
3282          * at the start of each isochronous packet. This quirk is
3283          * enabled in create_standard_audio_quirk().
3284          */
3285         USB_DEVICE(0x1686, 0x00dd),
3286         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3287                 .ifnum = QUIRK_ANY_INTERFACE,
3288                 .type = QUIRK_COMPOSITE,
3289                 .data = (const struct snd_usb_audio_quirk[]) {
3290                         {
3291                                 /* Playback  */
3292                                 .ifnum = 1,
3293                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3294                         },
3295                         {
3296                                 /* Capture */
3297                                 .ifnum = 2,
3298                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3299                         },
3300                         {
3301                                 /* Midi */
3302                                 .ifnum = 3,
3303                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3304                         },
3305                         {
3306                                 .ifnum = -1
3307                         },
3308                 }
3309         }
3310 },
3311
3312 {
3313         /*
3314          * Some USB MIDI devices don't have an audio control interface,
3315          * so we have to grab MIDI streaming interfaces here.
3316          */
3317         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3318                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3319         .bInterfaceClass = USB_CLASS_AUDIO,
3320         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3321         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3322                 .ifnum = QUIRK_ANY_INTERFACE,
3323                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3324         }
3325 },
3326
3327 /* Rane SL-1 */
3328 {
3329         USB_DEVICE(0x13e5, 0x0001),
3330         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3331                 .ifnum = QUIRK_ANY_INTERFACE,
3332                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3333         }
3334 },
3335
3336 /* disabled due to regression for other devices;
3337  * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3338  */
3339 #if 0
3340 {
3341         /*
3342          * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3343          * ID, but it looks like the product ID actually is only for Nura.
3344          * The capture interface does not work at all (even on Windows),
3345          * and only the 48 kHz sample rate works for the playback interface.
3346          */
3347         USB_DEVICE(0x0a12, 0x1243),
3348         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3349                 .ifnum = QUIRK_ANY_INTERFACE,
3350                 .type = QUIRK_COMPOSITE,
3351                 .data = (const struct snd_usb_audio_quirk[]) {
3352                         {
3353                                 .ifnum = 0,
3354                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3355                         },
3356                         /* Capture */
3357                         {
3358                                 .ifnum = 1,
3359                                 .type = QUIRK_IGNORE_INTERFACE,
3360                         },
3361                         /* Playback */
3362                         {
3363                                 .ifnum = 2,
3364                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3365                                 .data = &(const struct audioformat) {
3366                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3367                                         .channels = 2,
3368                                         .iface = 2,
3369                                         .altsetting = 1,
3370                                         .altset_idx = 1,
3371                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3372                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3373                                         .endpoint = 0x03,
3374                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3375                                         .rates = SNDRV_PCM_RATE_48000,
3376                                         .rate_min = 48000,
3377                                         .rate_max = 48000,
3378                                         .nr_rates = 1,
3379                                         .rate_table = (unsigned int[]) {
3380                                                 48000
3381                                         }
3382                                 }
3383                         },
3384                         {
3385                                 .ifnum = -1
3386                         },
3387                 }
3388         }
3389 },
3390 #endif /* disabled */
3391
3392 {
3393         /*
3394          * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3395          * even though it advertises more. The capture interface doesn't work
3396          * even on windows.
3397          */
3398         USB_DEVICE(0x19b5, 0x0021),
3399         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3400                 .ifnum = QUIRK_ANY_INTERFACE,
3401                 .type = QUIRK_COMPOSITE,
3402                 .data = (const struct snd_usb_audio_quirk[]) {
3403                         {
3404                                 .ifnum = 0,
3405                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3406                         },
3407                         /* Playback */
3408                         {
3409                                 .ifnum = 1,
3410                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3411                                 .data = &(const struct audioformat) {
3412                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3413                                         .channels = 2,
3414                                         .iface = 1,
3415                                         .altsetting = 1,
3416                                         .altset_idx = 1,
3417                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3418                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3419                                         .endpoint = 0x03,
3420                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3421                                         .rates = SNDRV_PCM_RATE_48000,
3422                                         .rate_min = 48000,
3423                                         .rate_max = 48000,
3424                                         .nr_rates = 1,
3425                                         .rate_table = (unsigned int[]) {
3426                                                 48000
3427                                         }
3428                                 }
3429                         },
3430                         {
3431                                 .ifnum = -1
3432                         },
3433                 }
3434         }
3435 },
3436 /* MOTU Microbook II */
3437 {
3438         USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3439         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3440                 .vendor_name = "MOTU",
3441                 .product_name = "MicroBookII",
3442                 .ifnum = QUIRK_ANY_INTERFACE,
3443                 .type = QUIRK_COMPOSITE,
3444                 .data = (const struct snd_usb_audio_quirk[]) {
3445                         {
3446                                 .ifnum = 0,
3447                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3448                         },
3449                         {
3450                                 .ifnum = 0,
3451                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3452                                 .data = &(const struct audioformat) {
3453                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3454                                         .channels = 6,
3455                                         .iface = 0,
3456                                         .altsetting = 1,
3457                                         .altset_idx = 1,
3458                                         .attributes = 0,
3459                                         .endpoint = 0x84,
3460                                         .rates = SNDRV_PCM_RATE_96000,
3461                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3462                                                    USB_ENDPOINT_SYNC_ASYNC,
3463                                         .rate_min = 96000,
3464                                         .rate_max = 96000,
3465                                         .nr_rates = 1,
3466                                         .maxpacksize = 0x00d8,
3467                                         .rate_table = (unsigned int[]) {
3468                                                 96000
3469                                         }
3470                                 }
3471                         },
3472                         {
3473                                 .ifnum = 0,
3474                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3475                                 .data = &(const struct audioformat) {
3476                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3477                                         .channels = 8,
3478                                         .iface = 0,
3479                                         .altsetting = 1,
3480                                         .altset_idx = 1,
3481                                         .attributes = 0,
3482                                         .endpoint = 0x03,
3483                                         .ep_idx = 1,
3484                                         .rates = SNDRV_PCM_RATE_96000,
3485                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3486                                                    USB_ENDPOINT_SYNC_ASYNC,
3487                                         .rate_min = 96000,
3488                                         .rate_max = 96000,
3489                                         .nr_rates = 1,
3490                                         .maxpacksize = 0x0120,
3491                                         .rate_table = (unsigned int[]) {
3492                                                 96000
3493                                         }
3494                                 }
3495                         },
3496                         {
3497                                 .ifnum = -1
3498                         }
3499                 }
3500         }
3501 },
3502 {
3503         /*
3504          * PIONEER DJ DDJ-SX3
3505          * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3506          * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3507          * The feedback for the output is the input.
3508          */
3509         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3510         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3511                 .ifnum = QUIRK_ANY_INTERFACE,
3512                 .type = QUIRK_COMPOSITE,
3513                 .data = (const struct snd_usb_audio_quirk[]) {
3514                         {
3515                                 .ifnum = 0,
3516                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3517                                 .data = &(const struct audioformat) {
3518                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3519                                         .channels = 12,
3520                                         .iface = 0,
3521                                         .altsetting = 1,
3522                                         .altset_idx = 1,
3523                                         .endpoint = 0x05,
3524                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3525                                                    USB_ENDPOINT_SYNC_ASYNC,
3526                                         .rates = SNDRV_PCM_RATE_44100,
3527                                         .rate_min = 44100,
3528                                         .rate_max = 44100,
3529                                         .nr_rates = 1,
3530                                         .rate_table = (unsigned int[]) { 44100 }
3531                                 }
3532                         },
3533                         {
3534                                 .ifnum = 0,
3535                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3536                                 .data = &(const struct audioformat) {
3537                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3538                                         .channels = 10,
3539                                         .iface = 0,
3540                                         .altsetting = 1,
3541                                         .altset_idx = 1,
3542                                         .endpoint = 0x86,
3543                                         .ep_idx = 1,
3544                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3545                                                  USB_ENDPOINT_SYNC_ASYNC|
3546                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3547                                         .rates = SNDRV_PCM_RATE_44100,
3548                                         .rate_min = 44100,
3549                                         .rate_max = 44100,
3550                                         .nr_rates = 1,
3551                                         .rate_table = (unsigned int[]) { 44100 }
3552                                 }
3553                         },
3554                         {
3555                                 .ifnum = -1
3556                         }
3557                 }
3558         }
3559 },
3560 {
3561         /*
3562          * Pioneer DJ DJM-250MK2
3563          * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3564          * and 8 channels in @ 48 fixed (endpoint 0x82).
3565          *
3566          * Both playback and recording is working, even simultaneously.
3567          *
3568          * Playback channels could be mapped to:
3569          *  - CH1
3570          *  - CH2
3571          *  - AUX
3572          *
3573          * Recording channels could be mapped to:
3574          *  - Post CH1 Fader
3575          *  - Post CH2 Fader
3576          *  - Cross Fader A
3577          *  - Cross Fader B
3578          *  - MIC
3579          *  - AUX
3580          *  - REC OUT
3581          *
3582          * There is remaining problem with recording directly from PHONO/LINE.
3583          * If we map a channel to:
3584          *  - CH1 Control Tone PHONO
3585          *  - CH1 Control Tone LINE
3586          *  - CH2 Control Tone PHONO
3587          *  - CH2 Control Tone LINE
3588          * it is silent.
3589          * There is no signal even on other operating systems with official drivers.
3590          * The signal appears only when a supported application is started.
3591          * This needs to be investigated yet...
3592          * (there is quite a lot communication on the USB in both directions)
3593          *
3594          * In current version this mixer could be used for playback
3595          * and for recording from vinyls (through Post CH* Fader)
3596          * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3597          */
3598         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3599         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3600                 .ifnum = QUIRK_ANY_INTERFACE,
3601                 .type = QUIRK_COMPOSITE,
3602                 .data = (const struct snd_usb_audio_quirk[]) {
3603                         {
3604                                 .ifnum = 0,
3605                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3606                                 .data = &(const struct audioformat) {
3607                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3608                                         .channels = 8, // outputs
3609                                         .iface = 0,
3610                                         .altsetting = 1,
3611                                         .altset_idx = 1,
3612                                         .endpoint = 0x01,
3613                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3614                                                 USB_ENDPOINT_SYNC_ASYNC,
3615                                         .rates = SNDRV_PCM_RATE_48000,
3616                                         .rate_min = 48000,
3617                                         .rate_max = 48000,
3618                                         .nr_rates = 1,
3619                                         .rate_table = (unsigned int[]) { 48000 }
3620                                         }
3621                         },
3622                         {
3623                                 .ifnum = 0,
3624                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3625                                 .data = &(const struct audioformat) {
3626                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3627                                         .channels = 8, // inputs
3628                                         .iface = 0,
3629                                         .altsetting = 1,
3630                                         .altset_idx = 1,
3631                                         .endpoint = 0x82,
3632                                         .ep_idx = 1,
3633                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3634                                                 USB_ENDPOINT_SYNC_ASYNC|
3635                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3636                                         .rates = SNDRV_PCM_RATE_48000,
3637                                         .rate_min = 48000,
3638                                         .rate_max = 48000,
3639                                         .nr_rates = 1,
3640                                         .rate_table = (unsigned int[]) { 48000 }
3641                                 }
3642                         },
3643                         {
3644                                 .ifnum = -1
3645                         }
3646                 }
3647         }
3648 },
3649 {
3650         /*
3651          * PIONEER DJ DDJ-RB
3652          * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3653          * The feedback for the output is the dummy input.
3654          */
3655         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3656         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3657                 .ifnum = QUIRK_ANY_INTERFACE,
3658                 .type = QUIRK_COMPOSITE,
3659                 .data = (const struct snd_usb_audio_quirk[]) {
3660                         {
3661                                 .ifnum = 0,
3662                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3663                                 .data = &(const struct audioformat) {
3664                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3665                                         .channels = 4,
3666                                         .iface = 0,
3667                                         .altsetting = 1,
3668                                         .altset_idx = 1,
3669                                         .endpoint = 0x01,
3670                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3671                                                    USB_ENDPOINT_SYNC_ASYNC,
3672                                         .rates = SNDRV_PCM_RATE_44100,
3673                                         .rate_min = 44100,
3674                                         .rate_max = 44100,
3675                                         .nr_rates = 1,
3676                                         .rate_table = (unsigned int[]) { 44100 }
3677                                 }
3678                         },
3679                         {
3680                                 .ifnum = 0,
3681                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3682                                 .data = &(const struct audioformat) {
3683                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3684                                         .channels = 2,
3685                                         .iface = 0,
3686                                         .altsetting = 1,
3687                                         .altset_idx = 1,
3688                                         .endpoint = 0x82,
3689                                         .ep_idx = 1,
3690                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3691                                                  USB_ENDPOINT_SYNC_ASYNC|
3692                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3693                                         .rates = SNDRV_PCM_RATE_44100,
3694                                         .rate_min = 44100,
3695                                         .rate_max = 44100,
3696                                         .nr_rates = 1,
3697                                         .rate_table = (unsigned int[]) { 44100 }
3698                                 }
3699                         },
3700                         {
3701                                 .ifnum = -1
3702                         }
3703                 }
3704         }
3705 },
3706
3707 {
3708         /*
3709          * PIONEER DJ DDJ-RR
3710          * PCM is 6 channels out & 4 channels in @ 44.1 fixed
3711          */
3712         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000d),
3713         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3714                 .ifnum = QUIRK_ANY_INTERFACE,
3715                 .type = QUIRK_COMPOSITE,
3716                 .data = (const struct snd_usb_audio_quirk[]) {
3717                         {
3718                                 .ifnum = 0,
3719                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3720                                 .data = &(const struct audioformat) {
3721                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3722                                         .channels = 6, //Master, Headphones & Booth
3723                                         .iface = 0,
3724                                         .altsetting = 1,
3725                                         .altset_idx = 1,
3726                                         .endpoint = 0x01,
3727                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3728                                                    USB_ENDPOINT_SYNC_ASYNC,
3729                                         .rates = SNDRV_PCM_RATE_44100,
3730                                         .rate_min = 44100,
3731                                         .rate_max = 44100,
3732                                         .nr_rates = 1,
3733                                         .rate_table = (unsigned int[]) { 44100 }
3734                                 }
3735                         },
3736                         {
3737                                 .ifnum = 0,
3738                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3739                                 .data = &(const struct audioformat) {
3740                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3741                                         .channels = 4, //2x RCA inputs (CH1 & CH2)
3742                                         .iface = 0,
3743                                         .altsetting = 1,
3744                                         .altset_idx = 1,
3745                                         .endpoint = 0x82,
3746                                         .ep_idx = 1,
3747                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3748                                                  USB_ENDPOINT_SYNC_ASYNC|
3749                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3750                                         .rates = SNDRV_PCM_RATE_44100,
3751                                         .rate_min = 44100,
3752                                         .rate_max = 44100,
3753                                         .nr_rates = 1,
3754                                         .rate_table = (unsigned int[]) { 44100 }
3755                                 }
3756                         },
3757                         {
3758                                 .ifnum = -1
3759                         }
3760                 }
3761         }
3762 },
3763
3764 {
3765         /*
3766          * PIONEER DJ DDJ-SR2
3767          * PCM is 4 channels out, 6 channels in @ 44.1 fixed
3768          * The Feedback for the output is the input
3769          */
3770         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001e),
3771                 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3772                 .ifnum = QUIRK_ANY_INTERFACE,
3773                 .type = QUIRK_COMPOSITE,
3774                 .data = (const struct snd_usb_audio_quirk[]) {
3775                         {
3776                                 .ifnum = 0,
3777                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3778                                 .data = &(const struct audioformat) {
3779                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3780                                         .channels = 4,
3781                                         .iface = 0,
3782                                         .altsetting = 1,
3783                                         .altset_idx = 1,
3784                                         .endpoint = 0x01,
3785                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3786                                                 USB_ENDPOINT_SYNC_ASYNC,
3787                                         .rates = SNDRV_PCM_RATE_44100,
3788                                         .rate_min = 44100,
3789                                         .rate_max = 44100,
3790                                         .nr_rates = 1,
3791                                         .rate_table = (unsigned int[]) { 44100 }
3792                                 }
3793                         },
3794                         {
3795                                 .ifnum = 0,
3796                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3797                                 .data = &(const struct audioformat) {
3798                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3799                                         .channels = 6,
3800                                         .iface = 0,
3801                                         .altsetting = 1,
3802                                         .altset_idx = 1,
3803                                         .endpoint = 0x82,
3804                                         .ep_idx = 1,
3805                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3806                                                 USB_ENDPOINT_SYNC_ASYNC|
3807                                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3808                                         .rates = SNDRV_PCM_RATE_44100,
3809                                         .rate_min = 44100,
3810                                         .rate_max = 44100,
3811                                         .nr_rates = 1,
3812                                         .rate_table = (unsigned int[]) { 44100 }
3813                                 }
3814                         },
3815                         {
3816                                 .ifnum = -1
3817                         }
3818                 }
3819         }
3820 },
3821
3822 {
3823         /*
3824          * Pioneer DJ DJM-900NXS2
3825          * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3826          */
3827         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3828         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3829                 .ifnum = QUIRK_ANY_INTERFACE,
3830                 .type = QUIRK_COMPOSITE,
3831                 .data = (const struct snd_usb_audio_quirk[]) {
3832                         {
3833                                 .ifnum = 0,
3834                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3835                                 .data = &(const struct audioformat) {
3836                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3837                                         .channels = 10,
3838                                         .iface = 0,
3839                                         .altsetting = 1,
3840                                         .altset_idx = 1,
3841                                         .endpoint = 0x01,
3842                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3843                                             USB_ENDPOINT_SYNC_ASYNC,
3844                                         .rates = SNDRV_PCM_RATE_44100|
3845                                             SNDRV_PCM_RATE_48000|
3846                                             SNDRV_PCM_RATE_96000,
3847                                         .rate_min = 44100,
3848                                         .rate_max = 96000,
3849                                         .nr_rates = 3,
3850                                         .rate_table = (unsigned int[]) {
3851                                                 44100, 48000, 96000
3852                                         }
3853                                 }
3854                         },
3855                         {
3856                                 .ifnum = 0,
3857                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3858                                 .data = &(const struct audioformat) {
3859                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3860                                         .channels = 12,
3861                                         .iface = 0,
3862                                         .altsetting = 1,
3863                                         .altset_idx = 1,
3864                                         .endpoint = 0x82,
3865                                         .ep_idx = 1,
3866                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3867                                             USB_ENDPOINT_SYNC_ASYNC|
3868                                             USB_ENDPOINT_USAGE_IMPLICIT_FB,
3869                                         .rates = SNDRV_PCM_RATE_44100|
3870                                             SNDRV_PCM_RATE_48000|
3871                                             SNDRV_PCM_RATE_96000,
3872                                         .rate_min = 44100,
3873                                         .rate_max = 96000,
3874                                         .nr_rates = 3,
3875                                         .rate_table = (unsigned int[]) {
3876                                                 44100, 48000, 96000
3877                                         }
3878                                 }
3879                         },
3880                         {
3881                                 .ifnum = -1
3882                         }
3883                 }
3884         }
3885 },
3886
3887 {
3888         /*
3889          * PIONEER DJ DDJ-800
3890          * PCM is 6 channels out, 6 channels in @ 44.1 fixed
3891          * The Feedback for the output is the input
3892          */
3893         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0029),
3894                 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3895                 .ifnum = QUIRK_ANY_INTERFACE,
3896                 .type = QUIRK_COMPOSITE,
3897                 .data = (const struct snd_usb_audio_quirk[]) {
3898                         {
3899                                 .ifnum = 0,
3900                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3901                                 .data = &(const struct audioformat) {
3902                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3903                                         .channels = 6,
3904                                         .iface = 0,
3905                                         .altsetting = 1,
3906                                         .altset_idx = 1,
3907                                         .endpoint = 0x01,
3908                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3909                                                 USB_ENDPOINT_SYNC_ASYNC,
3910                                         .rates = SNDRV_PCM_RATE_44100,
3911                                         .rate_min = 44100,
3912                                         .rate_max = 44100,
3913                                         .nr_rates = 1,
3914                                         .rate_table = (unsigned int[]) { 44100 }
3915                                 }
3916                         },
3917                         {
3918                                 .ifnum = 0,
3919                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3920                                 .data = &(const struct audioformat) {
3921                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3922                                         .channels = 6,
3923                                         .iface = 0,
3924                                         .altsetting = 1,
3925                                         .altset_idx = 1,
3926                                         .endpoint = 0x82,
3927                                         .ep_idx = 1,
3928                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3929                                                 USB_ENDPOINT_SYNC_ASYNC|
3930                                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3931                                         .rates = SNDRV_PCM_RATE_44100,
3932                                         .rate_min = 44100,
3933                                         .rate_max = 44100,
3934                                         .nr_rates = 1,
3935                                         .rate_table = (unsigned int[]) { 44100 }
3936                                 }
3937                         },
3938                         {
3939                                 .ifnum = -1
3940                         }
3941                 }
3942         }
3943 },
3944
3945 /*
3946  * MacroSilicon MS2100/MS2106 based AV capture cards
3947  *
3948  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3949  * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
3950  * they pretend to be 96kHz mono as a workaround for stereo being broken
3951  * by that...
3952  *
3953  * They also have an issue with initial stream alignment that causes the
3954  * channels to be swapped and out of phase, which is dealt with in quirks.c.
3955  */
3956 {
3957         USB_AUDIO_DEVICE(0x534d, 0x0021),
3958         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3959                 .vendor_name = "MacroSilicon",
3960                 .product_name = "MS210x",
3961                 .ifnum = QUIRK_ANY_INTERFACE,
3962                 .type = QUIRK_COMPOSITE,
3963                 .data = &(const struct snd_usb_audio_quirk[]) {
3964                         {
3965                                 .ifnum = 2,
3966                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3967                         },
3968                         {
3969                                 .ifnum = 3,
3970                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3971                                 .data = &(const struct audioformat) {
3972                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3973                                         .channels = 2,
3974                                         .iface = 3,
3975                                         .altsetting = 1,
3976                                         .altset_idx = 1,
3977                                         .attributes = 0,
3978                                         .endpoint = 0x82,
3979                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3980                                                 USB_ENDPOINT_SYNC_ASYNC,
3981                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3982                                         .rate_min = 48000,
3983                                         .rate_max = 48000,
3984                                 }
3985                         },
3986                         {
3987                                 .ifnum = -1
3988                         }
3989                 }
3990         }
3991 },
3992
3993 /*
3994  * MacroSilicon MS2109 based HDMI capture cards
3995  *
3996  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3997  * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
3998  * they pretend to be 96kHz mono as a workaround for stereo being broken
3999  * by that...
4000  *
4001  * They also have an issue with initial stream alignment that causes the
4002  * channels to be swapped and out of phase, which is dealt with in quirks.c.
4003  */
4004 {
4005         USB_AUDIO_DEVICE(0x534d, 0x2109),
4006         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4007                 .vendor_name = "MacroSilicon",
4008                 .product_name = "MS2109",
4009                 .ifnum = QUIRK_ANY_INTERFACE,
4010                 .type = QUIRK_COMPOSITE,
4011                 .data = &(const struct snd_usb_audio_quirk[]) {
4012                         {
4013                                 .ifnum = 2,
4014                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
4015                         },
4016                         {
4017                                 .ifnum = 3,
4018                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4019                                 .data = &(const struct audioformat) {
4020                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
4021                                         .channels = 2,
4022                                         .iface = 3,
4023                                         .altsetting = 1,
4024                                         .altset_idx = 1,
4025                                         .attributes = 0,
4026                                         .endpoint = 0x82,
4027                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4028                                                 USB_ENDPOINT_SYNC_ASYNC,
4029                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
4030                                         .rate_min = 48000,
4031                                         .rate_max = 48000,
4032                                 }
4033                         },
4034                         {
4035                                 .ifnum = -1
4036                         }
4037                 }
4038         }
4039 },
4040 {
4041         /*
4042          * Pioneer DJ DJM-750
4043          * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE
4044          */
4045         USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f),
4046         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4047                 .ifnum = QUIRK_ANY_INTERFACE,
4048                 .type = QUIRK_COMPOSITE,
4049                 .data = (const struct snd_usb_audio_quirk[]) {
4050                         {
4051                                 .ifnum = 0,
4052                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4053                                 .data = &(const struct audioformat) {
4054                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4055                                         .channels = 8,
4056                                         .iface = 0,
4057                                         .altsetting = 1,
4058                                         .altset_idx = 1,
4059                                         .endpoint = 0x05,
4060                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4061                                             USB_ENDPOINT_SYNC_ASYNC,
4062                                         .rates = SNDRV_PCM_RATE_44100|
4063                                                 SNDRV_PCM_RATE_48000|
4064                                                 SNDRV_PCM_RATE_96000,
4065                                         .rate_min = 44100,
4066                                         .rate_max = 96000,
4067                                         .nr_rates = 3,
4068                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4069                                 }
4070                         },
4071                         {
4072                                 .ifnum = 0,
4073                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4074                                 .data = &(const struct audioformat) {
4075                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4076                                         .channels = 8,
4077                                         .iface = 0,
4078                                         .altsetting = 1,
4079                                         .altset_idx = 1,
4080                                         .endpoint = 0x86,
4081                                         .ep_idx = 1,
4082                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4083                                                 USB_ENDPOINT_SYNC_ASYNC|
4084                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
4085                                         .rates = SNDRV_PCM_RATE_44100|
4086                                                 SNDRV_PCM_RATE_48000|
4087                                                 SNDRV_PCM_RATE_96000,
4088                                         .rate_min = 44100,
4089                                         .rate_max = 96000,
4090                                         .nr_rates = 3,
4091                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4092                                 }
4093                         },
4094                         {
4095                                 .ifnum = -1
4096                         }
4097                 }
4098         }
4099 },
4100 {
4101         /*
4102          * Pioneer DJ DJM-750MK2
4103          * 10 channels playback & 12 channels capture @ 48kHz S24LE
4104          */
4105         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001b),
4106         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4107                 .ifnum = QUIRK_ANY_INTERFACE,
4108                 .type = QUIRK_COMPOSITE,
4109                 .data = (const struct snd_usb_audio_quirk[]) {
4110                         {
4111                                 .ifnum = 0,
4112                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4113                                 .data = &(const struct audioformat) {
4114                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4115                                         .channels = 10,
4116                                         .iface = 0,
4117                                         .altsetting = 1,
4118                                         .altset_idx = 1,
4119                                         .endpoint = 0x01,
4120                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4121                                             USB_ENDPOINT_SYNC_ASYNC,
4122                                         .rates = SNDRV_PCM_RATE_48000,
4123                                         .rate_min = 48000,
4124                                         .rate_max = 48000,
4125                                         .nr_rates = 1,
4126                                         .rate_table = (unsigned int[]) {
4127                                                 48000
4128                                         }
4129                                 }
4130                         },
4131                         {
4132                                 .ifnum = 0,
4133                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4134                                 .data = &(const struct audioformat) {
4135                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4136                                         .channels = 12,
4137                                         .iface = 0,
4138                                         .altsetting = 1,
4139                                         .altset_idx = 1,
4140                                         .endpoint = 0x82,
4141                                         .ep_idx = 1,
4142                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4143                                                 USB_ENDPOINT_SYNC_ASYNC|
4144                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
4145                                         .rates = SNDRV_PCM_RATE_48000,
4146                                         .rate_min = 48000,
4147                                         .rate_max = 48000,
4148                                         .nr_rates = 1,
4149                                         .rate_table = (unsigned int[]) { 48000 }
4150                                 }
4151                         },
4152                         {
4153                                 .ifnum = -1
4154                         }
4155                 }
4156         }
4157 },
4158 {
4159         /*
4160          * Pioneer DJ DJM-850
4161          * 8 channels playback and 8 channels capture @ 44.1/48/96kHz S24LE
4162          * Playback on EP 0x05
4163          * Capture on EP 0x86
4164          */
4165         USB_DEVICE_VENDOR_SPEC(0x08e4, 0x0163),
4166         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4167                 .ifnum = QUIRK_ANY_INTERFACE,
4168                 .type = QUIRK_COMPOSITE,
4169                 .data = (const struct snd_usb_audio_quirk[]) {
4170                         {
4171                                 .ifnum = 0,
4172                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4173                                 .data = &(const struct audioformat) {
4174                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4175                                         .channels = 8,
4176                                         .iface = 0,
4177                                         .altsetting = 1,
4178                                         .altset_idx = 1,
4179                                         .endpoint = 0x05,
4180                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4181                                             USB_ENDPOINT_SYNC_ASYNC|
4182                                                 USB_ENDPOINT_USAGE_DATA,
4183                                         .rates = SNDRV_PCM_RATE_44100|
4184                                                 SNDRV_PCM_RATE_48000|
4185                                                 SNDRV_PCM_RATE_96000,
4186                                         .rate_min = 44100,
4187                                         .rate_max = 96000,
4188                                         .nr_rates = 3,
4189                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4190                                 }
4191                         },
4192                         {
4193                                 .ifnum = 0,
4194                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4195                                 .data = &(const struct audioformat) {
4196                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4197                                         .channels = 8,
4198                                         .iface = 0,
4199                                         .altsetting = 1,
4200                                         .altset_idx = 1,
4201                                         .endpoint = 0x86,
4202                                         .ep_idx = 1,
4203                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4204                                                 USB_ENDPOINT_SYNC_ASYNC|
4205                                                 USB_ENDPOINT_USAGE_DATA,
4206                                         .rates = SNDRV_PCM_RATE_44100|
4207                                                 SNDRV_PCM_RATE_48000|
4208                                                 SNDRV_PCM_RATE_96000,
4209                                         .rate_min = 44100,
4210                                         .rate_max = 96000,
4211                                         .nr_rates = 3,
4212                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4213                                 }
4214                         },
4215                         {
4216                                 .ifnum = -1
4217                         }
4218                 }
4219         }
4220 },
4221 {
4222         /*
4223          * Pioneer DJ DJM-450
4224          * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
4225          * and 8 channels in @ 48 fixed (endpoint 0x82).
4226          */
4227         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013),
4228         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4229                 .ifnum = QUIRK_ANY_INTERFACE,
4230                 .type = QUIRK_COMPOSITE,
4231                 .data = (const struct snd_usb_audio_quirk[]) {
4232                         {
4233                                 .ifnum = 0,
4234                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4235                                 .data = &(const struct audioformat) {
4236                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4237                                         .channels = 8, // outputs
4238                                         .iface = 0,
4239                                         .altsetting = 1,
4240                                         .altset_idx = 1,
4241                                         .endpoint = 0x01,
4242                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4243                                                 USB_ENDPOINT_SYNC_ASYNC,
4244                                         .rates = SNDRV_PCM_RATE_48000,
4245                                         .rate_min = 48000,
4246                                         .rate_max = 48000,
4247                                         .nr_rates = 1,
4248                                         .rate_table = (unsigned int[]) { 48000 }
4249                                         }
4250                         },
4251                         {
4252                                 .ifnum = 0,
4253                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4254                                 .data = &(const struct audioformat) {
4255                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4256                                         .channels = 8, // inputs
4257                                         .iface = 0,
4258                                         .altsetting = 1,
4259                                         .altset_idx = 1,
4260                                         .endpoint = 0x82,
4261                                         .ep_idx = 1,
4262                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
4263                                                 USB_ENDPOINT_SYNC_ASYNC|
4264                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
4265                                         .rates = SNDRV_PCM_RATE_48000,
4266                                         .rate_min = 48000,
4267                                         .rate_max = 48000,
4268                                         .nr_rates = 1,
4269                                         .rate_table = (unsigned int[]) { 48000 }
4270                                 }
4271                         },
4272                         {
4273                                 .ifnum = -1
4274                         }
4275                 }
4276         }
4277 },
4278 {
4279         /*
4280          * Sennheiser GSP670
4281          * Change order of interfaces loaded
4282          */
4283         USB_DEVICE(0x1395, 0x0300),
4284         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
4285         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4286                 .ifnum = QUIRK_ANY_INTERFACE,
4287                 .type = QUIRK_COMPOSITE,
4288                 .data = &(const struct snd_usb_audio_quirk[]) {
4289                         // Communication
4290                         {
4291                                 .ifnum = 3,
4292                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4293                         },
4294                         // Recording
4295                         {
4296                                 .ifnum = 4,
4297                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4298                         },
4299                         // Main
4300                         {
4301                                 .ifnum = 1,
4302                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4303                         },
4304                         {
4305                                 .ifnum = -1
4306                         }
4307                 }
4308         }
4309 },
4310 {
4311         /*
4312          * Fiero SC-01 (firmware v1.0.0 @ 48 kHz)
4313          */
4314         USB_DEVICE(0x2b53, 0x0023),
4315         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4316                 .vendor_name = "Fiero",
4317                 .product_name = "SC-01",
4318                 .ifnum = QUIRK_ANY_INTERFACE,
4319                 .type = QUIRK_COMPOSITE,
4320                 .data = &(const struct snd_usb_audio_quirk[]) {
4321                         {
4322                                 .ifnum = 0,
4323                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4324                         },
4325                         /* Playback */
4326                         {
4327                                 .ifnum = 1,
4328                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4329                                 .data = &(const struct audioformat) {
4330                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4331                                         .channels = 2,
4332                                         .fmt_bits = 24,
4333                                         .iface = 1,
4334                                         .altsetting = 1,
4335                                         .altset_idx = 1,
4336                                         .endpoint = 0x01,
4337                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4338                                                    USB_ENDPOINT_SYNC_ASYNC,
4339                                         .rates = SNDRV_PCM_RATE_48000,
4340                                         .rate_min = 48000,
4341                                         .rate_max = 48000,
4342                                         .nr_rates = 1,
4343                                         .rate_table = (unsigned int[]) { 48000 },
4344                                         .clock = 0x29
4345                                 }
4346                         },
4347                         /* Capture */
4348                         {
4349                                 .ifnum = 2,
4350                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4351                                 .data = &(const struct audioformat) {
4352                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4353                                         .channels = 2,
4354                                         .fmt_bits = 24,
4355                                         .iface = 2,
4356                                         .altsetting = 1,
4357                                         .altset_idx = 1,
4358                                         .endpoint = 0x82,
4359                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4360                                                    USB_ENDPOINT_SYNC_ASYNC |
4361                                                    USB_ENDPOINT_USAGE_IMPLICIT_FB,
4362                                         .rates = SNDRV_PCM_RATE_48000,
4363                                         .rate_min = 48000,
4364                                         .rate_max = 48000,
4365                                         .nr_rates = 1,
4366                                         .rate_table = (unsigned int[]) { 48000 },
4367                                         .clock = 0x29
4368                                 }
4369                         },
4370                         {
4371                                 .ifnum = -1
4372                         }
4373                 }
4374         }
4375 },
4376 {
4377         /*
4378          * Fiero SC-01 (firmware v1.0.0 @ 96 kHz)
4379          */
4380         USB_DEVICE(0x2b53, 0x0024),
4381         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4382                 .vendor_name = "Fiero",
4383                 .product_name = "SC-01",
4384                 .ifnum = QUIRK_ANY_INTERFACE,
4385                 .type = QUIRK_COMPOSITE,
4386                 .data = &(const struct snd_usb_audio_quirk[]) {
4387                         {
4388                                 .ifnum = 0,
4389                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4390                         },
4391                         /* Playback */
4392                         {
4393                                 .ifnum = 1,
4394                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4395                                 .data = &(const struct audioformat) {
4396                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4397                                         .channels = 2,
4398                                         .fmt_bits = 24,
4399                                         .iface = 1,
4400                                         .altsetting = 1,
4401                                         .altset_idx = 1,
4402                                         .endpoint = 0x01,
4403                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4404                                                    USB_ENDPOINT_SYNC_ASYNC,
4405                                         .rates = SNDRV_PCM_RATE_96000,
4406                                         .rate_min = 96000,
4407                                         .rate_max = 96000,
4408                                         .nr_rates = 1,
4409                                         .rate_table = (unsigned int[]) { 96000 },
4410                                         .clock = 0x29
4411                                 }
4412                         },
4413                         /* Capture */
4414                         {
4415                                 .ifnum = 2,
4416                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4417                                 .data = &(const struct audioformat) {
4418                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4419                                         .channels = 2,
4420                                         .fmt_bits = 24,
4421                                         .iface = 2,
4422                                         .altsetting = 1,
4423                                         .altset_idx = 1,
4424                                         .endpoint = 0x82,
4425                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4426                                                    USB_ENDPOINT_SYNC_ASYNC |
4427                                                    USB_ENDPOINT_USAGE_IMPLICIT_FB,
4428                                         .rates = SNDRV_PCM_RATE_96000,
4429                                         .rate_min = 96000,
4430                                         .rate_max = 96000,
4431                                         .nr_rates = 1,
4432                                         .rate_table = (unsigned int[]) { 96000 },
4433                                         .clock = 0x29
4434                                 }
4435                         },
4436                         {
4437                                 .ifnum = -1
4438                         }
4439                 }
4440         }
4441 },
4442 {
4443         /*
4444          * Fiero SC-01 (firmware v1.1.0)
4445          */
4446         USB_DEVICE(0x2b53, 0x0031),
4447         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4448                 .vendor_name = "Fiero",
4449                 .product_name = "SC-01",
4450                 .ifnum = QUIRK_ANY_INTERFACE,
4451                 .type = QUIRK_COMPOSITE,
4452                 .data = &(const struct snd_usb_audio_quirk[]) {
4453                         {
4454                                 .ifnum = 0,
4455                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4456                         },
4457                         /* Playback */
4458                         {
4459                                 .ifnum = 1,
4460                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4461                                 .data = &(const struct audioformat) {
4462                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4463                                         .channels = 2,
4464                                         .fmt_bits = 24,
4465                                         .iface = 1,
4466                                         .altsetting = 1,
4467                                         .altset_idx = 1,
4468                                         .endpoint = 0x01,
4469                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4470                                                    USB_ENDPOINT_SYNC_ASYNC,
4471                                         .rates = SNDRV_PCM_RATE_48000 |
4472                                                  SNDRV_PCM_RATE_96000,
4473                                         .rate_min = 48000,
4474                                         .rate_max = 96000,
4475                                         .nr_rates = 2,
4476                                         .rate_table = (unsigned int[]) { 48000, 96000 },
4477                                         .clock = 0x29
4478                                 }
4479                         },
4480                         /* Capture */
4481                         {
4482                                 .ifnum = 2,
4483                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4484                                 .data = &(const struct audioformat) {
4485                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
4486                                         .channels = 2,
4487                                         .fmt_bits = 24,
4488                                         .iface = 2,
4489                                         .altsetting = 1,
4490                                         .altset_idx = 1,
4491                                         .endpoint = 0x82,
4492                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
4493                                                    USB_ENDPOINT_SYNC_ASYNC |
4494                                                    USB_ENDPOINT_USAGE_IMPLICIT_FB,
4495                                         .rates = SNDRV_PCM_RATE_48000 |
4496                                                  SNDRV_PCM_RATE_96000,
4497                                         .rate_min = 48000,
4498                                         .rate_max = 96000,
4499                                         .nr_rates = 2,
4500                                         .rate_table = (unsigned int[]) { 48000, 96000 },
4501                                         .clock = 0x29
4502                                 }
4503                         },
4504                         {
4505                                 .ifnum = -1
4506                         }
4507                 }
4508         }
4509 },
4510 {
4511         /* Advanced modes of the Mythware XA001AU.
4512          * For the standard mode, Mythware XA001AU has ID ffad:a001
4513          */
4514         USB_DEVICE_VENDOR_SPEC(0xffad, 0xa001),
4515         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4516                 .vendor_name = "Mythware",
4517                 .product_name = "XA001AU",
4518                 .ifnum = QUIRK_ANY_INTERFACE,
4519                 .type = QUIRK_COMPOSITE,
4520                 .data = (const struct snd_usb_audio_quirk[]) {
4521                         {
4522                                 .ifnum = 0,
4523                                 .type = QUIRK_IGNORE_INTERFACE,
4524                         },
4525                         {
4526                                 .ifnum = 1,
4527                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
4528                         },
4529                         {
4530                                 .ifnum = 2,
4531                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
4532                         },
4533                         {
4534                                 .ifnum = -1
4535                         }
4536                 }
4537         }
4538 },
4539
4540 #undef USB_DEVICE_VENDOR_SPEC
4541 #undef USB_AUDIO_DEVICE