sound/usb/quirks-table.h

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