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