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