sound/usb/quirks-table.h

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