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