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