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