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

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

2001                .ifnum = 0,
2002                .type = QUIRK_MIDI_CME
2003        }
2004},
2005
2006/* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2007{
2008        USB_DEVICE(0x103d, 0x0100),
2009                .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2010                .vendor_name = "Stanton",
2011                .product_name = "ScratchAmp",
2012                .ifnum = QUIRK_NO_INTERFACE
2013        }
2014},
2015{
2016        USB_DEVICE(0x103d, 0x0101),
2017                .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2018                .vendor_name = "Stanton",
2019                .product_name = "ScratchAmp",
2020                .ifnum = QUIRK_NO_INTERFACE
2021        }
2022},
2023
2024/* Novation EMS devices */
2025{
2026        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2027        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2028                .vendor_name = "Novation",
2029                .product_name = "ReMOTE Audio/XStation",
2030                .ifnum = 4,
2031                .type = QUIRK_MIDI_NOVATION
2032        }
2033},
2034{
2035        USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2036        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2037                .vendor_name = "Novation",
2038                .product_name = "Speedio",
2039                .ifnum = 3,
2040                .type = QUIRK_MIDI_NOVATION
2041        }
2042},
2043{
2044        USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2045        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2046                .vendor_name = "Novation",
2047                .product_name = "ReMOTE25",
2048                .ifnum = 0,
2049                .type = QUIRK_MIDI_NOVATION
2050        }
2051},
2052
2053/* */
2054{
2055        /* aka. Serato Scratch Live DJ Box */
2056        USB_DEVICE(0x13e5, 0x0001),
2057        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2058                .vendor_name = "Rane",
2059                .product_name = "SL-1",
2060                .ifnum = QUIRK_NO_INTERFACE
2061        }
2062},
2063
2064/* Miditech devices */
2065{
2066        USB_DEVICE(0x4752, 0x0011),
2067        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2068                .vendor_name = "Miditech",
2069                .product_name = "Midistart-2",
2070                .ifnum = 0,
2071                .type = QUIRK_MIDI_CME
2072        }
2073},
2074
2075/* Central Music devices */
2076{
2077        /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2078        USB_DEVICE(0x7104, 0x2202),
2079        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2080                .ifnum = 0,
2081                .type = QUIRK_MIDI_CME
2082        }
2083},
2084
2085{
2086        /*
2087         * Some USB MIDI devices don't have an audio control interface,
2088         * so we have to grab MIDI streaming interfaces here.
2089         */
2090        .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2091                       USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2092        .bInterfaceClass = USB_CLASS_AUDIO,
2093        .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
2094        .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2095                .ifnum = QUIRK_ANY_INTERFACE,
2096                .type = QUIRK_MIDI_STANDARD_INTERFACE
2097        }
2098},
2099
2100#undef USB_DEVICE_VENDOR_SPEC
2101