LXR linux/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/* Creative/Toshiba Multimedia Center SB-0500 */
  43{
  44        USB_DEVICE(0x041e, 0x3048),
  45        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  46                .vendor_name = "Toshiba",
  47                .product_name = "SB-0500",
  48                .ifnum = QUIRK_NO_INTERFACE
  49        }
  50},
  51
  52/* Creative/E-Mu devices */
  53{
  54        USB_DEVICE(0x041e, 0x3010),
  55        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  56                .vendor_name = "Creative Labs",
  57                .product_name = "Sound Blaster MP3+",
  58                .ifnum = QUIRK_NO_INTERFACE
  59        }
  60},
  61{
  62        /* E-Mu 0202 USB */
  63        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  64        .idVendor = 0x041e,
  65        .idProduct = 0x3f02,
  66        .bInterfaceClass = USB_CLASS_AUDIO,
  67},
  68{
  69        /* E-Mu 0404 USB */
  70        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  71        .idVendor = 0x041e,
  72        .idProduct = 0x3f04,
  73        .bInterfaceClass = USB_CLASS_AUDIO,
  74},
  75{
  76        /* E-Mu Tracker Pre */
  77        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  78        .idVendor = 0x041e,
  79        .idProduct = 0x3f0a,
  80        .bInterfaceClass = USB_CLASS_AUDIO,
  81},
  82{
  83        /* E-Mu 0204 USB */
  84        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  85        .idVendor = 0x041e,
  86        .idProduct = 0x3f19,
  87        .bInterfaceClass = USB_CLASS_AUDIO,
  88},
  89
  90/*
  91 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
  92 * class matches do not take effect without an explicit ID match.
  93 */
  94{
  95        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  96                       USB_DEVICE_ID_MATCH_INT_CLASS |
  97                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  98        .idVendor = 0x046d,
  99        .idProduct = 0x0850,
 100        .bInterfaceClass = USB_CLASS_AUDIO,
 101        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 102},
 103{
 104        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 105                       USB_DEVICE_ID_MATCH_INT_CLASS |
 106                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 107        .idVendor = 0x046d,
 108        .idProduct = 0x08ae,
 109        .bInterfaceClass = USB_CLASS_AUDIO,
 110        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 111},
 112{
 113        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 114                       USB_DEVICE_ID_MATCH_INT_CLASS |
 115                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 116        .idVendor = 0x046d,
 117        .idProduct = 0x08c6,
 118        .bInterfaceClass = USB_CLASS_AUDIO,
 119        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 120},
 121{
 122        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 123                       USB_DEVICE_ID_MATCH_INT_CLASS |
 124                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 125        .idVendor = 0x046d,
 126        .idProduct = 0x08f0,
 127        .bInterfaceClass = USB_CLASS_AUDIO,
 128        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 129},
 130{
 131        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 132                       USB_DEVICE_ID_MATCH_INT_CLASS |
 133                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 134        .idVendor = 0x046d,
 135        .idProduct = 0x08f5,
 136        .bInterfaceClass = USB_CLASS_AUDIO,
 137        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 138},
 139{
 140        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 141                       USB_DEVICE_ID_MATCH_INT_CLASS |
 142                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 143        .idVendor = 0x046d,
 144        .idProduct = 0x08f6,
 145        .bInterfaceClass = USB_CLASS_AUDIO,
 146        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 147},
 148{
 149        USB_DEVICE(0x046d, 0x0990),
 150        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 151                .vendor_name = "Logitech, Inc.",
 152                .product_name = "QuickCam Pro 9000",
 153                .ifnum = QUIRK_NO_INTERFACE
 154        }
 155},
 156
 157/*
 158 * Yamaha devices
 159 */
 160
 161#define YAMAHA_DEVICE(id, name) { \
 162        USB_DEVICE(0x0499, id), \
 163        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 164                .vendor_name = "Yamaha", \
 165                .product_name = name, \
 166                .ifnum = QUIRK_ANY_INTERFACE, \
 167                .type = QUIRK_MIDI_YAMAHA \
 168        } \
 169}
 170#define YAMAHA_INTERFACE(id, intf, name) { \
 171        USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 172        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 173                .vendor_name = "Yamaha", \
 174                .product_name = name, \
 175                .ifnum = intf, \
 176                .type = QUIRK_MIDI_YAMAHA \
 177        } \
 178}
 179YAMAHA_DEVICE(0x1000, "UX256"),
 180YAMAHA_DEVICE(0x1001, "MU1000"),
 181YAMAHA_DEVICE(0x1002, "MU2000"),
 182YAMAHA_DEVICE(0x1003, "MU500"),
 183YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 184YAMAHA_DEVICE(0x1005, "MOTIF6"),
 185YAMAHA_DEVICE(0x1006, "MOTIF7"),
 186YAMAHA_DEVICE(0x1007, "MOTIF8"),
 187YAMAHA_DEVICE(0x1008, "UX96"),
 188YAMAHA_DEVICE(0x1009, "UX16"),
 189YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 190YAMAHA_DEVICE(0x100c, "UC-MX"),
 191YAMAHA_DEVICE(0x100d, "UC-KX"),
 192YAMAHA_DEVICE(0x100e, "S08"),
 193YAMAHA_DEVICE(0x100f, "CLP-150"),
 194YAMAHA_DEVICE(0x1010, "CLP-170"),
 195YAMAHA_DEVICE(0x1011, "P-250"),
 196YAMAHA_DEVICE(0x1012, "TYROS"),
 197YAMAHA_DEVICE(0x1013, "PF-500"),
 198YAMAHA_DEVICE(0x1014, "S90"),
 199YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 200YAMAHA_DEVICE(0x1016, "MDP-5"),
 201YAMAHA_DEVICE(0x1017, "CVP-204"),
 202YAMAHA_DEVICE(0x1018, "CVP-206"),
 203YAMAHA_DEVICE(0x1019, "CVP-208"),
 204YAMAHA_DEVICE(0x101a, "CVP-210"),
 205YAMAHA_DEVICE(0x101b, "PSR-1100"),
 206YAMAHA_DEVICE(0x101c, "PSR-2100"),
 207YAMAHA_DEVICE(0x101d, "CLP-175"),
 208YAMAHA_DEVICE(0x101e, "PSR-K1"),
 209YAMAHA_DEVICE(0x101f, "EZ-J24"),
 210YAMAHA_DEVICE(0x1020, "EZ-250i"),
 211YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 212YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 213YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 214YAMAHA_DEVICE(0x1024, "CVP-301"),
 215YAMAHA_DEVICE(0x1025, "CVP-303"),
 216YAMAHA_DEVICE(0x1026, "CVP-305"),
 217YAMAHA_DEVICE(0x1027, "CVP-307"),
 218YAMAHA_DEVICE(0x1028, "CVP-309"),
 219YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 220YAMAHA_DEVICE(0x102a, "PSR-1500"),
 221YAMAHA_DEVICE(0x102b, "PSR-3000"),
 222YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 223YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 224YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 225YAMAHA_DEVICE(0x1032, "DGX-305"),
 226YAMAHA_DEVICE(0x1033, "DGX-505"),
 227YAMAHA_DEVICE(0x1034, NULL),
 228YAMAHA_DEVICE(0x1035, NULL),
 229YAMAHA_DEVICE(0x1036, NULL),
 230YAMAHA_DEVICE(0x1037, NULL),
 231YAMAHA_DEVICE(0x1038, NULL),
 232YAMAHA_DEVICE(0x1039, NULL),
 233YAMAHA_DEVICE(0x103a, NULL),
 234YAMAHA_DEVICE(0x103b, NULL),
 235YAMAHA_DEVICE(0x103c, NULL),
 236YAMAHA_DEVICE(0x103d, NULL),
 237YAMAHA_DEVICE(0x103e, NULL),
 238YAMAHA_DEVICE(0x103f, NULL),
 239YAMAHA_DEVICE(0x1040, NULL),
 240YAMAHA_DEVICE(0x1041, NULL),
 241YAMAHA_DEVICE(0x1042, NULL),
 242YAMAHA_DEVICE(0x1043, NULL),
 243YAMAHA_DEVICE(0x1044, NULL),
 244YAMAHA_DEVICE(0x1045, NULL),
 245YAMAHA_INTERFACE(0x104e, 0, NULL),
 246YAMAHA_DEVICE(0x104f, NULL),
 247YAMAHA_DEVICE(0x1050, NULL),
 248YAMAHA_DEVICE(0x1051, NULL),
 249YAMAHA_DEVICE(0x1052, NULL),
 250YAMAHA_INTERFACE(0x1053, 0, NULL),
 251YAMAHA_INTERFACE(0x1054, 0, NULL),
 252YAMAHA_DEVICE(0x1055, NULL),
 253YAMAHA_DEVICE(0x1056, NULL),
 254YAMAHA_DEVICE(0x1057, NULL),
 255YAMAHA_DEVICE(0x1058, NULL),
 256YAMAHA_DEVICE(0x1059, NULL),
 257YAMAHA_DEVICE(0x105a, NULL),
 258YAMAHA_DEVICE(0x105b, NULL),
 259YAMAHA_DEVICE(0x105c, NULL),
 260YAMAHA_DEVICE(0x105d, NULL),
 261YAMAHA_DEVICE(0x2000, "DGP-7"),
 262YAMAHA_DEVICE(0x2001, "DGP-5"),
 263YAMAHA_DEVICE(0x2002, NULL),
 264YAMAHA_DEVICE(0x2003, NULL),
 265YAMAHA_DEVICE(0x5000, "CS1D"),
 266YAMAHA_DEVICE(0x5001, "DSP1D"),
 267YAMAHA_DEVICE(0x5002, "DME32"),
 268YAMAHA_DEVICE(0x5003, "DM2000"),
 269YAMAHA_DEVICE(0x5004, "02R96"),
 270YAMAHA_DEVICE(0x5005, "ACU16-C"),
 271YAMAHA_DEVICE(0x5006, "NHB32-C"),
 272YAMAHA_DEVICE(0x5007, "DM1000"),
 273YAMAHA_DEVICE(0x5008, "01V96"),
 274YAMAHA_DEVICE(0x5009, "SPX2000"),
 275YAMAHA_DEVICE(0x500a, "PM5D"),
 276YAMAHA_DEVICE(0x500b, "DME64N"),
 277YAMAHA_DEVICE(0x500c, "DME24N"),
 278YAMAHA_DEVICE(0x500d, NULL),
 279YAMAHA_DEVICE(0x500e, NULL),
 280YAMAHA_DEVICE(0x500f, NULL),
 281YAMAHA_DEVICE(0x7000, "DTX"),
 282YAMAHA_DEVICE(0x7010, "UB99"),
 283#undef YAMAHA_DEVICE
 284#undef YAMAHA_INTERFACE
 285
 286/*
 287 * Roland/RolandED/Edirol/BOSS devices
 288 */
 289{
 290        USB_DEVICE(0x0582, 0x0000),
 291        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 292                .vendor_name = "Roland",
 293                .product_name = "UA-100",
 294                .ifnum = QUIRK_ANY_INTERFACE,
 295                .type = QUIRK_COMPOSITE,
 296                .data = (const struct snd_usb_audio_quirk[]) {
 297                        {
 298                                .ifnum = 0,
 299                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 300                                .data = & (const struct audioformat) {
 301                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
 302                                        .channels = 4,
 303                                        .iface = 0,
 304                                        .altsetting = 1,
 305                                        .altset_idx = 1,
 306                                        .attributes = 0,
 307                                        .endpoint = 0x01,
 308                                        .ep_attr = 0x09,
 309                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 310                                        .rate_min = 44100,
 311                                        .rate_max = 44100,
 312                                }
 313                        },
 314                        {
 315                                .ifnum = 1,
 316                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 317                                .data = & (const struct audioformat) {
 318                                        .formats = SNDRV_PCM_FMTBIT_S16_LE,
 319                                        .channels = 2,
 320                                        .iface = 1,
 321                                        .altsetting = 1,
 322                                        .altset_idx = 1,
 323                                        .attributes = UAC_EP_CS_ATTR_FILL_MAX,
 324                                        .endpoint = 0x81,
 325                                        .ep_attr = 0x05,
 326                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 327                                        .rate_min = 44100,
 328                                        .rate_max = 44100,
 329                                }
 330                        },
 331                        {
 332                                .ifnum = 2,
 333                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 334                                .data = & (const struct snd_usb_midi_endpoint_info) {
 335                                        .out_cables = 0x0007,
 336                                        .in_cables  = 0x0007
 337                                }
 338                        },
 339                        {
 340                                .ifnum = -1
 341                        }
 342                }
 343        }
 344},
 345{
 346        USB_DEVICE(0x0582, 0x0002),
 347        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 348                .vendor_name = "EDIROL",
 349                .product_name = "UM-4",
 350                .ifnum = QUIRK_ANY_INTERFACE,
 351                .type = QUIRK_COMPOSITE,
 352                .data = (const struct snd_usb_audio_quirk[]) {
 353                        {
 354                                .ifnum = 0,
 355                                .type = QUIRK_IGNORE_INTERFACE
 356                        },
 357                        {
 358                                .ifnum = 1,
 359                                .type = QUIRK_IGNORE_INTERFACE
 360                        },
 361                        {
 362                                .ifnum = 2,
 363                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 364                                .data = & (const struct snd_usb_midi_endpoint_info) {
 365                                        .out_cables = 0x000f,
 366                                        .in_cables  = 0x000f
 367                                }
 368                        },
 369                        {
 370                                .ifnum = -1
 371                        }
 372                }
 373        }
 374},
 375{
 376        USB_DEVICE(0x0582, 0x0003),
 377        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 378                .vendor_name = "Roland",
 379                .product_name = "SC-8850",
 380                .ifnum = QUIRK_ANY_INTERFACE,
 381                .type = QUIRK_COMPOSITE,
 382                .data = (const struct snd_usb_audio_quirk[]) {
 383                        {
 384                                .ifnum = 0,
 385                                .type = QUIRK_IGNORE_INTERFACE
 386                        },
 387                        {
 388                                .ifnum = 1,
 389                                .type = QUIRK_IGNORE_INTERFACE
 390                        },
 391                        {
 392                                .ifnum = 2,
 393                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 394                                .data = & (const struct snd_usb_midi_endpoint_info) {
 395                                        .out_cables = 0x003f,
 396                                        .in_cables  = 0x003f
 397                                }
 398                        },
 399                        {
 400                                .ifnum = -1
 401                        }
 402                }
 403        }
 404},
 405{
 406        USB_DEVICE(0x0582, 0x0004),
 407        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 408                .vendor_name = "Roland",
 409                .product_name = "U-8",
 410                .ifnum = QUIRK_ANY_INTERFACE,
 411                .type = QUIRK_COMPOSITE,
 412                .data = (const struct snd_usb_audio_quirk[]) {
 413                        {
 414                                .ifnum = 0,
 415                                .type = QUIRK_IGNORE_INTERFACE
 416                        },
 417                        {
 418                                .ifnum = 1,
 419                                .type = QUIRK_IGNORE_INTERFACE
 420                        },
 421                        {
 422                                .ifnum = 2,
 423                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 424                                .data = & (const struct snd_usb_midi_endpoint_info) {
 425                                        .out_cables = 0x0005,
 426                                        .in_cables  = 0x0005
 427                                }
 428                        },
 429                        {
 430                                .ifnum = -1
 431                        }
 432                }
 433        }
 434},
 435{
 436        /* Has ID 0x0099 when not in "Advanced Driver" mode.
 437         * The UM-2EX has only one input, but we cannot detect this. */
 438        USB_DEVICE(0x0582, 0x0005),
 439        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 440                .vendor_name = "EDIROL",
 441                .product_name = "UM-2",
 442                .ifnum = QUIRK_ANY_INTERFACE,
 443                .type = QUIRK_COMPOSITE,
 444                .data = (const struct snd_usb_audio_quirk[]) {
 445                        {
 446                                .ifnum = 0,
 447                                .type = QUIRK_IGNORE_INTERFACE
 448                        },
 449                        {
 450                                .ifnum = 1,
 451                                .type = QUIRK_IGNORE_INTERFACE
 452                        },
 453                        {
 454                                .ifnum = 2,
 455                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 456                                .data = & (const struct snd_usb_midi_endpoint_info) {
 457                                        .out_cables = 0x0003,
 458                                        .in_cables  = 0x0003
 459                                }
 460                        },
 461                        {
 462                                .ifnum = -1
 463                        }
 464                }
 465        }
 466},
 467{
 468        USB_DEVICE(0x0582, 0x0007),
 469        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 470                .vendor_name = "Roland",
 471                .product_name = "SC-8820",
 472                .ifnum = QUIRK_ANY_INTERFACE,
 473                .type = QUIRK_COMPOSITE,
 474                .data = (const struct snd_usb_audio_quirk[]) {
 475                        {
 476                                .ifnum = 0,
 477                                .type = QUIRK_IGNORE_INTERFACE
 478                        },
 479                        {
 480                                .ifnum = 1,
 481                                .type = QUIRK_IGNORE_INTERFACE
 482                        },
 483                        {
 484                                .ifnum = 2,
 485                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 486                                .data = & (const struct snd_usb_midi_endpoint_info) {
 487                                        .out_cables = 0x0013,
 488                                        .in_cables  = 0x0013
 489                                }
 490                        },
 491                        {
 492                                .ifnum = -1
 493                        }
 494                }
 495        }
 496},
 497{
 498        USB_DEVICE(0x0582, 0x0008),
 499        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 500                .vendor_name = "Roland",
 501                .product_name = "PC-300",
 502                .ifnum = QUIRK_ANY_INTERFACE,
 503                .type = QUIRK_COMPOSITE,
 504                .data = (const struct snd_usb_audio_quirk[]) {
 505                        {
 506                                .ifnum = 0,
 507                                .type = QUIRK_IGNORE_INTERFACE
 508                        },
 509                        {
 510                                .ifnum = 1,
 511                                .type = QUIRK_IGNORE_INTERFACE
 512                        },
 513                        {
 514                                .ifnum = 2,
 515                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 516                                .data = & (const struct snd_usb_midi_endpoint_info) {
 517                                        .out_cables = 0x0001,
 518                                        .in_cables  = 0x0001
 519                                }
 520                        },
 521                        {
 522                                .ifnum = -1
 523                        }
 524                }
 525        }
 526},
 527{
 528        /* has ID 0x009d when not in "Advanced Driver" mode */
 529        USB_DEVICE(0x0582, 0x0009),
 530        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 531                .vendor_name = "EDIROL",
 532                .product_name = "UM-1",
 533                .ifnum = QUIRK_ANY_INTERFACE,
 534                .type = QUIRK_COMPOSITE,
 535                .data = (const struct snd_usb_audio_quirk[]) {
 536                        {
 537                                .ifnum = 0,
 538                                .type = QUIRK_IGNORE_INTERFACE
 539                        },
 540                        {
 541                                .ifnum = 1,
 542                                .type = QUIRK_IGNORE_INTERFACE
 543                        },
 544                        {
 545                                .ifnum = 2,
 546                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 547                                .data = & (const struct snd_usb_midi_endpoint_info) {
 548                                        .out_cables = 0x0001,
 549                                        .in_cables  = 0x0001
 550                                }
 551                        },
 552                        {
 553                                .ifnum = -1
 554                        }
 555                }
 556        }
 557},
 558{
 559        USB_DEVICE(0x0582, 0x000b),
 560        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 561                .vendor_name = "Roland",
 562                .product_name = "SK-500",
 563                .ifnum = QUIRK_ANY_INTERFACE,
 564                .type = QUIRK_COMPOSITE,
 565                .data = (const struct snd_usb_audio_quirk[]) {
 566                        {
 567                                .ifnum = 0,
 568                                .type = QUIRK_IGNORE_INTERFACE
 569                        },
 570                        {
 571                                .ifnum = 1,
 572                                .type = QUIRK_IGNORE_INTERFACE
 573                        },
 574                        {
 575                                .ifnum = 2,
 576                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 577                                .data = & (const struct snd_usb_midi_endpoint_info) {
 578                                        .out_cables = 0x0013,
 579                                        .in_cables  = 0x0013
 580                                }
 581                        },
 582                        {
 583                                .ifnum = -1
 584                        }
 585                }
 586        }
 587},
 588{
 589        /* thanks to Emiliano Grilli <emillo@libero.it>
 590         * for helping researching this data */
 591        USB_DEVICE(0x0582, 0x000c),
 592        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 593                .vendor_name = "Roland",
 594                .product_name = "SC-D70",
 595                .ifnum = QUIRK_ANY_INTERFACE,
 596                .type = QUIRK_COMPOSITE,
 597                .data = (const struct snd_usb_audio_quirk[]) {
 598                        {
 599                                .ifnum = 0,
 600                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 601                                .data = & (const struct audioformat) {
 602                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 603                                        .channels = 2,
 604                                        .iface = 0,
 605                                        .altsetting = 1,
 606                                        .altset_idx = 1,
 607                                        .attributes = 0,
 608                                        .endpoint = 0x01,
 609                                        .ep_attr = 0x01,
 610                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 611                                        .rate_min = 44100,
 612                                        .rate_max = 44100,
 613                                }
 614                        },
 615                        {
 616                                .ifnum = 1,
 617                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 618                                .data = & (const struct audioformat) {
 619                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 620                                        .channels = 2,
 621                                        .iface = 1,
 622                                        .altsetting = 1,
 623                                        .altset_idx = 1,
 624                                        .attributes = 0,
 625                                        .endpoint = 0x81,
 626                                        .ep_attr = 0x01,
 627                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 628                                        .rate_min = 44100,
 629                                        .rate_max = 44100,
 630                                }
 631                        },
 632                        {
 633                                .ifnum = 2,
 634                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 635                                .data = & (const struct snd_usb_midi_endpoint_info) {
 636                                        .out_cables = 0x0007,
 637                                        .in_cables  = 0x0007
 638                                }
 639                        },
 640                        {
 641                                .ifnum = -1
 642                        }
 643                }
 644        }
 645},
 646{       /*
 647         * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 648         * If the advanced mode switch at the back of the unit is off, the
 649         * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 650         * but offers only 16-bit PCM.
 651         * In advanced mode, the UA-5 will output S24_3LE samples (two
 652         * channels) at the rate indicated on the front switch, including
 653         * the 96kHz sample rate.
 654         */
 655        USB_DEVICE(0x0582, 0x0010),
 656        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 657                .vendor_name = "EDIROL",
 658                .product_name = "UA-5",
 659                .ifnum = QUIRK_ANY_INTERFACE,
 660                .type = QUIRK_COMPOSITE,
 661                .data = (const struct snd_usb_audio_quirk[]) {
 662                        {
 663                                .ifnum = 1,
 664                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 665                        },
 666                        {
 667                                .ifnum = 2,
 668                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 669                        },
 670                        {
 671                                .ifnum = -1
 672                        }
 673                }
 674        }
 675},
 676{
 677        /* has ID 0x0013 when not in "Advanced Driver" mode */
 678        USB_DEVICE(0x0582, 0x0012),
 679        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 680                .vendor_name = "Roland",
 681                .product_name = "XV-5050",
 682                .ifnum = 0,
 683                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 684                .data = & (const struct snd_usb_midi_endpoint_info) {
 685                        .out_cables = 0x0001,
 686                        .in_cables  = 0x0001
 687                }
 688        }
 689},
 690{
 691        /* has ID 0x0015 when not in "Advanced Driver" mode */
 692        USB_DEVICE(0x0582, 0x0014),
 693        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 694                .vendor_name = "EDIROL",
 695                .product_name = "UM-880",
 696                .ifnum = 0,
 697                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 698                .data = & (const struct snd_usb_midi_endpoint_info) {
 699                        .out_cables = 0x01ff,
 700                        .in_cables  = 0x01ff
 701                }
 702        }
 703},
 704{
 705        /* has ID 0x0017 when not in "Advanced Driver" mode */
 706        USB_DEVICE(0x0582, 0x0016),
 707        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 708                .vendor_name = "EDIROL",
 709                .product_name = "SD-90",
 710                .ifnum = QUIRK_ANY_INTERFACE,
 711                .type = QUIRK_COMPOSITE,
 712                .data = (const struct snd_usb_audio_quirk[]) {
 713                        {
 714                                .ifnum = 0,
 715                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 716                        },
 717                        {
 718                                .ifnum = 1,
 719                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 720                        },
 721                        {
 722                                .ifnum = 2,
 723                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 724                                .data = & (const struct snd_usb_midi_endpoint_info) {
 725                                        .out_cables = 0x000f,
 726                                        .in_cables  = 0x000f
 727                                }
 728                        },
 729                        {
 730                                .ifnum = -1
 731                        }
 732                }
 733        }
 734},
 735{
 736        /* has ID 0x001c when not in "Advanced Driver" mode */
 737        USB_DEVICE(0x0582, 0x001b),
 738        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 739                .vendor_name = "Roland",
 740                .product_name = "MMP-2",
 741                .ifnum = QUIRK_ANY_INTERFACE,
 742                .type = QUIRK_COMPOSITE,
 743                .data = (const struct snd_usb_audio_quirk[]) {
 744                        {
 745                                .ifnum = 0,
 746                                .type = QUIRK_IGNORE_INTERFACE
 747                        },
 748                        {
 749                                .ifnum = 1,
 750                                .type = QUIRK_IGNORE_INTERFACE
 751                        },
 752                        {
 753                                .ifnum = 2,
 754                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 755                                .data = & (const struct snd_usb_midi_endpoint_info) {
 756                                        .out_cables = 0x0001,
 757                                        .in_cables  = 0x0001
 758                                }
 759                        },
 760                        {
 761                                .ifnum = -1
 762                        }
 763                }
 764        }
 765},
 766{
 767        /* has ID 0x001e when not in "Advanced Driver" mode */
 768        USB_DEVICE(0x0582, 0x001d),
 769        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 770                .vendor_name = "Roland",
 771                .product_name = "V-SYNTH",
 772                .ifnum = 0,
 773                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 774                .data = & (const struct snd_usb_midi_endpoint_info) {
 775                        .out_cables = 0x0001,
 776                        .in_cables  = 0x0001
 777                }
 778        }
 779},
 780{
 781        /* has ID 0x0024 when not in "Advanced Driver" mode */
 782        USB_DEVICE(0x0582, 0x0023),
 783        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 784                .vendor_name = "EDIROL",
 785                .product_name = "UM-550",
 786                .ifnum = 0,
 787                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 788                .data = & (const struct snd_usb_midi_endpoint_info) {
 789                        .out_cables = 0x003f,
 790                        .in_cables  = 0x003f
 791                }
 792        }
 793},
 794{
 795        /*
 796         * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 797         * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 798         * and no MIDI.
 799         */
 800        USB_DEVICE(0x0582, 0x0025),
 801        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 802                .vendor_name = "EDIROL",
 803                .product_name = "UA-20",
 804                .ifnum = QUIRK_ANY_INTERFACE,
 805                .type = QUIRK_COMPOSITE,
 806                .data = (const struct snd_usb_audio_quirk[]) {
 807                        {
 808                                .ifnum = 0,
 809                                .type = QUIRK_IGNORE_INTERFACE
 810                        },
 811                        {
 812                                .ifnum = 1,
 813                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 814                                .data = & (const struct audioformat) {
 815                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 816                                        .channels = 2,
 817                                        .iface = 1,
 818                                        .altsetting = 1,
 819                                        .altset_idx = 1,
 820                                        .attributes = 0,
 821                                        .endpoint = 0x01,
 822                                        .ep_attr = 0x01,
 823                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 824                                        .rate_min = 44100,
 825                                        .rate_max = 44100,
 826                                }
 827                        },
 828                        {
 829                                .ifnum = 2,
 830                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 831                                .data = & (const struct audioformat) {
 832                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 833                                        .channels = 2,
 834                                        .iface = 2,
 835                                        .altsetting = 1,
 836                                        .altset_idx = 1,
 837                                        .attributes = 0,
 838                                        .endpoint = 0x82,
 839                                        .ep_attr = 0x01,
 840                                        .rates = SNDRV_PCM_RATE_CONTINUOUS,
 841                                        .rate_min = 44100,
 842                                        .rate_max = 44100,
 843                                }
 844                        },
 845                        {
 846                                .ifnum = 3,
 847                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 848                                .data = & (const struct snd_usb_midi_endpoint_info) {
 849                                        .out_cables = 0x0001,
 850                                        .in_cables  = 0x0001
 851                                }
 852                        },
 853                        {
 854                                .ifnum = -1
 855                        }
 856                }
 857        }
 858},
 859{
 860        /* has ID 0x0028 when not in "Advanced Driver" mode */
 861        USB_DEVICE(0x0582, 0x0027),
 862        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 863                .vendor_name = "EDIROL",
 864                .product_name = "SD-20",
 865                .ifnum = 0,
 866                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 867                .data = & (const struct snd_usb_midi_endpoint_info) {
 868                        .out_cables = 0x0003,
 869                        .in_cables  = 0x0007
 870                }
 871        }
 872},
 873{
 874        /* has ID 0x002a when not in "Advanced Driver" mode */
 875        USB_DEVICE(0x0582, 0x0029),
 876        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 877                .vendor_name = "EDIROL",
 878                .product_name = "SD-80",
 879                .ifnum = 0,
 880                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 881                .data = & (const struct snd_usb_midi_endpoint_info) {
 882                        .out_cables = 0x000f,
 883                        .in_cables  = 0x000f
 884                }
 885        }
 886},
 887{       /*
 888         * This quirk is for the "Advanced" modes of the Edirol UA-700.
 889         * If the sample format switch is not in an advanced setting, the
 890         * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 891         * but offers only 16-bit PCM and no MIDI.
 892         */
 893        USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 894        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 895                .vendor_name = "EDIROL",
 896                .product_name = "UA-700",
 897                .ifnum = QUIRK_ANY_INTERFACE,
 898                .type = QUIRK_COMPOSITE,
 899                .data = (const struct snd_usb_audio_quirk[]) {
 900                        {
 901                                .ifnum = 1,
 902                                .type = QUIRK_AUDIO_EDIROL_UAXX
 903                        },
 904                        {
 905                                .ifnum = 2,
 906                                .type = QUIRK_AUDIO_EDIROL_UAXX
 907                        },
 908                        {
 909                                .ifnum = 3,
 910                                .type = QUIRK_AUDIO_EDIROL_UAXX
 911                        },
 912                        {
 913                                .ifnum = -1
 914                        }
 915                }
 916        }
 917},
 918{
 919        /* has ID 0x002e when not in "Advanced Driver" mode */
 920        USB_DEVICE(0x0582, 0x002d),
 921        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 922                .vendor_name = "Roland",
 923                .product_name = "XV-2020",
 924                .ifnum = 0,
 925                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 926                .data = & (const struct snd_usb_midi_endpoint_info) {
 927                        .out_cables = 0x0001,
 928                        .in_cables  = 0x0001
 929                }
 930        }
 931},
 932{
 933        /* has ID 0x0030 when not in "Advanced Driver" mode */
 934        USB_DEVICE(0x0582, 0x002f),
 935        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 936                .vendor_name = "Roland",
 937                .product_name = "VariOS",
 938                .ifnum = 0,
 939                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 940                .data = & (const struct snd_usb_midi_endpoint_info) {
 941                        .out_cables = 0x0007,
 942                        .in_cables  = 0x0007
 943                }
 944        }
 945},
 946{
 947        /* has ID 0x0034 when not in "Advanced Driver" mode */
 948        USB_DEVICE(0x0582, 0x0033),
 949        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 950                .vendor_name = "EDIROL",
 951                .product_name = "PCR",
 952                .ifnum = 0,
 953                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 954                .data = & (const struct snd_usb_midi_endpoint_info) {
 955                        .out_cables = 0x0003,
 956                        .in_cables  = 0x0007
 957                }
 958        }
 959},
 960        /* TODO: add Roland M-1000 support */
 961{
 962        /*
 963         * Has ID 0x0038 when not in "Advanced Driver" mode;
 964         * later revisions use IDs 0x0054 and 0x00a2.
 965         */
 966        USB_DEVICE(0x0582, 0x0037),
 967        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 968                .vendor_name = "Roland",
 969                .product_name = "Digital Piano",
 970                .ifnum = 0,
 971                .type = QUIRK_MIDI_FIXED_ENDPOINT,
 972                .data = & (const struct snd_usb_midi_endpoint_info) {
 973                        .out_cables = 0x0001,
 974                        .in_cables  = 0x0001
 975                }
 976        }
 977},
 978{
 979        /*
 980         * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
 981         * has ID 0x003c and is standard compliant, but has only 16-bit PCM
 982         * and no MIDI.
 983         */
 984        USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 985        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 986                .vendor_name = "BOSS",
 987                .product_name = "GS-10",
 988                .ifnum = QUIRK_ANY_INTERFACE,
 989                .type = QUIRK_COMPOSITE,
 990                .data = & (const struct snd_usb_audio_quirk[]) {
 991                        {
 992                                .ifnum = 1,
 993                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 994                        },
 995                        {
 996                                .ifnum = 2,
 997                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
 998                        },
 999                        {
1000                                .ifnum = 3,

1001                                .type = QUIRK_MIDI_STANDARD_INTERFACE
1002                        },
1003                        {
1004                                .ifnum = -1
1005                        }
1006                }
1007        }
1008},
1009{
1010        /* has ID 0x0041 when not in "Advanced Driver" mode */
1011        USB_DEVICE(0x0582, 0x0040),
1012        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1013                .vendor_name = "Roland",
1014                .product_name = "GI-20",
1015                .ifnum = 0,
1016                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1017                .data = & (const struct snd_usb_midi_endpoint_info) {
1018                        .out_cables = 0x0001,
1019                        .in_cables  = 0x0001
1020                }
1021        }
1022},
1023{
1024        /* has ID 0x0043 when not in "Advanced Driver" mode */
1025        USB_DEVICE(0x0582, 0x0042),
1026        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1027                .vendor_name = "Roland",
1028                .product_name = "RS-70",
1029                .ifnum = 0,
1030                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1031                .data = & (const struct snd_usb_midi_endpoint_info) {
1032                        .out_cables = 0x0001,
1033                        .in_cables  = 0x0001
1034                }
1035        }
1036},
1037{
1038        /* has ID 0x0049 when not in "Advanced Driver" mode */
1039        USB_DEVICE(0x0582, 0x0047),
1040        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1041                /* .vendor_name = "EDIROL", */
1042                /* .product_name = "UR-80", */
1043                .ifnum = QUIRK_ANY_INTERFACE,
1044                .type = QUIRK_COMPOSITE,
1045                .data = (const struct snd_usb_audio_quirk[]) {
1046                        /* in the 96 kHz modes, only interface 1 is there */
1047                        {
1048                                .ifnum = 1,
1049                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1050                        },
1051                        {
1052                                .ifnum = 2,
1053                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1054                        },
1055                        {
1056                                .ifnum = -1
1057                        }
1058                }
1059        }
1060},
1061{
1062        /* has ID 0x004a when not in "Advanced Driver" mode */
1063        USB_DEVICE(0x0582, 0x0048),
1064        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1065                /* .vendor_name = "EDIROL", */
1066                /* .product_name = "UR-80", */
1067                .ifnum = 0,
1068                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1069                .data = & (const struct snd_usb_midi_endpoint_info) {
1070                        .out_cables = 0x0003,
1071                        .in_cables  = 0x0007
1072                }
1073        }
1074},
1075        /* TODO: add Edirol M-100FX support */
1076{
1077        /* has ID 0x004e when not in "Advanced Driver" mode */
1078        USB_DEVICE(0x0582, 0x004c),
1079        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1080                .vendor_name = "EDIROL",
1081                .product_name = "PCR-A",
1082                .ifnum = QUIRK_ANY_INTERFACE,
1083                .type = QUIRK_COMPOSITE,
1084                .data = (const struct snd_usb_audio_quirk[]) {
1085                        {
1086                                .ifnum = 1,
1087                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1088                        },
1089                        {
1090                                .ifnum = 2,
1091                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1092                        },
1093                        {
1094                                .ifnum = -1
1095                        }
1096                }
1097        }
1098},
1099{
1100        /* has ID 0x004f when not in "Advanced Driver" mode */
1101        USB_DEVICE(0x0582, 0x004d),
1102        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1103                .vendor_name = "EDIROL",
1104                .product_name = "PCR-A",
1105                .ifnum = 0,
1106                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1107                .data = & (const struct snd_usb_midi_endpoint_info) {
1108                        .out_cables = 0x0003,
1109                        .in_cables  = 0x0007
1110                }
1111        }
1112},
1113{
1114        /*
1115         * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1116         * is standard compliant, but has only 16-bit PCM.
1117         */
1118        USB_DEVICE(0x0582, 0x0050),
1119        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1120                .vendor_name = "EDIROL",
1121                .product_name = "UA-3FX",
1122                .ifnum = QUIRK_ANY_INTERFACE,
1123                .type = QUIRK_COMPOSITE,
1124                .data = (const struct snd_usb_audio_quirk[]) {
1125                        {
1126                                .ifnum = 1,
1127                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1128                        },
1129                        {
1130                                .ifnum = 2,
1131                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1132                        },
1133                        {
1134                                .ifnum = -1
1135                        }
1136                }
1137        }
1138},
1139{
1140        USB_DEVICE(0x0582, 0x0052),
1141        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1142                .vendor_name = "EDIROL",
1143                .product_name = "UM-1SX",
1144                .ifnum = 0,
1145                .type = QUIRK_MIDI_STANDARD_INTERFACE
1146        }
1147},
1148{
1149        USB_DEVICE(0x0582, 0x0060),
1150        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1151                .vendor_name = "Roland",
1152                .product_name = "EXR Series",
1153                .ifnum = 0,
1154                .type = QUIRK_MIDI_STANDARD_INTERFACE
1155        }
1156},
1157{
1158        /* has ID 0x0066 when not in "Advanced Driver" mode */
1159        USB_DEVICE(0x0582, 0x0064),
1160        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1161                /* .vendor_name = "EDIROL", */
1162                /* .product_name = "PCR-1", */
1163                .ifnum = QUIRK_ANY_INTERFACE,
1164                .type = QUIRK_COMPOSITE,
1165                .data = (const struct snd_usb_audio_quirk[]) {
1166                        {
1167                                .ifnum = 1,
1168                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1169                        },
1170                        {
1171                                .ifnum = 2,
1172                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1173                        },
1174                        {
1175                                .ifnum = -1
1176                        }
1177                }
1178        }
1179},
1180{
1181        /* has ID 0x0067 when not in "Advanced Driver" mode */
1182        USB_DEVICE(0x0582, 0x0065),
1183        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1184                /* .vendor_name = "EDIROL", */
1185                /* .product_name = "PCR-1", */
1186                .ifnum = 0,
1187                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1188                .data = & (const struct snd_usb_midi_endpoint_info) {
1189                        .out_cables = 0x0001,
1190                        .in_cables  = 0x0003
1191                }
1192        }
1193},
1194{
1195        /* has ID 0x006b when not in "Advanced Driver" mode */
1196        USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1197        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198                .vendor_name = "Roland",
1199                .product_name = "SP-606",
1200                .ifnum = 3,
1201                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1202                .data = & (const struct snd_usb_midi_endpoint_info) {
1203                        .out_cables = 0x0001,
1204                        .in_cables  = 0x0001
1205                }
1206        }
1207},
1208{
1209        /* has ID 0x006e when not in "Advanced Driver" mode */
1210        USB_DEVICE(0x0582, 0x006d),
1211        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1212                .vendor_name = "Roland",
1213                .product_name = "FANTOM-X",
1214                .ifnum = 0,
1215                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1216                .data = & (const struct snd_usb_midi_endpoint_info) {
1217                        .out_cables = 0x0001,
1218                        .in_cables  = 0x0001
1219                }
1220        }
1221},
1222{       /*
1223         * This quirk is for the "Advanced" modes of the Edirol UA-25.
1224         * If the switch is not in an advanced setting, the UA-25 has
1225         * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1226         * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1227         */
1228        USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1229        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1230                .vendor_name = "EDIROL",
1231                .product_name = "UA-25",
1232                .ifnum = QUIRK_ANY_INTERFACE,
1233                .type = QUIRK_COMPOSITE,
1234                .data = (const struct snd_usb_audio_quirk[]) {
1235                        {
1236                                .ifnum = 0,
1237                                .type = QUIRK_AUDIO_EDIROL_UAXX
1238                        },
1239                        {
1240                                .ifnum = 1,
1241                                .type = QUIRK_AUDIO_EDIROL_UAXX
1242                        },
1243                        {
1244                                .ifnum = 2,
1245                                .type = QUIRK_AUDIO_EDIROL_UAXX
1246                        },
1247                        {
1248                                .ifnum = -1
1249                        }
1250                }
1251        }
1252},
1253{
1254        /* has ID 0x0076 when not in "Advanced Driver" mode */
1255        USB_DEVICE(0x0582, 0x0075),
1256        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1257                .vendor_name = "BOSS",
1258                .product_name = "DR-880",
1259                .ifnum = 0,
1260                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1261                .data = & (const struct snd_usb_midi_endpoint_info) {
1262                        .out_cables = 0x0001,
1263                        .in_cables  = 0x0001
1264                }
1265        }
1266},
1267{
1268        /* has ID 0x007b when not in "Advanced Driver" mode */
1269        USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1270        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1271                .vendor_name = "Roland",
1272                /* "RD" or "RD-700SX"? */
1273                .ifnum = 0,
1274                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1275                .data = & (const struct snd_usb_midi_endpoint_info) {
1276                        .out_cables = 0x0003,
1277                        .in_cables  = 0x0003
1278                }
1279        }
1280},
1281{
1282        /* has ID 0x0081 when not in "Advanced Driver" mode */
1283        USB_DEVICE(0x0582, 0x0080),
1284        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1285                .vendor_name = "Roland",
1286                .product_name = "G-70",
1287                .ifnum = 0,
1288                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1289                .data = & (const struct snd_usb_midi_endpoint_info) {
1290                        .out_cables = 0x0001,
1291                        .in_cables  = 0x0001
1292                }
1293        }
1294},
1295        /* TODO: add Roland V-SYNTH XT support */
1296        /* TODO: add BOSS GT-PRO support */
1297{
1298        /* has ID 0x008c when not in "Advanced Driver" mode */
1299        USB_DEVICE(0x0582, 0x008b),
1300        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1301                .vendor_name = "EDIROL",
1302                .product_name = "PC-50",
1303                .ifnum = 0,
1304                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1305                .data = & (const struct snd_usb_midi_endpoint_info) {
1306                        .out_cables = 0x0001,
1307                        .in_cables  = 0x0001
1308                }
1309        }
1310},
1311        /* TODO: add Edirol PC-80 support */
1312{
1313        USB_DEVICE(0x0582, 0x0096),
1314        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1315                .vendor_name = "EDIROL",
1316                .product_name = "UA-1EX",
1317                .ifnum = QUIRK_ANY_INTERFACE,
1318                .type = QUIRK_COMPOSITE,
1319                .data = (const struct snd_usb_audio_quirk[]) {
1320                        {
1321                                .ifnum = 0,
1322                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1323                        },
1324                        {
1325                                .ifnum = 1,
1326                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1327                        },
1328                        {
1329                                .ifnum = -1
1330                        }
1331                }
1332        }
1333},
1334{
1335        USB_DEVICE(0x0582, 0x009a),
1336        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1337                .vendor_name = "EDIROL",
1338                .product_name = "UM-3EX",
1339                .ifnum = 0,
1340                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1341                .data = & (const struct snd_usb_midi_endpoint_info) {
1342                        .out_cables = 0x000f,
1343                        .in_cables  = 0x000f
1344                }
1345        }
1346},
1347{
1348        /*
1349         * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1350         * is standard compliant, but has only 16-bit PCM and no MIDI.
1351         */
1352        USB_DEVICE(0x0582, 0x00a3),
1353        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1354                .vendor_name = "EDIROL",
1355                .product_name = "UA-4FX",
1356                .ifnum = QUIRK_ANY_INTERFACE,
1357                .type = QUIRK_COMPOSITE,
1358                .data = (const struct snd_usb_audio_quirk[]) {
1359                        {
1360                                .ifnum = 0,
1361                                .type = QUIRK_AUDIO_EDIROL_UAXX
1362                        },
1363                        {
1364                                .ifnum = 1,
1365                                .type = QUIRK_AUDIO_EDIROL_UAXX
1366                        },
1367                        {
1368                                .ifnum = 2,
1369                                .type = QUIRK_AUDIO_EDIROL_UAXX
1370                        },
1371                        {
1372                                .ifnum = -1
1373                        }
1374                }
1375        }
1376},
1377        /* TODO: add Edirol MD-P1 support */
1378{
1379        USB_DEVICE(0x582, 0x00a6),
1380        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1381                .vendor_name = "Roland",
1382                .product_name = "Juno-G",
1383                .ifnum = 0,
1384                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1385                .data = & (const struct snd_usb_midi_endpoint_info) {
1386                        .out_cables = 0x0001,
1387                        .in_cables  = 0x0001
1388                }
1389        }
1390},
1391{
1392        /* Roland SH-201 */
1393        USB_DEVICE(0x0582, 0x00ad),
1394        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1395                .vendor_name = "Roland",
1396                .product_name = "SH-201",
1397                .ifnum = QUIRK_ANY_INTERFACE,
1398                .type = QUIRK_COMPOSITE,
1399                .data = (const struct snd_usb_audio_quirk[]) {
1400                        {
1401                                .ifnum = 0,
1402                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1403                        },
1404                        {
1405                                .ifnum = 1,
1406                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1407                        },
1408                        {
1409                                .ifnum = 2,
1410                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1411                                .data = & (const struct snd_usb_midi_endpoint_info) {
1412                                        .out_cables = 0x0001,
1413                                        .in_cables  = 0x0001
1414                                }
1415                        },
1416                        {
1417                                .ifnum = -1
1418                        }
1419                }
1420        }
1421},
1422{
1423        /* Roland SonicCell */
1424        USB_DEVICE(0x0582, 0x00c2),
1425        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1426                .vendor_name = "Roland",
1427                .product_name = "SonicCell",
1428                .ifnum = QUIRK_ANY_INTERFACE,
1429                .type = QUIRK_COMPOSITE,
1430                .data = (const struct snd_usb_audio_quirk[]) {
1431                        {
1432                                .ifnum = 0,
1433                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1434                        },
1435                        {
1436                                .ifnum = 1,
1437                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1438                        },
1439                        {
1440                                .ifnum = 2,
1441                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1442                                .data = & (const struct snd_usb_midi_endpoint_info) {
1443                                        .out_cables = 0x0001,
1444                                        .in_cables  = 0x0001
1445                                }
1446                        },
1447                        {
1448                                .ifnum = -1
1449                        }
1450                }
1451        }
1452},
1453{
1454        /* Edirol M-16DX */
1455        /* FIXME: This quirk gives a good-working capture stream but the
1456         *        playback seems problematic because of lacking of sync
1457         *        with capture stream.  It needs to sync with the capture
1458         *        clock.  As now, you'll get frequent sound distortions
1459         *        via the playback.
1460         */
1461        USB_DEVICE(0x0582, 0x00c4),
1462        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1463                .ifnum = QUIRK_ANY_INTERFACE,
1464                .type = QUIRK_COMPOSITE,
1465                .data = (const struct snd_usb_audio_quirk[]) {
1466                        {
1467                                .ifnum = 0,
1468                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1469                        },
1470                        {
1471                                .ifnum = 1,
1472                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1473                        },
1474                        {
1475                                .ifnum = 2,
1476                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1477                                .data = & (const struct snd_usb_midi_endpoint_info) {
1478                                        .out_cables = 0x0001,
1479                                        .in_cables  = 0x0001
1480                                }
1481                        },
1482                        {
1483                                .ifnum = -1
1484                        }
1485                }
1486        }
1487},
1488{
1489        /* BOSS GT-10 */
1490        USB_DEVICE(0x0582, 0x00da),
1491        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
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 modes of the Edirol UA-25EX.
1519         * For the standard mode, UA-25EX has ID 0582:00e7, which
1520         * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1521         */
1522        USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1523        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1524                .vendor_name = "EDIROL",
1525                .product_name = "UA-25EX",
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_EDIROL_UAXX
1532                        },
1533                        {
1534                                .ifnum = 1,
1535                                .type = QUIRK_AUDIO_EDIROL_UAXX
1536                        },
1537                        {
1538                                .ifnum = 2,
1539                                .type = QUIRK_AUDIO_EDIROL_UAXX
1540                        },
1541                        {
1542                                .ifnum = -1
1543                        }
1544                }
1545        }
1546},
1547{
1548        /* has ID 0x00ea when not in Advanced Driver mode */
1549        USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1550        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1551                /* .vendor_name = "Roland", */
1552                /* .product_name = "UA-1G", */
1553                .ifnum = QUIRK_ANY_INTERFACE,
1554                .type = QUIRK_COMPOSITE,
1555                .data = (const struct snd_usb_audio_quirk[]) {
1556                        {
1557                                .ifnum = 0,
1558                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1559                        },
1560                        {
1561                                .ifnum = 1,
1562                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1563                        },
1564                        {
1565                                .ifnum = -1
1566                        }
1567                }
1568        }
1569},
1570{
1571        USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1572        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1573                /* .vendor_name = "Roland", */
1574                /* .product_name = "UM-1G", */
1575                .ifnum = 0,
1576                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1577                .data = & (const struct snd_usb_midi_endpoint_info) {
1578                        .out_cables = 0x0001,
1579                        .in_cables  = 0x0001
1580                }
1581        }
1582},
1583{
1584        /* Boss JS-8 Jam Station  */
1585        USB_DEVICE(0x0582, 0x0109),
1586        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1587                /* .vendor_name = "BOSS", */
1588                /* .product_name = "JS-8", */
1589                .ifnum = QUIRK_ANY_INTERFACE,
1590                .type = QUIRK_COMPOSITE,
1591                .data = (const struct snd_usb_audio_quirk[]) {
1592                        {
1593                                .ifnum = 0,
1594                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1595                        },
1596                        {
1597                                .ifnum = 1,
1598                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1599                        },
1600                        {
1601                                .ifnum = 2,
1602                                .type = QUIRK_MIDI_STANDARD_INTERFACE
1603                        },
1604                        {
1605                                .ifnum = -1
1606                        }
1607                }
1608        }
1609},
1610{
1611        /* has ID 0x0110 when not in Advanced Driver mode */
1612        USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1613        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1614                /* .vendor_name = "Roland", */
1615                /* .product_name = "A-PRO", */
1616                .ifnum = 1,
1617                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1618                .data = & (const struct snd_usb_midi_endpoint_info) {
1619                        .out_cables = 0x0003,
1620                        .in_cables  = 0x0007
1621                }
1622        }
1623},
1624{
1625        USB_DEVICE(0x0582, 0x0113),
1626        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1627                /* .vendor_name = "BOSS", */
1628                /* .product_name = "ME-25", */
1629                .ifnum = QUIRK_ANY_INTERFACE,
1630                .type = QUIRK_COMPOSITE,
1631                .data = (const struct snd_usb_audio_quirk[]) {
1632                        {
1633                                .ifnum = 0,
1634                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1635                        },
1636                        {
1637                                .ifnum = 1,
1638                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1639                        },
1640                        {
1641                                .ifnum = 2,
1642                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1643                                .data = & (const struct snd_usb_midi_endpoint_info) {
1644                                        .out_cables = 0x0001,
1645                                        .in_cables  = 0x0001
1646                                }
1647                        },
1648                        {
1649                                .ifnum = -1
1650                        }
1651                }
1652        }
1653},
1654
1655/* Guillemot devices */
1656{
1657        /*
1658         * This is for the "Windows Edition" where the external MIDI ports are
1659         * the only MIDI ports; the control data is reported through HID
1660         * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1661         * compliant USB MIDI ports for external MIDI and controls.
1662         */
1663        USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1664        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1665                .vendor_name = "Hercules",
1666                .product_name = "DJ Console (WE)",
1667                .ifnum = 4,
1668                .type = QUIRK_MIDI_FIXED_ENDPOINT,
1669                .data = & (const struct snd_usb_midi_endpoint_info) {
1670                        .out_cables = 0x0001,
1671                        .in_cables = 0x0001
1672                }
1673        }
1674},
1675
1676/* Midiman/M-Audio devices */
1677{
1678        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1679        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1680                .vendor_name = "M-Audio",
1681                .product_name = "MidiSport 2x2",
1682                .ifnum = QUIRK_ANY_INTERFACE,
1683                .type = QUIRK_MIDI_MIDIMAN,
1684                .data = & (const struct snd_usb_midi_endpoint_info) {
1685                        .out_cables = 0x0003,
1686                        .in_cables  = 0x0003
1687                }
1688        }
1689},
1690{
1691        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1692        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1693                .vendor_name = "M-Audio",
1694                .product_name = "MidiSport 1x1",
1695                .ifnum = QUIRK_ANY_INTERFACE,
1696                .type = QUIRK_MIDI_MIDIMAN,
1697                .data = & (const struct snd_usb_midi_endpoint_info) {
1698                        .out_cables = 0x0001,
1699                        .in_cables  = 0x0001
1700                }
1701        }
1702},
1703{
1704        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1705        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1706                .vendor_name = "M-Audio",
1707                .product_name = "Keystation",
1708                .ifnum = QUIRK_ANY_INTERFACE,
1709                .type = QUIRK_MIDI_MIDIMAN,
1710                .data = & (const struct snd_usb_midi_endpoint_info) {
1711                        .out_cables = 0x0001,
1712                        .in_cables  = 0x0001
1713                }
1714        }
1715},
1716{
1717        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1718        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1719                .vendor_name = "M-Audio",
1720                .product_name = "MidiSport 4x4",
1721                .ifnum = QUIRK_ANY_INTERFACE,
1722                .type = QUIRK_MIDI_MIDIMAN,
1723                .data = & (const struct snd_usb_midi_endpoint_info) {
1724                        .out_cables = 0x000f,
1725                        .in_cables  = 0x000f
1726                }
1727        }
1728},
1729{
1730        /*
1731         * For hardware revision 1.05; in the later revisions (1.10 and
1732         * 1.21), 0x1031 is the ID for the device without firmware.
1733         * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1734         */
1735        USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1736        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1737                .vendor_name = "M-Audio",
1738                .product_name = "MidiSport 8x8",
1739                .ifnum = QUIRK_ANY_INTERFACE,
1740                .type = QUIRK_MIDI_MIDIMAN,
1741                .data = & (const struct snd_usb_midi_endpoint_info) {
1742                        .out_cables = 0x01ff,
1743                        .in_cables  = 0x01ff
1744                }
1745        }
1746},
1747{
1748        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1749        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1750                .vendor_name = "M-Audio",
1751                .product_name = "MidiSport 8x8",
1752                .ifnum = QUIRK_ANY_INTERFACE,
1753                .type = QUIRK_MIDI_MIDIMAN,
1754                .data = & (const struct snd_usb_midi_endpoint_info) {
1755                        .out_cables = 0x01ff,
1756                        .in_cables  = 0x01ff
1757                }
1758        }
1759},
1760{
1761        USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1762        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1763                .vendor_name = "M-Audio",
1764                .product_name = "MidiSport 2x4",
1765                .ifnum = QUIRK_ANY_INTERFACE,
1766                .type = QUIRK_MIDI_MIDIMAN,
1767                .data = & (const struct snd_usb_midi_endpoint_info) {
1768                        .out_cables = 0x000f,
1769                        .in_cables  = 0x0003
1770                }
1771        }
1772},
1773{
1774        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1775        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1776                .vendor_name = "M-Audio",
1777                .product_name = "Quattro",
1778                .ifnum = QUIRK_ANY_INTERFACE,
1779                .type = QUIRK_COMPOSITE,
1780                .data = & (const struct snd_usb_audio_quirk[]) {
1781                        /*
1782                         * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1783                         * and share endpoints with the other interfaces.
1784                         * Ignore them.  The other interfaces can do 24 bits,
1785                         * but captured samples are big-endian (see usbaudio.c).
1786                         */
1787                        {
1788                                .ifnum = 0,
1789                                .type = QUIRK_IGNORE_INTERFACE
1790                        },
1791                        {
1792                                .ifnum = 1,
1793                                .type = QUIRK_IGNORE_INTERFACE
1794                        },
1795                        {
1796                                .ifnum = 2,
1797                                .type = QUIRK_IGNORE_INTERFACE
1798                        },
1799                        {
1800                                .ifnum = 3,
1801                                .type = QUIRK_IGNORE_INTERFACE
1802                        },
1803                        {
1804                                .ifnum = 4,
1805                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1806                        },
1807                        {
1808                                .ifnum = 5,
1809                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1810                        },
1811                        {
1812                                .ifnum = 6,
1813                                .type = QUIRK_IGNORE_INTERFACE
1814                        },
1815                        {
1816                                .ifnum = 7,
1817                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1818                        },
1819                        {
1820                                .ifnum = 8,
1821                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1822                        },
1823                        {
1824                                .ifnum = 9,
1825                                .type = QUIRK_MIDI_MIDIMAN,
1826                                .data = & (const struct snd_usb_midi_endpoint_info) {
1827                                        .out_cables = 0x0001,
1828                                        .in_cables  = 0x0001
1829                                }
1830                        },
1831                        {
1832                                .ifnum = -1
1833                        }
1834                }
1835        }
1836},
1837{
1838        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1839        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1840                .vendor_name = "M-Audio",
1841                .product_name = "AudioPhile",
1842                .ifnum = 6,
1843                .type = QUIRK_MIDI_MIDIMAN,
1844                .data = & (const struct snd_usb_midi_endpoint_info) {
1845                        .out_cables = 0x0001,
1846                        .in_cables  = 0x0001
1847                }
1848        }
1849},
1850{
1851        USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1852        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1853                .vendor_name = "M-Audio",
1854                .product_name = "Ozone",
1855                .ifnum = 3,
1856                .type = QUIRK_MIDI_MIDIMAN,
1857                .data = & (const struct snd_usb_midi_endpoint_info) {
1858                        .out_cables = 0x0001,
1859                        .in_cables  = 0x0001
1860                }
1861        }
1862},
1863{
1864        USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1865        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1866                .vendor_name = "M-Audio",
1867                .product_name = "OmniStudio",
1868                .ifnum = QUIRK_ANY_INTERFACE,
1869                .type = QUIRK_COMPOSITE,
1870                .data = & (const struct snd_usb_audio_quirk[]) {
1871                        {
1872                                .ifnum = 0,
1873                                .type = QUIRK_IGNORE_INTERFACE
1874                        },
1875                        {
1876                                .ifnum = 1,
1877                                .type = QUIRK_IGNORE_INTERFACE
1878                        },
1879                        {
1880                                .ifnum = 2,
1881                                .type = QUIRK_IGNORE_INTERFACE
1882                        },
1883                        {
1884                                .ifnum = 3,
1885                                .type = QUIRK_IGNORE_INTERFACE
1886                        },
1887                        {
1888                                .ifnum = 4,
1889                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1890                        },
1891                        {
1892                                .ifnum = 5,
1893                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1894                        },
1895                        {
1896                                .ifnum = 6,
1897                                .type = QUIRK_IGNORE_INTERFACE
1898                        },
1899                        {
1900                                .ifnum = 7,
1901                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1902                        },
1903                        {
1904                                .ifnum = 8,
1905                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1906                        },
1907                        {
1908                                .ifnum = 9,
1909                                .type = QUIRK_MIDI_MIDIMAN,
1910                                .data = & (const struct snd_usb_midi_endpoint_info) {
1911                                        .out_cables = 0x0001,
1912                                        .in_cables  = 0x0001
1913                                }
1914                        },
1915                        {
1916                                .ifnum = -1
1917                        }
1918                }
1919        }
1920},
1921{
1922        USB_DEVICE(0x0763, 0x2019),
1923        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1924                /* .vendor_name = "M-Audio", */
1925                /* .product_name = "Ozone Academic", */
1926                .ifnum = QUIRK_ANY_INTERFACE,
1927                .type = QUIRK_COMPOSITE,
1928                .data = & (const struct snd_usb_audio_quirk[]) {
1929                        {
1930                                .ifnum = 0,
1931                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1932                        },
1933                        {
1934                                .ifnum = 1,
1935                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1936                        },
1937                        {
1938                                .ifnum = 2,
1939                                .type = QUIRK_AUDIO_STANDARD_INTERFACE
1940                        },
1941                        {
1942                                .ifnum = 3,
1943                                .type = QUIRK_MIDI_MIDIMAN,
1944                                .data = & (const struct snd_usb_midi_endpoint_info) {
1945                                        .out_cables = 0x0001,
1946                                        .in_cables  = 0x0001
1947                                }
1948                        },
1949                        {
1950                                .ifnum = -1
1951                        }
1952                }
1953        }
1954},
1955{
1956        USB_DEVICE(0x0763, 0x2080),
1957        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1958                /* .vendor_name = "M-Audio", */
1959                /* .product_name = "Fast Track Ultra", */
1960                .ifnum = QUIRK_ANY_INTERFACE,
1961                .type = QUIRK_COMPOSITE,
1962                .data = & (const struct snd_usb_audio_quirk[]) {
1963                        {
1964                                .ifnum = 0,
1965                                .type = QUIRK_IGNORE_INTERFACE
1966                        },
1967                        {
1968                                .ifnum = 1,
1969                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1970                                .data = & (const struct audioformat) {
1971                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1972                                        .channels = 8,
1973                                        .iface = 1,
1974                                        .altsetting = 1,
1975                                        .altset_idx = 1,
1976                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
1977                                        .endpoint = 0x01,
1978                                        .ep_attr = 0x09,
1979                                        .rates = SNDRV_PCM_RATE_44100 |
1980                                                 SNDRV_PCM_RATE_48000 |
1981                                                 SNDRV_PCM_RATE_88200 |
1982                                                 SNDRV_PCM_RATE_96000,
1983                                        .rate_min = 44100,
1984                                        .rate_max = 96000,
1985                                        .nr_rates = 4,
1986                                        .rate_table = (unsigned int[]) {
1987                                                44100, 48000, 88200, 96000
1988                                        }
1989                                }
1990                        },
1991                        {
1992                                .ifnum = 2,
1993                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1994                                .data = & (const struct audioformat) {
1995                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
1996                                        .channels = 8,
1997                                        .iface = 2,
1998                                        .altsetting = 1,
1999                                        .altset_idx = 1,
2000                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,

2001                                        .endpoint = 0x81,
2002                                        .ep_attr = 0x05,
2003                                        .rates = SNDRV_PCM_RATE_44100 |
2004                                                 SNDRV_PCM_RATE_48000 |
2005                                                 SNDRV_PCM_RATE_88200 |
2006                                                 SNDRV_PCM_RATE_96000,
2007                                        .rate_min = 44100,
2008                                        .rate_max = 96000,
2009                                        .nr_rates = 4,
2010                                        .rate_table = (unsigned int[]) {
2011                                                44100, 48000, 88200, 96000
2012                                        }
2013                                }
2014                        },
2015                        /* interface 3 (MIDI) is standard compliant */
2016                        {
2017                                .ifnum = -1
2018                        }
2019                }
2020        }
2021},
2022{
2023        USB_DEVICE(0x0763, 0x2081),
2024        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2025                /* .vendor_name = "M-Audio", */
2026                /* .product_name = "Fast Track Ultra 8R", */
2027                .ifnum = QUIRK_ANY_INTERFACE,
2028                .type = QUIRK_COMPOSITE,
2029                .data = & (const struct snd_usb_audio_quirk[]) {
2030                        {
2031                                .ifnum = 0,
2032                                .type = QUIRK_IGNORE_INTERFACE
2033                        },
2034                        {
2035                                .ifnum = 1,
2036                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2037                                .data = & (const struct audioformat) {
2038                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2039                                        .channels = 8,
2040                                        .iface = 1,
2041                                        .altsetting = 1,
2042                                        .altset_idx = 1,
2043                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2044                                        .endpoint = 0x01,
2045                                        .ep_attr = 0x09,
2046                                        .rates = SNDRV_PCM_RATE_44100 |
2047                                                 SNDRV_PCM_RATE_48000 |
2048                                                 SNDRV_PCM_RATE_88200 |
2049                                                 SNDRV_PCM_RATE_96000,
2050                                        .rate_min = 44100,
2051                                        .rate_max = 96000,
2052                                        .nr_rates = 4,
2053                                        .rate_table = (unsigned int[]) {
2054                                                        44100, 48000, 88200, 96000
2055                                        }
2056                                }
2057                        },
2058                        {
2059                                .ifnum = 2,
2060                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2061                                .data = & (const struct audioformat) {
2062                                        .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2063                                        .channels = 8,
2064                                        .iface = 2,
2065                                        .altsetting = 1,
2066                                        .altset_idx = 1,
2067                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2068                                        .endpoint = 0x81,
2069                                        .ep_attr = 0x05,
2070                                        .rates = SNDRV_PCM_RATE_44100 |
2071                                                 SNDRV_PCM_RATE_48000 |
2072                                                 SNDRV_PCM_RATE_88200 |
2073                                                 SNDRV_PCM_RATE_96000,
2074                                        .rate_min = 44100,
2075                                        .rate_max = 96000,
2076                                        .nr_rates = 4,
2077                                        .rate_table = (unsigned int[]) {
2078                                                44100, 48000, 88200, 96000
2079                                        }
2080                                }
2081                        },
2082                        /* interface 3 (MIDI) is standard compliant */
2083                        {
2084                                .ifnum = -1
2085                        }
2086                }
2087        }
2088},
2089
2090/* Casio devices */
2091{
2092        USB_DEVICE(0x07cf, 0x6801),
2093        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2094                .vendor_name = "Casio",
2095                .product_name = "PL-40R",
2096                .ifnum = 0,
2097                .type = QUIRK_MIDI_YAMAHA
2098        }
2099},
2100{
2101        /* this ID is used by several devices without a product ID */
2102        USB_DEVICE(0x07cf, 0x6802),
2103        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2104                .vendor_name = "Casio",
2105                .product_name = "Keyboard",
2106                .ifnum = 0,
2107                .type = QUIRK_MIDI_YAMAHA
2108        }
2109},
2110
2111/* Mark of the Unicorn devices */
2112{
2113        /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2114        .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2115                       USB_DEVICE_ID_MATCH_PRODUCT |
2116                       USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2117        .idVendor = 0x07fd,
2118        .idProduct = 0x0001,
2119        .bDeviceSubClass = 2,
2120        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2121                .vendor_name = "MOTU",
2122                .product_name = "Fastlane",
2123                .ifnum = QUIRK_ANY_INTERFACE,
2124                .type = QUIRK_COMPOSITE,
2125                .data = & (const struct snd_usb_audio_quirk[]) {
2126                        {
2127                                .ifnum = 0,
2128                                .type = QUIRK_MIDI_RAW_BYTES
2129                        },
2130                        {
2131                                .ifnum = 1,
2132                                .type = QUIRK_IGNORE_INTERFACE
2133                        },
2134                        {
2135                                .ifnum = -1
2136                        }
2137                }
2138        }
2139},
2140
2141/* Emagic devices */
2142{
2143        USB_DEVICE(0x086a, 0x0001),
2144        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2145                .vendor_name = "Emagic",
2146                /* .product_name = "Unitor8", */
2147                .ifnum = 2,
2148                .type = QUIRK_MIDI_EMAGIC,
2149                .data = & (const struct snd_usb_midi_endpoint_info) {
2150                        .out_cables = 0x80ff,
2151                        .in_cables  = 0x80ff
2152                }
2153        }
2154},
2155{
2156        USB_DEVICE(0x086a, 0x0002),
2157        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2158                .vendor_name = "Emagic",
2159                /* .product_name = "AMT8", */
2160                .ifnum = 2,
2161                .type = QUIRK_MIDI_EMAGIC,
2162                .data = & (const struct snd_usb_midi_endpoint_info) {
2163                        .out_cables = 0x80ff,
2164                        .in_cables  = 0x80ff
2165                }
2166        }
2167},
2168{
2169        USB_DEVICE(0x086a, 0x0003),
2170        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2171                .vendor_name = "Emagic",
2172                /* .product_name = "MT4", */
2173                .ifnum = 2,
2174                .type = QUIRK_MIDI_EMAGIC,
2175                .data = & (const struct snd_usb_midi_endpoint_info) {
2176                        .out_cables = 0x800f,
2177                        .in_cables  = 0x8003
2178                }
2179        }
2180},
2181
2182/* AKAI devices */
2183{
2184        USB_DEVICE(0x09e8, 0x0062),
2185        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2186                .vendor_name = "AKAI",
2187                .product_name = "MPD16",
2188                .ifnum = 0,
2189                .type = QUIRK_MIDI_AKAI,
2190        }
2191},
2192
2193/* TerraTec devices */
2194{
2195        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2196        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2197                .vendor_name = "TerraTec",
2198                .product_name = "PHASE 26",
2199                .ifnum = 3,
2200                .type = QUIRK_MIDI_STANDARD_INTERFACE
2201        }
2202},
2203{
2204        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2205        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2206                .vendor_name = "TerraTec",
2207                .product_name = "PHASE 26",
2208                .ifnum = 3,
2209                .type = QUIRK_MIDI_STANDARD_INTERFACE
2210        }
2211},
2212{
2213        USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2214        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2215                .vendor_name = "TerraTec",
2216                .product_name = "PHASE 26",
2217                .ifnum = 3,
2218                .type = QUIRK_MIDI_STANDARD_INTERFACE
2219        }
2220},
2221{
2222        USB_DEVICE(0x0ccd, 0x0028),
2223        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2224                .vendor_name = "TerraTec",
2225                .product_name = "Aureon5.1MkII",
2226                .ifnum = QUIRK_NO_INTERFACE
2227        }
2228},
2229{
2230        USB_DEVICE(0x0ccd, 0x0035),
2231        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2232                .vendor_name = "Miditech",
2233                .product_name = "Play'n Roll",
2234                .ifnum = 0,
2235                .type = QUIRK_MIDI_CME
2236        }
2237},
2238
2239/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2240{
2241        USB_DEVICE(0x103d, 0x0100),
2242                .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2243                .vendor_name = "Stanton",
2244                .product_name = "ScratchAmp",
2245                .ifnum = QUIRK_NO_INTERFACE
2246        }
2247},
2248{
2249        USB_DEVICE(0x103d, 0x0101),
2250                .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2251                .vendor_name = "Stanton",
2252                .product_name = "ScratchAmp",
2253                .ifnum = QUIRK_NO_INTERFACE
2254        }
2255},
2256
2257/* Novation EMS devices */
2258{
2259        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2260        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2261                .vendor_name = "Novation",
2262                .product_name = "ReMOTE Audio/XStation",
2263                .ifnum = 4,
2264                .type = QUIRK_MIDI_NOVATION
2265        }
2266},
2267{
2268        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2269        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2270                .vendor_name = "Novation",
2271                .product_name = "Speedio",
2272                .ifnum = 3,
2273                .type = QUIRK_MIDI_NOVATION
2274        }
2275},
2276{
2277        USB_DEVICE(0x1235, 0x000e),
2278        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2279                /* .vendor_name = "Novation", */
2280                /* .product_name = "Launchpad", */
2281                .ifnum = 0,
2282                .type = QUIRK_MIDI_RAW_BYTES
2283        }
2284},
2285{
2286        USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2287        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2288                .vendor_name = "Novation",
2289                .product_name = "ReMOTE25",
2290                .ifnum = 0,
2291                .type = QUIRK_MIDI_NOVATION
2292        }
2293},
2294
2295/* Access Music devices */
2296{
2297        /* VirusTI Desktop */
2298        USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2299        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2300                .ifnum = QUIRK_ANY_INTERFACE,
2301                .type = QUIRK_COMPOSITE,
2302                .data = &(const struct snd_usb_audio_quirk[]) {
2303                        {
2304                                .ifnum = 3,
2305                                .type = QUIRK_MIDI_FIXED_ENDPOINT,
2306                                .data = &(const struct snd_usb_midi_endpoint_info) {
2307                                        .out_cables = 0x0003,
2308                                        .in_cables  = 0x0003
2309                                }
2310                        },
2311                        {
2312                                .ifnum = 4,
2313                                .type = QUIRK_IGNORE_INTERFACE
2314                        },
2315                        {
2316                                .ifnum = -1
2317                        }
2318                }
2319        }
2320},
2321
2322/* */
2323{
2324        /* aka. Serato Scratch Live DJ Box */
2325        USB_DEVICE(0x13e5, 0x0001),
2326        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2327                .vendor_name = "Rane",
2328                .product_name = "SL-1",
2329                .ifnum = QUIRK_NO_INTERFACE
2330        }
2331},
2332
2333/* Native Instruments MK2 series */
2334{
2335        /* Traktor Audio 6 */
2336        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2337        .idVendor = 0x17cc,
2338        .idProduct = 0x1010,
2339},
2340{
2341        /* Traktor Audio 10 */
2342        .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2343        .idVendor = 0x17cc,
2344        .idProduct = 0x1020,
2345},
2346
2347/* Miditech devices */
2348{
2349        USB_DEVICE(0x4752, 0x0011),
2350        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2351                .vendor_name = "Miditech",
2352                .product_name = "Midistart-2",
2353                .ifnum = 0,
2354                .type = QUIRK_MIDI_CME
2355        }
2356},
2357
2358/* Central Music devices */
2359{
2360        /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2361        USB_DEVICE(0x7104, 0x2202),
2362        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2363                .ifnum = 0,
2364                .type = QUIRK_MIDI_CME
2365        }
2366},
2367
2368/* Hauppauge HVR-950Q and HVR-850 */
2369{
2370        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2371        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2372                       USB_DEVICE_ID_MATCH_INT_CLASS |
2373                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2374        .bInterfaceClass = USB_CLASS_AUDIO,
2375        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2376        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2377                .vendor_name = "Hauppauge",
2378                .product_name = "HVR-950Q",
2379                .ifnum = QUIRK_ANY_INTERFACE,
2380                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2381        }
2382},
2383{
2384        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2385        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2386                       USB_DEVICE_ID_MATCH_INT_CLASS |
2387                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2388        .bInterfaceClass = USB_CLASS_AUDIO,
2389        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2390        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2391                .vendor_name = "Hauppauge",
2392                .product_name = "HVR-850",
2393                .ifnum = QUIRK_ANY_INTERFACE,
2394                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2395        }
2396},
2397{
2398        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2399        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2400                       USB_DEVICE_ID_MATCH_INT_CLASS |
2401                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2402        .bInterfaceClass = USB_CLASS_AUDIO,
2403        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2404        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2405                .vendor_name = "Hauppauge",
2406                .product_name = "HVR-950Q",
2407                .ifnum = QUIRK_ANY_INTERFACE,
2408                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2409        }
2410},
2411{
2412        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2413        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2414                       USB_DEVICE_ID_MATCH_INT_CLASS |
2415                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2416        .bInterfaceClass = USB_CLASS_AUDIO,
2417        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2418        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2419                .vendor_name = "Hauppauge",
2420                .product_name = "HVR-950Q",
2421                .ifnum = QUIRK_ANY_INTERFACE,
2422                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2423        }
2424},
2425{
2426        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2427        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2428                       USB_DEVICE_ID_MATCH_INT_CLASS |
2429                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2430        .bInterfaceClass = USB_CLASS_AUDIO,
2431        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2432        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2433                .vendor_name = "Hauppauge",
2434                .product_name = "HVR-950Q",
2435                .ifnum = QUIRK_ANY_INTERFACE,
2436                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2437        }
2438},
2439{
2440        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2441        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2442                       USB_DEVICE_ID_MATCH_INT_CLASS |
2443                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2444        .bInterfaceClass = USB_CLASS_AUDIO,
2445        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2446        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2447                .vendor_name = "Hauppauge",
2448                .product_name = "HVR-950Q",
2449                .ifnum = QUIRK_ANY_INTERFACE,
2450                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2451        }
2452},
2453{
2454        USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2455        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2456                       USB_DEVICE_ID_MATCH_INT_CLASS |
2457                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2458        .bInterfaceClass = USB_CLASS_AUDIO,
2459        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2460        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2461                .vendor_name = "Hauppauge",
2462                .product_name = "HVR-950Q",
2463                .ifnum = QUIRK_ANY_INTERFACE,
2464                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2465        }
2466},
2467{
2468        USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2469        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2470                       USB_DEVICE_ID_MATCH_INT_CLASS |
2471                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2472        .bInterfaceClass = USB_CLASS_AUDIO,
2473        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2474        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2475                .vendor_name = "Hauppauge",
2476                .product_name = "HVR-950Q",
2477                .ifnum = QUIRK_ANY_INTERFACE,
2478                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2479        }
2480},
2481{
2482        USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2483        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2484                       USB_DEVICE_ID_MATCH_INT_CLASS |
2485                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2486        .bInterfaceClass = USB_CLASS_AUDIO,
2487        .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2488        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2489                .vendor_name = "Hauppauge",
2490                .product_name = "HVR-950Q",
2491                .ifnum = QUIRK_ANY_INTERFACE,
2492                .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2493        }
2494},
2495
2496/* Digidesign Mbox */
2497{
2498        /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2499        USB_DEVICE(0x0dba, 0x1000),
2500        .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2501                .vendor_name = "Digidesign",
2502                .product_name = "MBox",
2503                .ifnum = QUIRK_ANY_INTERFACE,
2504                .type = QUIRK_COMPOSITE,
2505                .data = (const struct snd_usb_audio_quirk[]){
2506                        {
2507                                .ifnum = 0,
2508                                .type = QUIRK_IGNORE_INTERFACE,
2509                        },
2510                        {
2511                                .ifnum = 1,
2512                                .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2513                                .data = &(const struct audioformat) {
2514                                        .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2515                                        .channels = 2,
2516                                        .iface = 1,
2517                                        .altsetting = 1,
2518                                        .altset_idx = 1,
2519                                        .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2520                                        .endpoint = 0x02,
2521                                        .ep_attr = 0x01,
2522                                        .maxpacksize = 0x130,
2523                                        .rates = SNDRV_PCM_RATE_44100 |
2524                                                 SNDRV_PCM_RATE_48000,
2525                                        .rate_min = 44100,
2526                                        .rate_max = 48000,
2527                                        .nr_rates = 2,
2528                                        .rate_table = (unsigned int[]) {
2529                                                44100, 48000
2530                                        }
2531                                }
2532                        },
2533                        {
2534                                .ifnum = -1
2535                        }
2536                }
2537
2538        }
2539},
2540
2541{
2542        /*
2543         * Some USB MIDI devices don't have an audio control interface,
2544         * so we have to grab MIDI streaming interfaces here.
2545         */
2546        .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2547                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2548        .bInterfaceClass = USB_CLASS_AUDIO,
2549        .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2550        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2551                .ifnum = QUIRK_ANY_INTERFACE,
2552                .type = QUIRK_MIDI_STANDARD_INTERFACE
2553        }
2554},
2555
2556#undef USB_DEVICE_VENDOR_SPEC
2557