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