sound/usb/quirks-table.h

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