Pileus Git - ~andy/linux/blob - sound/usb/quirks-table.h

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