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