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