sound/usb/quirks-table.h

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