sound/usb/quirks-table.h

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