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