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 /* this catches most recent vendor-specific Roland devices */
1678 {
1679         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1680                        USB_DEVICE_ID_MATCH_INT_CLASS,
1681         .idVendor = 0x0582,
1682         .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1683         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1684                 .ifnum = QUIRK_ANY_INTERFACE,
1685                 .type = QUIRK_AUTODETECT
1686         }
1687 },
1688
1689 /* Guillemot devices */
1690 {
1691         /*
1692          * This is for the "Windows Edition" where the external MIDI ports are
1693          * the only MIDI ports; the control data is reported through HID
1694          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1695          * compliant USB MIDI ports for external MIDI and controls.
1696          */
1697         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1698         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1699                 .vendor_name = "Hercules",
1700                 .product_name = "DJ Console (WE)",
1701                 .ifnum = 4,
1702                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1703                 .data = & (const struct snd_usb_midi_endpoint_info) {
1704                         .out_cables = 0x0001,
1705                         .in_cables = 0x0001
1706                 }
1707         }
1708 },
1709
1710 /* Midiman/M-Audio devices */
1711 {
1712         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1713         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1714                 .vendor_name = "M-Audio",
1715                 .product_name = "MidiSport 2x2",
1716                 .ifnum = QUIRK_ANY_INTERFACE,
1717                 .type = QUIRK_MIDI_MIDIMAN,
1718                 .data = & (const struct snd_usb_midi_endpoint_info) {
1719                         .out_cables = 0x0003,
1720                         .in_cables  = 0x0003
1721                 }
1722         }
1723 },
1724 {
1725         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1726         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1727                 .vendor_name = "M-Audio",
1728                 .product_name = "MidiSport 1x1",
1729                 .ifnum = QUIRK_ANY_INTERFACE,
1730                 .type = QUIRK_MIDI_MIDIMAN,
1731                 .data = & (const struct snd_usb_midi_endpoint_info) {
1732                         .out_cables = 0x0001,
1733                         .in_cables  = 0x0001
1734                 }
1735         }
1736 },
1737 {
1738         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1739         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1740                 .vendor_name = "M-Audio",
1741                 .product_name = "Keystation",
1742                 .ifnum = QUIRK_ANY_INTERFACE,
1743                 .type = QUIRK_MIDI_MIDIMAN,
1744                 .data = & (const struct snd_usb_midi_endpoint_info) {
1745                         .out_cables = 0x0001,
1746                         .in_cables  = 0x0001
1747                 }
1748         }
1749 },
1750 {
1751         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1752         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1753                 .vendor_name = "M-Audio",
1754                 .product_name = "MidiSport 4x4",
1755                 .ifnum = QUIRK_ANY_INTERFACE,
1756                 .type = QUIRK_MIDI_MIDIMAN,
1757                 .data = & (const struct snd_usb_midi_endpoint_info) {
1758                         .out_cables = 0x000f,
1759                         .in_cables  = 0x000f
1760                 }
1761         }
1762 },
1763 {
1764         /*
1765          * For hardware revision 1.05; in the later revisions (1.10 and
1766          * 1.21), 0x1031 is the ID for the device without firmware.
1767          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1768          */
1769         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1770         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1771                 .vendor_name = "M-Audio",
1772                 .product_name = "MidiSport 8x8",
1773                 .ifnum = QUIRK_ANY_INTERFACE,
1774                 .type = QUIRK_MIDI_MIDIMAN,
1775                 .data = & (const struct snd_usb_midi_endpoint_info) {
1776                         .out_cables = 0x01ff,
1777                         .in_cables  = 0x01ff
1778                 }
1779         }
1780 },
1781 {
1782         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1783         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1784                 .vendor_name = "M-Audio",
1785                 .product_name = "MidiSport 8x8",
1786                 .ifnum = QUIRK_ANY_INTERFACE,
1787                 .type = QUIRK_MIDI_MIDIMAN,
1788                 .data = & (const struct snd_usb_midi_endpoint_info) {
1789                         .out_cables = 0x01ff,
1790                         .in_cables  = 0x01ff
1791                 }
1792         }
1793 },
1794 {
1795         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1796         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1797                 .vendor_name = "M-Audio",
1798                 .product_name = "MidiSport 2x4",
1799                 .ifnum = QUIRK_ANY_INTERFACE,
1800                 .type = QUIRK_MIDI_MIDIMAN,
1801                 .data = & (const struct snd_usb_midi_endpoint_info) {
1802                         .out_cables = 0x000f,
1803                         .in_cables  = 0x0003
1804                 }
1805         }
1806 },
1807 {
1808         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1809         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1810                 .vendor_name = "M-Audio",
1811                 .product_name = "Quattro",
1812                 .ifnum = QUIRK_ANY_INTERFACE,
1813                 .type = QUIRK_COMPOSITE,
1814                 .data = & (const struct snd_usb_audio_quirk[]) {
1815                         /*
1816                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1817                          * and share endpoints with the other interfaces.
1818                          * Ignore them.  The other interfaces can do 24 bits,
1819                          * but captured samples are big-endian (see usbaudio.c).
1820                          */
1821                         {
1822                                 .ifnum = 0,
1823                                 .type = QUIRK_IGNORE_INTERFACE
1824                         },
1825                         {
1826                                 .ifnum = 1,
1827                                 .type = QUIRK_IGNORE_INTERFACE
1828                         },
1829                         {
1830                                 .ifnum = 2,
1831                                 .type = QUIRK_IGNORE_INTERFACE
1832                         },
1833                         {
1834                                 .ifnum = 3,
1835                                 .type = QUIRK_IGNORE_INTERFACE
1836                         },
1837                         {
1838                                 .ifnum = 4,
1839                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1840                         },
1841                         {
1842                                 .ifnum = 5,
1843                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1844                         },
1845                         {
1846                                 .ifnum = 6,
1847                                 .type = QUIRK_IGNORE_INTERFACE
1848                         },
1849                         {
1850                                 .ifnum = 7,
1851                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1852                         },
1853                         {
1854                                 .ifnum = 8,
1855                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1856                         },
1857                         {
1858                                 .ifnum = 9,
1859                                 .type = QUIRK_MIDI_MIDIMAN,
1860                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1861                                         .out_cables = 0x0001,
1862                                         .in_cables  = 0x0001
1863                                 }
1864                         },
1865                         {
1866                                 .ifnum = -1
1867                         }
1868                 }
1869         }
1870 },
1871 {
1872         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1873         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1874                 .vendor_name = "M-Audio",
1875                 .product_name = "AudioPhile",
1876                 .ifnum = 6,
1877                 .type = QUIRK_MIDI_MIDIMAN,
1878                 .data = & (const struct snd_usb_midi_endpoint_info) {
1879                         .out_cables = 0x0001,
1880                         .in_cables  = 0x0001
1881                 }
1882         }
1883 },
1884 {
1885         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1886         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1887                 .vendor_name = "M-Audio",
1888                 .product_name = "Ozone",
1889                 .ifnum = 3,
1890                 .type = QUIRK_MIDI_MIDIMAN,
1891                 .data = & (const struct snd_usb_midi_endpoint_info) {
1892                         .out_cables = 0x0001,
1893                         .in_cables  = 0x0001
1894                 }
1895         }
1896 },
1897 {
1898         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1899         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1900                 .vendor_name = "M-Audio",
1901                 .product_name = "OmniStudio",
1902                 .ifnum = QUIRK_ANY_INTERFACE,
1903                 .type = QUIRK_COMPOSITE,
1904                 .data = & (const struct snd_usb_audio_quirk[]) {
1905                         {
1906                                 .ifnum = 0,
1907                                 .type = QUIRK_IGNORE_INTERFACE
1908                         },
1909                         {
1910                                 .ifnum = 1,
1911                                 .type = QUIRK_IGNORE_INTERFACE
1912                         },
1913                         {
1914                                 .ifnum = 2,
1915                                 .type = QUIRK_IGNORE_INTERFACE
1916                         },
1917                         {
1918                                 .ifnum = 3,
1919                                 .type = QUIRK_IGNORE_INTERFACE
1920                         },
1921                         {
1922                                 .ifnum = 4,
1923                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1924                         },
1925                         {
1926                                 .ifnum = 5,
1927                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1928                         },
1929                         {
1930                                 .ifnum = 6,
1931                                 .type = QUIRK_IGNORE_INTERFACE
1932                         },
1933                         {
1934                                 .ifnum = 7,
1935                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1936                         },
1937                         {
1938                                 .ifnum = 8,
1939                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1940                         },
1941                         {
1942                                 .ifnum = 9,
1943                                 .type = QUIRK_MIDI_MIDIMAN,
1944                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1945                                         .out_cables = 0x0001,
1946                                         .in_cables  = 0x0001
1947                                 }
1948                         },
1949                         {
1950                                 .ifnum = -1
1951                         }
1952                 }
1953         }
1954 },
1955 {
1956         USB_DEVICE(0x0763, 0x2019),
1957         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1958                 /* .vendor_name = "M-Audio", */
1959                 /* .product_name = "Ozone Academic", */
1960                 .ifnum = QUIRK_ANY_INTERFACE,
1961                 .type = QUIRK_COMPOSITE,
1962                 .data = & (const struct snd_usb_audio_quirk[]) {
1963                         {
1964                                 .ifnum = 0,
1965                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1966                         },
1967                         {
1968                                 .ifnum = 1,
1969                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1970                         },
1971                         {
1972                                 .ifnum = 2,
1973                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1974                         },
1975                         {
1976                                 .ifnum = 3,
1977                                 .type = QUIRK_MIDI_MIDIMAN,
1978                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1979                                         .out_cables = 0x0001,
1980                                         .in_cables  = 0x0001
1981                                 }
1982                         },
1983                         {
1984                                 .ifnum = -1
1985                         }
1986                 }
1987         }
1988 },
1989 {
1990         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
1991         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1992                 /* .vendor_name = "M-Audio", */
1993                 /* .product_name = "Fast Track C400", */
1994                 .ifnum = QUIRK_ANY_INTERFACE,
1995                 .type = QUIRK_COMPOSITE,
1996                 .data = &(const struct snd_usb_audio_quirk[]) {
1997                         {
1998                                 .ifnum = 1,
1999                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2000                         },
2001                         /* Playback */
2002                         {
2003                                 .ifnum = 2,
2004                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2005                                 .data = &(const struct audioformat) {
2006                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2007                                         .channels = 6,
2008                                         .iface = 2,
2009                                         .altsetting = 1,
2010                                         .altset_idx = 1,
2011                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2012                                         .endpoint = 0x01,
2013                                         .ep_attr = 0x09,
2014                                         .rates = SNDRV_PCM_RATE_44100 |
2015                                                  SNDRV_PCM_RATE_48000 |
2016                                                  SNDRV_PCM_RATE_88200 |
2017                                                  SNDRV_PCM_RATE_96000,
2018                                         .rate_min = 44100,
2019                                         .rate_max = 96000,
2020                                         .nr_rates = 4,
2021                                         .rate_table = (unsigned int[]) {
2022                                                         44100, 48000, 88200, 96000
2023                                         },
2024                                         .clock = 0x80,
2025                                 }
2026                         },
2027                         /* Capture */
2028                         {
2029                                 .ifnum = 3,
2030                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2031                                 .data = &(const struct audioformat) {
2032                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2033                                         .channels = 4,
2034                                         .iface = 3,
2035                                         .altsetting = 1,
2036                                         .altset_idx = 1,
2037                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2038                                         .endpoint = 0x81,
2039                                         .ep_attr = 0x05,
2040                                         .rates = SNDRV_PCM_RATE_44100 |
2041                                                  SNDRV_PCM_RATE_48000 |
2042                                                  SNDRV_PCM_RATE_88200 |
2043                                                  SNDRV_PCM_RATE_96000,
2044                                         .rate_min = 44100,
2045                                         .rate_max = 96000,
2046                                         .nr_rates = 4,
2047                                         .rate_table = (unsigned int[]) {
2048                                                 44100, 48000, 88200, 96000
2049                                         },
2050                                         .clock = 0x80,
2051                                 }
2052                         },
2053                         /* MIDI */
2054                         {
2055                                 .ifnum = -1 /* Interface = 4 */
2056                         }
2057                 }
2058         }
2059 },
2060 {
2061         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2062         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2063                 /* .vendor_name = "M-Audio", */
2064                 /* .product_name = "Fast Track C600", */
2065                 .ifnum = QUIRK_ANY_INTERFACE,
2066                 .type = QUIRK_COMPOSITE,
2067                 .data = &(const struct snd_usb_audio_quirk[]) {
2068                         {
2069                                 .ifnum = 1,
2070                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2071                         },
2072                         /* Playback */
2073                         {
2074                                 .ifnum = 2,
2075                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2076                                 .data = &(const struct audioformat) {
2077                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2078                                         .channels = 8,
2079                                         .iface = 2,
2080                                         .altsetting = 1,
2081                                         .altset_idx = 1,
2082                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2083                                         .endpoint = 0x01,
2084                                         .ep_attr = 0x09,
2085                                         .rates = SNDRV_PCM_RATE_44100 |
2086                                                  SNDRV_PCM_RATE_48000 |
2087                                                  SNDRV_PCM_RATE_88200 |
2088                                                  SNDRV_PCM_RATE_96000,
2089                                         .rate_min = 44100,
2090                                         .rate_max = 96000,
2091                                         .nr_rates = 4,
2092                                         .rate_table = (unsigned int[]) {
2093                                                         44100, 48000, 88200, 96000
2094                                         },
2095                                         .clock = 0x80,
2096                                 }
2097                         },
2098                         /* Capture */
2099                         {
2100                                 .ifnum = 3,
2101                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2102                                 .data = &(const struct audioformat) {
2103                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2104                                         .channels = 6,
2105                                         .iface = 3,
2106                                         .altsetting = 1,
2107                                         .altset_idx = 1,
2108                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2109                                         .endpoint = 0x81,
2110                                         .ep_attr = 0x05,
2111                                         .rates = SNDRV_PCM_RATE_44100 |
2112                                                  SNDRV_PCM_RATE_48000 |
2113                                                  SNDRV_PCM_RATE_88200 |
2114                                                  SNDRV_PCM_RATE_96000,
2115                                         .rate_min = 44100,
2116                                         .rate_max = 96000,
2117                                         .nr_rates = 4,
2118                                         .rate_table = (unsigned int[]) {
2119                                                 44100, 48000, 88200, 96000
2120                                         },
2121                                         .clock = 0x80,
2122                                 }
2123                         },
2124                         /* MIDI */
2125                         {
2126                                 .ifnum = -1 /* Interface = 4 */
2127                         }
2128                 }
2129         }
2130 },
2131 {
2132         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2133         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2134                 /* .vendor_name = "M-Audio", */
2135                 /* .product_name = "Fast Track Ultra", */
2136                 .ifnum = QUIRK_ANY_INTERFACE,
2137                 .type = QUIRK_COMPOSITE,
2138                 .data = & (const struct snd_usb_audio_quirk[]) {
2139                         {
2140                                 .ifnum = 0,
2141                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2142                         },
2143                         {
2144                                 .ifnum = 1,
2145                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2146                                 .data = & (const struct audioformat) {
2147                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2148                                         .channels = 8,
2149                                         .iface = 1,
2150                                         .altsetting = 1,
2151                                         .altset_idx = 1,
2152                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2153                                         .endpoint = 0x01,
2154                                         .ep_attr = 0x09,
2155                                         .rates = SNDRV_PCM_RATE_44100 |
2156                                                  SNDRV_PCM_RATE_48000 |
2157                                                  SNDRV_PCM_RATE_88200 |
2158                                                  SNDRV_PCM_RATE_96000,
2159                                         .rate_min = 44100,
2160                                         .rate_max = 96000,
2161                                         .nr_rates = 4,
2162                                         .rate_table = (unsigned int[]) {
2163                                                 44100, 48000, 88200, 96000
2164                                         }
2165                                 }
2166                         },
2167                         {
2168                                 .ifnum = 2,
2169                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2170                                 .data = & (const struct audioformat) {
2171                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2172                                         .channels = 8,
2173                                         .iface = 2,
2174                                         .altsetting = 1,
2175                                         .altset_idx = 1,
2176                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2177                                         .endpoint = 0x81,
2178                                         .ep_attr = 0x05,
2179                                         .rates = SNDRV_PCM_RATE_44100 |
2180                                                  SNDRV_PCM_RATE_48000 |
2181                                                  SNDRV_PCM_RATE_88200 |
2182                                                  SNDRV_PCM_RATE_96000,
2183                                         .rate_min = 44100,
2184                                         .rate_max = 96000,
2185                                         .nr_rates = 4,
2186                                         .rate_table = (unsigned int[]) {
2187                                                 44100, 48000, 88200, 96000
2188                                         }
2189                                 }
2190                         },
2191                         /* interface 3 (MIDI) is standard compliant */
2192                         {
2193                                 .ifnum = -1
2194                         }
2195                 }
2196         }
2197 },
2198 {
2199         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2200         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2201                 /* .vendor_name = "M-Audio", */
2202                 /* .product_name = "Fast Track Ultra 8R", */
2203                 .ifnum = QUIRK_ANY_INTERFACE,
2204                 .type = QUIRK_COMPOSITE,
2205                 .data = & (const struct snd_usb_audio_quirk[]) {
2206                         {
2207                                 .ifnum = 0,
2208                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2209                         },
2210                         {
2211                                 .ifnum = 1,
2212                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2213                                 .data = & (const struct audioformat) {
2214                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2215                                         .channels = 8,
2216                                         .iface = 1,
2217                                         .altsetting = 1,
2218                                         .altset_idx = 1,
2219                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2220                                         .endpoint = 0x01,
2221                                         .ep_attr = 0x09,
2222                                         .rates = SNDRV_PCM_RATE_44100 |
2223                                                  SNDRV_PCM_RATE_48000 |
2224                                                  SNDRV_PCM_RATE_88200 |
2225                                                  SNDRV_PCM_RATE_96000,
2226                                         .rate_min = 44100,
2227                                         .rate_max = 96000,
2228                                         .nr_rates = 4,
2229                                         .rate_table = (unsigned int[]) {
2230                                                         44100, 48000, 88200, 96000
2231                                         }
2232                                 }
2233                         },
2234                         {
2235                                 .ifnum = 2,
2236                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2237                                 .data = & (const struct audioformat) {
2238                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2239                                         .channels = 8,
2240                                         .iface = 2,
2241                                         .altsetting = 1,
2242                                         .altset_idx = 1,
2243                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2244                                         .endpoint = 0x81,
2245                                         .ep_attr = 0x05,
2246                                         .rates = SNDRV_PCM_RATE_44100 |
2247                                                  SNDRV_PCM_RATE_48000 |
2248                                                  SNDRV_PCM_RATE_88200 |
2249                                                  SNDRV_PCM_RATE_96000,
2250                                         .rate_min = 44100,
2251                                         .rate_max = 96000,
2252                                         .nr_rates = 4,
2253                                         .rate_table = (unsigned int[]) {
2254                                                 44100, 48000, 88200, 96000
2255                                         }
2256                                 }
2257                         },
2258                         /* interface 3 (MIDI) is standard compliant */
2259                         {
2260                                 .ifnum = -1
2261                         }
2262                 }
2263         }
2264 },
2265
2266 /* Casio devices */
2267 {
2268         USB_DEVICE(0x07cf, 0x6801),
2269         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2270                 .vendor_name = "Casio",
2271                 .product_name = "PL-40R",
2272                 .ifnum = 0,
2273                 .type = QUIRK_MIDI_YAMAHA
2274         }
2275 },
2276 {
2277         /* this ID is used by several devices without a product ID */
2278         USB_DEVICE(0x07cf, 0x6802),
2279         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2280                 .vendor_name = "Casio",
2281                 .product_name = "Keyboard",
2282                 .ifnum = 0,
2283                 .type = QUIRK_MIDI_YAMAHA
2284         }
2285 },
2286
2287 /* Mark of the Unicorn devices */
2288 {
2289         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2290         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2291                        USB_DEVICE_ID_MATCH_PRODUCT |
2292                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2293         .idVendor = 0x07fd,
2294         .idProduct = 0x0001,
2295         .bDeviceSubClass = 2,
2296         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2297                 .vendor_name = "MOTU",
2298                 .product_name = "Fastlane",
2299                 .ifnum = QUIRK_ANY_INTERFACE,
2300                 .type = QUIRK_COMPOSITE,
2301                 .data = & (const struct snd_usb_audio_quirk[]) {
2302                         {
2303                                 .ifnum = 0,
2304                                 .type = QUIRK_MIDI_RAW_BYTES
2305                         },
2306                         {
2307                                 .ifnum = 1,
2308                                 .type = QUIRK_IGNORE_INTERFACE
2309                         },
2310                         {
2311                                 .ifnum = -1
2312                         }
2313                 }
2314         }
2315 },
2316
2317 /* Emagic devices */
2318 {
2319         USB_DEVICE(0x086a, 0x0001),
2320         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2321                 .vendor_name = "Emagic",
2322                 .product_name = "Unitor8",
2323                 .ifnum = 2,
2324                 .type = QUIRK_MIDI_EMAGIC,
2325                 .data = & (const struct snd_usb_midi_endpoint_info) {
2326                         .out_cables = 0x80ff,
2327                         .in_cables  = 0x80ff
2328                 }
2329         }
2330 },
2331 {
2332         USB_DEVICE(0x086a, 0x0002),
2333         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2334                 .vendor_name = "Emagic",
2335                 /* .product_name = "AMT8", */
2336                 .ifnum = 2,
2337                 .type = QUIRK_MIDI_EMAGIC,
2338                 .data = & (const struct snd_usb_midi_endpoint_info) {
2339                         .out_cables = 0x80ff,
2340                         .in_cables  = 0x80ff
2341                 }
2342         }
2343 },
2344 {
2345         USB_DEVICE(0x086a, 0x0003),
2346         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2347                 .vendor_name = "Emagic",
2348                 /* .product_name = "MT4", */
2349                 .ifnum = 2,
2350                 .type = QUIRK_MIDI_EMAGIC,
2351                 .data = & (const struct snd_usb_midi_endpoint_info) {
2352                         .out_cables = 0x800f,
2353                         .in_cables  = 0x8003
2354                 }
2355         }
2356 },
2357
2358 /* KORG devices */
2359 {
2360         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2361         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2362                 .vendor_name = "KORG, Inc.",
2363                 /* .product_name = "PANDORA PX5D", */
2364                 .ifnum = 3,
2365                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2366         }
2367 },
2368
2369 {
2370         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2371         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2372                 .vendor_name = "KORG, Inc.",
2373                 /* .product_name = "ToneLab ST", */
2374                 .ifnum = 3,
2375                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2376         }
2377 },
2378
2379 /* AKAI devices */
2380 {
2381         USB_DEVICE(0x09e8, 0x0062),
2382         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2383                 .vendor_name = "AKAI",
2384                 .product_name = "MPD16",
2385                 .ifnum = 0,
2386                 .type = QUIRK_MIDI_AKAI,
2387         }
2388 },
2389
2390 {
2391         /* Akai MPC Element */
2392         USB_DEVICE(0x09e8, 0x0021),
2393         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2394                 .ifnum = QUIRK_ANY_INTERFACE,
2395                 .type = QUIRK_COMPOSITE,
2396                 .data = & (const struct snd_usb_audio_quirk[]) {
2397                         {
2398                                 .ifnum = 0,
2399                                 .type = QUIRK_IGNORE_INTERFACE
2400                         },
2401                         {
2402                                 .ifnum = 1,
2403                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2404                         },
2405                         {
2406                                 .ifnum = -1
2407                         }
2408                 }
2409         }
2410 },
2411
2412 /* Steinberg devices */
2413 {
2414         /* Steinberg MI2 */
2415         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2416         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2417                 .ifnum = QUIRK_ANY_INTERFACE,
2418                 .type = QUIRK_COMPOSITE,
2419                 .data = & (const struct snd_usb_audio_quirk[]) {
2420                         {
2421                                 .ifnum = 0,
2422                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2423                         },
2424                         {
2425                                 .ifnum = 1,
2426                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2427                         },
2428                         {
2429                                 .ifnum = 2,
2430                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2431                         },
2432                         {
2433                                 .ifnum = 3,
2434                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2435                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2436                                         .out_cables = 0x0001,
2437                                         .in_cables  = 0x0001
2438                                 }
2439                         },
2440                         {
2441                                 .ifnum = -1
2442                         }
2443                 }
2444         }
2445 },
2446 {
2447         /* Steinberg MI4 */
2448         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2449         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2450                 .ifnum = QUIRK_ANY_INTERFACE,
2451                 .type = QUIRK_COMPOSITE,
2452                 .data = & (const struct snd_usb_audio_quirk[]) {
2453                         {
2454                                 .ifnum = 0,
2455                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2456                         },
2457                         {
2458                                 .ifnum = 1,
2459                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2460                         },
2461                         {
2462                                 .ifnum = 2,
2463                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2464                         },
2465                         {
2466                                 .ifnum = 3,
2467                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2468                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2469                                         .out_cables = 0x0001,
2470                                         .in_cables  = 0x0001
2471                                 }
2472                         },
2473                         {
2474                                 .ifnum = -1
2475                         }
2476                 }
2477         }
2478 },
2479
2480 /* TerraTec devices */
2481 {
2482         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2483         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2484                 .vendor_name = "TerraTec",
2485                 .product_name = "PHASE 26",
2486                 .ifnum = 3,
2487                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2488         }
2489 },
2490 {
2491         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2492         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2493                 .vendor_name = "TerraTec",
2494                 .product_name = "PHASE 26",
2495                 .ifnum = 3,
2496                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2497         }
2498 },
2499 {
2500         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2501         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2502                 .vendor_name = "TerraTec",
2503                 .product_name = "PHASE 26",
2504                 .ifnum = 3,
2505                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2506         }
2507 },
2508 {
2509         USB_DEVICE(0x0ccd, 0x0035),
2510         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2511                 .vendor_name = "Miditech",
2512                 .product_name = "Play'n Roll",
2513                 .ifnum = 0,
2514                 .type = QUIRK_MIDI_CME
2515         }
2516 },
2517
2518 /* Novation EMS devices */
2519 {
2520         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2521         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2522                 .vendor_name = "Novation",
2523                 .product_name = "ReMOTE Audio/XStation",
2524                 .ifnum = 4,
2525                 .type = QUIRK_MIDI_NOVATION
2526         }
2527 },
2528 {
2529         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2530         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2531                 .vendor_name = "Novation",
2532                 .product_name = "Speedio",
2533                 .ifnum = 3,
2534                 .type = QUIRK_MIDI_NOVATION
2535         }
2536 },
2537 {
2538         USB_DEVICE(0x1235, 0x000a),
2539         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2540                 /* .vendor_name = "Novation", */
2541                 /* .product_name = "Nocturn", */
2542                 .ifnum = 0,
2543                 .type = QUIRK_MIDI_RAW_BYTES
2544         }
2545 },
2546 {
2547         USB_DEVICE(0x1235, 0x000e),
2548         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2549                 /* .vendor_name = "Novation", */
2550                 /* .product_name = "Launchpad", */
2551                 .ifnum = 0,
2552                 .type = QUIRK_MIDI_RAW_BYTES
2553         }
2554 },
2555 {
2556         USB_DEVICE(0x1235, 0x0010),
2557         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2558                 .vendor_name = "Focusrite",
2559                 .product_name = "Saffire 6 USB",
2560                 .ifnum = QUIRK_ANY_INTERFACE,
2561                 .type = QUIRK_COMPOSITE,
2562                 .data = (const struct snd_usb_audio_quirk[]) {
2563                         {
2564                                 .ifnum = 0,
2565                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2566                         },
2567                         {
2568                                 .ifnum = 0,
2569                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2570                                 .data = &(const struct audioformat) {
2571                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2572                                         .channels = 4,
2573                                         .iface = 0,
2574                                         .altsetting = 1,
2575                                         .altset_idx = 1,
2576                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2577                                         .endpoint = 0x01,
2578                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2579                                         .datainterval = 1,
2580                                         .maxpacksize = 0x024c,
2581                                         .rates = SNDRV_PCM_RATE_44100 |
2582                                                  SNDRV_PCM_RATE_48000,
2583                                         .rate_min = 44100,
2584                                         .rate_max = 48000,
2585                                         .nr_rates = 2,
2586                                         .rate_table = (unsigned int[]) {
2587                                                 44100, 48000
2588                                         }
2589                                 }
2590                         },
2591                         {
2592                                 .ifnum = 0,
2593                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2594                                 .data = &(const struct audioformat) {
2595                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2596                                         .channels = 2,
2597                                         .iface = 0,
2598                                         .altsetting = 1,
2599                                         .altset_idx = 1,
2600                                         .attributes = 0,
2601                                         .endpoint = 0x82,
2602                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2603                                         .datainterval = 1,
2604                                         .maxpacksize = 0x0126,
2605                                         .rates = SNDRV_PCM_RATE_44100 |
2606                                                  SNDRV_PCM_RATE_48000,
2607                                         .rate_min = 44100,
2608                                         .rate_max = 48000,
2609                                         .nr_rates = 2,
2610                                         .rate_table = (unsigned int[]) {
2611                                                 44100, 48000
2612                                         }
2613                                 }
2614                         },
2615                         {
2616                                 .ifnum = 1,
2617                                 .type = QUIRK_MIDI_RAW_BYTES
2618                         },
2619                         {
2620                                 .ifnum = -1
2621                         }
2622                 }
2623         }
2624 },
2625 {
2626         USB_DEVICE(0x1235, 0x0018),
2627         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2628                 .vendor_name = "Novation",
2629                 .product_name = "Twitch",
2630                 .ifnum = QUIRK_ANY_INTERFACE,
2631                 .type = QUIRK_COMPOSITE,
2632                 .data = (const struct snd_usb_audio_quirk[]) {
2633                         {
2634                                 .ifnum = 0,
2635                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2636                                 .data = & (const struct audioformat) {
2637                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2638                                         .channels = 4,
2639                                         .iface = 0,
2640                                         .altsetting = 1,
2641                                         .altset_idx = 1,
2642                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2643                                         .endpoint = 0x01,
2644                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2645                                         .rates = SNDRV_PCM_RATE_44100 |
2646                                                  SNDRV_PCM_RATE_48000,
2647                                         .rate_min = 44100,
2648                                         .rate_max = 48000,
2649                                         .nr_rates = 2,
2650                                         .rate_table = (unsigned int[]) {
2651                                                 44100, 48000
2652                                         }
2653                                 }
2654                         },
2655                         {
2656                                 .ifnum = 1,
2657                                 .type = QUIRK_MIDI_RAW_BYTES
2658                         },
2659                         {
2660                                 .ifnum = -1
2661                         }
2662                 }
2663         }
2664 },
2665 {
2666         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2667         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2668                 .vendor_name = "Novation",
2669                 .product_name = "ReMOTE25",
2670                 .ifnum = 0,
2671                 .type = QUIRK_MIDI_NOVATION
2672         }
2673 },
2674
2675 /* Access Music devices */
2676 {
2677         /* VirusTI Desktop */
2678         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2679         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2680                 .ifnum = QUIRK_ANY_INTERFACE,
2681                 .type = QUIRK_COMPOSITE,
2682                 .data = &(const struct snd_usb_audio_quirk[]) {
2683                         {
2684                                 .ifnum = 3,
2685                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2686                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2687                                         .out_cables = 0x0003,
2688                                         .in_cables  = 0x0003
2689                                 }
2690                         },
2691                         {
2692                                 .ifnum = 4,
2693                                 .type = QUIRK_IGNORE_INTERFACE
2694                         },
2695                         {
2696                                 .ifnum = -1
2697                         }
2698                 }
2699         }
2700 },
2701
2702 /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
2703 {
2704         USB_DEVICE(0x17aa, 0x1046),
2705         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2706                 .ifnum = QUIRK_ANY_INTERFACE,
2707                 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2708         }
2709 },
2710 /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
2711 {
2712         USB_DEVICE(0x17aa, 0x104d),
2713         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2714                 .ifnum = QUIRK_ANY_INTERFACE,
2715                 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND
2716         }
2717 },
2718
2719 /* Native Instruments MK2 series */
2720 {
2721         /* Komplete Audio 6 */
2722         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2723         .idVendor = 0x17cc,
2724         .idProduct = 0x1000,
2725 },
2726 {
2727         /* Traktor Audio 6 */
2728         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2729         .idVendor = 0x17cc,
2730         .idProduct = 0x1010,
2731 },
2732 {
2733         /* Traktor Audio 10 */
2734         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2735         .idVendor = 0x17cc,
2736         .idProduct = 0x1020,
2737 },
2738
2739 /* QinHeng devices */
2740 {
2741         USB_DEVICE(0x1a86, 0x752d),
2742         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2743                 .vendor_name = "QinHeng",
2744                 .product_name = "CH345",
2745                 .ifnum = 1,
2746                 .type = QUIRK_MIDI_CH345
2747         }
2748 },
2749
2750 /* KeithMcMillen Stringport */
2751 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
2752
2753 /* Miditech devices */
2754 {
2755         USB_DEVICE(0x4752, 0x0011),
2756         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2757                 .vendor_name = "Miditech",
2758                 .product_name = "Midistart-2",
2759                 .ifnum = 0,
2760                 .type = QUIRK_MIDI_CME
2761         }
2762 },
2763
2764 /* Central Music devices */
2765 {
2766         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2767         USB_DEVICE(0x7104, 0x2202),
2768         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2769                 .ifnum = 0,
2770                 .type = QUIRK_MIDI_CME
2771         }
2772 },
2773
2774 /*
2775  * Auvitek au0828 devices with audio interface.
2776  * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
2777  * Please notice that some drivers are DVB only, and don't need to be
2778  * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2779  */
2780
2781 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2782         USB_AUDIO_DEVICE(vid, pid), \
2783         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2784                 .vendor_name = vname, \
2785                 .product_name = pname, \
2786                 .ifnum = QUIRK_ANY_INTERFACE, \
2787                 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2788                 .shares_media_device = 1, \
2789         } \
2790 }
2791
2792 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2793 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2794 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2795 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2796 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2797 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2798 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2799 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2800 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2801 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2802 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2803 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2804 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2805 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2806 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2807 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2808 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2809
2810 /* Syntek STK1160 */
2811 {
2812         USB_AUDIO_DEVICE(0x05e1, 0x0408),
2813         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2814                 .vendor_name = "Syntek",
2815                 .product_name = "STK1160",
2816                 .ifnum = QUIRK_ANY_INTERFACE,
2817                 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2818         }
2819 },
2820
2821 /* Digidesign Mbox */
2822 {
2823         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2824         USB_DEVICE(0x0dba, 0x1000),
2825         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2826                 .vendor_name = "Digidesign",
2827                 .product_name = "MBox",
2828                 .ifnum = QUIRK_ANY_INTERFACE,
2829                 .type = QUIRK_COMPOSITE,
2830                 .data = (const struct snd_usb_audio_quirk[]){
2831                         {
2832                                 .ifnum = 0,
2833                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2834                         },
2835                         {
2836                                 .ifnum = 1,
2837                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2838                                 .data = &(const struct audioformat) {
2839                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2840                                         .channels = 2,
2841                                         .iface = 1,
2842                                         .altsetting = 1,
2843                                         .altset_idx = 1,
2844                                         .attributes = 0x4,
2845                                         .endpoint = 0x02,
2846                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
2847                                                 USB_ENDPOINT_SYNC_SYNC,
2848                                         .maxpacksize = 0x130,
2849                                         .rates = SNDRV_PCM_RATE_48000,
2850                                         .rate_min = 48000,
2851                                         .rate_max = 48000,
2852                                         .nr_rates = 1,
2853                                         .rate_table = (unsigned int[]) {
2854                                                 48000
2855                                         }
2856                                 }
2857                         },
2858                         {
2859                                 .ifnum = 1,
2860                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2861                                 .data = &(const struct audioformat) {
2862                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2863                                         .channels = 2,
2864                                         .iface = 1,
2865                                         .altsetting = 1,
2866                                         .altset_idx = 1,
2867                                         .attributes = 0x4,
2868                                         .endpoint = 0x81,
2869                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
2870                                                 USB_ENDPOINT_SYNC_ASYNC,
2871                                         .maxpacksize = 0x130,
2872                                         .rates = SNDRV_PCM_RATE_48000,
2873                                         .rate_min = 48000,
2874                                         .rate_max = 48000,
2875                                         .nr_rates = 1,
2876                                         .rate_table = (unsigned int[]) {
2877                                                 48000
2878                                         }
2879                                 }
2880                         },
2881                         {
2882                                 .ifnum = -1
2883                         }
2884                 }
2885         }
2886 },
2887
2888 /* DIGIDESIGN MBOX 2 */
2889 {
2890         USB_DEVICE(0x0dba, 0x3000),
2891         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2892                 .vendor_name = "Digidesign",
2893                 .product_name = "Mbox 2",
2894                 .ifnum = QUIRK_ANY_INTERFACE,
2895                 .type = QUIRK_COMPOSITE,
2896                 .data = (const struct snd_usb_audio_quirk[]) {
2897                         {
2898                                 .ifnum = 0,
2899                                 .type = QUIRK_IGNORE_INTERFACE
2900                         },
2901                         {
2902                                 .ifnum = 1,
2903                                 .type = QUIRK_IGNORE_INTERFACE
2904                         },
2905                         {
2906                                 .ifnum = 2,
2907                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2908                                 .data = &(const struct audioformat) {
2909                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2910                                         .channels = 2,
2911                                         .iface = 2,
2912                                         .altsetting = 2,
2913                                         .altset_idx = 1,
2914                                         .attributes = 0x00,
2915                                         .endpoint = 0x03,
2916                                         .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2917                                         .rates = SNDRV_PCM_RATE_48000,
2918                                         .rate_min = 48000,
2919                                         .rate_max = 48000,
2920                                         .nr_rates = 1,
2921                                         .rate_table = (unsigned int[]) {
2922                                                 48000
2923                                         }
2924                                 }
2925                         },
2926                         {
2927                                 .ifnum = 3,
2928                                 .type = QUIRK_IGNORE_INTERFACE
2929                         },
2930                         {
2931                                 .ifnum = 4,
2932                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2933                                 .data = &(const struct audioformat) {
2934                                 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2935                                         .channels = 2,
2936                                         .iface = 4,
2937                                         .altsetting = 2,
2938                                         .altset_idx = 1,
2939                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2940                                         .endpoint = 0x85,
2941                                         .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2942                                         .rates = SNDRV_PCM_RATE_48000,
2943                                         .rate_min = 48000,
2944                                         .rate_max = 48000,
2945                                         .nr_rates = 1,
2946                                         .rate_table = (unsigned int[]) {
2947                                                 48000
2948                                         }
2949                                 }
2950                         },
2951                         {
2952                                 .ifnum = 5,
2953                                 .type = QUIRK_IGNORE_INTERFACE
2954                         },
2955                         {
2956                                 .ifnum = 6,
2957                                 .type = QUIRK_MIDI_MIDIMAN,
2958                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2959                                         .out_ep =  0x02,
2960                                         .out_cables = 0x0001,
2961                                         .in_ep = 0x81,
2962                                         .in_interval = 0x01,
2963                                         .in_cables = 0x0001
2964                                 }
2965                         },
2966                         {
2967                                 .ifnum = -1
2968                         }
2969                 }
2970         }
2971 },
2972 {
2973         /* Tascam US122 MKII - playback-only support */
2974         USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
2975         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2976                 .vendor_name = "TASCAM",
2977                 .product_name = "US122 MKII",
2978                 .ifnum = QUIRK_ANY_INTERFACE,
2979                 .type = QUIRK_COMPOSITE,
2980                 .data = (const struct snd_usb_audio_quirk[]) {
2981                         {
2982                                 .ifnum = 0,
2983                                 .type = QUIRK_IGNORE_INTERFACE
2984                         },
2985                         {
2986                                 .ifnum = 1,
2987                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2988                                 .data = &(const struct audioformat) {
2989                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2990                                         .channels = 2,
2991                                         .iface = 1,
2992                                         .altsetting = 1,
2993                                         .altset_idx = 1,
2994                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2995                                         .endpoint = 0x02,
2996                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2997                                         .rates = SNDRV_PCM_RATE_44100 |
2998                                                  SNDRV_PCM_RATE_48000 |
2999                                                  SNDRV_PCM_RATE_88200 |
3000                                                  SNDRV_PCM_RATE_96000,
3001                                         .rate_min = 44100,
3002                                         .rate_max = 96000,
3003                                         .nr_rates = 4,
3004                                         .rate_table = (unsigned int[]) {
3005                                                 44100, 48000, 88200, 96000
3006                                         }
3007                                 }
3008                         },
3009                         {
3010                                 .ifnum = -1
3011                         }
3012                 }
3013         }
3014 },
3015
3016 /* Microsoft XboxLive Headset/Xbox Communicator */
3017 {
3018         USB_DEVICE(0x045e, 0x0283),
3019         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3020         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3021                 .vendor_name = "Microsoft",
3022                 .product_name = "XboxLive Headset/Xbox Communicator",
3023                 .ifnum = QUIRK_ANY_INTERFACE,
3024                 .type = QUIRK_COMPOSITE,
3025                 .data = &(const struct snd_usb_audio_quirk[]) {
3026                         {
3027                                 /* playback */
3028                                 .ifnum = 0,
3029                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3030                                 .data = &(const struct audioformat) {
3031                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3032                                         .channels = 1,
3033                                         .iface = 0,
3034                                         .altsetting = 0,
3035                                         .altset_idx = 0,
3036                                         .attributes = 0,
3037                                         .endpoint = 0x04,
3038                                         .ep_attr = 0x05,
3039                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3040                                         .rate_min = 22050,
3041                                         .rate_max = 22050
3042                                 }
3043                         },
3044                         {
3045                                 /* capture */
3046                                 .ifnum = 1,
3047                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3048                                 .data = &(const struct audioformat) {
3049                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3050                                         .channels = 1,
3051                                         .iface = 1,
3052                                         .altsetting = 0,
3053                                         .altset_idx = 0,
3054                                         .attributes = 0,
3055                                         .endpoint = 0x85,
3056                                         .ep_attr = 0x05,
3057                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3058                                         .rate_min = 16000,
3059                                         .rate_max = 16000
3060                                 }
3061                         },
3062                         {
3063                                 .ifnum = -1
3064                         }
3065                 }
3066         }
3067 },
3068
3069 /* Reloop Play */
3070 {
3071         USB_DEVICE(0x200c, 0x100b),
3072         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3073         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3074                 .ifnum = QUIRK_ANY_INTERFACE,
3075                 .type = QUIRK_COMPOSITE,
3076                 .data = &(const struct snd_usb_audio_quirk[]) {
3077                         {
3078                                 .ifnum = 0,
3079                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3080                         },
3081                         {
3082                                 .ifnum = 1,
3083                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3084                                 .data = &(const struct audioformat) {
3085                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3086                                         .channels = 4,
3087                                         .iface = 1,
3088                                         .altsetting = 1,
3089                                         .altset_idx = 1,
3090                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3091                                         .endpoint = 0x01,
3092                                         .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3093                                         .rates = SNDRV_PCM_RATE_44100 |
3094                                                  SNDRV_PCM_RATE_48000,
3095                                         .rate_min = 44100,
3096                                         .rate_max = 48000,
3097                                         .nr_rates = 2,
3098                                         .rate_table = (unsigned int[]) {
3099                                                 44100, 48000
3100                                         }
3101                                 }
3102                         },
3103                         {
3104                                 .ifnum = -1
3105                         }
3106                 }
3107         }
3108 },
3109
3110 {
3111         /*
3112          * ZOOM R16/24 in audio interface mode.
3113          * Playback requires an extra four byte LE length indicator
3114          * at the start of each isochronous packet. This quirk is
3115          * enabled in create_standard_audio_quirk().
3116          */
3117         USB_DEVICE(0x1686, 0x00dd),
3118         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3119                 .ifnum = QUIRK_ANY_INTERFACE,
3120                 .type = QUIRK_COMPOSITE,
3121                 .data = (const struct snd_usb_audio_quirk[]) {
3122                         {
3123                                 /* Playback  */
3124                                 .ifnum = 1,
3125                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3126                         },
3127                         {
3128                                 /* Capture */
3129                                 .ifnum = 2,
3130                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3131                         },
3132                         {
3133                                 /* Midi */
3134                                 .ifnum = 3,
3135                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3136                         },
3137                         {
3138                                 .ifnum = -1
3139                         },
3140                 }
3141         }
3142 },
3143
3144 {
3145         /*
3146          * Some USB MIDI devices don't have an audio control interface,
3147          * so we have to grab MIDI streaming interfaces here.
3148          */
3149         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3150                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3151         .bInterfaceClass = USB_CLASS_AUDIO,
3152         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3153         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3154                 .ifnum = QUIRK_ANY_INTERFACE,
3155                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3156         }
3157 },
3158
3159 /* disabled due to regression for other devices;
3160  * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3161  */
3162 #if 0
3163 {
3164         /*
3165          * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3166          * ID, but it looks like the product ID actually is only for Nura.
3167          * The capture interface does not work at all (even on Windows),
3168          * and only the 48 kHz sample rate works for the playback interface.
3169          */
3170         USB_DEVICE(0x0a12, 0x1243),
3171         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3172                 .ifnum = QUIRK_ANY_INTERFACE,
3173                 .type = QUIRK_COMPOSITE,
3174                 .data = (const struct snd_usb_audio_quirk[]) {
3175                         {
3176                                 .ifnum = 0,
3177                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3178                         },
3179                         /* Capture */
3180                         {
3181                                 .ifnum = 1,
3182                                 .type = QUIRK_IGNORE_INTERFACE,
3183                         },
3184                         /* Playback */
3185                         {
3186                                 .ifnum = 2,
3187                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3188                                 .data = &(const struct audioformat) {
3189                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3190                                         .channels = 2,
3191                                         .iface = 2,
3192                                         .altsetting = 1,
3193                                         .altset_idx = 1,
3194                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3195                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3196                                         .endpoint = 0x03,
3197                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3198                                         .rates = SNDRV_PCM_RATE_48000,
3199                                         .rate_min = 48000,
3200                                         .rate_max = 48000,
3201                                         .nr_rates = 1,
3202                                         .rate_table = (unsigned int[]) {
3203                                                 48000
3204                                         }
3205                                 }
3206                         },
3207                         {
3208                                 .ifnum = -1
3209                         },
3210                 }
3211         }
3212 },
3213 #endif /* disabled */
3214
3215 {
3216         /*
3217          * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3218          * even though it advertises more. The capture interface doesn't work
3219          * even on windows.
3220          */
3221         USB_DEVICE(0x19b5, 0x0021),
3222         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3223                 .ifnum = QUIRK_ANY_INTERFACE,
3224                 .type = QUIRK_COMPOSITE,
3225                 .data = (const struct snd_usb_audio_quirk[]) {
3226                         {
3227                                 .ifnum = 0,
3228                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3229                         },
3230                         /* Playback */
3231                         {
3232                                 .ifnum = 1,
3233                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3234                                 .data = &(const struct audioformat) {
3235                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3236                                         .channels = 2,
3237                                         .iface = 1,
3238                                         .altsetting = 1,
3239                                         .altset_idx = 1,
3240                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3241                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
3242                                         .endpoint = 0x03,
3243                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
3244                                         .rates = SNDRV_PCM_RATE_48000,
3245                                         .rate_min = 48000,
3246                                         .rate_max = 48000,
3247                                         .nr_rates = 1,
3248                                         .rate_table = (unsigned int[]) {
3249                                                 48000
3250                                         }
3251                                 }
3252                         },
3253                         {
3254                                 .ifnum = -1
3255                         },
3256                 }
3257         }
3258 },
3259 /* MOTU Microbook II */
3260 {
3261         USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3262         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3263                 .vendor_name = "MOTU",
3264                 .product_name = "MicroBookII",
3265                 .ifnum = QUIRK_ANY_INTERFACE,
3266                 .type = QUIRK_COMPOSITE,
3267                 .data = (const struct snd_usb_audio_quirk[]) {
3268                         {
3269                                 .ifnum = 0,
3270                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3271                         },
3272                         {
3273                                 .ifnum = 0,
3274                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3275                                 .data = &(const struct audioformat) {
3276                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3277                                         .channels = 6,
3278                                         .iface = 0,
3279                                         .altsetting = 1,
3280                                         .altset_idx = 1,
3281                                         .attributes = 0,
3282                                         .endpoint = 0x84,
3283                                         .rates = SNDRV_PCM_RATE_96000,
3284                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3285                                                    USB_ENDPOINT_SYNC_ASYNC,
3286                                         .rate_min = 96000,
3287                                         .rate_max = 96000,
3288                                         .nr_rates = 1,
3289                                         .maxpacksize = 0x00d8,
3290                                         .rate_table = (unsigned int[]) {
3291                                                 96000
3292                                         }
3293                                 }
3294                         },
3295                         {
3296                                 .ifnum = 0,
3297                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3298                                 .data = &(const struct audioformat) {
3299                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3300                                         .channels = 8,
3301                                         .iface = 0,
3302                                         .altsetting = 1,
3303                                         .altset_idx = 1,
3304                                         .attributes = 0,
3305                                         .endpoint = 0x03,
3306                                         .rates = SNDRV_PCM_RATE_96000,
3307                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3308                                                    USB_ENDPOINT_SYNC_ASYNC,
3309                                         .rate_min = 96000,
3310                                         .rate_max = 96000,
3311                                         .nr_rates = 1,
3312                                         .maxpacksize = 0x0120,
3313                                         .rate_table = (unsigned int[]) {
3314                                                 96000
3315                                         }
3316                                 }
3317                         },
3318                         {
3319                                 .ifnum = -1
3320                         }
3321                 }
3322         }
3323 },
3324 {
3325         /*
3326          * PIONEER DJ DDJ-SX3
3327          * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3328          * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3329          * The feedback for the output is the input.
3330          */
3331         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3332         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3333                 .ifnum = QUIRK_ANY_INTERFACE,
3334                 .type = QUIRK_COMPOSITE,
3335                 .data = (const struct snd_usb_audio_quirk[]) {
3336                         {
3337                                 .ifnum = 0,
3338                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3339                                 .data = &(const struct audioformat) {
3340                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3341                                         .channels = 12,
3342                                         .iface = 0,
3343                                         .altsetting = 1,
3344                                         .altset_idx = 1,
3345                                         .endpoint = 0x05,
3346                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3347                                                    USB_ENDPOINT_SYNC_ASYNC,
3348                                         .rates = SNDRV_PCM_RATE_44100,
3349                                         .rate_min = 44100,
3350                                         .rate_max = 44100,
3351                                         .nr_rates = 1,
3352                                         .rate_table = (unsigned int[]) { 44100 }
3353                                 }
3354                         },
3355                         {
3356                                 .ifnum = 0,
3357                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3358                                 .data = &(const struct audioformat) {
3359                                         .formats = SNDRV_PCM_FMTBIT_S32_LE,
3360                                         .channels = 10,
3361                                         .iface = 0,
3362                                         .altsetting = 1,
3363                                         .altset_idx = 1,
3364                                         .endpoint = 0x86,
3365                                         .ep_idx = 1,
3366                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3367                                                  USB_ENDPOINT_SYNC_ASYNC|
3368                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3369                                         .rates = SNDRV_PCM_RATE_44100,
3370                                         .rate_min = 44100,
3371                                         .rate_max = 44100,
3372                                         .nr_rates = 1,
3373                                         .rate_table = (unsigned int[]) { 44100 }
3374                                 }
3375                         },
3376                         {
3377                                 .ifnum = -1
3378                         }
3379                 }
3380         }
3381 },
3382 {
3383         /*
3384          * Pioneer DJ DJM-250MK2
3385          * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3386          * and 8 channels in @ 48 fixed (endpoint 0x82).
3387          *
3388          * Both playback and recording is working, even simultaneously.
3389          *
3390          * Playback channels could be mapped to:
3391          *  - CH1
3392          *  - CH2
3393          *  - AUX
3394          *
3395          * Recording channels could be mapped to:
3396          *  - Post CH1 Fader
3397          *  - Post CH2 Fader
3398          *  - Cross Fader A
3399          *  - Cross Fader B
3400          *  - MIC
3401          *  - AUX
3402          *  - REC OUT
3403          *
3404          * There is remaining problem with recording directly from PHONO/LINE.
3405          * If we map a channel to:
3406          *  - CH1 Control Tone PHONO
3407          *  - CH1 Control Tone LINE
3408          *  - CH2 Control Tone PHONO
3409          *  - CH2 Control Tone LINE
3410          * it is silent.
3411          * There is no signal even on other operating systems with official drivers.
3412          * The signal appears only when a supported application is started.
3413          * This needs to be investigated yet...
3414          * (there is quite a lot communication on the USB in both directions)
3415          *
3416          * In current version this mixer could be used for playback
3417          * and for recording from vinyls (through Post CH* Fader)
3418          * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3419          */
3420         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3421         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3422                 .ifnum = QUIRK_ANY_INTERFACE,
3423                 .type = QUIRK_COMPOSITE,
3424                 .data = (const struct snd_usb_audio_quirk[]) {
3425                         {
3426                                 .ifnum = 0,
3427                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3428                                 .data = &(const struct audioformat) {
3429                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3430                                         .channels = 8, // outputs
3431                                         .iface = 0,
3432                                         .altsetting = 1,
3433                                         .altset_idx = 1,
3434                                         .endpoint = 0x01,
3435                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3436                                                 USB_ENDPOINT_SYNC_ASYNC,
3437                                         .rates = SNDRV_PCM_RATE_48000,
3438                                         .rate_min = 48000,
3439                                         .rate_max = 48000,
3440                                         .nr_rates = 1,
3441                                         .rate_table = (unsigned int[]) { 48000 }
3442                                         }
3443                         },
3444                         {
3445                                 .ifnum = 0,
3446                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3447                                 .data = &(const struct audioformat) {
3448                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3449                                         .channels = 8, // inputs
3450                                         .iface = 0,
3451                                         .altsetting = 1,
3452                                         .altset_idx = 1,
3453                                         .endpoint = 0x82,
3454                                         .ep_idx = 1,
3455                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3456                                                 USB_ENDPOINT_SYNC_ASYNC|
3457                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3458                                         .rates = SNDRV_PCM_RATE_48000,
3459                                         .rate_min = 48000,
3460                                         .rate_max = 48000,
3461                                         .nr_rates = 1,
3462                                         .rate_table = (unsigned int[]) { 48000 }
3463                                 }
3464                         },
3465                         {
3466                                 .ifnum = -1
3467                         }
3468                 }
3469         }
3470 },
3471 {
3472         /*
3473          * PIONEER DJ DDJ-RB
3474          * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3475          * The feedback for the output is the dummy input.
3476          */
3477         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3478         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3479                 .ifnum = QUIRK_ANY_INTERFACE,
3480                 .type = QUIRK_COMPOSITE,
3481                 .data = (const struct snd_usb_audio_quirk[]) {
3482                         {
3483                                 .ifnum = 0,
3484                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3485                                 .data = &(const struct audioformat) {
3486                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3487                                         .channels = 4,
3488                                         .iface = 0,
3489                                         .altsetting = 1,
3490                                         .altset_idx = 1,
3491                                         .endpoint = 0x01,
3492                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3493                                                    USB_ENDPOINT_SYNC_ASYNC,
3494                                         .rates = SNDRV_PCM_RATE_44100,
3495                                         .rate_min = 44100,
3496                                         .rate_max = 44100,
3497                                         .nr_rates = 1,
3498                                         .rate_table = (unsigned int[]) { 44100 }
3499                                 }
3500                         },
3501                         {
3502                                 .ifnum = 0,
3503                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3504                                 .data = &(const struct audioformat) {
3505                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3506                                         .channels = 2,
3507                                         .iface = 0,
3508                                         .altsetting = 1,
3509                                         .altset_idx = 1,
3510                                         .endpoint = 0x82,
3511                                         .ep_idx = 1,
3512                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3513                                                  USB_ENDPOINT_SYNC_ASYNC|
3514                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3515                                         .rates = SNDRV_PCM_RATE_44100,
3516                                         .rate_min = 44100,
3517                                         .rate_max = 44100,
3518                                         .nr_rates = 1,
3519                                         .rate_table = (unsigned int[]) { 44100 }
3520                                 }
3521                         },
3522                         {
3523                                 .ifnum = -1
3524                         }
3525                 }
3526         }
3527 },
3528
3529 {
3530         /*
3531          * PIONEER DJ DDJ-RR
3532          * PCM is 6 channels out & 4 channels in @ 44.1 fixed
3533          */
3534         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000d),
3535         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3536                 .ifnum = QUIRK_ANY_INTERFACE,
3537                 .type = QUIRK_COMPOSITE,
3538                 .data = (const struct snd_usb_audio_quirk[]) {
3539                         {
3540                                 .ifnum = 0,
3541                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3542                                 .data = &(const struct audioformat) {
3543                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3544                                         .channels = 6, //Master, Headphones & Booth
3545                                         .iface = 0,
3546                                         .altsetting = 1,
3547                                         .altset_idx = 1,
3548                                         .endpoint = 0x01,
3549                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3550                                                    USB_ENDPOINT_SYNC_ASYNC,
3551                                         .rates = SNDRV_PCM_RATE_44100,
3552                                         .rate_min = 44100,
3553                                         .rate_max = 44100,
3554                                         .nr_rates = 1,
3555                                         .rate_table = (unsigned int[]) { 44100 }
3556                                 }
3557                         },
3558                         {
3559                                 .ifnum = 0,
3560                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3561                                 .data = &(const struct audioformat) {
3562                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3563                                         .channels = 4, //2x RCA inputs (CH1 & CH2)
3564                                         .iface = 0,
3565                                         .altsetting = 1,
3566                                         .altset_idx = 1,
3567                                         .endpoint = 0x82,
3568                                         .ep_idx = 1,
3569                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3570                                                  USB_ENDPOINT_SYNC_ASYNC|
3571                                                  USB_ENDPOINT_USAGE_IMPLICIT_FB,
3572                                         .rates = SNDRV_PCM_RATE_44100,
3573                                         .rate_min = 44100,
3574                                         .rate_max = 44100,
3575                                         .nr_rates = 1,
3576                                         .rate_table = (unsigned int[]) { 44100 }
3577                                 }
3578                         },
3579                         {
3580                                 .ifnum = -1
3581                         }
3582                 }
3583         }
3584 },
3585
3586 {
3587         /*
3588          * PIONEER DJ DDJ-SR2
3589          * PCM is 4 channels out, 6 channels in @ 44.1 fixed
3590          * The Feedback for the output is the input
3591          */
3592         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001e),
3593                 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3594                 .ifnum = QUIRK_ANY_INTERFACE,
3595                 .type = QUIRK_COMPOSITE,
3596                 .data = (const struct snd_usb_audio_quirk[]) {
3597                         {
3598                                 .ifnum = 0,
3599                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3600                                 .data = &(const struct audioformat) {
3601                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3602                                         .channels = 4,
3603                                         .iface = 0,
3604                                         .altsetting = 1,
3605                                         .altset_idx = 1,
3606                                         .endpoint = 0x01,
3607                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3608                                                 USB_ENDPOINT_SYNC_ASYNC,
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 = 0,
3618                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3619                                 .data = &(const struct audioformat) {
3620                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3621                                         .channels = 6,
3622                                         .iface = 0,
3623                                         .altsetting = 1,
3624                                         .altset_idx = 1,
3625                                         .endpoint = 0x82,
3626                                         .ep_idx = 1,
3627                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3628                                                 USB_ENDPOINT_SYNC_ASYNC|
3629                                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3630                                         .rates = SNDRV_PCM_RATE_44100,
3631                                         .rate_min = 44100,
3632                                         .rate_max = 44100,
3633                                         .nr_rates = 1,
3634                                         .rate_table = (unsigned int[]) { 44100 }
3635                                 }
3636                         },
3637                         {
3638                                 .ifnum = -1
3639                         }
3640                 }
3641         }
3642 },
3643
3644 {
3645         /*
3646          * Pioneer DJ DJM-900NXS2
3647          * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3648          */
3649         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3650         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3651                 .ifnum = QUIRK_ANY_INTERFACE,
3652                 .type = QUIRK_COMPOSITE,
3653                 .data = (const struct snd_usb_audio_quirk[]) {
3654                         {
3655                                 .ifnum = 0,
3656                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3657                                 .data = &(const struct audioformat) {
3658                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3659                                         .channels = 10,
3660                                         .iface = 0,
3661                                         .altsetting = 1,
3662                                         .altset_idx = 1,
3663                                         .endpoint = 0x01,
3664                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3665                                             USB_ENDPOINT_SYNC_ASYNC,
3666                                         .rates = SNDRV_PCM_RATE_44100|
3667                                             SNDRV_PCM_RATE_48000|
3668                                             SNDRV_PCM_RATE_96000,
3669                                         .rate_min = 44100,
3670                                         .rate_max = 96000,
3671                                         .nr_rates = 3,
3672                                         .rate_table = (unsigned int[]) {
3673                                                 44100, 48000, 96000
3674                                         }
3675                                 }
3676                         },
3677                         {
3678                                 .ifnum = 0,
3679                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3680                                 .data = &(const struct audioformat) {
3681                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3682                                         .channels = 12,
3683                                         .iface = 0,
3684                                         .altsetting = 1,
3685                                         .altset_idx = 1,
3686                                         .endpoint = 0x82,
3687                                         .ep_idx = 1,
3688                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3689                                             USB_ENDPOINT_SYNC_ASYNC|
3690                                             USB_ENDPOINT_USAGE_IMPLICIT_FB,
3691                                         .rates = SNDRV_PCM_RATE_44100|
3692                                             SNDRV_PCM_RATE_48000|
3693                                             SNDRV_PCM_RATE_96000,
3694                                         .rate_min = 44100,
3695                                         .rate_max = 96000,
3696                                         .nr_rates = 3,
3697                                         .rate_table = (unsigned int[]) {
3698                                                 44100, 48000, 96000
3699                                         }
3700                                 }
3701                         },
3702                         {
3703                                 .ifnum = -1
3704                         }
3705                 }
3706         }
3707 },
3708
3709 /*
3710  * MacroSilicon MS2109 based HDMI capture cards
3711  *
3712  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3713  * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if
3714  * they pretend to be 96kHz mono as a workaround for stereo being broken
3715  * by that...
3716  *
3717  * They also have an issue with initial stream alignment that causes the
3718  * channels to be swapped and out of phase, which is dealt with in quirks.c.
3719  */
3720 {
3721         USB_AUDIO_DEVICE(0x534d, 0x2109),
3722         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3723                 .vendor_name = "MacroSilicon",
3724                 .product_name = "MS2109",
3725                 .ifnum = QUIRK_ANY_INTERFACE,
3726                 .type = QUIRK_COMPOSITE,
3727                 .data = &(const struct snd_usb_audio_quirk[]) {
3728                         {
3729                                 .ifnum = 2,
3730                                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
3731                         },
3732                         {
3733                                 .ifnum = 2,
3734                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3735                         },
3736                         {
3737                                 .ifnum = 3,
3738                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3739                                 .data = &(const struct audioformat) {
3740                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
3741                                         .channels = 2,
3742                                         .iface = 3,
3743                                         .altsetting = 1,
3744                                         .altset_idx = 1,
3745                                         .attributes = 0,
3746                                         .endpoint = 0x82,
3747                                         .ep_attr = USB_ENDPOINT_XFER_ISOC |
3748                                                 USB_ENDPOINT_SYNC_ASYNC,
3749                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
3750                                         .rate_min = 48000,
3751                                         .rate_max = 48000,
3752                                 }
3753                         },
3754                         {
3755                                 .ifnum = -1
3756                         }
3757                 }
3758         }
3759 },
3760 {
3761         /*
3762          * Pioneer DJ DJM-750
3763          * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE
3764          */
3765         USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f),
3766         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3767                 .ifnum = QUIRK_ANY_INTERFACE,
3768                 .type = QUIRK_COMPOSITE,
3769                 .data = (const struct snd_usb_audio_quirk[]) {
3770                         {
3771                                 .ifnum = 0,
3772                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3773                                 .data = &(const struct audioformat) {
3774                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3775                                         .channels = 8,
3776                                         .iface = 0,
3777                                         .altsetting = 1,
3778                                         .altset_idx = 1,
3779                                         .endpoint = 0x05,
3780                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3781                                             USB_ENDPOINT_SYNC_ASYNC,
3782                                         .rates = SNDRV_PCM_RATE_44100|
3783                                                 SNDRV_PCM_RATE_48000|
3784                                                 SNDRV_PCM_RATE_96000,
3785                                         .rate_min = 44100,
3786                                         .rate_max = 96000,
3787                                         .nr_rates = 3,
3788                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3789                                 }
3790                         },
3791                         {
3792                                 .ifnum = 0,
3793                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3794                                 .data = &(const struct audioformat) {
3795                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3796                                         .channels = 8,
3797                                         .iface = 0,
3798                                         .altsetting = 1,
3799                                         .altset_idx = 1,
3800                                         .endpoint = 0x86,
3801                                         .ep_idx = 1,
3802                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3803                                                 USB_ENDPOINT_SYNC_ASYNC|
3804                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3805                                         .rates = SNDRV_PCM_RATE_44100|
3806                                                 SNDRV_PCM_RATE_48000|
3807                                                 SNDRV_PCM_RATE_96000,
3808                                         .rate_min = 44100,
3809                                         .rate_max = 96000,
3810                                         .nr_rates = 3,
3811                                         .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3812                                 }
3813                         },
3814                         {
3815                                 .ifnum = -1
3816                         }
3817                 }
3818         }
3819 },
3820 {
3821         /*
3822          * Pioneer DJ DJM-450
3823          * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3824          * and 8 channels in @ 48 fixed (endpoint 0x82).
3825          */
3826         USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013),
3827         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3828                 .ifnum = QUIRK_ANY_INTERFACE,
3829                 .type = QUIRK_COMPOSITE,
3830                 .data = (const struct snd_usb_audio_quirk[]) {
3831                         {
3832                                 .ifnum = 0,
3833                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3834                                 .data = &(const struct audioformat) {
3835                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3836                                         .channels = 8, // outputs
3837                                         .iface = 0,
3838                                         .altsetting = 1,
3839                                         .altset_idx = 1,
3840                                         .endpoint = 0x01,
3841                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3842                                                 USB_ENDPOINT_SYNC_ASYNC,
3843                                         .rates = SNDRV_PCM_RATE_48000,
3844                                         .rate_min = 48000,
3845                                         .rate_max = 48000,
3846                                         .nr_rates = 1,
3847                                         .rate_table = (unsigned int[]) { 48000 }
3848                                         }
3849                         },
3850                         {
3851                                 .ifnum = 0,
3852                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3853                                 .data = &(const struct audioformat) {
3854                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3855                                         .channels = 8, // inputs
3856                                         .iface = 0,
3857                                         .altsetting = 1,
3858                                         .altset_idx = 1,
3859                                         .endpoint = 0x82,
3860                                         .ep_idx = 1,
3861                                         .ep_attr = USB_ENDPOINT_XFER_ISOC|
3862                                                 USB_ENDPOINT_SYNC_ASYNC|
3863                                                 USB_ENDPOINT_USAGE_IMPLICIT_FB,
3864                                         .rates = SNDRV_PCM_RATE_48000,
3865                                         .rate_min = 48000,
3866                                         .rate_max = 48000,
3867                                         .nr_rates = 1,
3868                                         .rate_table = (unsigned int[]) { 48000 }
3869                                 }
3870                         },
3871                         {
3872                                 .ifnum = -1
3873                         }
3874                 }
3875         }
3876 },
3877
3878 #undef USB_DEVICE_VENDOR_SPEC
3879 #undef USB_AUDIO_DEVICE