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